From: Phil Edwards Date: Fri, 13 Apr 2001 09:03:18 +0000 (+0000) Subject: boost_concept_check.h: Uglify, fork from Boost. X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=62bb0c97fdbb70f6f93fb0d77e1743117ae53930;p=gcc.git boost_concept_check.h: Uglify, fork from Boost. 2001-04-13 Phil Edwards * include/bits/boost_concept_check.h: Uglify, fork from Boost. * include/bits/concept_check.h: Uglify. * include/bits/stl_algo.h: Likewise. * include/bits/stl_algobase.h: Likewise. * include/bits/stl_deque.h: Likewise. * include/bits/stl_heap.h: Likewise. * include/bits/stl_iterator_base_funcs.h: Likewise. * include/bits/stl_list.h: Likewise. * include/bits/stl_map.h: Likewise. * include/bits/stl_multimap.h: Likewise. * include/bits/stl_multiset.h: Likewise. * include/bits/stl_numeric.h: Likewise. * include/bits/stl_queue.h: Likewise. * include/bits/stl_set.h: Likewise. * include/bits/stl_stack.h: Likewise. * include/bits/stl_vector.h: Likewise. * include/ext/hash_map: Likewise. * include/ext/hash_set: Likewise. * include/ext/slist: Likewise. From-SVN: r41333 --- diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 22aae1fc355..0c68727f98c 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,25 @@ +2001-04-13 Phil Edwards + + * include/bits/boost_concept_check.h: Uglify, fork from Boost. + * include/bits/concept_check.h: Uglify. + * include/bits/stl_algo.h: Likewise. + * include/bits/stl_algobase.h: Likewise. + * include/bits/stl_deque.h: Likewise. + * include/bits/stl_heap.h: Likewise. + * include/bits/stl_iterator_base_funcs.h: Likewise. + * include/bits/stl_list.h: Likewise. + * include/bits/stl_map.h: Likewise. + * include/bits/stl_multimap.h: Likewise. + * include/bits/stl_multiset.h: Likewise. + * include/bits/stl_numeric.h: Likewise. + * include/bits/stl_queue.h: Likewise. + * include/bits/stl_set.h: Likewise. + * include/bits/stl_stack.h: Likewise. + * include/bits/stl_vector.h: Likewise. + * include/ext/hash_map: Likewise. + * include/ext/hash_set: Likewise. + * include/ext/slist: Likewise. + 2001-04-13 Gabriel Dos Reis * testsuite/23_containers/set_operators.cc: Just try to compile. diff --git a/libstdc++-v3/include/bits/boost_concept_check.h b/libstdc++-v3/include/bits/boost_concept_check.h index 1142e049618..be6bc27245c 100644 --- a/libstdc++-v3/include/bits/boost_concept_check.h +++ b/libstdc++-v3/include/bits/boost_concept_check.h @@ -7,181 +7,184 @@ // // GCC Note: based on version 1.12.0 of the Boost library. -#ifndef BOOST_CONCEPT_CHECKS_HPP -#define BOOST_CONCEPT_CHECKS_HPP +#ifndef _GLIBCPP_BOOST_CONCEPT_CHECK +#define _GLIBCPP_BOOST_CONCEPT_CHECK 1 #pragma GCC system_header #include // for traits and tags #include // for pair<> -namespace boost { +namespace __gnu_cxx +{ -template void ignore_unused_variable_warning(const T&) { } +#define _IsUnused __attribute__ ((__unused__)) -template -void function_requires() +template +void __function_requires() { - void (Concept::*x)() = &Concept::constraints; - ignore_unused_variable_warning(x); + void (_Concept::*__x)() _IsUnused = &_Concept::__constraints; } -#define BOOST_CLASS_REQUIRES(type_var, ns, concept) \ - typedef void (ns::concept ::* func##type_var##concept)(); \ - template \ - struct concept_checking_##type_var##concept { }; \ - typedef concept_checking_##type_var##concept< \ - &ns::concept ::constraints> \ - concept_checking_typedef_##type_var##concept - -#define BOOST_CLASS_REQUIRES2(type_var1, type_var2, ns, concept) \ - typedef void (ns::concept ::* func##type_var1##type_var2##concept)(); \ - template \ - struct concept_checking_##type_var1##type_var2##concept { }; \ - typedef concept_checking_##type_var1##type_var2##concept< \ - &ns::concept ::constraints> \ - concept_checking_typedef_##type_var1##type_var2##concept - -#define BOOST_CLASS_REQUIRES3(type_var1, type_var2, type_var3, ns, concept) \ - typedef void (ns::concept ::* func##type_var1##type_var2##type_var3##concept)(); \ - template \ - struct concept_checking_##type_var1##type_var2##type_var3##concept { }; \ - typedef concept_checking_##type_var1##type_var2##type_var3##concept< \ - &ns::concept ::constraints> \ - concept_checking_typedef_##type_var1##type_var2##type_var3##concept - -#define BOOST_CLASS_REQUIRES4(type_var1, type_var2, type_var3, type_var4, ns, concept) \ - typedef void (ns::concept ::* func##type_var1##type_var2##type_var3##type_var4##concept)(); \ - template \ - struct concept_checking_##type_var1##type_var2##type_var3##type_var4##concept { }; \ - typedef concept_checking_##type_var1##type_var2##type_var3##type_var4##concept< \ - &ns::concept ::constraints> \ - concept_checking_typedef_##type_var1##type_var2##type_var3##type_var4##concept - - -template -struct require_same { }; - -template -struct require_same { typedef T type; }; - - template - struct SameTypeConcept - { - void constraints() { - typedef typename require_same::type req; - } - }; - - template - struct IntegerConcept { - void constraints() { - errortype_must_be_an_integer_type(); - } - }; - template <> struct IntegerConcept { void constraints() {} }; - template <> struct IntegerConcept { void constraints() {} }; - template <> struct IntegerConcept { void constraints() {} }; - template <> struct IntegerConcept { void constraints() {} }; - template <> struct IntegerConcept { void constraints() {} }; - template <> struct IntegerConcept { void constraints() {} }; - // etc. - - template - struct SignedIntegerConcept { - void constraints() { - errortype_must_be_a_signed_integer_type(); - } - }; - template <> struct SignedIntegerConcept { void constraints() {} }; - template <> struct SignedIntegerConcept { void constraints() {} }; - template <> struct SignedIntegerConcept { void constraints() {} }; - // etc. - - template - struct UnsignedIntegerConcept { - void constraints() { - errortype_must_be_an_unsigned_integer_type(); - } - }; - template <> struct UnsignedIntegerConcept - { void constraints() {} }; - template <> struct UnsignedIntegerConcept - { void constraints() {} }; - template <> struct UnsignedIntegerConcept - { void constraints() {} }; - // etc. +// ??? Should the "concept_checking*" structs begin with more than _ ? +#define _GLIBCPP_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< \ + &_ns::_concept <_type_var>::__constraints> \ + _concept_checking_typedef##_type_var##_concept + +#define _GLIBCPP_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< \ + &_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) \ + 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< \ + &_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) \ + 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< \ + &_ns::_concept <_type_var1,_type_var2,_type_var3,_type_var4>::__constraints> \ + _concept_checking_typedef##_type_var1##_type_var2##_type_var3##_type_var4##_concept + + +template +struct _Aux_require_same { }; + +template +struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; }; + + template + struct _SameTypeConcept + { + void __constraints() { + typedef typename _Aux_require_same<_Tp1, _Tp2>::_Type _Required; + } + }; + + template + struct _IntegerConcept { + void __constraints() { + __error_type_must_be_an_integer_type(); + } + }; + template <> struct _IntegerConcept { void __constraints() {} }; + template <> struct _IntegerConcept { void __constraints(){} }; + template <> struct _IntegerConcept { void __constraints() {} }; + template <> struct _IntegerConcept { void __constraints() {} }; + template <> struct _IntegerConcept { void __constraints() {} }; + template <> struct _IntegerConcept { void __constraints() {} }; +#ifdef _GLIBCPP_USE_LONG_LONG + template <> struct _IntegerConcept { void __constraints() {} }; + template <> struct _IntegerConcept + { void __constraints() {} }; +#endif + + template + struct _SignedIntegerConcept { + void __constraints() { + __error_type_must_be_a_signed_integer_type(); + } + }; + template <> struct _SignedIntegerConcept { void __constraints() {} }; + template <> struct _SignedIntegerConcept { void __constraints() {} }; + template <> struct _SignedIntegerConcept { void __constraints() {} }; +#ifdef _GLIBCPP_USE_LONG_LONG + template <> struct _SignedIntegerConcept { void __constraints(){}}; +#endif + + template + struct _UnsignedIntegerConcept { + void __constraints() { + __error_type_must_be_an_unsigned_integer_type(); + } + }; + template <> struct _UnsignedIntegerConcept + { void __constraints() {} }; + template <> struct _UnsignedIntegerConcept + { void __constraints() {} }; + template <> struct _UnsignedIntegerConcept + { void __constraints() {} }; +#ifdef _GLIBCPP_USE_LONG_LONG + template <> struct _UnsignedIntegerConcept + { void __constraints() {} }; +#endif //=========================================================================== // Basic Concepts - template - struct DefaultConstructibleConcept + template + struct _DefaultConstructibleConcept { - void constraints() { - TT a; // require default constructor - ignore_unused_variable_warning(a); + void __constraints() { + _Tp __a _IsUnused; // require default constructor } }; - template - struct AssignableConcept + template + struct _AssignableConcept { - void constraints() { - a = a; // require assignment operator - const_constraints(a); + void __constraints() { + __a = __a; // require assignment operator + __const_constraints(__a); } - void const_constraints(const TT& b) { - a = b; // const required for argument to assignment + void __const_constraints(const _Tp& __b) { + __a = __b; // const required for argument to assignment } - TT a; + _Tp __a; }; - template - struct CopyConstructibleConcept + template + struct _CopyConstructibleConcept { - void constraints() { - TT a(b); // require copy constructor - TT* ptr = &a; // require address of operator - const_constraints(a); - ignore_unused_variable_warning(ptr); + void __constraints() { + _Tp __a(__b); // require copy constructor + _Tp* __ptr _IsUnused = &__a; // require address of operator + __const_constraints(__a); } - void const_constraints(const TT& a) { - TT c(a); // require const copy constructor - const TT* ptr = &a; // require const address of operator - ignore_unused_variable_warning(c); - ignore_unused_variable_warning(ptr); + void __const_constraints(const _Tp& __a) { + _Tp __c(__a) _IsUnused; // require const copy constructor + const _Tp* __ptr _IsUnused = &__a; // require const address of operator } - TT b; + _Tp __b; }; // The SGI STL version of Assignable requires copy constructor and operator= - template - struct SGIAssignableConcept + template + struct _SGIAssignableConcept { - void constraints() { - TT b(a); - a = a; // require assignment operator - const_constraints(a); - ignore_unused_variable_warning(b); + void __constraints() { + _Tp __b(__a) _IsUnused; + __a = __a; // require assignment operator + __const_constraints(__a); } - void const_constraints(const TT& b) { - TT c(b); - a = b; // const required for argument to assignment - ignore_unused_variable_warning(c); + void __const_constraints(const _Tp& __b) { + _Tp __c(__b) _IsUnused; + __a = __b; // const required for argument to assignment } - TT a; + _Tp __a; }; - template - struct ConvertibleConcept + template + struct _ConvertibleConcept { - void constraints() { - Y y = x; - ignore_unused_variable_warning(y); + void __constraints() { + _To __y _IsUnused = __x; } - X x; + _From __x; }; // The C++ standard requirements for many concepts talk about return @@ -193,695 +196,700 @@ struct require_same { typedef T type; }; // 2) stay with convertible to bool, and also // specify stuff about all the logical operators. // For now we just test for convertible to bool. - template - void require_boolean_expr(const TT& t) { - bool x = t; - ignore_unused_variable_warning(x); + template + void __aux_require_boolean_expr(const _Tp& __t) { + bool __x _IsUnused = __t; } - template - struct EqualityComparableConcept +// FIXME + template + struct _EqualityComparableConcept { - void constraints() { - require_boolean_expr(a == b); - require_boolean_expr(a != b); + void __constraints() { + __aux_require_boolean_expr(__a == __b); + __aux_require_boolean_expr(__a != __b); } - TT a, b; + _Tp __a, __b; }; - template - struct LessThanComparableConcept + template + struct _LessThanComparableConcept { - void constraints() { - require_boolean_expr(a < b); + void __constraints() { + __aux_require_boolean_expr(__a < __b); } - TT a, b; + _Tp __a, __b; }; // This is equivalent to SGI STL's LessThanComparable. - template - struct ComparableConcept + template + struct _ComparableConcept { - void constraints() { - require_boolean_expr(a < b); - require_boolean_expr(a > b); - require_boolean_expr(a <= b); - require_boolean_expr(a >= b); + void __constraints() { + __aux_require_boolean_expr(__a < __b); + __aux_require_boolean_expr(__a > __b); + __aux_require_boolean_expr(__a <= __b); + __aux_require_boolean_expr(__a >= __b); } - TT a, b; + _Tp __a, __b; }; -#define BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(OP,NAME) \ - template \ - struct NAME { \ - void constraints() { (void)constraints_(); } \ - bool constraints_() { \ - return a OP b; \ +#define _GLIBCPP_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(_OP,_NAME) \ + template \ + struct _NAME { \ + void __constraints() { (void)__constraints_(); } \ + bool __constraints_() { \ + return __a _OP __b; \ } \ - First a; \ - Second b; \ + _First __a; \ + _Second __b; \ } -#define BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(OP,NAME) \ - template \ - struct NAME { \ - void constraints() { (void)constraints_(); } \ - Ret constraints_() { \ - return a OP b; \ +#define _GLIBCPP_DEFINE_BINARY_OPERATOR_CONSTRAINT(_OP,_NAME) \ + template \ + struct _NAME { \ + void __constraints() { (void)__constraints_(); } \ + _Ret __constraints_() { \ + return __a _OP __b; \ } \ - First a; \ - Second b; \ + _First __a; \ + _Second __b; \ } - BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(==, EqualOpConcept); - BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(!=, NotEqualOpConcept); - BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<, LessThanOpConcept); - BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<=, LessEqualOpConcept); - BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>, GreaterThanOpConcept); - BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>=, GreaterEqualOpConcept); + _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); - BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(+, PlusOpConcept); - BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(*, TimesOpConcept); - BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(/, DivideOpConcept); - BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(-, SubtractOpConcept); - BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(%, ModOpConcept); + _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); -#undef BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT -#undef BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT +#undef _GLIBCPP_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT +#undef _GLIBCPP_DEFINE_BINARY_OPERATOR_CONSTRAINT //=========================================================================== // Function Object Concepts - template - struct GeneratorConcept + template + struct _GeneratorConcept { - void constraints() { - const Return& r = f(); // require operator() member function - ignore_unused_variable_warning(r); + void __constraints() { + const _Return& __r _IsUnused = __f();// require operator() member function } - Func f; + _Func __f; }; - template - struct GeneratorConcept + template + struct _GeneratorConcept<_Func,void> { - void constraints() { - f(); // require operator() member function + void __constraints() { + __f(); // require operator() member function } - Func f; + _Func __f; }; - template - struct UnaryFunctionConcept + template + struct _UnaryFunctionConcept { - void constraints() { - r = f(arg); // require operator() + void __constraints() { + __r = __f(__arg); // require operator() } - Func f; - Arg arg; - Return r; + _Func __f; + _Arg __arg; + _Return __r; }; - template - struct UnaryFunctionConcept { - void constraints() { - f(arg); // require operator() + template + struct _UnaryFunctionConcept<_Func, void, _Arg> { + void __constraints() { + __f(__arg); // require operator() } - Func f; + _Func __f; + _Arg __arg; }; - template - struct BinaryFunctionConcept + template + struct _BinaryFunctionConcept { - void constraints() { - r = f(first, second); // require operator() + void __constraints() { + __r = __f(__first, __second); // require operator() } - Func f; - First first; - Second second; - Return r; + _Func __f; + _First __first; + _Second __second; + _Return __r; }; - template - struct BinaryFunctionConcept + template + struct _BinaryFunctionConcept<_Func, void, _First, _Second> { - void constraints() { - f(first, second); // require operator() + void __constraints() { + __f(__first, __second); // require operator() } - Func f; - First first; - Second second; + _Func __f; + _First __first; + _Second __second; }; - template - struct UnaryPredicateConcept + template + struct _UnaryPredicateConcept { - void constraints() { - require_boolean_expr(f(arg)); // require operator() returning bool + void __constraints() { + __aux_require_boolean_expr(__f(__arg)); // require op() returning bool } - Func f; - Arg arg; + _Func __f; + _Arg __arg; }; - template - struct BinaryPredicateConcept + template + struct _BinaryPredicateConcept { - void constraints() { - require_boolean_expr(f(a, b)); // require operator() returning bool + void __constraints() { + __aux_require_boolean_expr(__f(__a, __b)); // require op() returning bool } - Func f; - First a; - Second b; + _Func __f; + _First __a; + _Second __b; }; // use this when functor is used inside a container class like std::set - template - struct Const_BinaryPredicateConcept { - void constraints() { - const_constraints(f); + template + struct _Const_BinaryPredicateConcept { + void __constraints() { + __const_constraints(__f); } - void const_constraints(const Func& fun) { - function_requires >(); + void __const_constraints(const _Func& __fun) { + __function_requires<_BinaryPredicateConcept<_Func, _First, _Second> >(); // operator() must be a const member function - require_boolean_expr(fun(a, b)); + __aux_require_boolean_expr(__fun(__a, __b)); } - Func f; - First a; - Second b; + _Func __f; + _First __a; + _Second __b; }; //=========================================================================== // Iterator Concepts - template - struct TrivialIteratorConcept + template + struct _TrivialIteratorConcept { - void constraints() { - function_requires< AssignableConcept >(); - function_requires< DefaultConstructibleConcept >(); - function_requires< EqualityComparableConcept >(); - typedef typename std::iterator_traits::value_type V; - (void)*i; // require dereference operator + void __constraints() { + __function_requires< _DefaultConstructibleConcept<_Tp> >(); + __function_requires< _AssignableConcept<_Tp> >(); + __function_requires< _EqualityComparableConcept<_Tp> >(); + typedef typename std::iterator_traits<_Tp>::value_type _V; + (void)*__i; // require dereference operator } - TT i; + _Tp __i; }; - template - struct Mutable_TrivialIteratorConcept + template + struct _Mutable_TrivialIteratorConcept { - void constraints() { - function_requires< TrivialIteratorConcept >(); - *i = *j; // require dereference and assignment + void __constraints() { + __function_requires< _TrivialIteratorConcept<_Tp> >(); + *__i = *__j; // require dereference and assignment } - TT i, j; + _Tp __i, __j; }; - template - struct InputIteratorConcept + template + struct _InputIteratorConcept { - void constraints() { - function_requires< TrivialIteratorConcept >(); + void __constraints() { + __function_requires< _TrivialIteratorConcept<_Tp> >(); // require iterator_traits typedef's - typedef typename std::iterator_traits::difference_type D; - function_requires< SignedIntegerConcept >(); - typedef typename std::iterator_traits::reference R; - typedef typename std::iterator_traits::pointer P; - typedef typename std::iterator_traits::iterator_category C; - function_requires< ConvertibleConcept< - typename std::iterator_traits::iterator_category, + 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>::pointer _Pt; + typedef typename std::iterator_traits<_Tp>::iterator_category _Cat; + __function_requires< _ConvertibleConcept< + typename std::iterator_traits<_Tp>::iterator_category, std::input_iterator_tag> >(); - ++i; // require preincrement operator - i++; // require postincrement operator + ++__i; // require preincrement operator + __i++; // require postincrement operator } - TT i; + _Tp __i; }; - template - struct OutputIteratorConcept + template + struct _OutputIteratorConcept { - void constraints() { - function_requires< AssignableConcept >(); - ++i; // require preincrement operator - i++; // require postincrement operator - *i++ = t; // require postincrement and assignment + void __constraints() { + __function_requires< _AssignableConcept<_Tp> >(); + ++__i; // require preincrement operator + __i++; // require postincrement operator + *__i++ = __t; // require postincrement and assignment } - TT i; - ValueT t; + _Tp __i; + _ValueT __t; }; - template - struct ForwardIteratorConcept + template + struct _ForwardIteratorConcept { - void constraints() { - function_requires< InputIteratorConcept >(); - function_requires< ConvertibleConcept< - typename std::iterator_traits::iterator_category, + void __constraints() { + __function_requires< _InputIteratorConcept<_Tp> >(); + __function_requires< _ConvertibleConcept< + typename std::iterator_traits<_Tp>::iterator_category, std::forward_iterator_tag> >(); - typedef typename std::iterator_traits::reference reference; - reference r = *i; - ignore_unused_variable_warning(r); + typedef typename std::iterator_traits<_Tp>::reference _R; + _R __r _IsUnused = *__i; } - TT i; + _Tp __i; }; - template - struct Mutable_ForwardIteratorConcept + template + struct _Mutable_ForwardIteratorConcept { - void constraints() { - function_requires< ForwardIteratorConcept >(); - *i++ = *i; // require postincrement and assignment + void __constraints() { + __function_requires< _ForwardIteratorConcept<_Tp> >(); + *__i++ = *__i; // require postincrement and assignment } - TT i; + _Tp __i; }; - template - struct BidirectionalIteratorConcept + template + struct _BidirectionalIteratorConcept { - void constraints() { - function_requires< ForwardIteratorConcept >(); - function_requires< ConvertibleConcept< - typename std::iterator_traits::iterator_category, + void __constraints() { + __function_requires< _ForwardIteratorConcept<_Tp> >(); + __function_requires< _ConvertibleConcept< + typename std::iterator_traits<_Tp>::iterator_category, std::bidirectional_iterator_tag> >(); - --i; // require predecrement operator - i--; // require postdecrement operator + --__i; // require predecrement operator + __i--; // require postdecrement operator } - TT i; + _Tp __i; }; - template - struct Mutable_BidirectionalIteratorConcept + template + struct _Mutable_BidirectionalIteratorConcept { - void constraints() { - function_requires< BidirectionalIteratorConcept >(); - function_requires< Mutable_ForwardIteratorConcept >(); - *i-- = *i; // require postdecrement and assignment + void __constraints() { + __function_requires< _BidirectionalIteratorConcept<_Tp> >(); + __function_requires< _Mutable_ForwardIteratorConcept<_Tp> >(); + *__i-- = *__i; // require postdecrement and assignment } - TT i; + _Tp __i; }; - template - struct RandomAccessIteratorConcept + template + struct _RandomAccessIteratorConcept { - void constraints() { - function_requires< BidirectionalIteratorConcept >(); - function_requires< ComparableConcept >(); - function_requires< ConvertibleConcept< - typename std::iterator_traits::iterator_category, + void __constraints() { + __function_requires< _BidirectionalIteratorConcept<_Tp> >(); + __function_requires< _ComparableConcept<_Tp> >(); + __function_requires< _ConvertibleConcept< + typename std::iterator_traits<_Tp>::iterator_category, std::random_access_iterator_tag> >(); - typedef typename std::iterator_traits::reference R; + // ??? We don't use _R, are we just checking for "referenceability"? + typedef typename std::iterator_traits<_Tp>::reference _R; - i += n; // require assignment addition operator - i = i + n; i = n + i; // require addition with difference type - i -= n; // require assignment subtraction operator - i = i - n; // require subtraction with difference type - n = i - j; // require difference operator - (void)i[n]; // require element access operator + __i += __n; // require assignment addition operator + __i = __i + __n; __i = __n + __i; // require addition with difference type + __i -= __n; // require assignment subtraction op + __i = __i - __n; // require subtraction with + // difference type + __n = __i - __j; // require difference operator + (void)__i[__n]; // require element access operator } - TT a, b; - TT i, j; - typename std::iterator_traits::difference_type n; + _Tp __a, __b; + _Tp __i, __j; + typename std::iterator_traits<_Tp>::difference_type __n; }; - template - struct Mutable_RandomAccessIteratorConcept + template + struct _Mutable_RandomAccessIteratorConcept { - void constraints() { - function_requires< RandomAccessIteratorConcept >(); - function_requires< Mutable_BidirectionalIteratorConcept >(); - i[n] = *i; // require element access and assignment + void __constraints() { + __function_requires< _RandomAccessIteratorConcept<_Tp> >(); + __function_requires< _Mutable_BidirectionalIteratorConcept<_Tp> >(); + __i[__n] = *__i; // require element access and assignment } - TT i; - typename std::iterator_traits::difference_type n; + _Tp __i; + typename std::iterator_traits<_Tp>::difference_type __n; }; //=========================================================================== // Container Concepts - template - struct ContainerConcept - { - typedef typename Container::value_type value_type; - typedef typename Container::difference_type difference_type; - typedef typename Container::size_type size_type; - typedef typename Container::const_reference const_reference; - typedef typename Container::const_pointer const_pointer; - typedef typename Container::const_iterator const_iterator; - - void constraints() { - function_requires< InputIteratorConcept >(); - function_requires< AssignableConcept >(); - const Container c; - i = c.begin(); - i = c.end(); - n = c.size(); - n = c.max_size(); - b = c.empty(); - } - bool b; - const_iterator i; - size_type n; - }; - - template - struct Mutable_ContainerConcept - { - typedef typename Container::value_type value_type; - typedef typename Container::reference reference; - typedef typename Container::iterator iterator; - typedef typename Container::pointer pointer; + template + struct _ContainerConcept + { + typedef typename _Container::value_type _Value_type; + typedef typename _Container::difference_type _Difference_type; + typedef typename _Container::size_type _Size_type; + typedef typename _Container::const_reference _Const_reference; + typedef typename _Container::const_pointer _Const_pointer; + typedef typename _Container::const_iterator _Const_iterator; + + void __constraints() { + __function_requires< _InputIteratorConcept<_Const_iterator> >(); + __function_requires< _AssignableConcept<_Container> >(); + const _Container __c; + __i = __c.begin(); + __i = __c.end(); + __n = __c.size(); + __n = __c.max_size(); + __b = __c.empty(); + } + bool __b; + _Const_iterator __i; + _Size_type __n; + }; + + template + struct _Mutable_ContainerConcept + { + typedef typename _Container::value_type _Value_type; + typedef typename _Container::reference _Reference; + typedef typename _Container::iterator _Iterator; + typedef typename _Container::pointer _Pointer; - void constraints() { - function_requires< ContainerConcept >(); - function_requires< AssignableConcept >(); - function_requires< InputIteratorConcept >(); + void __constraints() { + __function_requires< _ContainerConcept<_Container> >(); + __function_requires< _AssignableConcept<_Value_type> >(); + __function_requires< _InputIteratorConcept<_Iterator> >(); - i = c.begin(); - i = c.end(); - c.swap(c2); + __i = __c.begin(); + __i = __c.end(); + __c.swap(__c2); } - iterator i; - Container c, c2; + _Iterator _i; + _Container __c, __c2; }; - template - struct ForwardContainerConcept + template + struct _ForwardContainerConcept { - void constraints() { - function_requires< ContainerConcept >(); - typedef typename ForwardContainer::const_iterator const_iterator; - function_requires< ForwardIteratorConcept >(); + void __constraints() { + __function_requires< _ContainerConcept<_ForwardContainer> >(); + typedef typename _ForwardContainer::const_iterator _Const_iterator; + __function_requires< _ForwardIteratorConcept<_Const_iterator> >(); } }; - template - struct Mutable_ForwardContainerConcept + template + struct _Mutable_ForwardContainerConcept { - void constraints() { - function_requires< ForwardContainerConcept >(); - function_requires< Mutable_ContainerConcept >(); - typedef typename ForwardContainer::iterator iterator; - function_requires< Mutable_ForwardIteratorConcept >(); + void __constraints() { + __function_requires< _ForwardContainerConcept<_ForwardContainer> >(); + __function_requires< _Mutable_ContainerConcept<_ForwardContainer> >(); + typedef typename _ForwardContainer::iterator _Iterator; + __function_requires< _Mutable_ForwardIteratorConcept<_Iterator> >(); } }; - template - struct ReversibleContainerConcept + template + struct _ReversibleContainerConcept { - typedef typename ReversibleContainer::const_iterator const_iterator; - typedef typename ReversibleContainer::const_reverse_iterator - const_reverse_iterator; + typedef typename _ReversibleContainer::const_iterator _Const_iterator; + typedef typename _ReversibleContainer::const_reverse_iterator + _Const_reverse_iterator; - void constraints() { - function_requires< ForwardContainerConcept >(); - function_requires< BidirectionalIteratorConcept >(); - function_requires< BidirectionalIteratorConcept >(); + void __constraints() { + __function_requires< _ForwardContainerConcept<_ReversibleContainer> >(); + __function_requires< _BidirectionalIteratorConcept<_Const_iterator> >(); + __function_requires< + _BidirectionalIteratorConcept<_Const_reverse_iterator> >(); - const ReversibleContainer c; - const_reverse_iterator i = c.rbegin(); - i = c.rend(); + const _ReversibleContainer __c; + _Const_reverse_iterator __i = __c.rbegin(); + __i = __c.rend(); } }; - template - struct Mutable_ReversibleContainerConcept + template + struct _Mutable_ReversibleContainerConcept { - typedef typename ReversibleContainer::iterator iterator; - typedef typename ReversibleContainer::reverse_iterator reverse_iterator; + typedef typename _ReversibleContainer::iterator _Iterator; + typedef typename _ReversibleContainer::reverse_iterator _Reverse_iterator; - void constraints() { - function_requires< ReversibleContainerConcept >(); - function_requires< Mutable_ForwardContainerConcept >(); - function_requires< Mutable_BidirectionalIteratorConcept >(); - function_requires< Mutable_BidirectionalIteratorConcept >(); + void __constraints() { + __function_requires<_ReversibleContainerConcept<_ReversibleContainer> >(); + __function_requires< + _Mutable_ForwardContainerConcept<_ReversibleContainer> >(); + __function_requires<_Mutable_BidirectionalIteratorConcept<_Iterator> >(); + __function_requires< + _Mutable_BidirectionalIteratorConcept<_Reverse_iterator> >(); - reverse_iterator i = c.rbegin(); - i = c.rend(); + _Reverse_iterator __i = __c.rbegin(); + __i = __c.rend(); } - ReversibleContainer c; + _ReversibleContainer __c; }; - template - struct RandomAccessContainerConcept + template + struct _RandomAccessContainerConcept { - typedef typename RandomAccessContainer::size_type size_type; - typedef typename RandomAccessContainer::const_reference const_reference; - typedef typename RandomAccessContainer::const_iterator const_iterator; - typedef typename RandomAccessContainer::const_reverse_iterator - const_reverse_iterator; + typedef typename _RandomAccessContainer::size_type _Size_type; + typedef typename _RandomAccessContainer::const_reference _Const_reference; + typedef typename _RandomAccessContainer::const_iterator _Const_iterator; + typedef typename _RandomAccessContainer::const_reverse_iterator + _Const_reverse_iterator; - void constraints() { - function_requires< ReversibleContainerConcept >(); - function_requires< RandomAccessIteratorConcept >(); - function_requires< RandomAccessIteratorConcept >(); + void __constraints() { + __function_requires< + _ReversibleContainerConcept<_RandomAccessContainer> >(); + __function_requires< _RandomAccessIteratorConcept<_Const_iterator> >(); + __function_requires< + _RandomAccessIteratorConcept<_Const_reverse_iterator> >(); - const RandomAccessContainer c; - const_reference r = c[n]; - ignore_unused_variable_warning(r); + const _RandomAccessContainer __c; + _Const_reference __r _IsUnused = __c[__n]; } - size_type n; + _Size_type __n; }; - template - struct Mutable_RandomAccessContainerConcept + template + struct _Mutable_RandomAccessContainerConcept { - typedef typename RandomAccessContainer::size_type size_type; - typedef typename RandomAccessContainer::reference reference; - typedef typename RandomAccessContainer::iterator iterator; - typedef typename RandomAccessContainer::reverse_iterator reverse_iterator; + typedef typename _RandomAccessContainer::size_type _Size_type; + typedef typename _RandomAccessContainer::reference _Reference; + typedef typename _RandomAccessContainer::iterator _Iterator; + typedef typename _RandomAccessContainer::reverse_iterator _Reverse_iterator; - void constraints() { - function_requires< RandomAccessContainerConcept >(); - function_requires< Mutable_ReversibleContainerConcept >(); - function_requires< Mutable_RandomAccessIteratorConcept >(); - function_requires< Mutable_RandomAccessIteratorConcept >(); + void __constraints() { + __function_requires< + _RandomAccessContainerConcept<_RandomAccessContainer> >(); + __function_requires< + _Mutable_ReversibleContainerConcept<_RandomAccessContainer> >(); + __function_requires< _Mutable_RandomAccessIteratorConcept<_Iterator> >(); + __function_requires< + _Mutable_RandomAccessIteratorConcept<_Reverse_iterator> >(); - reference r = c[i]; - ignore_unused_variable_warning(r); + _Reference __r _IsUnused = __c[__i]; } - size_type i; - RandomAccessContainer c; + _Size_type __i; + _RandomAccessContainer __c; }; // A Sequence is inherently mutable - template - struct SequenceConcept + template + struct _SequenceConcept { + typedef typename _Sequence::reference _Reference; + typedef typename _Sequence::const_reference _Const_reference; - typedef typename Sequence::reference reference; - typedef typename Sequence::const_reference const_reference; - - void constraints() { + void __constraints() { // Matt Austern's book puts DefaultConstructible here, the C++ // standard places it in Container // function_requires< DefaultConstructible >(); - function_requires< Mutable_ForwardContainerConcept >(); - function_requires< DefaultConstructibleConcept >(); + __function_requires< _Mutable_ForwardContainerConcept<_Sequence> >(); + __function_requires< _DefaultConstructibleConcept<_Sequence> >(); - Sequence - c(n), - c2(n, t), - c3(first, last); + _Sequence + __c(__n) _IsUnused, + __c2(__n, __t) _IsUnused, + __c3(__first, __last) _IsUnused; - c.insert(p, t); - c.insert(p, n, t); - c.insert(p, first, last); + __c.insert(__p, __t); + __c.insert(__p, __n, __t); + __c.insert(__p, __first, __last); - c.erase(p); - c.erase(p, q); + __c.erase(__p); + __c.erase(__p, __q); - reference r = c.front(); + _Reference __r _IsUnused = __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); + __const_constraints(__c); } - void const_constraints(const Sequence& c) { - const_reference r = c.front(); - ignore_unused_variable_warning(r); + void __const_constraints(const _Sequence& __c) { + _Const_reference __r _IsUnused = __c.front(); } - typename Sequence::value_type t; - typename Sequence::size_type n; - typename Sequence::value_type* first, *last; - typename Sequence::iterator p, q; + typename _Sequence::value_type __t; + typename _Sequence::size_type __n; + typename _Sequence::value_type *__first, *__last; + typename _Sequence::iterator __p, __q; }; - template - struct FrontInsertionSequenceConcept + template + struct _FrontInsertionSequenceConcept { - void constraints() { - function_requires< SequenceConcept >(); + void __constraints() { + __function_requires< _SequenceConcept<_FrontInsertionSequence> >(); - c.push_front(t); - c.pop_front(); + __c.push_front(__t); + __c.pop_front(); } - FrontInsertionSequence c; - typename FrontInsertionSequence::value_type t; + _FrontInsertionSequence __c; + typename _FrontInsertionSequence::value_type __t; }; - template - struct BackInsertionSequenceConcept + template + struct _BackInsertionSequenceConcept { - typedef typename BackInsertionSequence::reference reference; - typedef typename BackInsertionSequence::const_reference const_reference; + typedef typename _BackInsertionSequence::reference _Reference; + typedef typename _BackInsertionSequence::const_reference _Const_reference; - void constraints() { - function_requires< SequenceConcept >(); + void __constraints() { + __function_requires< _SequenceConcept<_BackInsertionSequence> >(); - c.push_back(t); - c.pop_back(); - reference r = c.back(); - ignore_unused_variable_warning(r); + __c.push_back(__t); + __c.pop_back(); + _Reference __r _IsUnused = __c.back(); } - void const_constraints(const BackInsertionSequence& c) { - const_reference r = c.back(); - ignore_unused_variable_warning(r); + void __const_constraints(const _BackInsertionSequence& __c) { + _Const_reference __r _IsUnused = __c.back(); }; - BackInsertionSequence c; - typename BackInsertionSequence::value_type t; + _BackInsertionSequence __c; + typename _BackInsertionSequence::value_type __t; }; - template - struct AssociativeContainerConcept + template + struct _AssociativeContainerConcept { - void constraints() { - function_requires< ForwardContainerConcept >(); - function_requires< DefaultConstructibleConcept >(); + 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 r; - const_iterator ci; - std::pair cr; - typename AssociativeContainer::key_type k; - typename AssociativeContainer::size_type n; - }; - - template - struct UniqueAssociativeContainerConcept - { - void constraints() { - function_requires< AssociativeContainerConcept >(); + __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 + struct _UniqueAssociativeContainerConcept + { + void __constraints() { + __function_requires< + _AssociativeContainerConcept<_UniqueAssociativeContainer> >(); - UniqueAssociativeContainer c(first, last); + _UniqueAssociativeContainer __c(__first, __last); - pos_flag = c.insert(t); - c.insert(first, last); - - ignore_unused_variable_warning(c); + __pos_flag = __c.insert(__t); + __c.insert(__first, __last); } - std::pair pos_flag; - typename UniqueAssociativeContainer::value_type t; - typename UniqueAssociativeContainer::value_type* first, *last; + std::pair __pos_flag; + typename _UniqueAssociativeContainer::value_type __t; + typename _UniqueAssociativeContainer::value_type *__first, *__last; }; - template - struct MultipleAssociativeContainerConcept + template + struct _MultipleAssociativeContainerConcept { - void constraints() { - function_requires< AssociativeContainerConcept >(); + void __constraints() { + __function_requires< + _AssociativeContainerConcept<_MultipleAssociativeContainer> >(); - MultipleAssociativeContainer c(first, last); + _MultipleAssociativeContainer __c(__first, __last); - pos = c.insert(t); - c.insert(first, last); + __pos = __c.insert(__t); + __c.insert(__first, __last); - ignore_unused_variable_warning(c); - ignore_unused_variable_warning(pos); } - typename MultipleAssociativeContainer::iterator pos; - typename MultipleAssociativeContainer::value_type t; - typename MultipleAssociativeContainer::value_type* first, *last; + typename _MultipleAssociativeContainer::iterator __pos _IsUnused; + typename _MultipleAssociativeContainer::value_type __t; + typename _MultipleAssociativeContainer::value_type *__first, *__last; }; - template - struct SimpleAssociativeContainerConcept + template + struct _SimpleAssociativeContainerConcept { - void constraints() { - function_requires< AssociativeContainerConcept >(); - typedef typename SimpleAssociativeContainer::key_type key_type; - typedef typename SimpleAssociativeContainer::value_type value_type; - typedef typename require_same::type req; + 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 - struct PairAssociativeContainerConcept + template + struct _PairAssociativeContainerConcept { - void constraints() { - function_requires< AssociativeContainerConcept >(); - typedef typename SimpleAssociativeContainer::key_type key_type; - typedef typename SimpleAssociativeContainer::value_type value_type; - typedef typename SimpleAssociativeContainer::mapped_type mapped_type; - typedef std::pair required_value_type; - typedef typename require_same::type req; + 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 _Required_value_type; + typedef typename _Aux_require_same<_Value_type, + _Required_value_type>::_Type _Required; } }; - template - struct SortedAssociativeContainerConcept + template + struct _SortedAssociativeContainerConcept { - void constraints() { - function_requires< AssociativeContainerConcept >(); - function_requires< ReversibleContainerConcept >(); + void __constraints() { + __function_requires< + _AssociativeContainerConcept<_SortedAssociativeContainer> >(); + __function_requires< + _ReversibleContainerConcept<_SortedAssociativeContainer> >(); - SortedAssociativeContainer - c(kc), - c2(first, last), - c3(first, last, kc); + _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); + __p = __c.upper_bound(__k); + __p = __c.lower_bound(__k); + __r = __c.equal_range(__k); - c.insert(p, t); - - ignore_unused_variable_warning(c); - ignore_unused_variable_warning(c2); - ignore_unused_variable_warning(c3); - } - 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 r; - std::pair cr; - typename SortedAssociativeContainer::value_type* first, *last; + __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 boost +} // namespace __gnu_cxx + +#undef _IsUnused + +#endif // _GLIBCPP_BOOST_CONCEPT_CHECK -#endif // BOOST_CONCEPT_CHECKS_HPP diff --git a/libstdc++-v3/include/bits/concept_check.h b/libstdc++-v3/include/bits/concept_check.h index 28886a9eb0a..79cf29c8829 100644 --- a/libstdc++-v3/include/bits/concept_check.h +++ b/libstdc++-v3/include/bits/concept_check.h @@ -55,11 +55,11 @@ #if defined(_GLIBCPP_NO_CONCEPT_CHECKS) || defined(_STL_NO_CONCEPT_CHECKS) \ || defined(NDEBUG) -#define glibcpp_function_requires(...) -#define glibcpp_class_requires(a,b) -#define glibcpp_class_requires2(a,b,c) -#define glibcpp_class_requires3(a,b,c,d) -#define glibcpp_class_requires4(a,b,c,d,e) +#define __glibcpp_function_requires(...) +#define __glibcpp_class_requires(_a,_b) +#define __glibcpp_class_requires2(_a,_b,_c) +#define __glibcpp_class_requires3(_a,_b,_c,_d) +#define __glibcpp_class_requires4(_a,_b,_c,_d,_e) #else // the checks are on @@ -74,18 +74,18 @@ // BinaryPredicateConcept. The preprocessor tries to split things up on // the commas in the template argument list. We can't use an inner pair of // parenthesis to hide the commas, because "boost::(Temp)" isn't -// a valid instantiation pattern. - -#define glibcpp_function_requires(...) \ - boost::function_requires< boost::__VA_ARGS__ >() -#define glibcpp_class_requires(a,C) \ - BOOST_CLASS_REQUIRES(a, boost, C) -#define glibcpp_class_requires2(a,b,C) \ - BOOST_CLASS_REQUIRES2(a, b, boost, C) -#define glibcpp_class_requires3(a,b,c,C) \ - BOOST_CLASS_REQUIRES3(a, b, c, boost, C) -#define glibcpp_class_requires4(a,b,c,d,C) \ - BOOST_CLASS_REQUIRES4(a, b, c, d, boost, C) +// a valid instantiation pattern. Thus, we steal a feature from C99. + +#define __glibcpp_function_requires(...) \ + __gnu_cxx::__function_requires< __gnu_cxx::__VA_ARGS__ >() +#define __glibcpp_class_requires(_a,_C) \ + _GLIBCPP_CLASS_REQUIRES(_a, __gnu_cxx, _C) +#define __glibcpp_class_requires2(_a,_b,_C) \ + _GLIBCPP_CLASS_REQUIRES2(_a, _b, __gnu_cxx, _C) +#define __glibcpp_class_requires3(_a,_b,_c,_C) \ + _GLIBCPP_CLASS_REQUIRES3(_a, _b, _c, __gnu_cxx, _C) +#define __glibcpp_class_requires4(_a,_b,_c,_d,_C) \ + _GLIBCPP_CLASS_REQUIRES4(_a, _b, _c, _d, __gnu_cxx, _C) #endif // enable/disable diff --git a/libstdc++-v3/include/bits/stl_algo.h b/libstdc++-v3/include/bits/stl_algo.h index 929c4ff372f..721d9aae950 100644 --- a/libstdc++-v3/include/bits/stl_algo.h +++ b/libstdc++-v3/include/bits/stl_algo.h @@ -33,7 +33,7 @@ #include -// See concept_check.h for the glibcpp_*_requires macros. +// See concept_check.h for the __glibcpp_*_requires macros. namespace std { @@ -44,7 +44,7 @@ template inline const _Tp& __median(const _Tp& __a, const _Tp& __b, const _Tp& __c) { // concept requirements - glibcpp_function_requires(LessThanComparableConcept<_Tp>); + __glibcpp_function_requires(_LessThanComparableConcept<_Tp>); if (__a < __b) if (__b < __c) return __b; @@ -65,7 +65,7 @@ inline const _Tp& __median(const _Tp& __a, const _Tp& __b, const _Tp& __c, _Compare __comp) { // concept requirements - glibcpp_function_requires(BinaryFunctionConcept<_Compare, bool, _Tp, _Tp>); + __glibcpp_function_requires(_BinaryFunctionConcept<_Compare, bool, _Tp, _Tp>); if (__comp(__a, __b)) if (__comp(__b, __c)) return __b; @@ -86,7 +86,7 @@ template _Function for_each(_InputIter __first, _InputIter __last, _Function __f) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter>); + __glibcpp_function_requires(_InputIteratorConcept<_InputIter>); for ( ; __first != __last; ++__first) __f(*__first); return __f; @@ -195,8 +195,8 @@ inline _InputIter find(_InputIter __first, _InputIter __last, const _Tp& __val) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter>); - glibcpp_function_requires(EqualOpConcept< + __glibcpp_function_requires(_InputIteratorConcept<_InputIter>); + __glibcpp_function_requires(_EqualOpConcept< typename iterator_traits<_InputIter>::value_type, _Tp>); return find(__first, __last, __val, __iterator_category(__first)); } @@ -206,8 +206,8 @@ inline _InputIter find_if(_InputIter __first, _InputIter __last, _Predicate __pred) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter>); - glibcpp_function_requires(UnaryPredicateConcept<_Predicate, + __glibcpp_function_requires(_InputIteratorConcept<_InputIter>); + __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate, typename iterator_traits<_InputIter>::value_type>); return find_if(__first, __last, __pred, __iterator_category(__first)); } @@ -218,8 +218,8 @@ template _ForwardIter adjacent_find(_ForwardIter __first, _ForwardIter __last) { // concept requirements - glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>); - glibcpp_function_requires(EqualityComparableConcept< + __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>); + __glibcpp_function_requires(_EqualityComparableConcept< typename iterator_traits<_ForwardIter>::value_type>); if (__first == __last) return __last; @@ -237,8 +237,8 @@ _ForwardIter adjacent_find(_ForwardIter __first, _ForwardIter __last, _BinaryPredicate __binary_pred) { // concept requirements - glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>); - glibcpp_function_requires(BinaryPredicateConcept<_BinaryPredicate, + __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>); + __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPredicate, typename iterator_traits<_ForwardIter>::value_type, typename iterator_traits<_ForwardIter>::value_type>); if (__first == __last) @@ -263,10 +263,10 @@ void count(_InputIter __first, _InputIter __last, const _Tp& __value, _Size& __n) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter>); - glibcpp_function_requires(EqualityComparableConcept< + __glibcpp_function_requires(_InputIteratorConcept<_InputIter>); + __glibcpp_function_requires(_EqualityComparableConcept< typename iterator_traits<_InputIter>::value_type >); - glibcpp_function_requires(EqualityComparableConcept<_Tp>); + __glibcpp_function_requires(_EqualityComparableConcept<_Tp>); for ( ; __first != __last; ++__first) if (*__first == __value) ++__n; @@ -277,8 +277,8 @@ void count_if(_InputIter __first, _InputIter __last, _Predicate __pred, _Size& __n) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter>); - glibcpp_function_requires(UnaryPredicateConcept<_Predicate, + __glibcpp_function_requires(_InputIteratorConcept<_InputIter>); + __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate, typename iterator_traits<_InputIter>::value_type>); for ( ; __first != __last; ++__first) if (__pred(*__first)) @@ -290,10 +290,10 @@ typename iterator_traits<_InputIter>::difference_type count(_InputIter __first, _InputIter __last, const _Tp& __value) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter>); - glibcpp_function_requires(EqualityComparableConcept< + __glibcpp_function_requires(_InputIteratorConcept<_InputIter>); + __glibcpp_function_requires(_EqualityComparableConcept< typename iterator_traits<_InputIter>::value_type >); - glibcpp_function_requires(EqualityComparableConcept<_Tp>); + __glibcpp_function_requires(_EqualityComparableConcept<_Tp>); typename iterator_traits<_InputIter>::difference_type __n = 0; for ( ; __first != __last; ++__first) if (*__first == __value) @@ -306,8 +306,8 @@ typename iterator_traits<_InputIter>::difference_type count_if(_InputIter __first, _InputIter __last, _Predicate __pred) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter>); - glibcpp_function_requires(UnaryPredicateConcept<_Predicate, + __glibcpp_function_requires(_InputIteratorConcept<_InputIter>); + __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate, typename iterator_traits<_InputIter>::value_type>); typename iterator_traits<_InputIter>::difference_type __n = 0; for ( ; __first != __last; ++__first) @@ -324,9 +324,9 @@ _ForwardIter1 search(_ForwardIter1 __first1, _ForwardIter1 __last1, _ForwardIter2 __first2, _ForwardIter2 __last2) { // concept requirements - glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter1>); - glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter2>); - glibcpp_function_requires(EqualOpConcept< + __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter1>); + __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter2>); + __glibcpp_function_requires(_EqualOpConcept< typename iterator_traits<_ForwardIter1>::value_type, typename iterator_traits<_ForwardIter2>::value_type>); @@ -376,9 +376,9 @@ _ForwardIter1 search(_ForwardIter1 __first1, _ForwardIter1 __last1, _BinaryPred __predicate) { // concept requirements - glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter1>); - glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter2>); - glibcpp_function_requires(BinaryPredicateConcept<_BinaryPred, + __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter1>); + __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter2>); + __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPred, typename iterator_traits<_ForwardIter1>::value_type, typename iterator_traits<_ForwardIter2>::value_type>); @@ -437,10 +437,10 @@ _ForwardIter search_n(_ForwardIter __first, _ForwardIter __last, _Integer __count, const _Tp& __val) { // concept requirements - glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>); - glibcpp_function_requires(EqualityComparableConcept< + __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>); + __glibcpp_function_requires(_EqualityComparableConcept< typename iterator_traits<_ForwardIter>::value_type>); - glibcpp_function_requires(EqualityComparableConcept<_Tp>); + __glibcpp_function_requires(_EqualityComparableConcept<_Tp>); if (__count <= 0) return __first; @@ -469,8 +469,8 @@ _ForwardIter search_n(_ForwardIter __first, _ForwardIter __last, _BinaryPred __binary_pred) { // concept requirements - glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>); - glibcpp_function_requires(BinaryPredicateConcept<_BinaryPred, + __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>); + __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPred, typename iterator_traits<_ForwardIter>::value_type, _Tp>); if (__count <= 0) @@ -511,12 +511,12 @@ _ForwardIter2 swap_ranges(_ForwardIter1 __first1, _ForwardIter1 __last1, _ForwardIter2 __first2) { // concept requirements - glibcpp_function_requires(Mutable_ForwardIteratorConcept<_ForwardIter1>); - glibcpp_function_requires(Mutable_ForwardIteratorConcept<_ForwardIter2>); - glibcpp_function_requires(ConvertibleConcept< + __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter1>); + __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter2>); + __glibcpp_function_requires(_ConvertibleConcept< typename iterator_traits<_ForwardIter1>::value_type, typename iterator_traits<_ForwardIter2>::value_type>); - glibcpp_function_requires(ConvertibleConcept< + __glibcpp_function_requires(_ConvertibleConcept< typename iterator_traits<_ForwardIter2>::value_type, typename iterator_traits<_ForwardIter1>::value_type>); @@ -532,8 +532,8 @@ _OutputIter transform(_InputIter __first, _InputIter __last, _OutputIter __result, _UnaryOperation __unary_op) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter>); - glibcpp_function_requires(OutputIteratorConcept<_OutputIter, + __glibcpp_function_requires(_InputIteratorConcept<_InputIter>); + __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter, typename iterator_traits<_InputIter>::value_type>); for ( ; __first != __last; ++__first, ++__result) @@ -548,10 +548,10 @@ _OutputIter transform(_InputIter1 __first1, _InputIter1 __last1, _BinaryOperation __binary_op) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter1>); - glibcpp_function_requires(InputIteratorConcept<_InputIter2>); - glibcpp_function_requires(OutputIteratorConcept<_OutputIter, - // XXX really should be "the type returned by _BinaryOperation + __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>); + __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>); + __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter, + // XXX really should be "the type returned by _BinaryOperation" typename iterator_traits<_InputIter1>::value_type>); for ( ; __first1 != __last1; ++__first1, ++__first2, ++__result) @@ -566,10 +566,10 @@ void replace(_ForwardIter __first, _ForwardIter __last, const _Tp& __old_value, const _Tp& __new_value) { // concept requirements - glibcpp_function_requires(Mutable_ForwardIteratorConcept<_ForwardIter>); - glibcpp_function_requires(EqualOpConcept< + __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>); + __glibcpp_function_requires(_EqualOpConcept< typename iterator_traits<_ForwardIter>::value_type, _Tp>); - glibcpp_function_requires(ConvertibleConcept<_Tp, + __glibcpp_function_requires(_ConvertibleConcept<_Tp, typename iterator_traits<_ForwardIter>::value_type>); for ( ; __first != __last; ++__first) @@ -582,10 +582,10 @@ void replace_if(_ForwardIter __first, _ForwardIter __last, _Predicate __pred, const _Tp& __new_value) { // concept requirements - glibcpp_function_requires(Mutable_ForwardIteratorConcept<_ForwardIter>); - glibcpp_function_requires(ConvertibleConcept<_Tp, + __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>); + __glibcpp_function_requires(_ConvertibleConcept<_Tp, typename iterator_traits<_ForwardIter>::value_type>); - glibcpp_function_requires(UnaryPredicateConcept<_Predicate, + __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate, typename iterator_traits<_ForwardIter>::value_type>); for ( ; __first != __last; ++__first) @@ -599,10 +599,10 @@ _OutputIter replace_copy(_InputIter __first, _InputIter __last, const _Tp& __old_value, const _Tp& __new_value) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter>); - glibcpp_function_requires(OutputIteratorConcept<_OutputIter, + __glibcpp_function_requires(_InputIteratorConcept<_InputIter>); + __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter, typename iterator_traits<_InputIter>::value_type>); - glibcpp_function_requires(EqualOpConcept< + __glibcpp_function_requires(_EqualOpConcept< typename iterator_traits<_InputIter>::value_type, _Tp>); for ( ; __first != __last; ++__first, ++__result) @@ -616,10 +616,10 @@ _OutputIter replace_copy_if(_InputIter __first, _InputIter __last, _Predicate __pred, const _Tp& __new_value) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter>); - glibcpp_function_requires(OutputIteratorConcept<_OutputIter, + __glibcpp_function_requires(_InputIteratorConcept<_InputIter>); + __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter, typename iterator_traits<_InputIter>::value_type>); - glibcpp_function_requires(UnaryPredicateConcept<_Predicate, + __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate, typename iterator_traits<_InputIter>::value_type>); for ( ; __first != __last; ++__first, ++__result) @@ -633,8 +633,8 @@ template void generate(_ForwardIter __first, _ForwardIter __last, _Generator __gen) { // concept requirements - glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>); - glibcpp_function_requires(GeneratorConcept<_Generator, + __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>); + __glibcpp_function_requires(_GeneratorConcept<_Generator, typename iterator_traits<_ForwardIter>::value_type>); for ( ; __first != __last; ++__first) @@ -646,7 +646,7 @@ _OutputIter generate_n(_OutputIter __first, _Size __n, _Generator __gen) { /* // XXX concept requirements - glibcpp_function_requires(OutputIteratorConcept<_OutputIter, + __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter, "the return type of _Generator" ?? >); */ @@ -662,10 +662,10 @@ _OutputIter remove_copy(_InputIter __first, _InputIter __last, _OutputIter __result, const _Tp& __value) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter>); - glibcpp_function_requires(OutputIteratorConcept<_OutputIter, + __glibcpp_function_requires(_InputIteratorConcept<_InputIter>); + __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter, typename iterator_traits<_InputIter>::value_type>); - glibcpp_function_requires(EqualOpConcept< + __glibcpp_function_requires(_EqualOpConcept< typename iterator_traits<_InputIter>::value_type, _Tp>); for ( ; __first != __last; ++__first) @@ -681,10 +681,10 @@ _OutputIter remove_copy_if(_InputIter __first, _InputIter __last, _OutputIter __result, _Predicate __pred) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter>); - glibcpp_function_requires(OutputIteratorConcept<_OutputIter, + __glibcpp_function_requires(_InputIteratorConcept<_InputIter>); + __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter, typename iterator_traits<_InputIter>::value_type>); - glibcpp_function_requires(UnaryPredicateConcept<_Predicate, + __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate, typename iterator_traits<_InputIter>::value_type>); for ( ; __first != __last; ++__first) @@ -700,10 +700,10 @@ _ForwardIter remove(_ForwardIter __first, _ForwardIter __last, const _Tp& __value) { // concept requirements - glibcpp_function_requires(Mutable_ForwardIteratorConcept<_ForwardIter>); - glibcpp_function_requires(ConvertibleConcept<_Tp, + __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>); + __glibcpp_function_requires(_ConvertibleConcept<_Tp, typename iterator_traits<_ForwardIter>::value_type>); - glibcpp_function_requires(EqualOpConcept< + __glibcpp_function_requires(_EqualOpConcept< typename iterator_traits<_ForwardIter>::value_type, _Tp>); __first = find(__first, __last, __value); @@ -717,8 +717,8 @@ _ForwardIter remove_if(_ForwardIter __first, _ForwardIter __last, _Predicate __pred) { // concept requirements - glibcpp_function_requires(Mutable_ForwardIteratorConcept<_ForwardIter>); - glibcpp_function_requires(UnaryPredicateConcept<_Predicate, + __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>); + __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate, typename iterator_traits<_ForwardIter>::value_type>); __first = find_if(__first, __last, __pred); @@ -770,10 +770,10 @@ inline _OutputIter unique_copy(_InputIter __first, _InputIter __last, _OutputIter __result) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter>); - glibcpp_function_requires(OutputIteratorConcept<_OutputIter, + __glibcpp_function_requires(_InputIteratorConcept<_InputIter>); + __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter, typename iterator_traits<_InputIter>::value_type>); - glibcpp_function_requires(EqualityComparableConcept< + __glibcpp_function_requires(_EqualityComparableConcept< typename iterator_traits<_InputIter>::value_type>); if (__first == __last) return __result; @@ -788,7 +788,7 @@ _OutputIter __unique_copy(_InputIter __first, _InputIter __last, _BinaryPredicate __binary_pred, _Tp*) { // concept requirements -- iterators already checked - glibcpp_function_requires(BinaryPredicateConcept<_BinaryPredicate, _Tp, _Tp>); + __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPredicate, _Tp, _Tp>); _Tp __value = *__first; *__result = __value; @@ -818,7 +818,7 @@ _ForwardIter __unique_copy(_InputIter __first, _InputIter __last, forward_iterator_tag) { // concept requirements -- iterators already checked - glibcpp_function_requires(BinaryPredicateConcept<_BinaryPredicate, + __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPredicate, typename iterator_traits<_ForwardIter>::value_type, typename iterator_traits<_InputIter>::value_type>); @@ -834,8 +834,8 @@ inline _OutputIter unique_copy(_InputIter __first, _InputIter __last, _BinaryPredicate __binary_pred) { // concept requirements -- predicates checked later - glibcpp_function_requires(InputIteratorConcept<_InputIter>); - glibcpp_function_requires(OutputIteratorConcept<_OutputIter, + __glibcpp_function_requires(_InputIteratorConcept<_InputIter>); + __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter, typename iterator_traits<_InputIter>::value_type>); if (__first == __last) return __result; @@ -847,8 +847,8 @@ template _ForwardIter unique(_ForwardIter __first, _ForwardIter __last) { // concept requirements - glibcpp_function_requires(Mutable_ForwardIteratorConcept<_ForwardIter>); - glibcpp_function_requires(EqualityComparableConcept< + __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>); + __glibcpp_function_requires(_EqualityComparableConcept< typename iterator_traits<_ForwardIter>::value_type>); __first = adjacent_find(__first, __last); @@ -860,8 +860,8 @@ _ForwardIter unique(_ForwardIter __first, _ForwardIter __last, _BinaryPredicate __binary_pred) { // concept requirements - glibcpp_function_requires(Mutable_ForwardIteratorConcept<_ForwardIter>); - glibcpp_function_requires(BinaryPredicateConcept<_BinaryPredicate, + __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>); + __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPredicate, typename iterator_traits<_ForwardIter>::value_type, typename iterator_traits<_ForwardIter>::value_type>); @@ -892,7 +892,7 @@ template inline void reverse(_BidirectionalIter __first, _BidirectionalIter __last) { // concept requirements - glibcpp_function_requires(Mutable_BidirectionalIteratorConcept< + __glibcpp_function_requires(_Mutable_BidirectionalIteratorConcept< _BidirectionalIter>); __reverse(__first, __last, __iterator_category(__first)); } @@ -903,8 +903,8 @@ _OutputIter reverse_copy(_BidirectionalIter __first, _OutputIter __result) { // concept requirements - glibcpp_function_requires(BidirectionalIteratorConcept<_BidirectionalIter>); - glibcpp_function_requires(OutputIteratorConcept<_OutputIter, + __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter>); + __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter, typename iterator_traits<_BidirectionalIter>::value_type>); while (__first != __last) { @@ -972,7 +972,7 @@ _BidirectionalIter __rotate(_BidirectionalIter __first, bidirectional_iterator_tag) { // concept requirements - glibcpp_function_requires(Mutable_BidirectionalIteratorConcept< + __glibcpp_function_requires(_Mutable_BidirectionalIteratorConcept< _BidirectionalIter>); if (__first == __middle) @@ -1003,7 +1003,7 @@ _RandomAccessIter __rotate(_RandomAccessIter __first, _Distance *, _Tp *) { // concept requirements - glibcpp_function_requires(Mutable_RandomAccessIteratorConcept< + __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept< _RandomAccessIter>); _Distance __n = __last - __first; @@ -1061,7 +1061,7 @@ inline _ForwardIter rotate(_ForwardIter __first, _ForwardIter __middle, _ForwardIter __last) { // concept requirements - glibcpp_function_requires(Mutable_ForwardIteratorConcept<_ForwardIter>); + __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>); return __rotate(__first, __middle, __last, __distance_type(__first), @@ -1073,8 +1073,8 @@ _OutputIter rotate_copy(_ForwardIter __first, _ForwardIter __middle, _ForwardIter __last, _OutputIter __result) { // concept requirements - glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>); - glibcpp_function_requires(OutputIteratorConcept<_OutputIter, + __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>); + __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter, typename iterator_traits<_ForwardIter>::value_type>); return copy(__first, __middle, copy(__middle, __last, __result)); @@ -1100,7 +1100,7 @@ inline void random_shuffle(_RandomAccessIter __first, _RandomAccessIter __last) { // concept requirements - glibcpp_function_requires(Mutable_RandomAccessIteratorConcept< + __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept< _RandomAccessIter>); if (__first == __last) return; @@ -1113,7 +1113,7 @@ void random_shuffle(_RandomAccessIter __first, _RandomAccessIter __last, _RandomNumberGenerator& __rand) { // concept requirements - glibcpp_function_requires(Mutable_RandomAccessIteratorConcept< + __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept< _RandomAccessIter>); if (__first == __last) return; @@ -1128,8 +1128,8 @@ _OutputIter random_sample_n(_ForwardIter __first, _ForwardIter __last, _OutputIter __out, const _Distance __n) { // concept requirements - glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>); - glibcpp_function_requires(OutputIteratorConcept<_OutputIter, + __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>); + __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter, typename iterator_traits<_ForwardIter>::value_type>); _Distance __remaining = 0; @@ -1156,10 +1156,10 @@ _OutputIter random_sample_n(_ForwardIter __first, _ForwardIter __last, _RandomNumberGenerator& __rand) { // concept requirements - glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>); - glibcpp_function_requires(OutputIteratorConcept<_OutputIter, + __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>); + __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter, typename iterator_traits<_ForwardIter>::value_type>); - glibcpp_function_requires(UnaryFunctionConcept< + __glibcpp_function_requires(_UnaryFunctionConcept< _RandomNumberGenerator, _Distance, _Distance>); _Distance __remaining = 0; @@ -1208,7 +1208,7 @@ _RandomAccessIter __random_sample(_InputIter __first, _InputIter __last, const _Distance __n) { // concept requirements - glibcpp_function_requires(UnaryFunctionConcept< + __glibcpp_function_requires(_UnaryFunctionConcept< _RandomNumberGenerator, _Distance, _Distance>); _Distance __m = 0; @@ -1233,8 +1233,8 @@ random_sample(_InputIter __first, _InputIter __last, _RandomAccessIter __out_first, _RandomAccessIter __out_last) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter>); - glibcpp_function_requires(Mutable_RandomAccessIteratorConcept< + __glibcpp_function_requires(_InputIteratorConcept<_InputIter>); + __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept< _RandomAccessIter>); return __random_sample(__first, __last, @@ -1250,8 +1250,8 @@ random_sample(_InputIter __first, _InputIter __last, _RandomNumberGenerator& __rand) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter>); - glibcpp_function_requires(Mutable_RandomAccessIteratorConcept< + __glibcpp_function_requires(_InputIteratorConcept<_InputIter>); + __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept< _RandomAccessIter>); return __random_sample(__first, __last, @@ -1316,8 +1316,8 @@ inline _ForwardIter partition(_ForwardIter __first, _Predicate __pred) { // concept requirements - glibcpp_function_requires(Mutable_ForwardIteratorConcept<_ForwardIter>); - glibcpp_function_requires(UnaryPredicateConcept<_Predicate, + __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>); + __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate, typename iterator_traits<_ForwardIter>::value_type>); return __partition(__first, __last, __pred, __iterator_category(__first)); @@ -1397,8 +1397,8 @@ inline _ForwardIter stable_partition(_ForwardIter __first, _Predicate __pred) { // concept requirements - glibcpp_function_requires(Mutable_ForwardIteratorConcept<_ForwardIter>); - glibcpp_function_requires(UnaryPredicateConcept<_Predicate, + __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>); + __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate, typename iterator_traits<_ForwardIter>::value_type>); if (__first == __last) @@ -1630,9 +1630,9 @@ template inline void sort(_RandomAccessIter __first, _RandomAccessIter __last) { // concept requirements - glibcpp_function_requires(Mutable_RandomAccessIteratorConcept< + __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept< _RandomAccessIter>); - glibcpp_function_requires(LessThanComparableConcept< + __glibcpp_function_requires(_LessThanComparableConcept< typename iterator_traits<_RandomAccessIter>::value_type>); if (__first != __last) { @@ -1648,9 +1648,9 @@ inline void sort(_RandomAccessIter __first, _RandomAccessIter __last, _Compare __comp) { // concept requirements - glibcpp_function_requires(Mutable_RandomAccessIteratorConcept< + __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept< _RandomAccessIter>); - glibcpp_function_requires(BinaryPredicateConcept<_Compare, + __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, typename iterator_traits<_RandomAccessIter>::value_type, typename iterator_traits<_RandomAccessIter>::value_type>); @@ -1881,9 +1881,9 @@ inline void stable_sort(_RandomAccessIter __first, _RandomAccessIter __last) { // concept requirements - glibcpp_function_requires(Mutable_RandomAccessIteratorConcept< + __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept< _RandomAccessIter>); - glibcpp_function_requires(LessThanComparableConcept< + __glibcpp_function_requires(_LessThanComparableConcept< typename iterator_traits<_RandomAccessIter>::value_type>); __stable_sort_aux(__first, __last, @@ -1896,9 +1896,9 @@ inline void stable_sort(_RandomAccessIter __first, _RandomAccessIter __last, _Compare __comp) { // concept requirements - glibcpp_function_requires(Mutable_RandomAccessIteratorConcept< + __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept< _RandomAccessIter>); - glibcpp_function_requires(BinaryPredicateConcept<_Compare, + __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, typename iterator_traits<_RandomAccessIter>::value_type, typename iterator_traits<_RandomAccessIter>::value_type>); @@ -1928,9 +1928,9 @@ inline void partial_sort(_RandomAccessIter __first, _RandomAccessIter __last) { // concept requirements - glibcpp_function_requires(Mutable_RandomAccessIteratorConcept< + __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept< _RandomAccessIter>); - glibcpp_function_requires(LessThanComparableConcept< + __glibcpp_function_requires(_LessThanComparableConcept< typename iterator_traits<_RandomAccessIter>::value_type>); __partial_sort(__first, __middle, __last, __value_type(__first)); @@ -1954,9 +1954,9 @@ inline void partial_sort(_RandomAccessIter __first, _RandomAccessIter __last, _Compare __comp) { // concept requirements - glibcpp_function_requires(Mutable_RandomAccessIteratorConcept< + __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept< _RandomAccessIter>); - glibcpp_function_requires(BinaryPredicateConcept<_Compare, + __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, typename iterator_traits<_RandomAccessIter>::value_type, typename iterator_traits<_RandomAccessIter>::value_type>); @@ -1997,13 +1997,13 @@ partial_sort_copy(_InputIter __first, _InputIter __last, _RandomAccessIter __result_last) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter>); - glibcpp_function_requires(ConvertibleConcept< + __glibcpp_function_requires(_InputIteratorConcept<_InputIter>); + __glibcpp_function_requires(_ConvertibleConcept< typename iterator_traits<_InputIter>::value_type, typename iterator_traits<_RandomAccessIter>::value_type>); - glibcpp_function_requires(LessThanComparableConcept< + __glibcpp_function_requires(_LessThanComparableConcept< typename iterator_traits<_RandomAccessIter>::value_type>); - glibcpp_function_requires(LessThanComparableConcept< + __glibcpp_function_requires(_LessThanComparableConcept< typename iterator_traits<_InputIter>::value_type>); return __partial_sort_copy(__first, __last, __result_first, __result_last, @@ -2046,13 +2046,13 @@ partial_sort_copy(_InputIter __first, _InputIter __last, _RandomAccessIter __result_last, _Compare __comp) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter>); - glibcpp_function_requires(Mutable_RandomAccessIteratorConcept< + __glibcpp_function_requires(_InputIteratorConcept<_InputIter>); + __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept< _RandomAccessIter>); - glibcpp_function_requires(ConvertibleConcept< + __glibcpp_function_requires(_ConvertibleConcept< typename iterator_traits<_InputIter>::value_type, typename iterator_traits<_RandomAccessIter>::value_type>); - glibcpp_function_requires(BinaryPredicateConcept<_Compare, + __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, typename iterator_traits<_RandomAccessIter>::value_type, typename iterator_traits<_RandomAccessIter>::value_type>); @@ -2087,9 +2087,9 @@ inline void nth_element(_RandomAccessIter __first, _RandomAccessIter __nth, _RandomAccessIter __last) { // concept requirements - glibcpp_function_requires(Mutable_RandomAccessIteratorConcept< + __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept< _RandomAccessIter>); - glibcpp_function_requires(LessThanComparableConcept< + __glibcpp_function_requires(_LessThanComparableConcept< typename iterator_traits<_RandomAccessIter>::value_type>); __nth_element(__first, __nth, __last, __value_type(__first)); @@ -2120,9 +2120,9 @@ inline void nth_element(_RandomAccessIter __first, _RandomAccessIter __nth, _RandomAccessIter __last, _Compare __comp) { // concept requirements - glibcpp_function_requires(Mutable_RandomAccessIteratorConcept< + __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept< _RandomAccessIter>); - glibcpp_function_requires(BinaryPredicateConcept<_Compare, + __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, typename iterator_traits<_RandomAccessIter>::value_type, typename iterator_traits<_RandomAccessIter>::value_type>); @@ -2161,10 +2161,10 @@ inline _ForwardIter lower_bound(_ForwardIter __first, _ForwardIter __last, const _Tp& __val) { // concept requirements - glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>); - glibcpp_function_requires(SameTypeConcept<_Tp, + __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>); + __glibcpp_function_requires(_SameTypeConcept<_Tp, typename iterator_traits<_ForwardIter>::value_type>); - glibcpp_function_requires(LessThanComparableConcept<_Tp>); + __glibcpp_function_requires(_LessThanComparableConcept<_Tp>); return __lower_bound(__first, __last, __val, __distance_type(__first)); @@ -2199,10 +2199,10 @@ inline _ForwardIter lower_bound(_ForwardIter __first, _ForwardIter __last, const _Tp& __val, _Compare __comp) { // concept requirements - glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>); - glibcpp_function_requires(SameTypeConcept<_Tp, + __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>); + __glibcpp_function_requires(_SameTypeConcept<_Tp, typename iterator_traits<_ForwardIter>::value_type>); - glibcpp_function_requires(BinaryPredicateConcept<_Compare, _Tp, _Tp>); + __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, _Tp, _Tp>); return __lower_bound(__first, __last, __val, __comp, __distance_type(__first)); @@ -2237,10 +2237,10 @@ inline _ForwardIter upper_bound(_ForwardIter __first, _ForwardIter __last, const _Tp& __val) { // concept requirements - glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>); - glibcpp_function_requires(SameTypeConcept<_Tp, + __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>); + __glibcpp_function_requires(_SameTypeConcept<_Tp, typename iterator_traits<_ForwardIter>::value_type>); - glibcpp_function_requires(LessThanComparableConcept<_Tp>); + __glibcpp_function_requires(_LessThanComparableConcept<_Tp>); return __upper_bound(__first, __last, __val, __distance_type(__first)); @@ -2275,10 +2275,10 @@ inline _ForwardIter upper_bound(_ForwardIter __first, _ForwardIter __last, const _Tp& __val, _Compare __comp) { // concept requirements - glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>); - glibcpp_function_requires(SameTypeConcept<_Tp, + __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>); + __glibcpp_function_requires(_SameTypeConcept<_Tp, typename iterator_traits<_ForwardIter>::value_type>); - glibcpp_function_requires(BinaryPredicateConcept<_Compare, _Tp, _Tp>); + __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, _Tp, _Tp>); return __upper_bound(__first, __last, __val, __comp, __distance_type(__first)); @@ -2320,10 +2320,10 @@ inline pair<_ForwardIter, _ForwardIter> equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val) { // concept requirements - glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>); - glibcpp_function_requires(SameTypeConcept<_Tp, + __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>); + __glibcpp_function_requires(_SameTypeConcept<_Tp, typename iterator_traits<_ForwardIter>::value_type>); - glibcpp_function_requires(LessThanComparableConcept<_Tp>); + __glibcpp_function_requires(_LessThanComparableConcept<_Tp>); return __equal_range(__first, __last, __val, __distance_type(__first)); @@ -2366,10 +2366,10 @@ equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val, _Compare __comp) { // concept requirements - glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>); - glibcpp_function_requires(SameTypeConcept<_Tp, + __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>); + __glibcpp_function_requires(_SameTypeConcept<_Tp, typename iterator_traits<_ForwardIter>::value_type>); - glibcpp_function_requires(BinaryPredicateConcept<_Compare, _Tp, _Tp>); + __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, _Tp, _Tp>); return __equal_range(__first, __last, __val, __comp, __distance_type(__first)); @@ -2380,10 +2380,10 @@ bool binary_search(_ForwardIter __first, _ForwardIter __last, const _Tp& __val) { // concept requirements - glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>); - glibcpp_function_requires(SameTypeConcept<_Tp, + __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>); + __glibcpp_function_requires(_SameTypeConcept<_Tp, typename iterator_traits<_ForwardIter>::value_type>); - glibcpp_function_requires(LessThanComparableConcept<_Tp>); + __glibcpp_function_requires(_LessThanComparableConcept<_Tp>); _ForwardIter __i = lower_bound(__first, __last, __val); return __i != __last && !(__val < *__i); @@ -2395,10 +2395,10 @@ bool binary_search(_ForwardIter __first, _ForwardIter __last, _Compare __comp) { // concept requirements - glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>); - glibcpp_function_requires(SameTypeConcept<_Tp, + __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>); + __glibcpp_function_requires(_SameTypeConcept<_Tp, typename iterator_traits<_ForwardIter>::value_type>); - glibcpp_function_requires(BinaryPredicateConcept<_Compare, _Tp, _Tp>); + __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, _Tp, _Tp>); _ForwardIter __i = lower_bound(__first, __last, __val, __comp); return __i != __last && !__comp(__val, *__i); @@ -2412,14 +2412,14 @@ _OutputIter merge(_InputIter1 __first1, _InputIter1 __last1, _OutputIter __result) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter1>); - glibcpp_function_requires(InputIteratorConcept<_InputIter2>); - glibcpp_function_requires(OutputIteratorConcept<_OutputIter, + __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>); + __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>); + __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter, typename iterator_traits<_InputIter1>::value_type>); - glibcpp_function_requires(SameTypeConcept< + __glibcpp_function_requires(_SameTypeConcept< typename iterator_traits<_InputIter1>::value_type, typename iterator_traits<_InputIter2>::value_type>); - glibcpp_function_requires(LessThanComparableConcept< + __glibcpp_function_requires(_LessThanComparableConcept< typename iterator_traits<_InputIter1>::value_type>); while (__first1 != __last1 && __first2 != __last2) { @@ -2443,14 +2443,14 @@ _OutputIter merge(_InputIter1 __first1, _InputIter1 __last1, _OutputIter __result, _Compare __comp) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter1>); - glibcpp_function_requires(InputIteratorConcept<_InputIter2>); - glibcpp_function_requires(SameTypeConcept< + __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>); + __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>); + __glibcpp_function_requires(_SameTypeConcept< typename iterator_traits<_InputIter1>::value_type, typename iterator_traits<_InputIter2>::value_type>); - glibcpp_function_requires(OutputIteratorConcept<_OutputIter, + __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter, typename iterator_traits<_InputIter1>::value_type>); - glibcpp_function_requires(BinaryPredicateConcept<_Compare, + __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, typename iterator_traits<_InputIter1>::value_type, typename iterator_traits<_InputIter2>::value_type>); @@ -2762,9 +2762,9 @@ inline void inplace_merge(_BidirectionalIter __first, _BidirectionalIter __last) { // concept requirements - glibcpp_function_requires(Mutable_BidirectionalIteratorConcept< + __glibcpp_function_requires(_Mutable_BidirectionalIteratorConcept< _BidirectionalIter>); - glibcpp_function_requires(LessThanComparableConcept< + __glibcpp_function_requires(_LessThanComparableConcept< typename iterator_traits<_BidirectionalIter>::value_type>); if (__first == __middle || __middle == __last) @@ -2779,9 +2779,9 @@ inline void inplace_merge(_BidirectionalIter __first, _BidirectionalIter __last, _Compare __comp) { // concept requirements - glibcpp_function_requires(Mutable_BidirectionalIteratorConcept< + __glibcpp_function_requires(_Mutable_BidirectionalIteratorConcept< _BidirectionalIter>); - glibcpp_function_requires(BinaryPredicateConcept<_Compare, + __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, typename iterator_traits<_BidirectionalIter>::value_type, typename iterator_traits<_BidirectionalIter>::value_type>); @@ -2802,12 +2802,12 @@ bool includes(_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter1>); - glibcpp_function_requires(InputIteratorConcept<_InputIter2>); - glibcpp_function_requires(SameTypeConcept< + __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>); + __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>); + __glibcpp_function_requires(_SameTypeConcept< typename iterator_traits<_InputIter1>::value_type, typename iterator_traits<_InputIter2>::value_type>); - glibcpp_function_requires(LessThanComparableConcept< + __glibcpp_function_requires(_LessThanComparableConcept< typename iterator_traits<_InputIter1>::value_type>); while (__first1 != __last1 && __first2 != __last2) @@ -2826,12 +2826,12 @@ bool includes(_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2, _Compare __comp) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter1>); - glibcpp_function_requires(InputIteratorConcept<_InputIter2>); - glibcpp_function_requires(SameTypeConcept< + __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>); + __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>); + __glibcpp_function_requires(_SameTypeConcept< typename iterator_traits<_InputIter1>::value_type, typename iterator_traits<_InputIter2>::value_type>); - glibcpp_function_requires(BinaryPredicateConcept<_Compare, + __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, typename iterator_traits<_InputIter1>::value_type, typename iterator_traits<_InputIter2>::value_type>); @@ -2852,14 +2852,14 @@ _OutputIter set_union(_InputIter1 __first1, _InputIter1 __last1, _OutputIter __result) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter1>); - glibcpp_function_requires(InputIteratorConcept<_InputIter2>); - glibcpp_function_requires(OutputIteratorConcept<_OutputIter, + __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>); + __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>); + __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter, typename iterator_traits<_InputIter1>::value_type>); - glibcpp_function_requires(SameTypeConcept< + __glibcpp_function_requires(_SameTypeConcept< typename iterator_traits<_InputIter1>::value_type, typename iterator_traits<_InputIter2>::value_type>); - glibcpp_function_requires(LessThanComparableConcept< + __glibcpp_function_requires(_LessThanComparableConcept< typename iterator_traits<_InputIter1>::value_type>); while (__first1 != __last1 && __first2 != __last2) { @@ -2888,14 +2888,14 @@ _OutputIter set_union(_InputIter1 __first1, _InputIter1 __last1, _OutputIter __result, _Compare __comp) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter1>); - glibcpp_function_requires(InputIteratorConcept<_InputIter2>); - glibcpp_function_requires(SameTypeConcept< + __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>); + __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>); + __glibcpp_function_requires(_SameTypeConcept< typename iterator_traits<_InputIter1>::value_type, typename iterator_traits<_InputIter2>::value_type>); - glibcpp_function_requires(OutputIteratorConcept<_OutputIter, + __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter, typename iterator_traits<_InputIter1>::value_type>); - glibcpp_function_requires(BinaryPredicateConcept<_Compare, + __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, typename iterator_traits<_InputIter1>::value_type, typename iterator_traits<_InputIter2>::value_type>); @@ -2924,14 +2924,14 @@ _OutputIter set_intersection(_InputIter1 __first1, _InputIter1 __last1, _OutputIter __result) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter1>); - glibcpp_function_requires(InputIteratorConcept<_InputIter2>); - glibcpp_function_requires(OutputIteratorConcept<_OutputIter, + __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>); + __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>); + __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter, typename iterator_traits<_InputIter1>::value_type>); - glibcpp_function_requires(SameTypeConcept< + __glibcpp_function_requires(_SameTypeConcept< typename iterator_traits<_InputIter1>::value_type, typename iterator_traits<_InputIter2>::value_type>); - glibcpp_function_requires(LessThanComparableConcept< + __glibcpp_function_requires(_LessThanComparableConcept< typename iterator_traits<_InputIter1>::value_type>); while (__first1 != __last1 && __first2 != __last2) @@ -2955,14 +2955,14 @@ _OutputIter set_intersection(_InputIter1 __first1, _InputIter1 __last1, _OutputIter __result, _Compare __comp) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter1>); - glibcpp_function_requires(InputIteratorConcept<_InputIter2>); - glibcpp_function_requires(SameTypeConcept< + __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>); + __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>); + __glibcpp_function_requires(_SameTypeConcept< typename iterator_traits<_InputIter1>::value_type, typename iterator_traits<_InputIter2>::value_type>); - glibcpp_function_requires(OutputIteratorConcept<_OutputIter, + __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter, typename iterator_traits<_InputIter1>::value_type>); - glibcpp_function_requires(BinaryPredicateConcept<_Compare, + __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, typename iterator_traits<_InputIter1>::value_type, typename iterator_traits<_InputIter2>::value_type>); @@ -2986,14 +2986,14 @@ _OutputIter set_difference(_InputIter1 __first1, _InputIter1 __last1, _OutputIter __result) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter1>); - glibcpp_function_requires(InputIteratorConcept<_InputIter2>); - glibcpp_function_requires(OutputIteratorConcept<_OutputIter, + __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>); + __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>); + __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter, typename iterator_traits<_InputIter1>::value_type>); - glibcpp_function_requires(SameTypeConcept< + __glibcpp_function_requires(_SameTypeConcept< typename iterator_traits<_InputIter1>::value_type, typename iterator_traits<_InputIter2>::value_type>); - glibcpp_function_requires(LessThanComparableConcept< + __glibcpp_function_requires(_LessThanComparableConcept< typename iterator_traits<_InputIter1>::value_type>); while (__first1 != __last1 && __first2 != __last2) @@ -3018,14 +3018,14 @@ _OutputIter set_difference(_InputIter1 __first1, _InputIter1 __last1, _OutputIter __result, _Compare __comp) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter1>); - glibcpp_function_requires(InputIteratorConcept<_InputIter2>); - glibcpp_function_requires(SameTypeConcept< + __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>); + __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>); + __glibcpp_function_requires(_SameTypeConcept< typename iterator_traits<_InputIter1>::value_type, typename iterator_traits<_InputIter2>::value_type>); - glibcpp_function_requires(OutputIteratorConcept<_OutputIter, + __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter, typename iterator_traits<_InputIter1>::value_type>); - glibcpp_function_requires(BinaryPredicateConcept<_Compare, + __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, typename iterator_traits<_InputIter1>::value_type, typename iterator_traits<_InputIter2>::value_type>); @@ -3051,14 +3051,14 @@ set_symmetric_difference(_InputIter1 __first1, _InputIter1 __last1, _OutputIter __result) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter1>); - glibcpp_function_requires(InputIteratorConcept<_InputIter2>); - glibcpp_function_requires(OutputIteratorConcept<_OutputIter, + __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>); + __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>); + __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter, typename iterator_traits<_InputIter1>::value_type>); - glibcpp_function_requires(SameTypeConcept< + __glibcpp_function_requires(_SameTypeConcept< typename iterator_traits<_InputIter1>::value_type, typename iterator_traits<_InputIter2>::value_type>); - glibcpp_function_requires(LessThanComparableConcept< + __glibcpp_function_requires(_LessThanComparableConcept< typename iterator_traits<_InputIter1>::value_type>); while (__first1 != __last1 && __first2 != __last2) @@ -3088,14 +3088,14 @@ set_symmetric_difference(_InputIter1 __first1, _InputIter1 __last1, _Compare __comp) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter1>); - glibcpp_function_requires(InputIteratorConcept<_InputIter2>); - glibcpp_function_requires(SameTypeConcept< + __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>); + __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>); + __glibcpp_function_requires(_SameTypeConcept< typename iterator_traits<_InputIter1>::value_type, typename iterator_traits<_InputIter2>::value_type>); - glibcpp_function_requires(OutputIteratorConcept<_OutputIter, + __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter, typename iterator_traits<_InputIter1>::value_type>); - glibcpp_function_requires(BinaryPredicateConcept<_Compare, + __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, typename iterator_traits<_InputIter1>::value_type, typename iterator_traits<_InputIter2>::value_type>); @@ -3124,8 +3124,8 @@ template _ForwardIter max_element(_ForwardIter __first, _ForwardIter __last) { // concept requirements - glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>); - glibcpp_function_requires(LessThanComparableConcept< + __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>); + __glibcpp_function_requires(_LessThanComparableConcept< typename iterator_traits<_ForwardIter>::value_type>); if (__first == __last) return __first; @@ -3141,8 +3141,8 @@ _ForwardIter max_element(_ForwardIter __first, _ForwardIter __last, _Compare __comp) { // concept requirements - glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>); - glibcpp_function_requires(BinaryPredicateConcept<_Compare, + __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>); + __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, typename iterator_traits<_ForwardIter>::value_type, typename iterator_traits<_ForwardIter>::value_type>); @@ -3157,8 +3157,8 @@ template _ForwardIter min_element(_ForwardIter __first, _ForwardIter __last) { // concept requirements - glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>); - glibcpp_function_requires(LessThanComparableConcept< + __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>); + __glibcpp_function_requires(_LessThanComparableConcept< typename iterator_traits<_ForwardIter>::value_type>); if (__first == __last) return __first; @@ -3174,8 +3174,8 @@ _ForwardIter min_element(_ForwardIter __first, _ForwardIter __last, _Compare __comp) { // concept requirements - glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>); - glibcpp_function_requires(BinaryPredicateConcept<_Compare, + __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>); + __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, typename iterator_traits<_ForwardIter>::value_type, typename iterator_traits<_ForwardIter>::value_type>); @@ -3194,8 +3194,8 @@ template bool next_permutation(_BidirectionalIter __first, _BidirectionalIter __last) { // concept requirements - glibcpp_function_requires(BidirectionalIteratorConcept<_BidirectionalIter>); - glibcpp_function_requires(LessThanComparableConcept< + __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter>); + __glibcpp_function_requires(_LessThanComparableConcept< typename iterator_traits<_BidirectionalIter>::value_type>); if (__first == __last) @@ -3230,8 +3230,8 @@ bool next_permutation(_BidirectionalIter __first, _BidirectionalIter __last, _Compare __comp) { // concept requirements - glibcpp_function_requires(BidirectionalIteratorConcept<_BidirectionalIter>); - glibcpp_function_requires(BinaryPredicateConcept<_Compare, + __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter>); + __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, typename iterator_traits<_BidirectionalIter>::value_type, typename iterator_traits<_BidirectionalIter>::value_type>); @@ -3266,8 +3266,8 @@ template bool prev_permutation(_BidirectionalIter __first, _BidirectionalIter __last) { // concept requirements - glibcpp_function_requires(BidirectionalIteratorConcept<_BidirectionalIter>); - glibcpp_function_requires(LessThanComparableConcept< + __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter>); + __glibcpp_function_requires(_LessThanComparableConcept< typename iterator_traits<_BidirectionalIter>::value_type>); if (__first == __last) @@ -3302,8 +3302,8 @@ bool prev_permutation(_BidirectionalIter __first, _BidirectionalIter __last, _Compare __comp) { // concept requirements - glibcpp_function_requires(BidirectionalIteratorConcept<_BidirectionalIter>); - glibcpp_function_requires(BinaryPredicateConcept<_Compare, + __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter>); + __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, typename iterator_traits<_BidirectionalIter>::value_type, typename iterator_traits<_BidirectionalIter>::value_type>); @@ -3341,9 +3341,9 @@ _InputIter find_first_of(_InputIter __first1, _InputIter __last1, _ForwardIter __first2, _ForwardIter __last2) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter>); - glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>); - glibcpp_function_requires(EqualOpConcept< + __glibcpp_function_requires(_InputIteratorConcept<_InputIter>); + __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>); + __glibcpp_function_requires(_EqualOpConcept< typename iterator_traits<_InputIter>::value_type, typename iterator_traits<_ForwardIter>::value_type>); @@ -3360,12 +3360,12 @@ _InputIter find_first_of(_InputIter __first1, _InputIter __last1, _BinaryPredicate __comp) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter>); - glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>); - glibcpp_function_requires(EqualOpConcept< + __glibcpp_function_requires(_InputIteratorConcept<_InputIter>); + __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>); + __glibcpp_function_requires(_EqualOpConcept< typename iterator_traits<_InputIter>::value_type, typename iterator_traits<_ForwardIter>::value_type>); - glibcpp_function_requires(BinaryPredicateConcept<_BinaryPredicate, + __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPredicate, typename iterator_traits<_InputIter>::value_type, typename iterator_traits<_ForwardIter>::value_type>); @@ -3439,8 +3439,8 @@ __find_end(_BidirectionalIter1 __first1, _BidirectionalIter1 __last1, bidirectional_iterator_tag, bidirectional_iterator_tag) { // concept requirements - glibcpp_function_requires(BidirectionalIteratorConcept<_BidirectionalIter1>); - glibcpp_function_requires(BidirectionalIteratorConcept<_BidirectionalIter2>); + __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter1>); + __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter2>); typedef reverse_iterator<_BidirectionalIter1> _RevIter1; typedef reverse_iterator<_BidirectionalIter2> _RevIter2; @@ -3468,8 +3468,8 @@ __find_end(_BidirectionalIter1 __first1, _BidirectionalIter1 __last1, _BinaryPredicate __comp) { // concept requirements - glibcpp_function_requires(BidirectionalIteratorConcept<_BidirectionalIter1>); - glibcpp_function_requires(BidirectionalIteratorConcept<_BidirectionalIter2>); + __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter1>); + __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter2>); typedef reverse_iterator<_BidirectionalIter1> _RevIter1; typedef reverse_iterator<_BidirectionalIter2> _RevIter2; @@ -3497,9 +3497,9 @@ find_end(_ForwardIter1 __first1, _ForwardIter1 __last1, _ForwardIter2 __first2, _ForwardIter2 __last2) { // concept requirements - glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter1>); - glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter2>); - glibcpp_function_requires(EqualOpConcept< + __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter1>); + __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter2>); + __glibcpp_function_requires(_EqualOpConcept< typename iterator_traits<_ForwardIter1>::value_type, typename iterator_traits<_ForwardIter2>::value_type>); @@ -3516,9 +3516,9 @@ find_end(_ForwardIter1 __first1, _ForwardIter1 __last1, _BinaryPredicate __comp) { // concept requirements - glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter1>); - glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter2>); - glibcpp_function_requires(BinaryPredicateConcept<_BinaryPredicate, + __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter1>); + __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter2>); + __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPredicate, typename iterator_traits<_ForwardIter1>::value_type, typename iterator_traits<_ForwardIter2>::value_type>); @@ -3563,8 +3563,8 @@ template inline bool is_heap(_RandomAccessIter __first, _RandomAccessIter __last) { // concept requirements - glibcpp_function_requires(RandomAccessIteratorConcept<_RandomAccessIter>); - glibcpp_function_requires(LessThanComparableConcept< + __glibcpp_function_requires(_RandomAccessIteratorConcept<_RandomAccessIter>); + __glibcpp_function_requires(_LessThanComparableConcept< typename iterator_traits<_RandomAccessIter>::value_type>); return __is_heap(__first, __last - __first); @@ -3576,8 +3576,8 @@ inline bool is_heap(_RandomAccessIter __first, _RandomAccessIter __last, _StrictWeakOrdering __comp) { // concept requirements - glibcpp_function_requires(RandomAccessIteratorConcept<_RandomAccessIter>); - glibcpp_function_requires(BinaryPredicateConcept<_StrictWeakOrdering, + __glibcpp_function_requires(_RandomAccessIteratorConcept<_RandomAccessIter>); + __glibcpp_function_requires(_BinaryPredicateConcept<_StrictWeakOrdering, typename iterator_traits<_RandomAccessIter>::value_type, typename iterator_traits<_RandomAccessIter>::value_type>); @@ -3592,8 +3592,8 @@ template bool is_sorted(_ForwardIter __first, _ForwardIter __last) { // concept requirements - glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>); - glibcpp_function_requires(LessThanComparableConcept< + __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>); + __glibcpp_function_requires(_LessThanComparableConcept< typename iterator_traits<_ForwardIter>::value_type>); if (__first == __last) @@ -3613,8 +3613,8 @@ bool is_sorted(_ForwardIter __first, _ForwardIter __last, _StrictWeakOrdering __comp) { // concept requirements - glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>); - glibcpp_function_requires(BinaryPredicateConcept<_StrictWeakOrdering, + __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>); + __glibcpp_function_requires(_BinaryPredicateConcept<_StrictWeakOrdering, typename iterator_traits<_ForwardIter>::value_type, typename iterator_traits<_ForwardIter>::value_type>); diff --git a/libstdc++-v3/include/bits/stl_algobase.h b/libstdc++-v3/include/bits/stl_algobase.h index 29bc953d610..a70da2db871 100644 --- a/libstdc++-v3/include/bits/stl_algobase.h +++ b/libstdc++-v3/include/bits/stl_algobase.h @@ -68,12 +68,12 @@ template inline void iter_swap(_ForwardIter1 __a, _ForwardIter2 __b) { // concept requirements - glibcpp_function_requires(Mutable_ForwardIteratorConcept<_ForwardIter1>); - glibcpp_function_requires(Mutable_ForwardIteratorConcept<_ForwardIter2>); - glibcpp_function_requires(ConvertibleConcept< + __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter1>); + __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter2>); + __glibcpp_function_requires(_ConvertibleConcept< typename iterator_traits<_ForwardIter1>::value_type, typename iterator_traits<_ForwardIter2>::value_type>); - glibcpp_function_requires(ConvertibleConcept< + __glibcpp_function_requires(_ConvertibleConcept< typename iterator_traits<_ForwardIter2>::value_type, typename iterator_traits<_ForwardIter1>::value_type>); @@ -84,7 +84,7 @@ template inline void swap(_Tp& __a, _Tp& __b) { // concept requirements - glibcpp_function_requires(SGIAssignableConcept<_Tp>); + __glibcpp_function_requires(_SGIAssignableConcept<_Tp>); _Tp __tmp = __a; __a = __b; @@ -100,7 +100,7 @@ inline void swap(_Tp& __a, _Tp& __b) template inline const _Tp& min(const _Tp& __a, const _Tp& __b) { // concept requirements - glibcpp_function_requires(LessThanComparableConcept<_Tp>); + __glibcpp_function_requires(_LessThanComparableConcept<_Tp>); //return __b < __a ? __b : __a; if (__b < __a) return __b; return __a; } @@ -108,7 +108,7 @@ inline const _Tp& min(const _Tp& __a, const _Tp& __b) { template inline const _Tp& max(const _Tp& __a, const _Tp& __b) { // concept requirements - glibcpp_function_requires(LessThanComparableConcept<_Tp>); + __glibcpp_function_requires(_LessThanComparableConcept<_Tp>); //return __a < __b ? __b : __a; if (__a < __b) return __b; return __a; } @@ -244,8 +244,8 @@ inline _OutputIter copy(_InputIter __first, _InputIter __last, _OutputIter __result) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter>); - glibcpp_function_requires(OutputIteratorConcept<_OutputIter, + __glibcpp_function_requires(_InputIteratorConcept<_InputIter>); + __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter, typename iterator_traits<_InputIter>::value_type>); typedef typename _Is_normal_iterator<_InputIter>::_Normal __Normal; @@ -362,9 +362,9 @@ template inline _BI2 copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) { // concept requirements - glibcpp_function_requires(BidirectionalIteratorConcept<_BI1>); - glibcpp_function_requires(Mutable_BidirectionalIteratorConcept<_BI2>); - glibcpp_function_requires(ConvertibleConcept< + __glibcpp_function_requires(_BidirectionalIteratorConcept<_BI1>); + __glibcpp_function_requires(_Mutable_BidirectionalIteratorConcept<_BI2>); + __glibcpp_function_requires(_ConvertibleConcept< typename iterator_traits<_BI1>::value_type, typename iterator_traits<_BI2>::value_type>); @@ -409,8 +409,8 @@ inline pair<_InputIter, _OutputIter> copy_n(_InputIter __first, _Size __count, _OutputIter __result) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter>); - glibcpp_function_requires(OutputIteratorConcept<_OutputIter, + __glibcpp_function_requires(_InputIteratorConcept<_InputIter>); + __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter, typename iterator_traits<_InputIter>::value_type>); return __copy_n(__first, __count, __result); @@ -424,7 +424,7 @@ template void fill(_ForwardIter __first, _ForwardIter __last, const _Tp& __value) { // concept requirements - glibcpp_function_requires(Mutable_ForwardIteratorConcept<_ForwardIter>); + __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>); for ( ; __first != __last; ++__first) *__first = __value; @@ -434,7 +434,7 @@ template _OutputIter fill_n(_OutputIter __first, _Size __n, const _Tp& __value) { // concept requirements - glibcpp_function_requires(OutputIteratorConcept<_OutputIter,_Tp>); + __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,_Tp>); for ( ; __n > 0; --__n, ++__first) *__first = __value; @@ -496,11 +496,11 @@ pair<_InputIter1, _InputIter2> mismatch(_InputIter1 __first1, _InputIter2 __first2) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter1>); - glibcpp_function_requires(InputIteratorConcept<_InputIter2>); - glibcpp_function_requires(EqualityComparableConcept< + __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>); + __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>); + __glibcpp_function_requires(_EqualityComparableConcept< typename iterator_traits<_InputIter1>::value_type>); - glibcpp_function_requires(EqualityComparableConcept< + __glibcpp_function_requires(_EqualityComparableConcept< typename iterator_traits<_InputIter2>::value_type>); while (__first1 != __last1 && *__first1 == *__first2) { @@ -517,8 +517,8 @@ pair<_InputIter1, _InputIter2> mismatch(_InputIter1 __first1, _BinaryPredicate __binary_pred) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter1>); - glibcpp_function_requires(InputIteratorConcept<_InputIter2>); + __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>); + __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>); while (__first1 != __last1 && __binary_pred(*__first1, *__first2)) { ++__first1; @@ -532,11 +532,11 @@ inline bool equal(_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter1>); - glibcpp_function_requires(InputIteratorConcept<_InputIter2>); - glibcpp_function_requires(EqualityComparableConcept< + __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>); + __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>); + __glibcpp_function_requires(_EqualityComparableConcept< typename iterator_traits<_InputIter1>::value_type>); - glibcpp_function_requires(EqualityComparableConcept< + __glibcpp_function_requires(_EqualityComparableConcept< typename iterator_traits<_InputIter2>::value_type>); for ( ; __first1 != __last1; ++__first1, ++__first2) @@ -550,8 +550,8 @@ inline bool equal(_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _BinaryPredicate __binary_pred) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter1>); - glibcpp_function_requires(InputIteratorConcept<_InputIter2>); + __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>); + __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>); for ( ; __first1 != __last1; ++__first1, ++__first2) if (!__binary_pred(*__first1, *__first2)) @@ -568,11 +568,11 @@ bool lexicographical_compare(_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter1>); - glibcpp_function_requires(InputIteratorConcept<_InputIter2>); - glibcpp_function_requires(LessThanComparableConcept< + __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>); + __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>); + __glibcpp_function_requires(_LessThanComparableConcept< typename iterator_traits<_InputIter1>::value_type>); - glibcpp_function_requires(LessThanComparableConcept< + __glibcpp_function_requires(_LessThanComparableConcept< typename iterator_traits<_InputIter2>::value_type>); for ( ; __first1 != __last1 && __first2 != __last2 @@ -591,8 +591,8 @@ bool lexicographical_compare(_InputIter1 __first1, _InputIter1 __last1, _Compare __comp) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter1>); - glibcpp_function_requires(InputIteratorConcept<_InputIter2>); + __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>); + __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>); for ( ; __first1 != __last1 && __first2 != __last2 ; ++__first1, ++__first2) { @@ -688,11 +688,11 @@ int lexicographical_compare_3way(_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter1>); - glibcpp_function_requires(InputIteratorConcept<_InputIter2>); - glibcpp_function_requires(LessThanComparableConcept< + __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>); + __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>); + __glibcpp_function_requires(_LessThanComparableConcept< typename iterator_traits<_InputIter1>::value_type>); - glibcpp_function_requires(LessThanComparableConcept< + __glibcpp_function_requires(_LessThanComparableConcept< typename iterator_traits<_InputIter2>::value_type>); return __lexicographical_compare_3way(__first1, __last1, __first2, __last2); diff --git a/libstdc++-v3/include/bits/stl_deque.h b/libstdc++-v3/include/bits/stl_deque.h index 8e7f1305bfd..25fd6682a2d 100644 --- a/libstdc++-v3/include/bits/stl_deque.h +++ b/libstdc++-v3/include/bits/stl_deque.h @@ -357,7 +357,7 @@ template > class deque : protected _Deque_base<_Tp, _Alloc> { // concept requirements - glibcpp_class_requires(_Tp, SGIAssignableConcept); + __glibcpp_class_requires(_Tp, _SGIAssignableConcept); typedef _Deque_base<_Tp, _Alloc> _Base; public: // Basic types diff --git a/libstdc++-v3/include/bits/stl_heap.h b/libstdc++-v3/include/bits/stl_heap.h index 3fdd236b1c9..0770d7cf2aa 100644 --- a/libstdc++-v3/include/bits/stl_heap.h +++ b/libstdc++-v3/include/bits/stl_heap.h @@ -63,9 +63,9 @@ inline void push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) { // concept requirements - glibcpp_function_requires(Mutable_RandomAccessIteratorConcept< + __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept< _RandomAccessIterator>); - glibcpp_function_requires(LessThanComparableConcept< + __glibcpp_function_requires(_LessThanComparableConcept< typename iterator_traits<_RandomAccessIterator>::value_type>); __push_heap_aux(__first, __last, @@ -104,7 +104,7 @@ push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { // concept requirements - glibcpp_function_requires(Mutable_RandomAccessIteratorConcept< + __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept< _RandomAccessIterator>); __push_heap_aux(__first, __last, __comp, @@ -155,9 +155,9 @@ inline void pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) { // concept requirements - glibcpp_function_requires(Mutable_RandomAccessIteratorConcept< + __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept< _RandomAccessIterator>); - glibcpp_function_requires(LessThanComparableConcept< + __glibcpp_function_requires(_LessThanComparableConcept< typename iterator_traits<_RandomAccessIterator>::value_type>); __pop_heap_aux(__first, __last, __value_type(__first)); @@ -212,7 +212,7 @@ pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { // concept requirements - glibcpp_function_requires(Mutable_RandomAccessIteratorConcept< + __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept< _RandomAccessIterator>); __pop_heap_aux(__first, __last, __value_type(__first), __comp); @@ -239,9 +239,9 @@ inline void make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) { // concept requirements - glibcpp_function_requires(Mutable_RandomAccessIteratorConcept< + __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept< _RandomAccessIterator>); - glibcpp_function_requires(LessThanComparableConcept< + __glibcpp_function_requires(_LessThanComparableConcept< typename iterator_traits<_RandomAccessIterator>::value_type>); __make_heap(__first, __last, @@ -272,7 +272,7 @@ make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { // concept requirements - glibcpp_function_requires(Mutable_RandomAccessIteratorConcept< + __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept< _RandomAccessIterator>); __make_heap(__first, __last, __comp, @@ -283,9 +283,9 @@ template void sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) { // concept requirements - glibcpp_function_requires(Mutable_RandomAccessIteratorConcept< + __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept< _RandomAccessIterator>); - glibcpp_function_requires(LessThanComparableConcept< + __glibcpp_function_requires(_LessThanComparableConcept< typename iterator_traits<_RandomAccessIterator>::value_type>); while (__last - __first > 1) @@ -298,7 +298,7 @@ sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { // concept requirements - glibcpp_function_requires(Mutable_RandomAccessIteratorConcept< + __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept< _RandomAccessIterator>); while (__last - __first > 1) diff --git a/libstdc++-v3/include/bits/stl_iterator_base_funcs.h b/libstdc++-v3/include/bits/stl_iterator_base_funcs.h index 138a69be550..5288eda03f1 100644 --- a/libstdc++-v3/include/bits/stl_iterator_base_funcs.h +++ b/libstdc++-v3/include/bits/stl_iterator_base_funcs.h @@ -51,7 +51,7 @@ inline void __distance(_InputIterator __first, _InputIterator __last, _Distance& __n, input_iterator_tag) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIterator>); + __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>); while (__first != __last) { ++__first; ++__n; } } @@ -61,7 +61,7 @@ inline void __distance(_RandomAccessIterator __first, _Distance& __n, random_access_iterator_tag) { // concept requirements - glibcpp_function_requires(RandomAccessIteratorConcept<_RandomAccessIterator>); + __glibcpp_function_requires(_RandomAccessIteratorConcept<_RandomAccessIterator>); __n += __last - __first; } @@ -78,7 +78,7 @@ inline typename iterator_traits<_InputIterator>::difference_type __distance(_InputIterator __first, _InputIterator __last, input_iterator_tag) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIterator>); + __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>); typename iterator_traits<_InputIterator>::difference_type __n = 0; while (__first != __last) { ++__first; ++__n; @@ -92,7 +92,7 @@ __distance(_RandomAccessIterator __first, _RandomAccessIterator __last, random_access_iterator_tag) { // concept requirements - glibcpp_function_requires(RandomAccessIteratorConcept<_RandomAccessIterator>); + __glibcpp_function_requires(_RandomAccessIteratorConcept<_RandomAccessIterator>); return __last - __first; } @@ -110,7 +110,7 @@ template inline void __advance(_InputIter& __i, _Distance __n, input_iterator_tag) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIter>); + __glibcpp_function_requires(_InputIteratorConcept<_InputIter>); while (__n--) ++__i; } @@ -119,7 +119,7 @@ inline void __advance(_BidirectionalIterator& __i, _Distance __n, bidirectional_iterator_tag) { // concept requirements -glibcpp_function_requires(BidirectionalIteratorConcept<_BidirectionalIterator>); +__glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIterator>); if (__n >= 0) while (__n--) ++__i; else @@ -131,7 +131,7 @@ inline void __advance(_RandomAccessIterator& __i, _Distance __n, random_access_iterator_tag) { // concept requirements - glibcpp_function_requires(RandomAccessIteratorConcept<_RandomAccessIterator>); + __glibcpp_function_requires(_RandomAccessIteratorConcept<_RandomAccessIterator>); __i += __n; } diff --git a/libstdc++-v3/include/bits/stl_list.h b/libstdc++-v3/include/bits/stl_list.h index fb00c474423..d837556cc9f 100644 --- a/libstdc++-v3/include/bits/stl_list.h +++ b/libstdc++-v3/include/bits/stl_list.h @@ -201,7 +201,7 @@ template > class list : protected _List_base<_Tp, _Alloc> { // concept requirements - glibcpp_class_requires(_Tp, SGIAssignableConcept); + __glibcpp_class_requires(_Tp, _SGIAssignableConcept); typedef _List_base<_Tp, _Alloc> _Base; protected: diff --git a/libstdc++-v3/include/bits/stl_map.h b/libstdc++-v3/include/bits/stl_map.h index 7a6ef7a32a9..f1024fa2f5b 100644 --- a/libstdc++-v3/include/bits/stl_map.h +++ b/libstdc++-v3/include/bits/stl_map.h @@ -41,8 +41,8 @@ template , class map { // concept requirements - glibcpp_class_requires(_Tp, SGIAssignableConcept); - glibcpp_class_requires4(_Compare, bool, _Key, _Key, BinaryFunctionConcept); + __glibcpp_class_requires(_Tp, _SGIAssignableConcept); + __glibcpp_class_requires4(_Compare, bool, _Key, _Key, _BinaryFunctionConcept); public: // typedefs: diff --git a/libstdc++-v3/include/bits/stl_multimap.h b/libstdc++-v3/include/bits/stl_multimap.h index 558075ecbeb..c35708eb591 100644 --- a/libstdc++-v3/include/bits/stl_multimap.h +++ b/libstdc++-v3/include/bits/stl_multimap.h @@ -55,8 +55,8 @@ template class multimap { // concept requirements - glibcpp_class_requires(_Tp, SGIAssignableConcept); - glibcpp_class_requires4(_Compare, bool, _Key, _Key, BinaryFunctionConcept); + __glibcpp_class_requires(_Tp, _SGIAssignableConcept); + __glibcpp_class_requires4(_Compare, bool, _Key, _Key, _BinaryFunctionConcept); public: diff --git a/libstdc++-v3/include/bits/stl_multiset.h b/libstdc++-v3/include/bits/stl_multiset.h index e723cc22d41..bb4e5a98108 100644 --- a/libstdc++-v3/include/bits/stl_multiset.h +++ b/libstdc++-v3/include/bits/stl_multiset.h @@ -54,8 +54,8 @@ template class multiset { // concept requirements - glibcpp_class_requires(_Key, SGIAssignableConcept); - glibcpp_class_requires4(_Compare, bool, _Key, _Key, BinaryFunctionConcept); + __glibcpp_class_requires(_Key, _SGIAssignableConcept); + __glibcpp_class_requires4(_Compare, bool, _Key, _Key, _BinaryFunctionConcept); public: diff --git a/libstdc++-v3/include/bits/stl_numeric.h b/libstdc++-v3/include/bits/stl_numeric.h index 8656e9955a9..ccafd374488 100644 --- a/libstdc++-v3/include/bits/stl_numeric.h +++ b/libstdc++-v3/include/bits/stl_numeric.h @@ -39,7 +39,7 @@ template _Tp accumulate(_InputIterator __first, _InputIterator __last, _Tp __init) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIterator>); + __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>); for ( ; __first != __last; ++__first) __init = __init + *__first; @@ -51,7 +51,7 @@ _Tp accumulate(_InputIterator __first, _InputIterator __last, _Tp __init, _BinaryOperation __binary_op) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIterator>); + __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>); for ( ; __first != __last; ++__first) __init = __binary_op(__init, *__first); @@ -63,8 +63,8 @@ _Tp inner_product(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _Tp __init) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIterator1>); - glibcpp_function_requires(InputIteratorConcept<_InputIterator2>); + __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>); + __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>); for ( ; __first1 != __last1; ++__first1, ++__first2) __init = __init + (*__first1 * *__first2); @@ -79,8 +79,8 @@ _Tp inner_product(_InputIterator1 __first1, _InputIterator1 __last1, _BinaryOperation2 __binary_op2) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIterator1>); - glibcpp_function_requires(InputIteratorConcept<_InputIterator2>); + __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>); + __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>); for ( ; __first1 != __last1; ++__first1, ++__first2) __init = __binary_op1(__init, __binary_op2(*__first1, *__first2)); @@ -106,8 +106,8 @@ partial_sum(_InputIterator __first, _InputIterator __last, _OutputIterator __result) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIterator>); - glibcpp_function_requires(OutputIteratorConcept<_OutputIterator, + __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>); + __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator, typename iterator_traits<_InputIterator>::value_type>); if (__first == __last) return __result; @@ -135,8 +135,8 @@ partial_sum(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryOperation __binary_op) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIterator>); - glibcpp_function_requires(OutputIteratorConcept<_OutputIterator, + __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>); + __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator, typename iterator_traits<_InputIterator>::value_type>); if (__first == __last) return __result; @@ -165,8 +165,8 @@ adjacent_difference(_InputIterator __first, _InputIterator __last, _OutputIterator __result) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIterator>); - glibcpp_function_requires(OutputIteratorConcept<_OutputIterator, + __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>); + __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator, typename iterator_traits<_InputIterator>::value_type>); if (__first == __last) return __result; @@ -196,8 +196,8 @@ adjacent_difference(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryOperation __binary_op) { // concept requirements - glibcpp_function_requires(InputIteratorConcept<_InputIterator>); - glibcpp_function_requires(OutputIteratorConcept<_OutputIterator, + __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>); + __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator, typename iterator_traits<_InputIterator>::value_type>); if (__first == __last) return __result; @@ -262,8 +262,8 @@ void iota(_ForwardIter __first, _ForwardIter __last, _Tp __value) { // concept requirements - glibcpp_function_requires(Mutable_ForwardIteratorConcept<_ForwardIter>); - glibcpp_function_requires(ConvertibleConcept<_Tp, + __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>); + __glibcpp_function_requires(_ConvertibleConcept<_Tp, typename iterator_traits<_ForwardIter>::value_type>); while (__first != __last) diff --git a/libstdc++-v3/include/bits/stl_queue.h b/libstdc++-v3/include/bits/stl_queue.h index f52838ba565..ad27ba72db9 100644 --- a/libstdc++-v3/include/bits/stl_queue.h +++ b/libstdc++-v3/include/bits/stl_queue.h @@ -53,11 +53,11 @@ template class queue { // concept requirements - glibcpp_class_requires(_Tp, SGIAssignableConcept); - glibcpp_class_requires(_Sequence, FrontInsertionSequenceConcept); - glibcpp_class_requires(_Sequence, BackInsertionSequenceConcept); + __glibcpp_class_requires(_Tp, _SGIAssignableConcept); + __glibcpp_class_requires(_Sequence, _FrontInsertionSequenceConcept); + __glibcpp_class_requires(_Sequence, _BackInsertionSequenceConcept); typedef typename _Sequence::value_type _Sequence_value_type; - glibcpp_class_requires2(_Tp, _Sequence_value_type, SameTypeConcept); + __glibcpp_class_requires2(_Tp, _Sequence_value_type, _SameTypeConcept); template friend bool operator== (const queue<_Tp1, _Seq1>&, @@ -136,12 +136,12 @@ template class set { // concept requirements - glibcpp_class_requires(_Key, SGIAssignableConcept); - glibcpp_class_requires4(_Compare, bool, _Key, _Key, BinaryFunctionConcept); + __glibcpp_class_requires(_Key, _SGIAssignableConcept); + __glibcpp_class_requires4(_Compare, bool, _Key, _Key, _BinaryFunctionConcept); public: // typedefs: diff --git a/libstdc++-v3/include/bits/stl_stack.h b/libstdc++-v3/include/bits/stl_stack.h index 3774d4c3d12..9f4fd460604 100644 --- a/libstdc++-v3/include/bits/stl_stack.h +++ b/libstdc++-v3/include/bits/stl_stack.h @@ -53,10 +53,10 @@ template class stack { // concept requirements - glibcpp_class_requires(_Tp, SGIAssignableConcept); - glibcpp_class_requires(_Sequence, BackInsertionSequenceConcept); + __glibcpp_class_requires(_Tp, _SGIAssignableConcept); + __glibcpp_class_requires(_Sequence, _BackInsertionSequenceConcept); typedef typename _Sequence::value_type _Sequence_value_type; - glibcpp_class_requires2(_Tp, _Sequence_value_type, SameTypeConcept); + __glibcpp_class_requires2(_Tp, _Sequence_value_type, _SameTypeConcept); template friend bool operator== (const stack<_Tp1, _Seq1>&, diff --git a/libstdc++-v3/include/bits/stl_vector.h b/libstdc++-v3/include/bits/stl_vector.h index a764db3de38..4bc0253edc1 100644 --- a/libstdc++-v3/include/bits/stl_vector.h +++ b/libstdc++-v3/include/bits/stl_vector.h @@ -118,7 +118,7 @@ template > class vector : protected _Vector_base<_Tp, _Alloc> { // concept requirements - glibcpp_class_requires(_Tp, SGIAssignableConcept); + __glibcpp_class_requires(_Tp, _SGIAssignableConcept); private: typedef _Vector_base<_Tp, _Alloc> _Base; diff --git a/libstdc++-v3/include/ext/hash_map b/libstdc++-v3/include/ext/hash_map index ddb32c731a3..8386cb91c1f 100644 --- a/libstdc++-v3/include/ext/hash_map +++ b/libstdc++-v3/include/ext/hash_map @@ -204,10 +204,10 @@ template class hash_multimap { // concept requirements - glibcpp_class_requires(_Key, SGIAssignableConcept); - glibcpp_class_requires(_Tp, SGIAssignableConcept); - glibcpp_class_requires3(_HashFcn, size_t, _Key, UnaryFunctionConcept); - glibcpp_class_requires3(_EqualKey, _Key, _Key, BinaryPredicateConcept); + __glibcpp_class_requires(_Key, _SGIAssignableConcept); + __glibcpp_class_requires(_Tp, _SGIAssignableConcept); + __glibcpp_class_requires3(_HashFcn, size_t, _Key, _UnaryFunctionConcept); + __glibcpp_class_requires3(_EqualKey, _Key, _Key, _BinaryPredicateConcept); private: typedef hashtable, _Key, _HashFcn, diff --git a/libstdc++-v3/include/ext/hash_set b/libstdc++-v3/include/ext/hash_set index e99a884ba10..a6568e135a2 100644 --- a/libstdc++-v3/include/ext/hash_set +++ b/libstdc++-v3/include/ext/hash_set @@ -54,9 +54,9 @@ template class hash_set { // concept requirements - glibcpp_class_requires(_Value, SGIAssignableConcept); - glibcpp_class_requires3(_HashFcn, size_t, _Value, UnaryFunctionConcept); - glibcpp_class_requires3(_EqualKey, _Value, _Value, BinaryPredicateConcept); + __glibcpp_class_requires(_Value, _SGIAssignableConcept); + __glibcpp_class_requires3(_HashFcn, size_t, _Value, _UnaryFunctionConcept); + __glibcpp_class_requires3(_EqualKey, _Value, _Value, _BinaryPredicateConcept); private: typedef hashtable<_Value, _Value, _HashFcn, _Identity<_Value>, @@ -205,9 +205,9 @@ template class hash_multiset { // concept requirements - glibcpp_class_requires(_Value, SGIAssignableConcept); - glibcpp_class_requires3(_HashFcn, size_t, _Value, UnaryFunctionConcept); - glibcpp_class_requires3(_EqualKey, _Value, _Value, BinaryPredicateConcept); + __glibcpp_class_requires(_Value, _SGIAssignableConcept); + __glibcpp_class_requires3(_HashFcn, size_t, _Value, _UnaryFunctionConcept); + __glibcpp_class_requires3(_EqualKey, _Value, _Value, _BinaryPredicateConcept); private: typedef hashtable<_Value, _Value, _HashFcn, _Identity<_Value>, diff --git a/libstdc++-v3/include/ext/slist b/libstdc++-v3/include/ext/slist index 68cbccc0d24..134e9846f2f 100644 --- a/libstdc++-v3/include/ext/slist +++ b/libstdc++-v3/include/ext/slist @@ -258,7 +258,7 @@ template > class slist : private _Slist_base<_Tp,_Alloc> { // concept requirements - glibcpp_class_requires(_Tp, SGIAssignableConcept); + __glibcpp_class_requires(_Tp, _SGIAssignableConcept); private: typedef _Slist_base<_Tp,_Alloc> _Base;