X-Git-Url: https://oss.titaniummirror.com/gitweb?a=blobdiff_plain;f=libstdc%2B%2B-v3%2Finclude%2Fbits%2Fboost_concept_check.h;h=054fcf27e5e655dfb47baccc330ed50113461944;hb=6fed43773c9b0ce596dca5686f37ac3fc0fa11c0;hp=29ca61baef72c224c09a16a195328b1aa74d46b2;hpb=27b11d56b743098deb193d510b337ba22dc52e5c;p=msp430-gcc.git

diff --git a/libstdc++-v3/include/bits/boost_concept_check.h b/libstdc++-v3/include/bits/boost_concept_check.h
index 29ca61ba..054fcf27 100644
--- a/libstdc++-v3/include/bits/boost_concept_check.h
+++ b/libstdc++-v3/include/bits/boost_concept_check.h
@@ -1,4 +1,27 @@
+// -*- C++ -*-
+
+// Copyright (C) 2004, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
 //
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+// <http://www.gnu.org/licenses/>.
+
 // (C) Copyright Jeremy Siek 2000. Permission to copy, use, modify,
 // sell and distribute this software is granted provided this
 // copyright notice appears in all copies. This software is provided
@@ -6,24 +29,22 @@
 // to its suitability for any purpose.
 //
 
-// GCC Note:  based on version 1.12.0 of the Boost library.
-
 /** @file boost_concept_check.h
  *  This is an internal header file, included by other library headers.
  *  You should not attempt to use it directly.
  */
 
-#ifndef _GLIBCPP_BOOST_CONCEPT_CHECK
-#define _GLIBCPP_BOOST_CONCEPT_CHECK 1
+// GCC Note:  based on version 1.12.0 of the Boost library.
+
+#ifndef _BOOST_CONCEPT_CHECK_H
+#define _BOOST_CONCEPT_CHECK_H 1
 
 #pragma GCC system_header
+
 #include <cstddef>                // for ptrdiff_t, used next
 #include <bits/stl_iterator_base_types.h>    // for traits and tags
-#include <utility>                           // for pair<>
 
-
-namespace __gnu_cxx
-{
+_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
 
 #define _IsUnused __attribute__ ((__unused__))
 
@@ -36,9 +57,15 @@ inline void __function_requires()
   void (_Concept::*__x)() _IsUnused = &_Concept::__constraints;
 }
 
+// No definition: if this is referenced, there's a problem with
+// the instantiating type not being one of the required integer types.
+// Unfortunately, this results in a link-time error, not a compile-time error.
+void __error_type_must_be_an_integer_type();
+void __error_type_must_be_an_unsigned_integer_type();
+void __error_type_must_be_a_signed_integer_type();
 
 // ??? Should the "concept_checking*" structs begin with more than _ ?
-#define _GLIBCPP_CLASS_REQUIRES(_type_var, _ns, _concept) \
+#define _GLIBCXX_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 { }; \
@@ -46,7 +73,7 @@ inline void __function_requires()
     &_ns::_concept <_type_var>::__constraints> \
     _concept_checking_typedef##_type_var##_concept
 
-#define _GLIBCPP_CLASS_REQUIRES2(_type_var1, _type_var2, _ns, _concept) \
+#define _GLIBCXX_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 { }; \
@@ -54,7 +81,7 @@ inline void __function_requires()
     &_ns::_concept <_type_var1,_type_var2>::__constraints> \
     _concept_checking_typedef##_type_var1##_type_var2##_concept
 
-#define _GLIBCPP_CLASS_REQUIRES3(_type_var1, _type_var2, _type_var3, _ns, _concept) \
+#define _GLIBCXX_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 { }; \
@@ -62,7 +89,7 @@ inline void __function_requires()
     &_ns::_concept <_type_var1,_type_var2,_type_var3>::__constraints>  \
   _concept_checking_typedef##_type_var1##_type_var2##_type_var3##_concept
 
