
Changes made while bringing boost/concept_check.hpp to v3's concept_check.h:

1)  File format changed from DOS to Unix.
2)  Boost config.hpp and other workaround files dropped (unneeded in g++ v3).
3)  Conditionally-compiled code depending on those "breakage" macros was
    removed, or not, depending on the macro, so that the macros themselves
    are gone.  Since the same code would always be compiled, let's make it
    easier on the reader and a few milliseconds faster for cpplib.
4)  Tests for NDEBUG were removed; if NDEBUG is defined, none of the checking
    code will even be included.
5)  BOOST_CLASS_REQUIRES* changed to accept a namespace parameter.
6)  SameTypeConcept added (simple wrapper around existing code).
7)  An unused variable in OutputIteratorConcept was removed.

At checkin, this was the exact diff, modulo the end-of-line character changes:


--- concept_check.hpp.orig	Sun Apr  1 08:59:46 2001
+++ boost_concept_check.h	Mon Apr  2 18:56:41 2001
@@ -5,20 +5,15 @@
 // "as is" without express or implied warranty, and with no claim as
 // to its suitability for any purpose.
 //
+
+// GCC Note:  based on version 1.12.0 of the Boost library.
 #ifndef BOOST_CONCEPT_CHECKS_HPP
 #define BOOST_CONCEPT_CHECKS_HPP
 
