comparison DEPENDENCIES/generic/include/boost/concept_check.hpp @ 101:c530137014c0

Update Boost headers (1.58.0)

 # include <boost/detail/workaround.hpp>
 # include <boost/detail/iterator.hpp>
 
 # include <boost/concept/usage.hpp>
 # include <boost/concept/detail/concept_def.hpp>
+
+#if (defined _MSC_VER)
+# pragma warning( push )
+# pragma warning( disable : 4510 ) // default constructor could not be generated
+# pragma warning( disable : 4610 ) // object 'class' can never be instantiated - user-defined constructor required
+#endif
 
 namespace boost
 {
 
   //

       ignore_unused_variable_warning(ptr);
     }
     TT b;
   };
 
-#if (defined _MSC_VER)
-# pragma warning( push )
-# pragma warning( disable : 4510 ) // default constructor could not be generated
-# pragma warning( disable : 4610 ) // object 'class' can never be instantiated - user-defined constructor required
-#endif
   // The SGI STL version of Assignable requires copy constructor and operator=
   BOOST_concept(SGIAssignable,(TT))
   {
     BOOST_CONCEPT_USAGE(SGIAssignable) {
       TT c(a);

       ignore_unused_variable_warning(c);
     }
     TT a;
     TT b;
   };
-#if (defined _MSC_VER)
-# pragma warning( pop )
-#endif
 
   BOOST_concept(Convertible,(X)(Y))
   {
     BOOST_CONCEPT_USAGE(Convertible) {
       Y y = x;

 
   BOOST_concept(Mutable_ForwardIterator,(TT))
     : ForwardIterator<TT>
   {
       BOOST_CONCEPT_USAGE(Mutable_ForwardIterator) {
-        *i++ = *i;         // require postincrement and assignment
-      }
-   private:
-      TT i;
+        *i++ = *j;         // require postincrement and assignment
+      }
+   private:
+      TT i, j;
   };
 
   BOOST_concept(BidirectionalIterator,(TT))
     : ForwardIterator<TT>
   {

     : BidirectionalIterator<TT>
     , Mutable_ForwardIterator<TT>
   {
       BOOST_CONCEPT_USAGE(Mutable_BidirectionalIterator)
       {
-          *i-- = *i;                  // require postdecrement and assignment
-      }
-   private:
-      TT i;
+          *i-- = *j;                  // require postdecrement and assignment
+      }
+   private:
+      TT i, j;
   };
 
   BOOST_concept(RandomAccessIterator,(TT))
     : BidirectionalIterator<TT>
     , Comparable<TT>

     , DefaultConstructible<S>
   {
       BOOST_CONCEPT_USAGE(Sequence)
       {
           S
-              c(n),
-              c2(n, t),
-              c3(first, last);
+              c(n, t),
+              c2(first, last);
 
           c.insert(p, t);
           c.insert(p, n, t);
           c.insert(p, first, last);
 

 
           typename Sequence::reference r = c.front();
 
           ignore_unused_variable_warning(c);
           ignore_unused_variable_warning(c2);
-          ignore_unused_variable_warning(c3);
           ignore_unused_variable_warning(r);
           const_constraints(c);
       }
    private:
       void const_constraints(const S& c) {

    private:
       void const_constraints(const S& cc) {
           typename BackInsertionSequence::const_reference
               r = cc.back();
           ignore_unused_variable_warning(r);
-      };
+      }
       S c;
       typename S::value_type t;
   };
 
   BOOST_concept(AssociativeContainer,(C))

       const_iterator ci;
       size_type n;
   };
 } // namespace boost
 
+#if (defined _MSC_VER)
+# pragma warning( pop )
+#endif
+
 # include <boost/concept/detail/concept_undef.hpp>
 
 #endif // BOOST_CONCEPT_CHECKS_HPP