-#define _GLIBCPP_CLASS_REQUIRES4(_type_var1, _type_var2, _type_var3, _type_var4, _ns, _concept) \
+#define _GLIBCXX_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 { }; \
@@ -87,7 +114,7 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
 
   template <class _Tp>
   struct _IntegerConcept {
-    void __constraints() { 
+    void __constraints() {
       __error_type_must_be_an_integer_type();
     }
   };
@@ -103,7 +130,7 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
 
   template <class _Tp>
   struct _SignedIntegerConcept {
-    void __constraints() { 
+    void __constraints() {
       __error_type_must_be_a_signed_integer_type();
     }
   };
@@ -114,7 +141,7 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
 
   template <class _Tp>
   struct _UnsignedIntegerConcept {
-    void __constraints() { 
+    void __constraints() {
       __error_type_must_be_an_unsigned_integer_type();
     }
   };
@@ -149,6 +176,8 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
       __a = __b;                   // const required for argument to assignment
     }
     _Tp __a;
+    // possibly should be "Tp* a;" and then dereference "a" in constraint
+    // functions?  present way would require a default ctor, i think...
   };
 
   template <class _Tp>
@@ -160,7 +189,7 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
       __const_constraints(__a);
     }
     void __const_constraints(const _Tp& __a) {
-      _Tp __c(__a) _IsUnused;           // require const copy constructor
+      _Tp __c _IsUnused(__a);           // require const copy constructor
       const _Tp* __ptr _IsUnused = &__a; // require const address of operator
     }
     _Tp __b;
@@ -171,12 +200,12 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
   struct _SGIAssignableConcept
   {
     void __constraints() {
-      _Tp __b(__a) _IsUnused;
+      _Tp __b _IsUnused(__a);
       __a = __a;                        // require assignment operator
       __const_constraints(__a);
     }
     void __const_constraints(const _Tp& __b) {
-      _Tp __c(__b) _IsUnused;
+      _Tp __c _IsUnused(__b);
       __a = __b;              // const required for argument to assignment
     }
     _Tp __a;
@@ -211,7 +240,6 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
   {
     void __constraints() {
       __aux_require_boolean_expr(__a == __b);
-      __aux_require_boolean_expr(__a != __b);
     }
     _Tp __a, __b;
   };
@@ -238,7 +266,7 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
     _Tp __a, __b;
   };
 
-#define _GLIBCPP_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(_OP,_NAME) \
+#define _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(_OP,_NAME) \
   template <class _First, class _Second> \
   struct _NAME { \
     void __constraints() { (void)__constraints_(); } \
@@ -249,7 +277,7 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
     _Second __b; \
   }
 
-#define _GLIBCPP_DEFINE_BINARY_OPERATOR_CONSTRAINT(_OP,_NAME) \
+#define _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT(_OP,_NAME) \
   template <class _Ret, class _First, class _Second> \
   struct _NAME { \
     void __constraints() { (void)__constraints_(); } \
@@ -260,21 +288,21 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
     _Second __b; \
   }
 
-  _GLIBCPP_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(==, _EqualOpConcept);
-  _GLIBCPP_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(!=, _NotEqualOpConcept);
-  _GLIBCPP_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<, _LessThanOpConcept);
-  _GLIBCPP_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<=, _LessEqualOpConcept);
-  _GLIBCPP_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>, _GreaterThanOpConcept);
-  _GLIBCPP_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>=, _GreaterEqualOpConcept);
+  _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(==, _EqualOpConcept);
+  _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(!=, _NotEqualOpConcept);
+  _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<, _LessThanOpConcept);
+  _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<=, _LessEqualOpConcept);
+  _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>, _GreaterThanOpConcept);
+  _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>=, _GreaterEqualOpConcept);
 
