+2001-04-13 Phil Edwards <pme@sources.redhat.com>
+
+ * 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 <gdr@codesourcery.com>
* testsuite/23_containers/set_operators.cc: Just try to compile.
//
// 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 <bits/stl_iterator_base_types.h> // for traits and tags
#include <utility> // for pair<>
-namespace boost {
+namespace __gnu_cxx
+{
-template <class T> void ignore_unused_variable_warning(const T&) { }
+#define _IsUnused __attribute__ ((__unused__))
-template <class Concept>
-void function_requires()
+template <class _Concept>
+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 <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 BOOST_CLASS_REQUIRES2(type_var1, type_var2, ns, concept) \
- typedef void (ns::concept <type_var1,type_var2>::* func##type_var1##type_var2##concept)(); \
- template <func##type_var1##type_var2##concept _Tp1> \
- struct concept_checking_##type_var1##type_var2##concept { }; \
- typedef concept_checking_##type_var1##type_var2##concept< \
- &ns::concept <type_var1,type_var2>::constraints> \
- concept_checking_typedef_##type_var1##type_var2##concept
-
-#define BOOST_CLASS_REQUIRES3(type_var1, type_var2, type_var3, 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 BOOST_CLASS_REQUIRES4(type_var1, type_var2, type_var3, type_var4, ns, concept) \
- typedef void (ns::concept <type_var1,type_var2,type_var3,type_var4>::* func##type_var1##type_var2##type_var3##type_var4##concept)(); \
- template <func##type_var1##type_var2##type_var3##type_var4##concept _Tp1> \
- struct concept_checking_##type_var1##type_var2##type_var3##type_var4##concept { }; \
- typedef concept_checking_##type_var1##type_var2##type_var3##type_var4##concept< \
- &ns::concept <type_var1,type_var2,type_var3,type_var4>::constraints> \
- concept_checking_typedef_##type_var1##type_var2##type_var3##type_var4##concept
-
-
-template <class T, class U>
-struct require_same { };
-
-template <class T>
-struct require_same<T,T> { typedef T type; };
-
- template <class T, class U>
- struct SameTypeConcept
- {
- void constraints() {
- typedef typename require_same<T, U>::type req;
- }
- };
-
- template <class T>
- struct IntegerConcept {
- void constraints() {
- errortype_must_be_an_integer_type();
- }
- };
- template <> struct IntegerConcept<short> { void constraints() {} };
- template <> struct IntegerConcept<unsigned short> { void constraints() {} };
- template <> struct IntegerConcept<int> { void constraints() {} };
- template <> struct IntegerConcept<unsigned int> { void constraints() {} };
- template <> struct IntegerConcept<long> { void constraints() {} };
- template <> struct IntegerConcept<unsigned long> { void constraints() {} };
- // etc.
-
- template <class T>
- struct SignedIntegerConcept {
- void constraints() {
- errortype_must_be_a_signed_integer_type();
- }
- };
- template <> struct SignedIntegerConcept<short> { void constraints() {} };
- template <> struct SignedIntegerConcept<int> { void constraints() {} };
- template <> struct SignedIntegerConcept<long> { void constraints() {} };
- // etc.
-
- template <class T>
- struct UnsignedIntegerConcept {
- void constraints() {
- errortype_must_be_an_unsigned_integer_type();
- }
- };
- template <> struct UnsignedIntegerConcept<unsigned short>
- { void constraints() {} };
- template <> struct UnsignedIntegerConcept<unsigned int>
- { void constraints() {} };
- template <> struct UnsignedIntegerConcept<unsigned long>
- { 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 <class _Tp1, class _Tp2>
+struct _Aux_require_same { };
+
+template <class _Tp>
+struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
+
+ template <class _Tp1, class _Tp2>
+ struct _SameTypeConcept
+ {
+ void __constraints() {
+ typedef typename _Aux_require_same<_Tp1, _Tp2>::_Type _Required;
+ }
+ };
+
+ template <class _Tp>
+ struct _IntegerConcept {
+ void __constraints() {
+ __error_type_must_be_an_integer_type();
+ }
+ };
+ template <> struct _IntegerConcept<short> { void __constraints() {} };
+ template <> struct _IntegerConcept<unsigned short> { void __constraints(){} };
+ template <> struct _IntegerConcept<int> { void __constraints() {} };
+ template <> struct _IntegerConcept<unsigned int> { void __constraints() {} };
+ template <> struct _IntegerConcept<long> { void __constraints() {} };
+ template <> struct _IntegerConcept<unsigned long> { void __constraints() {} };
+#ifdef _GLIBCPP_USE_LONG_LONG
+ template <> struct _IntegerConcept<long long> { void __constraints() {} };
+ template <> struct _IntegerConcept<unsigned long long>
+ { void __constraints() {} };
+#endif
+
+ template <class _Tp>
+ struct _SignedIntegerConcept {
+ void __constraints() {
+ __error_type_must_be_a_signed_integer_type();
+ }
+ };
+ template <> struct _SignedIntegerConcept<short> { void __constraints() {} };
+ template <> struct _SignedIntegerConcept<int> { void __constraints() {} };
+ template <> struct _SignedIntegerConcept<long> { void __constraints() {} };
+#ifdef _GLIBCPP_USE_LONG_LONG
+ template <> struct _SignedIntegerConcept<long long> { void __constraints(){}};
+#endif
+
+ template <class _Tp>
+ struct _UnsignedIntegerConcept {
+ void __constraints() {
+ __error_type_must_be_an_unsigned_integer_type();
+ }
+ };
+ template <> struct _UnsignedIntegerConcept<unsigned short>
+ { void __constraints() {} };
+ template <> struct _UnsignedIntegerConcept<unsigned int>
+ { void __constraints() {} };
+ template <> struct _UnsignedIntegerConcept<unsigned long>
+ { void __constraints() {} };
+#ifdef _GLIBCPP_USE_LONG_LONG
+ template <> struct _UnsignedIntegerConcept<unsigned long long>
+ { void __constraints() {} };
+#endif
//===========================================================================
// Basic Concepts
- template <class TT>
- struct DefaultConstructibleConcept
+ template <class _Tp>
+ struct _DefaultConstructibleConcept
{
- void constraints() {
- TT a; // require default constructor
- ignore_unused_variable_warning(a);
+ void __constraints() {
+ _Tp __a _IsUnused; // require default constructor
}
};
- template <class TT>
- struct AssignableConcept
+ template <class _Tp>
+ 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 <class TT>
- struct CopyConstructibleConcept
+ template <class _Tp>
+ 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 <class TT>
- struct SGIAssignableConcept
+ template <class _Tp>
+ 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 <class X, class Y>
- struct ConvertibleConcept
+ template <class _From, class _To>
+ 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
// 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 <class TT>
- void require_boolean_expr(const TT& t) {
- bool x = t;
- ignore_unused_variable_warning(x);
+ template <class _Tp>
+ void __aux_require_boolean_expr(const _Tp& __t) {
+ bool __x _IsUnused = __t;
}
- template <class TT>
- struct EqualityComparableConcept
+// FIXME
+ template <class _Tp>
+ 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 <class TT>
- struct LessThanComparableConcept
+ template <class _Tp>
+ 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 <class TT>
- struct ComparableConcept
+ template <class _Tp>
+ 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 <class First, class Second> \
- struct NAME { \
- void constraints() { (void)constraints_(); } \
- bool constraints_() { \
- return a OP b; \
+#define _GLIBCPP_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(_OP,_NAME) \
+ template <class _First, class _Second> \
+ 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 <class Ret, class First, class Second> \
- struct NAME { \
- void constraints() { (void)constraints_(); } \
- Ret constraints_() { \
- return a OP b; \
+#define _GLIBCPP_DEFINE_BINARY_OPERATOR_CONSTRAINT(_OP,_NAME) \
+ template <class _Ret, class _First, class _Second> \
+ 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 <class Func, class Return>
- struct GeneratorConcept
+ template <class _Func, class _Return>
+ 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 <class Func>
- struct GeneratorConcept<Func,void>
+ template <class _Func>
+ struct _GeneratorConcept<_Func,void>
{
- void constraints() {
- f(); // require operator() member function
+ void __constraints() {
+ __f(); // require operator() member function
}
- Func f;
+ _Func __f;
};
- template <class Func, class Return, class Arg>
- struct UnaryFunctionConcept
+ template <class _Func, class _Return, class _Arg>
+ 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 <class Func, class Arg>
- struct UnaryFunctionConcept<Func, void, Arg> {
- void constraints() {
- f(arg); // require operator()
+ template <class _Func, class _Arg>
+ struct _UnaryFunctionConcept<_Func, void, _Arg> {
+ void __constraints() {
+ __f(__arg); // require operator()
}
- Func f;
+ _Func __f;
+ _Arg __arg;
};
- template <class Func, class Return, class First, class Second>
- struct BinaryFunctionConcept
+ template <class _Func, class _Return, class _First, class _Second>
+ 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 <class Func, class First, class Second>
- struct BinaryFunctionConcept<Func, void, First, Second>
+ template <class _Func, class _First, class _Second>
+ 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 <class Func, class Arg>
- struct UnaryPredicateConcept
+ template <class _Func, class _Arg>
+ 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 <class Func, class First, class Second>
- struct BinaryPredicateConcept
+ template <class _Func, class _First, class _Second>
+ 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 <class Func, class First, class Second>
- struct Const_BinaryPredicateConcept {
- void constraints() {
- const_constraints(f);
+ template <class _Func, class _First, class _Second>
+ struct _Const_BinaryPredicateConcept {
+ void __constraints() {
+ __const_constraints(__f);
}
- void const_constraints(const Func& fun) {
- function_requires<BinaryPredicateConcept<Func, First, Second> >();
+ 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 <class TT>
- struct TrivialIteratorConcept
+ template <class _Tp>
+ struct _TrivialIteratorConcept
{
- void constraints() {
- function_requires< AssignableConcept<TT> >();
- function_requires< DefaultConstructibleConcept<TT> >();
- function_requires< EqualityComparableConcept<TT> >();
- typedef typename std::iterator_traits<TT>::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 <class TT>
- struct Mutable_TrivialIteratorConcept
+ template <class _Tp>
+ struct _Mutable_TrivialIteratorConcept
{
- void constraints() {
- function_requires< TrivialIteratorConcept<TT> >();
- *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 <class TT>
- struct InputIteratorConcept
+ template <class _Tp>
+ struct _InputIteratorConcept
{
- void constraints() {
- function_requires< TrivialIteratorConcept<TT> >();
+ void __constraints() {
+ __function_requires< _TrivialIteratorConcept<_Tp> >();
// require iterator_traits typedef's
- typedef typename std::iterator_traits<TT>::difference_type D;
- function_requires< SignedIntegerConcept<D> >();
- typedef typename std::iterator_traits<TT>::reference R;
- typedef typename std::iterator_traits<TT>::pointer P;
- typedef typename std::iterator_traits<TT>::iterator_category C;
- function_requires< ConvertibleConcept<
- typename std::iterator_traits<TT>::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 <class TT, class ValueT>
- struct OutputIteratorConcept
+ template <class _Tp, class _ValueT>
+ struct _OutputIteratorConcept
{
- void constraints() {
- function_requires< AssignableConcept<TT> >();
- ++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 <class TT>
- struct ForwardIteratorConcept
+ template <class _Tp>
+ struct _ForwardIteratorConcept
{
- void constraints() {
- function_requires< InputIteratorConcept<TT> >();
- function_requires< ConvertibleConcept<
- typename std::iterator_traits<TT>::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<TT>::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 <class TT>
- struct Mutable_ForwardIteratorConcept
+ template <class _Tp>
+ struct _Mutable_ForwardIteratorConcept
{
- void constraints() {
- function_requires< ForwardIteratorConcept<TT> >();
- *i++ = *i; // require postincrement and assignment
+ void __constraints() {
+ __function_requires< _ForwardIteratorConcept<_Tp> >();
+ *__i++ = *__i; // require postincrement and assignment
}
- TT i;
+ _Tp __i;
};
- template <class TT>
- struct BidirectionalIteratorConcept
+ template <class _Tp>
+ struct _BidirectionalIteratorConcept
{
- void constraints() {
- function_requires< ForwardIteratorConcept<TT> >();
- function_requires< ConvertibleConcept<
- typename std::iterator_traits<TT>::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 <class TT>
- struct Mutable_BidirectionalIteratorConcept
+ template <class _Tp>
+ struct _Mutable_BidirectionalIteratorConcept
{
- void constraints() {
- function_requires< BidirectionalIteratorConcept<TT> >();
- function_requires< Mutable_ForwardIteratorConcept<TT> >();
- *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 <class TT>
- struct RandomAccessIteratorConcept
+ template <class _Tp>
+ struct _RandomAccessIteratorConcept
{
- void constraints() {
- function_requires< BidirectionalIteratorConcept<TT> >();
- function_requires< ComparableConcept<TT> >();
- function_requires< ConvertibleConcept<
- typename std::iterator_traits<TT>::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<TT>::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<TT>::difference_type n;
+ _Tp __a, __b;
+ _Tp __i, __j;
+ typename std::iterator_traits<_Tp>::difference_type __n;
};
- template <class TT>
- struct Mutable_RandomAccessIteratorConcept
+ template <class _Tp>
+ struct _Mutable_RandomAccessIteratorConcept
{
- void constraints() {
- function_requires< RandomAccessIteratorConcept<TT> >();
- function_requires< Mutable_BidirectionalIteratorConcept<TT> >();
- 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<TT>::difference_type n;
+ _Tp __i;
+ typename std::iterator_traits<_Tp>::difference_type __n;
};
//===========================================================================
// Container Concepts
- template <class Container>
- 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 <class Container>
- 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 <class _Container>
+ 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 <class _Container>
+ 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<Container> >();
- function_requires< AssignableConcept<value_type> >();
- function_requires< InputIteratorConcept<iterator> >();
+ 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 <class ForwardContainer>
- struct ForwardContainerConcept
+ template <class _ForwardContainer>
+ struct _ForwardContainerConcept
{
- void constraints() {
- function_requires< ContainerConcept<ForwardContainer> >();
- typedef typename ForwardContainer::const_iterator const_iterator;
- function_requires< ForwardIteratorConcept<const_iterator> >();
+ void __constraints() {
+ __function_requires< _ContainerConcept<_ForwardContainer> >();
+ typedef typename _ForwardContainer::const_iterator _Const_iterator;
+ __function_requires< _ForwardIteratorConcept<_Const_iterator> >();
}
};
- template <class ForwardContainer>
- struct Mutable_ForwardContainerConcept
+ template <class _ForwardContainer>
+ struct _Mutable_ForwardContainerConcept
{
- void constraints() {
- function_requires< ForwardContainerConcept<ForwardContainer> >();
- function_requires< Mutable_ContainerConcept<ForwardContainer> >();
- typedef typename ForwardContainer::iterator iterator;
- function_requires< Mutable_ForwardIteratorConcept<iterator> >();
+ void __constraints() {
+ __function_requires< _ForwardContainerConcept<_ForwardContainer> >();
+ __function_requires< _Mutable_ContainerConcept<_ForwardContainer> >();
+ typedef typename _ForwardContainer::iterator _Iterator;
+ __function_requires< _Mutable_ForwardIteratorConcept<_Iterator> >();
}
};
- template <class ReversibleContainer>
- struct ReversibleContainerConcept
+ template <class _ReversibleContainer>
+ 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<ReversibleContainer> >();
- function_requires< BidirectionalIteratorConcept<const_iterator> >();
- function_requires< BidirectionalIteratorConcept<const_reverse_iterator> >();
+ 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 <class ReversibleContainer>
- struct Mutable_ReversibleContainerConcept
+ template <class _ReversibleContainer>
+ 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<ReversibleContainer> >();
- function_requires< Mutable_ForwardContainerConcept<ReversibleContainer> >();
- function_requires< Mutable_BidirectionalIteratorConcept<iterator> >();
- function_requires< Mutable_BidirectionalIteratorConcept<reverse_iterator> >();
+ 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 <class RandomAccessContainer>
- struct RandomAccessContainerConcept
+ template <class _RandomAccessContainer>
+ 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<RandomAccessContainer> >();
- function_requires< RandomAccessIteratorConcept<const_iterator> >();
- function_requires< RandomAccessIteratorConcept<const_reverse_iterator> >();
+ 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 <class RandomAccessContainer>
- struct Mutable_RandomAccessContainerConcept
+ template <class _RandomAccessContainer>
+ 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<RandomAccessContainer> >();
- function_requires< Mutable_ReversibleContainerConcept<RandomAccessContainer> >();
- function_requires< Mutable_RandomAccessIteratorConcept<iterator> >();
- function_requires< Mutable_RandomAccessIteratorConcept<reverse_iterator> >();
+ 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 <class Sequence>
- struct SequenceConcept
+ template <class _Sequence>
+ 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<Sequence> >();
- function_requires< Mutable_ForwardContainerConcept<Sequence> >();
- function_requires< DefaultConstructibleConcept<Sequence> >();
+ __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 <class FrontInsertionSequence>
- struct FrontInsertionSequenceConcept
+ template <class _FrontInsertionSequence>
+ struct _FrontInsertionSequenceConcept
{
- void constraints() {
- function_requires< SequenceConcept<FrontInsertionSequence> >();
+ 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 <class BackInsertionSequence>
- struct BackInsertionSequenceConcept
+ template <class _BackInsertionSequence>
+ 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<BackInsertionSequence> >();
+ 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 <class AssociativeContainer>
- struct AssociativeContainerConcept
+ template <class _AssociativeContainer>
+ struct _AssociativeContainerConcept
{
- void constraints() {
- function_requires< ForwardContainerConcept<AssociativeContainer> >();
- function_requires< DefaultConstructibleConcept<AssociativeContainer> >();
+ void __constraints() {
+ __function_requires< _ForwardContainerConcept<_AssociativeContainer> >();
+ __function_requires<
+ _DefaultConstructibleConcept<_AssociativeContainer> >();
- i = c.find(k);
- r = c.equal_range(k);
- c.erase(k);
- c.erase(i);
- c.erase(r.first, r.second);
- const_constraints(c);
- }
- void const_constraints(const AssociativeContainer& c) {
- ci = c.find(k);
- n = c.count(k);
- cr = c.equal_range(k);
- }
- typedef typename AssociativeContainer::iterator iterator;
- typedef typename AssociativeContainer::const_iterator const_iterator;
-
- AssociativeContainer c;
- iterator i;
- std::pair<iterator,iterator> r;
- const_iterator ci;
- std::pair<const_iterator,const_iterator> cr;
- typename AssociativeContainer::key_type k;
- typename AssociativeContainer::size_type n;
- };
-
- template <class UniqueAssociativeContainer>
- struct UniqueAssociativeContainerConcept
- {
- void constraints() {
- function_requires< AssociativeContainerConcept<UniqueAssociativeContainer> >();
+ __i = __c.find(__k);
+ __r = __c.equal_range(__k);
+ __c.erase(__k);
+ __c.erase(__i);
+ __c.erase(__r.first, __r.second);
+ __const_constraints(__c);
+ }
+ void __const_constraints(const _AssociativeContainer& __c) {
+ __ci = __c.find(__k);
+ __n = __c.count(__k);
+ __cr = __c.equal_range(__k);
+ }
+ typedef typename _AssociativeContainer::iterator _Iterator;
+ typedef typename _AssociativeContainer::const_iterator _Const_iterator;
+
+ _AssociativeContainer __c;
+ _Iterator __i;
+ std::pair<_Iterator,_Iterator> __r;
+ _Const_iterator __ci;
+ std::pair<_Const_iterator,_Const_iterator> __cr;
+ typename _AssociativeContainer::key_type __k;
+ typename _AssociativeContainer::size_type __n;
+ };
+
+ template <class _UniqueAssociativeContainer>
+ struct _UniqueAssociativeContainerConcept
+ {
+ void __constraints() {
+ __function_requires<
+ _AssociativeContainerConcept<_UniqueAssociativeContainer> >();
- UniqueAssociativeContainer c(first, last);
+ _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<typename UniqueAssociativeContainer::iterator, bool> pos_flag;
- typename UniqueAssociativeContainer::value_type t;
- typename UniqueAssociativeContainer::value_type* first, *last;
+ std::pair<typename _UniqueAssociativeContainer::iterator, bool> __pos_flag;
+ typename _UniqueAssociativeContainer::value_type __t;
+ typename _UniqueAssociativeContainer::value_type *__first, *__last;
};
- template <class MultipleAssociativeContainer>
- struct MultipleAssociativeContainerConcept
+ template <class _MultipleAssociativeContainer>
+ struct _MultipleAssociativeContainerConcept
{
- void constraints() {
- function_requires< AssociativeContainerConcept<MultipleAssociativeContainer> >();
+ 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 <class SimpleAssociativeContainer>
- struct SimpleAssociativeContainerConcept
+ template <class _SimpleAssociativeContainer>
+ struct _SimpleAssociativeContainerConcept
{
- void constraints() {
- function_requires< AssociativeContainerConcept<SimpleAssociativeContainer> >();
- typedef typename SimpleAssociativeContainer::key_type key_type;
- typedef typename SimpleAssociativeContainer::value_type value_type;
- typedef typename require_same<key_type, value_type>::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 <class SimpleAssociativeContainer>
- struct PairAssociativeContainerConcept
+ template <class _SimpleAssociativeContainer>
+ struct _PairAssociativeContainerConcept
{
- void constraints() {
- function_requires< AssociativeContainerConcept<SimpleAssociativeContainer> >();
- typedef typename SimpleAssociativeContainer::key_type key_type;
- typedef typename SimpleAssociativeContainer::value_type value_type;
- typedef typename SimpleAssociativeContainer::mapped_type mapped_type;
- typedef std::pair<const key_type, mapped_type> required_value_type;
- typedef typename require_same<value_type, required_value_type>::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<const _Key_type, _Mapped_type> _Required_value_type;
+ typedef typename _Aux_require_same<_Value_type,
+ _Required_value_type>::_Type _Required;
}
};
- template <class SortedAssociativeContainer>
- struct SortedAssociativeContainerConcept
+ template <class _SortedAssociativeContainer>
+ struct _SortedAssociativeContainerConcept
{
- void constraints() {
- function_requires< AssociativeContainerConcept<SortedAssociativeContainer> >();
- function_requires< ReversibleContainerConcept<SortedAssociativeContainer> >();
+ 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<iterator,iterator> r;
- std::pair<const_iterator,const_iterator> 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
#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
// 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<Foo,Bar>)" 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
#include <bits/stl_heap.h>
-// See concept_check.h for the glibcpp_*_requires macros.
+// See concept_check.h for the __glibcpp_*_requires macros.
namespace std
{
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;
__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;
_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;
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));
}
_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));
}
_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;
_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)
_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;
_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))
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)
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)
_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>);
_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>);
_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;
_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)
_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>);
_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)
_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)
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)
_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)
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)
_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)
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)
{
/*
// XXX concept requirements
- glibcpp_function_requires(OutputIteratorConcept<_OutputIter,
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
"the return type of _Generator" ?? >);
*/
_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)
_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)
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);
_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);
_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;
_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;
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>);
_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;
_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);
_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>);
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));
}
_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) {
bidirectional_iterator_tag)
{
// concept requirements
- glibcpp_function_requires(Mutable_BidirectionalIteratorConcept<
+ __glibcpp_function_requires(_Mutable_BidirectionalIteratorConcept<
_BidirectionalIter>);
if (__first == __middle)
_Distance *, _Tp *)
{
// concept requirements
- glibcpp_function_requires(Mutable_RandomAccessIteratorConcept<
+ __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
_RandomAccessIter>);
_Distance __n = __last - __first;
_ForwardIter __last)
{
// concept requirements
- glibcpp_function_requires(Mutable_ForwardIteratorConcept<_ForwardIter>);
+ __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>);
return __rotate(__first, __middle, __last,
__distance_type(__first),
_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));
_RandomAccessIter __last)
{
// concept requirements
- glibcpp_function_requires(Mutable_RandomAccessIteratorConcept<
+ __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
_RandomAccessIter>);
if (__first == __last) return;
_RandomNumberGenerator& __rand)
{
// concept requirements
- glibcpp_function_requires(Mutable_RandomAccessIteratorConcept<
+ __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
_RandomAccessIter>);
if (__first == __last) return;
_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;
_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;
const _Distance __n)
{
// concept requirements
- glibcpp_function_requires(UnaryFunctionConcept<
+ __glibcpp_function_requires(_UnaryFunctionConcept<
_RandomNumberGenerator, _Distance, _Distance>);
_Distance __m = 0;
_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,
_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,
_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));
_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)
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) {
_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>);
_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,
_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>);
_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));
_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>);
_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,
_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>);
_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));
_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>);
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));
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));
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));
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));
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));
_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));
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);
_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);
_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) {
_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>);
_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)
_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>);
_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)
_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>);
_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) {
_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>);
_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)
_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>);
_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)
_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>);
_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)
_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>);
_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;
_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>);
_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;
_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>);
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)
_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>);
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)
_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>);
_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>);
_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>);
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;
_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;
_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>);
_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>);
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);
_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>);
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)
_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>);
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>);
inline void swap(_Tp& __a, _Tp& __b)
{
// concept requirements
- glibcpp_function_requires(SGIAssignableConcept<_Tp>);
+ __glibcpp_function_requires(_SGIAssignableConcept<_Tp>);
_Tp __tmp = __a;
__a = __b;
template <class _Tp>
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;
}
template <class _Tp>
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;
}
_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;
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>);
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);
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;
_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;
_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) {
_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;
_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)
_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))
_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
_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) {
_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);
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
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,
_Compare __comp)
{
// concept requirements
- glibcpp_function_requires(Mutable_RandomAccessIteratorConcept<
+ __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
_RandomAccessIterator>);
__push_heap_aux(__first, __last, __comp,
_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));
_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);
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,
_RandomAccessIterator __last, _Compare __comp)
{
// concept requirements
- glibcpp_function_requires(Mutable_RandomAccessIteratorConcept<
+ __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
_RandomAccessIterator>);
__make_heap(__first, __last, __comp,
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)
_RandomAccessIterator __last, _Compare __comp)
{
// concept requirements
- glibcpp_function_requires(Mutable_RandomAccessIteratorConcept<
+ __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
_RandomAccessIterator>);
while (__last - __first > 1)
_Distance& __n, input_iterator_tag)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIterator>);
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>);
while (__first != __last) { ++__first; ++__n; }
}
_Distance& __n, random_access_iterator_tag)
{
// concept requirements
- glibcpp_function_requires(RandomAccessIteratorConcept<_RandomAccessIterator>);
+ __glibcpp_function_requires(_RandomAccessIteratorConcept<_RandomAccessIterator>);
__n += __last - __first;
}
__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;
random_access_iterator_tag)
{
// concept requirements
- glibcpp_function_requires(RandomAccessIteratorConcept<_RandomAccessIterator>);
+ __glibcpp_function_requires(_RandomAccessIteratorConcept<_RandomAccessIterator>);
return __last - __first;
}
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;
}
bidirectional_iterator_tag)
{
// concept requirements
-glibcpp_function_requires(BidirectionalIteratorConcept<_BidirectionalIterator>);
+__glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIterator>);
if (__n >= 0)
while (__n--) ++__i;
else
random_access_iterator_tag)
{
// concept requirements
- glibcpp_function_requires(RandomAccessIteratorConcept<_RandomAccessIterator>);
+ __glibcpp_function_requires(_RandomAccessIteratorConcept<_RandomAccessIterator>);
__i += __n;
}
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:
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:
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:
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:
_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;
_BinaryOperation __binary_op)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIterator>);
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>);
for ( ; __first != __last; ++__first)
__init = __binary_op(__init, *__first);
_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);
_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));
_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;
_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;
_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;
_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;
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)
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 <class _Tp1, class _Seq1>
friend bool operator== (const queue<_Tp1, _Seq1>&,
class priority_queue
{
// concept requirements
- glibcpp_class_requires(_Tp, SGIAssignableConcept);
- glibcpp_class_requires(_Sequence, SequenceConcept);
- glibcpp_class_requires(_Sequence, RandomAccessContainerConcept);
+ __glibcpp_class_requires(_Tp, _SGIAssignableConcept);
+ __glibcpp_class_requires(_Sequence, _SequenceConcept);
+ __glibcpp_class_requires(_Sequence, _RandomAccessContainerConcept);
typedef typename _Sequence::value_type _Sequence_value_type;
- glibcpp_class_requires2(_Tp, _Sequence_value_type, SameTypeConcept);
- glibcpp_class_requires4(_Compare, bool, _Tp, _Tp, BinaryFunctionConcept);
+ __glibcpp_class_requires2(_Tp, _Sequence_value_type, _SameTypeConcept);
+ __glibcpp_class_requires4(_Compare, bool, _Tp, _Tp, _BinaryFunctionConcept);
public:
typedef typename _Sequence::value_type value_type;
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:
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 <class _Tp1, class _Seq1>
friend bool operator== (const stack<_Tp1, _Seq1>&,
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;
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<pair<const _Key, _Tp>, _Key, _HashFcn,
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>,
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>,
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;
projects / gcc.git / commitdiff