-#include <boost/config.hpp>
-#include <boost/iterator.hpp>
-#include <boost/iterator.hpp>
-#include <utility>
-#include <boost/pending/limits.hpp>
-
-#if (__GNUC__) || defined(__KCC) || defined(__ghs) || defined(__MWERKS__)
-#define BOOST_FPTR &
-#else
-#define BOOST_FPTR
-#endif
+#pragma GCC system_header
+#include <bits/stl_iterator_base_types.h>    // for traits and tags
+#include <utility>                           // for pair<>
+
 
 namespace boost {
 
@@ -27,80 +22,64 @@
 template <class Concept>
 void function_requires()
 {
-#if !defined(NDEBUG)
-  void (Concept::*x)() = BOOST_FPTR Concept::constraints;
+  void (Concept::*x)() = &Concept::constraints;
   ignore_unused_variable_warning(x);
-#endif
 }
 
-// The BOOST_CLASS_REQUIRES macros use function pointers as
-// template parameters, which VC++ does not support.
-
-#if defined(BOOST_NO_FUNCTION_PTR_TEMPLATE_PARAMETERS)
-
-#define BOOST_CLASS_REQUIRES(type_var, concept)
-#define BOOST_CLASS_REQUIRES2(type_var1, type_var2, concept)
-#define BOOST_CLASS_REQUIRES3(type_var1, type_var2, type_var3, concept)
-#define BOOST_CLASS_REQUIRES4(type_var1, type_var2, type_var3, type_var4, concept)
 
-#else
-
-#define BOOST_CLASS_REQUIRES(type_var, concept) \
-  typedef void (concept <type_var>::* func##type_var##concept)(); \
+#define BOOST_CLASS_REQUIRES(type_var, ns, concept) \
+  typedef void (ns::concept <type_var>::* func##type_var##concept)(); \
   template <func##type_var##concept _Tp1> \
   struct concept_checking_##type_var##concept { }; \
   typedef concept_checking_##type_var##concept< \
-    BOOST_FPTR concept <type_var>::constraints> \
+    &ns::concept <type_var>::constraints> \
     concept_checking_typedef_##type_var##concept
 
-#define BOOST_CLASS_REQUIRES2(type_var1, type_var2, concept) \
-  typedef void (concept <type_var1,type_var2>::* func##type_var1##type_var2##concept)(); \
+#define BOOST_CLASS_REQUIRES2(type_var1, type_var2, ns, concept) \
+  typedef void (ns::concept <type_var1,type_var2>::* func##type_var1##type_var2##concept)(); \
   template <func##type_var1##type_var2##concept _Tp1> \
   struct concept_checking_##type_var1##type_var2##concept { }; \
   typedef concept_checking_##type_var1##type_var2##concept< \
-    BOOST_FPTR concept <type_var1,type_var2>::constraints> \
+    &ns::concept <type_var1,type_var2>::constraints> \
     concept_checking_typedef_##type_var1##type_var2##concept
 
-#define BOOST_CLASS_REQUIRES3(type_var1, type_var2, type_var3, concept) \
-  typedef void (concept <type_var1,type_var2,type_var3>::* func##type_var1##type_var2##type_var3##concept)(); \
+#define BOOST_CLASS_REQUIRES3(type_var1, type_var2, type_var3, ns, concept) \
+  typedef void (ns::concept <type_var1,type_var2,type_var3>::* func##type_var1##type_var2##type_var3##concept)(); \
   template <func##type_var1##type_var2##type_var3##concept _Tp1> \
   struct concept_checking_##type_var1##type_var2##type_var3##concept { }; \
   typedef concept_checking_##type_var1##type_var2##type_var3##concept< \
-    BOOST_FPTR concept <type_var1,type_var2,type_var3>::constraints>  \
+    &ns::concept <type_var1,type_var2,type_var3>::constraints>  \
   concept_checking_typedef_##type_var1##type_var2##type_var3##concept
 
-#define BOOST_CLASS_REQUIRES4(type_var1, type_var2, type_var3, type_var4, concept) \
-  typedef void (concept <type_var1,type_var2,type_var3,type_var4>::* func##type_var1##type_var2##type_var3##type_var4##concept)(); \
+#define BOOST_CLASS_REQUIRES4(type_var1, type_var2, type_var3, type_var4, ns, concept) \
+  typedef void (ns::concept <type_var1,type_var2,type_var3,type_var4>::* func##type_var1##type_var2##type_var3##type_var4##concept)(); \
   template <func##type_var1##type_var2##type_var3##type_var4##concept _Tp1> \
   struct concept_checking_##type_var1##type_var2##type_var3##type_var4##concept { }; \
   typedef concept_checking_##type_var1##type_var2##type_var3##type_var4##concept< \
-    BOOST_FPTR concept <type_var1,type_var2,type_var3,type_var4>::constraints>  \
+    &ns::concept <type_var1,type_var2,type_var3,type_var4>::constraints>  \
     concept_checking_typedef_##type_var1##type_var2##type_var3##type_var4##concept
 
 
-#endif
-
-#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template <class T, class U>
 struct require_same { };
 
 template <class T>
 struct require_same<T,T> { typedef T type; };
-#else
-// This version does not perform checking, but will not do any harm.
-template <class T, class U>
-struct require_same { typedef T type; };
-#endif
+
+  template <class T, class U>
+  struct SameTypeConcept
+  {
+    void constraints() {
+      typedef typename require_same<T, U>::type req;
+    }
+  };
 
   template <class T>
   struct IntegerConcept {
     void constraints() { 
-#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
       errortype_must_be_an_integer_type();
-#endif      
     }
   };
-#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
   template <> struct IntegerConcept<short> { void constraints() {} };
   template <> struct IntegerConcept<unsigned short> { void constraints() {} };
   template <> struct IntegerConcept<int> { void constraints() {} };
@@ -108,32 +87,24 @@
   template <> struct IntegerConcept<long> { void constraints() {} };
   template <> struct IntegerConcept<unsigned long> { void constraints() {} };
   // etc.
-#endif      
 
   template <class T>
   struct SignedIntegerConcept {
     void constraints() { 
-#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
       errortype_must_be_a_signed_integer_type();
-#endif      
     }
   };
-#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
   template <> struct SignedIntegerConcept<short> { void constraints() {} };
   template <> struct SignedIntegerConcept<int> { void constraints() {} };
   template <> struct SignedIntegerConcept<long> { void constraints() {} };
   // etc.
-#endif      
 
   template <class T>
   struct UnsignedIntegerConcept {
     void constraints() { 
-#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
       errortype_must_be_an_unsigned_integer_type();
-#endif      
     }
   };
-#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
   template <> struct UnsignedIntegerConcept<unsigned short>
     { void constraints() {} };
   template <> struct UnsignedIntegerConcept<unsigned int>
@@ -141,7 +112,6 @@
   template <> struct UnsignedIntegerConcept<unsigned long>
     { void constraints() {} };
   // etc.
-#endif      
 
   //===========================================================================
   // Basic Concepts
@@ -159,15 +129,11 @@
   struct AssignableConcept
   {
     void constraints() {
-#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL
       a = a;              // require assignment operator
-#endif
       const_constraints(a);
     }
     void const_constraints(const TT& b) {
-#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL
       a = b;              // const required for argument to assignment
-#endif
     }
     TT a;
   };
@@ -196,17 +162,13 @@
   {
     void constraints() {
       TT b(a);
-#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL
       a = a;              // require assignment operator
-#endif
       const_constraints(a);
       ignore_unused_variable_warning(b);
     }
     void const_constraints(const TT& b) {
       TT c(b);
-#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL
       a = b;              // const required for argument to assignment
-#endif
       ignore_unused_variable_warning(c);
     }
     TT a;
@@ -304,6 +266,9 @@
   BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(-, SubtractOpConcept);
   BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(%, ModOpConcept);
 
+#undef BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT
+#undef BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT
+
   //===========================================================================
   // Function Object Concepts
 
@@ -318,7 +283,6 @@
   };
 
 
-#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
   template <class Func>
   struct GeneratorConcept<Func,void>
   {
@@ -327,7 +291,6 @@
     }
     Func f;
   };
-#endif
 
   template <class Func, class Return, class Arg>
   struct UnaryFunctionConcept
@@ -340,7 +303,6 @@
     Return r;
   };
 
-#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
   template <class Func, class Arg>
   struct UnaryFunctionConcept<Func, void, Arg> {
     void constraints() { 
@@ -348,7 +310,6 @@
     }
     Func f;
   };
-#endif
 
   template <class Func, class Return, class First, class Second>
   struct BinaryFunctionConcept
@@ -362,7 +323,6 @@
     Return r;
   };
 
-#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
   template <class Func, class First, class Second>
   struct BinaryFunctionConcept<Func, void, First, Second>
   {
@@ -373,7 +333,6 @@
     First first;
     Second second;
   };
-#endif
 
   template <class Func, class Arg>
   struct UnaryPredicateConcept
@@ -422,9 +381,7 @@
       function_requires< AssignableConcept<TT> >();
       function_requires< DefaultConstructibleConcept<TT> >();
       function_requires< EqualityComparableConcept<TT> >();
-#ifndef BOOST_NO_STD_ITERATOR_TRAITS
       typedef typename std::iterator_traits<TT>::value_type V;
-#endif
       (void)*i;           // require dereference operator
     }
     TT i;
@@ -446,7 +403,6 @@
     void constraints() {
       function_requires< TrivialIteratorConcept<TT> >();
       // require iterator_traits typedef's
-#ifndef BOOST_NO_STD_ITERATOR_TRAITS
       typedef typename std::iterator_traits<TT>::difference_type D;
       function_requires< SignedIntegerConcept<D> >();
       typedef typename std::iterator_traits<TT>::reference R;
@@ -455,7 +411,6 @@
       function_requires< ConvertibleConcept<
         typename std::iterator_traits<TT>::iterator_category,
         std::input_iterator_tag> >();
-#endif
       ++i;                // require preincrement operator
       i++;                // require postincrement operator
     }
@@ -471,7 +426,7 @@
       i++;                // require postincrement operator
       *i++ = t;           // require postincrement and assignment
     }
-    TT i, j;
+    TT i;
     ValueT t;
   };
 
@@ -480,14 +435,12 @@
   {
     void constraints() {
       function_requires< InputIteratorConcept<TT> >();
-#ifndef BOOST_NO_STD_ITERATOR_TRAITS
       function_requires< ConvertibleConcept<
         typename std::iterator_traits<TT>::iterator_category,
         std::forward_iterator_tag> >();
       typedef typename std::iterator_traits<TT>::reference reference;
       reference r = *i;
       ignore_unused_variable_warning(r);
-#endif
     }
     TT i;
   };
@@ -507,11 +460,9 @@
   {
     void constraints() {
       function_requires< ForwardIteratorConcept<TT> >();
-#ifndef BOOST_NO_STD_ITERATOR_TRAITS
       function_requires< ConvertibleConcept<
         typename std::iterator_traits<TT>::iterator_category,
         std::bidirectional_iterator_tag> >();
-#endif
       --i;                // require predecrement operator
       i--;                // require postdecrement operator
     }
@@ -536,12 +487,10 @@
     void constraints() {
       function_requires< BidirectionalIteratorConcept<TT> >();
       function_requires< ComparableConcept<TT> >();
-#ifndef BOOST_NO_STD_ITERATOR_TRAITS
       function_requires< ConvertibleConcept<
         typename std::iterator_traits<TT>::iterator_category,
         std::random_access_iterator_tag> >();
       typedef typename std::iterator_traits<TT>::reference R;
-#endif
 
       i += n;             // require assignment addition operator
       i = i + n; i = n + i; // require addition with difference type
@@ -552,11 +501,7 @@
     }
     TT a, b;
     TT i, j;
-#ifndef BOOST_NO_STD_ITERATOR_TRAITS
     typename std::iterator_traits<TT>::difference_type n;
-#else
-    std::ptrdiff_t n;
-#endif
   };
 
   template <class TT>
@@ -568,11 +513,7 @@
       i[n] = *i;                  // require element access and assignment
     }
     TT i;
-#ifndef BOOST_NO_STD_ITERATOR_TRAITS
     typename std::iterator_traits<TT>::difference_type n;
-#else
-    std::ptrdiff_t n;
-#endif
   };
 
   //===========================================================================