-  _GLIBCPP_DEFINE_BINARY_OPERATOR_CONSTRAINT(+, _PlusOpConcept);
-  _GLIBCPP_DEFINE_BINARY_OPERATOR_CONSTRAINT(*, _TimesOpConcept);
-  _GLIBCPP_DEFINE_BINARY_OPERATOR_CONSTRAINT(/, _DivideOpConcept);
-  _GLIBCPP_DEFINE_BINARY_OPERATOR_CONSTRAINT(-, _SubtractOpConcept);
-  _GLIBCPP_DEFINE_BINARY_OPERATOR_CONSTRAINT(%, _ModOpConcept);
+  _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT(+, _PlusOpConcept);
+  _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT(*, _TimesOpConcept);
+  _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT(/, _DivideOpConcept);
+  _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT(-, _SubtractOpConcept);
+  _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT(%, _ModOpConcept);
 
-#undef _GLIBCPP_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT
-#undef _GLIBCPP_DEFINE_BINARY_OPERATOR_CONSTRAINT
+#undef _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT
+#undef _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT
 
   //===========================================================================
   // Function Object Concepts
@@ -311,7 +339,7 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
 
   template <class _Func, class _Arg>
   struct _UnaryFunctionConcept<_Func, void, _Arg> {
-    void __constraints() { 
+    void __constraints() {
       __f(__arg);                       // require operator()
     }
     _Func __f;
@@ -321,7 +349,7 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
   template <class _Func, class _Return, class _First, class _Second>
   struct _BinaryFunctionConcept
   {
-    void __constraints() { 
+    void __constraints() {
       __r = __f(__first, __second);     // require operator()
     }
     _Func __f;
@@ -365,7 +393,7 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
   // use this when functor is used inside a container class like std::set
   template <class _Func, class _First, class _Second>
   struct _Const_BinaryPredicateConcept {
-    void __constraints() { 
+    void __constraints() {
       __const_constraints(__f);
     }
     void __const_constraints(const _Func& __fun) {
@@ -385,7 +413,7 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
   struct _TrivialIteratorConcept
   {
     void __constraints() {
-      __function_requires< _DefaultConstructibleConcept<_Tp> >();
+//    __function_requires< _DefaultConstructibleConcept<_Tp> >();
       __function_requires< _AssignableConcept<_Tp> >();
       __function_requires< _EqualityComparableConcept<_Tp> >();
 //      typedef typename std::iterator_traits<_Tp>::value_type _V;
@@ -410,9 +438,9 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
     void __constraints() {
       __function_requires< _TrivialIteratorConcept<_Tp> >();
       // require iterator_traits typedef's
-      typedef typename std::iterator_traits<_Tp>::difference_type _D;
-//      __function_requires< _SignedIntegerConcept<_D> >();
-      typedef typename std::iterator_traits<_Tp>::reference _R;
+      typedef typename std::iterator_traits<_Tp>::difference_type _Diff;
+//      __function_requires< _SignedIntegerConcept<_Diff> >();
+      typedef typename std::iterator_traits<_Tp>::reference _Ref;
       typedef typename std::iterator_traits<_Tp>::pointer _Pt;
       typedef typename std::iterator_traits<_Tp>::iterator_category _Cat;
       __function_requires< _ConvertibleConcept<
@@ -442,11 +470,12 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
   {
     void __constraints() {
       __function_requires< _InputIteratorConcept<_Tp> >();
+      __function_requires< _DefaultConstructibleConcept<_Tp> >();
       __function_requires< _ConvertibleConcept<
         typename std::iterator_traits<_Tp>::iterator_category,
         std::forward_iterator_tag> >();
-      typedef typename std::iterator_traits<_Tp>::reference _R;
-      _R __r _IsUnused = *__i;
+      typedef typename std::iterator_traits<_Tp>::reference _Ref;
+      _Ref __r _IsUnused = *__i;
     }
     _Tp __i;
   };
@@ -496,8 +525,8 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
       __function_requires< _ConvertibleConcept<
         typename std::iterator_traits<_Tp>::iterator_category,
         std::random_access_iterator_tag> >();
-      // ??? We don't use _R, are we just checking for "referenceability"?
-      typedef typename std::iterator_traits<_Tp>::reference _R;
+      // ??? We don't use _Ref, are we just checking for "referenceability"?
+      typedef typename std::iterator_traits<_Tp>::reference _Ref;
 
       __i += __n;                       // require assignment addition operator
       __i = __i + __n; __i = __n + __i; // require addition with difference type
@@ -559,7 +588,7 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
     typedef typename _Container::reference _Reference;
     typedef typename _Container::iterator _Iterator;
     typedef typename _Container::pointer _Pointer;
-    
+
     void __constraints() {
       __function_requires< _ContainerConcept<_Container> >();
       __function_requires< _AssignableConcept<_Value_type> >();
@@ -581,7 +610,7 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
       typedef typename _ForwardContainer::const_iterator _Const_iterator;
       __function_requires< _ForwardIteratorConcept<_Const_iterator> >();
     }
-  };  
+  };
 
   template <class _ForwardContainer>
   struct _Mutable_ForwardContainerConcept
@@ -592,7 +621,7 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
       typedef typename _ForwardContainer::iterator _Iterator;
       __function_requires< _Mutable_ForwardIteratorConcept<_Iterator> >();
     }
-  };  
+  };
 
   template <class _ReversibleContainer>
   struct _ReversibleContainerConcept
@@ -692,10 +721,9 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
       __function_requires< _Mutable_ForwardContainerConcept<_Sequence> >();
       __function_requires< _DefaultConstructibleConcept<_Sequence> >();
 
-      _Sequence 
-        __c(__n) _IsUnused,
-        __c2(__n, __t) _IsUnused,
-        __c3(__first, __last) _IsUnused;
+      _Sequence
+	__c _IsUnused(__n, __t),
+        __c2 _IsUnused(__first, __last);
 
       __c.insert(__p, __t);
       __c.insert(__p, __n, __t);
@@ -750,150 +778,10 @@ struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
     typename _BackInsertionSequence::value_type __t;
   };
 
-  template <class _AssociativeContainer>
-  struct _AssociativeContainerConcept
-  {
-    void __constraints() {
-      __function_requires< _ForwardContainerConcept<_AssociativeContainer> >();
-      __function_requires<
-        _DefaultConstructibleConcept<_AssociativeContainer> >();
-    
-      __i = __c.find(__k);
-      __r = __c.equal_range(__k);
-      __c.erase(__k);
-      __c.erase(__i);
-      __c.erase(__r.first, __r.second);
-      __const_constraints(__c);
-    }
-    void __const_constraints(const _AssociativeContainer& __c) {
-      __ci = __c.find(__k);
-      __n = __c.count(__k);
-      __cr = __c.equal_range(__k);
-    }
-    typedef typename _AssociativeContainer::iterator _Iterator;
-    typedef typename _AssociativeContainer::const_iterator _Const_iterator;
-
-    _AssociativeContainer __c;
-    _Iterator __i;
-    std::pair<_Iterator,_Iterator> __r;
-    _Const_iterator __ci;
-    std::pair<_Const_iterator,_Const_iterator> __cr;
-    typename _AssociativeContainer::key_type __k;
-    typename _AssociativeContainer::size_type __n;
-  };
-
-  template <class _UniqueAssociativeContainer>
-  struct _UniqueAssociativeContainerConcept
-  {
-    void __constraints() {
-      __function_requires<
-        _AssociativeContainerConcept<_UniqueAssociativeContainer> >();
-    
-      _UniqueAssociativeContainer __c(__first, __last);
-      
-      __pos_flag = __c.insert(__t);
-      __c.insert(__first, __last);
-    }
-    std::pair<typename _UniqueAssociativeContainer::iterator, bool> __pos_flag;
-    typename _UniqueAssociativeContainer::value_type __t;
-    typename _UniqueAssociativeContainer::value_type *__first, *__last;
-  };
-
-  template <class _MultipleAssociativeContainer>
-  struct _MultipleAssociativeContainerConcept
-  {
-    void __constraints() {
-      __function_requires<
-        _AssociativeContainerConcept<_MultipleAssociativeContainer> >();
-
-      _MultipleAssociativeContainer __c(__first, __last);
-      
-      __pos = __c.insert(__t);
-      __c.insert(__first, __last);
-
-    }
-    typename _MultipleAssociativeContainer::iterator __pos _IsUnused;
-    typename _MultipleAssociativeContainer::value_type __t;
-    typename _MultipleAssociativeContainer::value_type *__first, *__last;
-  };
-
-  template <class _SimpleAssociativeContainer>
-  struct _SimpleAssociativeContainerConcept
-  {
-    void __constraints() {
-      __function_requires<
-        _AssociativeContainerConcept<_SimpleAssociativeContainer> >();
-      typedef typename _SimpleAssociativeContainer::key_type _Key_type;
-      typedef typename _SimpleAssociativeContainer::value_type _Value_type;
-      typedef typename _Aux_require_same<_Key_type, _Value_type>::_Type
-        _Requqired;
-    }
-  };
-
-  template <class _SimpleAssociativeContainer>
-  struct _PairAssociativeContainerConcept
-  {
-    void __constraints() {
-      __function_requires<
-        _AssociativeContainerConcept<_SimpleAssociativeContainer> >();
-      typedef typename _SimpleAssociativeContainer::key_type _Key_type;
-      typedef typename _SimpleAssociativeContainer::value_type _Value_type;
-      typedef typename _SimpleAssociativeContainer::mapped_type _Mapped_type;
-      typedef std::pair<const _Key_type, _Mapped_type> _Required_value_type;
-      typedef typename _Aux_require_same<_Value_type,
-        _Required_value_type>::_Type _Required;
-    }
-  };
-
-  template <class _SortedAssociativeContainer>
-  struct _SortedAssociativeContainerConcept
-  {
-    void __constraints() {
-      __function_requires<
-        _AssociativeContainerConcept<_SortedAssociativeContainer> >();
-      __function_requires<
-        _ReversibleContainerConcept<_SortedAssociativeContainer> >();
-
-      _SortedAssociativeContainer 
-        __c(__kc) _IsUnused,
-        __c2(__first, __last) _IsUnused,
-        __c3(__first, __last, __kc) _IsUnused;
-
-      __p = __c.upper_bound(__k);
-      __p = __c.lower_bound(__k);
-      __r = __c.equal_range(__k);
-      
-      __c.insert(__p, __t);
-    }
-    void __const_constraints(const _SortedAssociativeContainer& __c) {
-      __kc = __c.key_comp();
-      __vc = __c.value_comp();
-
-      __cp = __c.upper_bound(__k);
-      __cp = __c.lower_bound(__k);
-      __cr = __c.equal_range(__k);
-    }
-    typename _SortedAssociativeContainer::key_compare __kc;
-    typename _SortedAssociativeContainer::value_compare __vc;
-    typename _SortedAssociativeContainer::value_type __t;
-    typename _SortedAssociativeContainer::key_type __k;
-    typedef typename _SortedAssociativeContainer::iterator _Iterator;
-    typedef typename _SortedAssociativeContainer::const_iterator
-      _Const_iterator;
-
-    _Iterator __p;
-    _Const_iterator __cp;
-    std::pair<_Iterator,_Iterator> __r;
-    std::pair<_Const_iterator,_Const_iterator> __cr;
-    typename _SortedAssociativeContainer::value_type *__first, *__last;
-  };
-
-  // HashedAssociativeContainer
-
-} // namespace __gnu_cxx
+_GLIBCXX_END_NAMESPACE
 
 #undef _IsUnused
 
-#endif // _GLIBCPP_BOOST_CONCEPT_CHECK
+#endif // _GLIBCXX_BOOST_CONCEPT_CHECK