This is the mail archive of the
libstdc++@gcc.gnu.org
mailing list for the libstdc++ project.
[v3] uglify concept-checking code
- To: libstdc++ at gcc dot gnu dot org, gcc-patches at gcc dot gnu dot org
- Subject: [v3] uglify concept-checking code
- From: Phil Edwards <pedwards at disaster dot jaj dot com>
- Date: Fri, 13 Apr 2001 05:16:49 -0400
Gaby and others reminded me that, when importing the checker code from Boost,
it moved from user-space to implementor-space, and as such needed to be
"uglified" -- basically, stick 1+ underscore in front of all identifiers;
see BADNAMES and C++STYLE for more. I had foolishly forgotten to do so.
The code is now so ugly that it will stop a clock. :-)
Since this touches just about every line of the header from Boost, this
essentially forks from their tree. All the code is now in a __gnu_cxx
"extensions" namespace, rather than namespace boost. We'd be lying if we
represented this code as that which they maintain. Most of the patch's
size is due to the changes in that header.
Also added is 'long long' support in line with the rest of the library.
One function is removed and replaced with a variable attribute; since this
(empty) function was actually being called, we save a call/return pair.
Tested and applied on trunk, no additional library regressions. (One problem
uncovered by the recent rel_ops/equal() patch is fixed in a separate patch,
arriving shortly.)
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.
Index: include/bits/boost_concept_check.h
===================================================================
RCS file: /cvs/gcc/gcc/libstdc++-v3/include/bits/boost_concept_check.h,v
retrieving revision 1.1
diff -u -3 -p -r1.1 boost_concept_check.h
--- boost_concept_check.h 2001/04/03 00:26:57 1.1
+++ boost_concept_check.h 2001/04/13 08:45:51
@@ -7,181 +7,184 @@
//
// GCC Note: based on version 1.12.0 of the Boost library.
-#ifndef BOOST_CONCEPT_CHECKS_HPP
-#define BOOST_CONCEPT_CHECKS_HPP
+#ifndef _GLIBCPP_BOOST_CONCEPT_CHECK
+#define _GLIBCPP_BOOST_CONCEPT_CHECK 1
#pragma GCC system_header
#include <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
@@ -193,695 +196,700 @@ struct require_same<T,T> { typedef T typ
// 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);
- }
- TT 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; \
+ 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);
+ }
+ _Tp __a, __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);
-
- 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_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);
+
+ _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
- }
- TT a, b;
- TT i, j;
- typename std::iterator_traits<TT>::difference_type n;
- };
-
- template <class TT>
- struct Mutable_RandomAccessIteratorConcept
- {
- void constraints() {
- function_requires< RandomAccessIteratorConcept<TT> >();
- function_requires< Mutable_BidirectionalIteratorConcept<TT> >();
- i[n] = *i; // require element access and assignment
+ __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
+ }
+ _Tp __a, __b;
+ _Tp __i, __j;
+ typename std::iterator_traits<_Tp>::difference_type __n;
+ };
+
+ template <class _Tp>
+ struct _Mutable_RandomAccessIteratorConcept
+ {
+ 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
+ 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;
+ 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> >();
-
- i = c.begin();
- i = c.end();
- c.swap(c2);
- }
- iterator i;
- Container c, c2;
- };
-
- 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<_Container> >();
+ __function_requires< _AssignableConcept<_Value_type> >();
+ __function_requires< _InputIteratorConcept<_Iterator> >();
+
+ __i = __c.begin();
+ __i = __c.end();
+ __c.swap(__c2);
+ }
+ _Iterator _i;
+ _Container __c, __c2;
+ };
+
+ template <class _ForwardContainer>
+ struct _ForwardContainerConcept
+ {
+ 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);
-
- c.insert(p, t);
+ __p = __c.upper_bound(__k);
+ __p = __c.lower_bound(__k);
+ __r = __c.equal_range(__k);
- 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 __gnu_cxx
+
+#undef _IsUnused
-} // namespace boost
+#endif // _GLIBCPP_BOOST_CONCEPT_CHECK
-#endif // BOOST_CONCEPT_CHECKS_HPP
Index: include/bits/concept_check.h
===================================================================
RCS file: /cvs/gcc/gcc/libstdc++-v3/include/bits/concept_check.h,v
retrieving revision 1.1
diff -u -3 -p -r1.1 concept_check.h
--- concept_check.h 2001/04/03 00:26:57 1.1
+++ concept_check.h 2001/04/13 08:45:51
@@ -55,11 +55,11 @@
#if defined(_GLIBCPP_NO_CONCEPT_CHECKS) || defined(_STL_NO_CONCEPT_CHECKS) \
|| defined(NDEBUG)
-#define glibcpp_function_requires(...)
-#define glibcpp_class_requires(a,b)
-#define glibcpp_class_requires2(a,b,c)
-#define glibcpp_class_requires3(a,b,c,d)
-#define glibcpp_class_requires4(a,b,c,d,e)
+#define __glibcpp_function_requires(...)
+#define __glibcpp_class_requires(_a,_b)
+#define __glibcpp_class_requires2(_a,_b,_c)
+#define __glibcpp_class_requires3(_a,_b,_c,_d)
+#define __glibcpp_class_requires4(_a,_b,_c,_d,_e)
#else // the checks are on
@@ -74,18 +74,18 @@
// BinaryPredicateConcept. The preprocessor tries to split things up on
// the commas in the template argument list. We can't use an inner pair of
// parenthesis to hide the commas, because "boost::(Temp<Foo,Bar>)" isn't
-// a valid instantiation pattern.
+// a valid instantiation pattern. Thus, we steal a feature from C99.
-#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)
+#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
Index: include/bits/stl_algo.h
===================================================================
RCS file: /cvs/gcc/gcc/libstdc++-v3/include/bits/stl_algo.h,v
retrieving revision 1.3
diff -u -3 -p -r1.3 stl_algo.h
--- stl_algo.h 2001/04/03 00:26:57 1.3
+++ stl_algo.h 2001/04/13 08:45:52
@@ -33,7 +33,7 @@
#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
{
@@ -44,7 +44,7 @@ template <class _Tp>
inline const _Tp& __median(const _Tp& __a, const _Tp& __b, const _Tp& __c)
{
// concept requirements
- glibcpp_function_requires(LessThanComparableConcept<_Tp>);
+ __glibcpp_function_requires(_LessThanComparableConcept<_Tp>);
if (__a < __b)
if (__b < __c)
return __b;
@@ -65,7 +65,7 @@ inline const _Tp&
__median(const _Tp& __a, const _Tp& __b, const _Tp& __c, _Compare __comp)
{
// concept requirements
- glibcpp_function_requires(BinaryFunctionConcept<_Compare, bool, _Tp, _Tp>);
+ __glibcpp_function_requires(_BinaryFunctionConcept<_Compare, bool, _Tp, _Tp>);
if (__comp(__a, __b))
if (__comp(__b, __c))
return __b;
@@ -86,7 +86,7 @@ template <class _InputIter, class _Funct
_Function for_each(_InputIter __first, _InputIter __last, _Function __f)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter>);
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
for ( ; __first != __last; ++__first)
__f(*__first);
return __f;
@@ -195,8 +195,8 @@ inline _InputIter find(_InputIter __firs
const _Tp& __val)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter>);
- glibcpp_function_requires(EqualOpConcept<
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
+ __glibcpp_function_requires(_EqualOpConcept<
typename iterator_traits<_InputIter>::value_type, _Tp>);
return find(__first, __last, __val, __iterator_category(__first));
}
@@ -206,8 +206,8 @@ inline _InputIter find_if(_InputIter __f
_Predicate __pred)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter>);
- glibcpp_function_requires(UnaryPredicateConcept<_Predicate,
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
+ __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
typename iterator_traits<_InputIter>::value_type>);
return find_if(__first, __last, __pred, __iterator_category(__first));
}
@@ -218,8 +218,8 @@ template <class _ForwardIter>
_ForwardIter adjacent_find(_ForwardIter __first, _ForwardIter __last)
{
// concept requirements
- glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>);
- glibcpp_function_requires(EqualityComparableConcept<
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
+ __glibcpp_function_requires(_EqualityComparableConcept<
typename iterator_traits<_ForwardIter>::value_type>);
if (__first == __last)
return __last;
@@ -237,8 +237,8 @@ _ForwardIter adjacent_find(_ForwardIter
_BinaryPredicate __binary_pred)
{
// concept requirements
- glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>);
- glibcpp_function_requires(BinaryPredicateConcept<_BinaryPredicate,
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
+ __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
typename iterator_traits<_ForwardIter>::value_type,
typename iterator_traits<_ForwardIter>::value_type>);
if (__first == __last)
@@ -263,10 +263,10 @@ void count(_InputIter __first, _InputIte
_Size& __n)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter>);
- glibcpp_function_requires(EqualityComparableConcept<
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
+ __glibcpp_function_requires(_EqualityComparableConcept<
typename iterator_traits<_InputIter>::value_type >);
- glibcpp_function_requires(EqualityComparableConcept<_Tp>);
+ __glibcpp_function_requires(_EqualityComparableConcept<_Tp>);
for ( ; __first != __last; ++__first)
if (*__first == __value)
++__n;
@@ -277,8 +277,8 @@ void count_if(_InputIter __first, _Input
_Size& __n)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter>);
- glibcpp_function_requires(UnaryPredicateConcept<_Predicate,
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
+ __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
typename iterator_traits<_InputIter>::value_type>);
for ( ; __first != __last; ++__first)
if (__pred(*__first))
@@ -290,10 +290,10 @@ typename iterator_traits<_InputIter>::di
count(_InputIter __first, _InputIter __last, const _Tp& __value)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter>);
- glibcpp_function_requires(EqualityComparableConcept<
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
+ __glibcpp_function_requires(_EqualityComparableConcept<
typename iterator_traits<_InputIter>::value_type >);
- glibcpp_function_requires(EqualityComparableConcept<_Tp>);
+ __glibcpp_function_requires(_EqualityComparableConcept<_Tp>);
typename iterator_traits<_InputIter>::difference_type __n = 0;
for ( ; __first != __last; ++__first)
if (*__first == __value)
@@ -306,8 +306,8 @@ typename iterator_traits<_InputIter>::di
count_if(_InputIter __first, _InputIter __last, _Predicate __pred)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter>);
- glibcpp_function_requires(UnaryPredicateConcept<_Predicate,
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
+ __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
typename iterator_traits<_InputIter>::value_type>);
typename iterator_traits<_InputIter>::difference_type __n = 0;
for ( ; __first != __last; ++__first)
@@ -324,9 +324,9 @@ _ForwardIter1 search(_ForwardIter1 __fir
_ForwardIter2 __first2, _ForwardIter2 __last2)
{
// concept requirements
- glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter1>);
- glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter2>);
- glibcpp_function_requires(EqualOpConcept<
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter1>);
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter2>);
+ __glibcpp_function_requires(_EqualOpConcept<
typename iterator_traits<_ForwardIter1>::value_type,
typename iterator_traits<_ForwardIter2>::value_type>);
@@ -376,9 +376,9 @@ _ForwardIter1 search(_ForwardIter1 __fir
_BinaryPred __predicate)
{
// concept requirements
- glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter1>);
- glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter2>);
- glibcpp_function_requires(BinaryPredicateConcept<_BinaryPred,
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter1>);
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter2>);
+ __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPred,
typename iterator_traits<_ForwardIter1>::value_type,
typename iterator_traits<_ForwardIter2>::value_type>);
@@ -437,10 +437,10 @@ _ForwardIter search_n(_ForwardIter __fir
_Integer __count, const _Tp& __val)
{
// concept requirements
- glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>);
- glibcpp_function_requires(EqualityComparableConcept<
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
+ __glibcpp_function_requires(_EqualityComparableConcept<
typename iterator_traits<_ForwardIter>::value_type>);
- glibcpp_function_requires(EqualityComparableConcept<_Tp>);
+ __glibcpp_function_requires(_EqualityComparableConcept<_Tp>);
if (__count <= 0)
return __first;
@@ -469,8 +469,8 @@ _ForwardIter search_n(_ForwardIter __fir
_BinaryPred __binary_pred)
{
// concept requirements
- glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>);
- glibcpp_function_requires(BinaryPredicateConcept<_BinaryPred,
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
+ __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPred,
typename iterator_traits<_ForwardIter>::value_type, _Tp>);
if (__count <= 0)
@@ -511,12 +511,12 @@ _ForwardIter2 swap_ranges(_ForwardIter1
_ForwardIter2 __first2)
{
// concept requirements
- glibcpp_function_requires(Mutable_ForwardIteratorConcept<_ForwardIter1>);
- glibcpp_function_requires(Mutable_ForwardIteratorConcept<_ForwardIter2>);
- glibcpp_function_requires(ConvertibleConcept<
+ __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter1>);
+ __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter2>);
+ __glibcpp_function_requires(_ConvertibleConcept<
typename iterator_traits<_ForwardIter1>::value_type,
typename iterator_traits<_ForwardIter2>::value_type>);
- glibcpp_function_requires(ConvertibleConcept<
+ __glibcpp_function_requires(_ConvertibleConcept<
typename iterator_traits<_ForwardIter2>::value_type,
typename iterator_traits<_ForwardIter1>::value_type>);
@@ -532,8 +532,8 @@ _OutputIter transform(_InputIter __first
_OutputIter __result, _UnaryOperation __unary_op)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter>);
- glibcpp_function_requires(OutputIteratorConcept<_OutputIter,
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
typename iterator_traits<_InputIter>::value_type>);
for ( ; __first != __last; ++__first, ++__result)
@@ -548,10 +548,10 @@ _OutputIter transform(_InputIter1 __firs
_BinaryOperation __binary_op)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter1>);
- glibcpp_function_requires(InputIteratorConcept<_InputIter2>);
- glibcpp_function_requires(OutputIteratorConcept<_OutputIter,
- // XXX really should be "the type returned by _BinaryOperation
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>);
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>);
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
+ // XXX really should be "the type returned by _BinaryOperation"
typename iterator_traits<_InputIter1>::value_type>);
for ( ; __first1 != __last1; ++__first1, ++__first2, ++__result)
@@ -566,10 +566,10 @@ void replace(_ForwardIter __first, _Forw
const _Tp& __old_value, const _Tp& __new_value)
{
// concept requirements
- glibcpp_function_requires(Mutable_ForwardIteratorConcept<_ForwardIter>);
- glibcpp_function_requires(EqualOpConcept<
+ __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>);
+ __glibcpp_function_requires(_EqualOpConcept<
typename iterator_traits<_ForwardIter>::value_type, _Tp>);
- glibcpp_function_requires(ConvertibleConcept<_Tp,
+ __glibcpp_function_requires(_ConvertibleConcept<_Tp,
typename iterator_traits<_ForwardIter>::value_type>);
for ( ; __first != __last; ++__first)
@@ -582,10 +582,10 @@ void replace_if(_ForwardIter __first, _F
_Predicate __pred, const _Tp& __new_value)
{
// concept requirements
- glibcpp_function_requires(Mutable_ForwardIteratorConcept<_ForwardIter>);
- glibcpp_function_requires(ConvertibleConcept<_Tp,
+ __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>);
+ __glibcpp_function_requires(_ConvertibleConcept<_Tp,
typename iterator_traits<_ForwardIter>::value_type>);
- glibcpp_function_requires(UnaryPredicateConcept<_Predicate,
+ __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
typename iterator_traits<_ForwardIter>::value_type>);
for ( ; __first != __last; ++__first)
@@ -599,10 +599,10 @@ _OutputIter replace_copy(_InputIter __fi
const _Tp& __old_value, const _Tp& __new_value)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter>);
- glibcpp_function_requires(OutputIteratorConcept<_OutputIter,
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
typename iterator_traits<_InputIter>::value_type>);
- glibcpp_function_requires(EqualOpConcept<
+ __glibcpp_function_requires(_EqualOpConcept<
typename iterator_traits<_InputIter>::value_type, _Tp>);
for ( ; __first != __last; ++__first, ++__result)
@@ -616,10 +616,10 @@ _OutputIter replace_copy_if(_InputIter _
_Predicate __pred, const _Tp& __new_value)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter>);
- glibcpp_function_requires(OutputIteratorConcept<_OutputIter,
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
typename iterator_traits<_InputIter>::value_type>);
- glibcpp_function_requires(UnaryPredicateConcept<_Predicate,
+ __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
typename iterator_traits<_InputIter>::value_type>);
for ( ; __first != __last; ++__first, ++__result)
@@ -633,8 +633,8 @@ template <class _ForwardIter, class _Gen
void generate(_ForwardIter __first, _ForwardIter __last, _Generator __gen)
{
// concept requirements
- glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>);
- glibcpp_function_requires(GeneratorConcept<_Generator,
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
+ __glibcpp_function_requires(_GeneratorConcept<_Generator,
typename iterator_traits<_ForwardIter>::value_type>);
for ( ; __first != __last; ++__first)
@@ -646,7 +646,7 @@ _OutputIter generate_n(_OutputIter __fir
{
/*
// XXX concept requirements
- glibcpp_function_requires(OutputIteratorConcept<_OutputIter,
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
"the return type of _Generator" ?? >);
*/
@@ -662,10 +662,10 @@ _OutputIter remove_copy(_InputIter __fir
_OutputIter __result, const _Tp& __value)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter>);
- glibcpp_function_requires(OutputIteratorConcept<_OutputIter,
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
typename iterator_traits<_InputIter>::value_type>);
- glibcpp_function_requires(EqualOpConcept<
+ __glibcpp_function_requires(_EqualOpConcept<
typename iterator_traits<_InputIter>::value_type, _Tp>);
for ( ; __first != __last; ++__first)
@@ -681,10 +681,10 @@ _OutputIter remove_copy_if(_InputIter __
_OutputIter __result, _Predicate __pred)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter>);
- glibcpp_function_requires(OutputIteratorConcept<_OutputIter,
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
typename iterator_traits<_InputIter>::value_type>);
- glibcpp_function_requires(UnaryPredicateConcept<_Predicate,
+ __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
typename iterator_traits<_InputIter>::value_type>);
for ( ; __first != __last; ++__first)
@@ -700,10 +700,10 @@ _ForwardIter remove(_ForwardIter __first
const _Tp& __value)
{
// concept requirements
- glibcpp_function_requires(Mutable_ForwardIteratorConcept<_ForwardIter>);
- glibcpp_function_requires(ConvertibleConcept<_Tp,
+ __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>);
+ __glibcpp_function_requires(_ConvertibleConcept<_Tp,
typename iterator_traits<_ForwardIter>::value_type>);
- glibcpp_function_requires(EqualOpConcept<
+ __glibcpp_function_requires(_EqualOpConcept<
typename iterator_traits<_ForwardIter>::value_type, _Tp>);
__first = find(__first, __last, __value);
@@ -717,8 +717,8 @@ _ForwardIter remove_if(_ForwardIter __fi
_Predicate __pred)
{
// concept requirements
- glibcpp_function_requires(Mutable_ForwardIteratorConcept<_ForwardIter>);
- glibcpp_function_requires(UnaryPredicateConcept<_Predicate,
+ __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>);
+ __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
typename iterator_traits<_ForwardIter>::value_type>);
__first = find_if(__first, __last, __pred);
@@ -770,10 +770,10 @@ inline _OutputIter unique_copy(_InputIte
_OutputIter __result)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter>);
- glibcpp_function_requires(OutputIteratorConcept<_OutputIter,
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
typename iterator_traits<_InputIter>::value_type>);
- glibcpp_function_requires(EqualityComparableConcept<
+ __glibcpp_function_requires(_EqualityComparableConcept<
typename iterator_traits<_InputIter>::value_type>);
if (__first == __last) return __result;
@@ -788,7 +788,7 @@ _OutputIter __unique_copy(_InputIter __f
_BinaryPredicate __binary_pred, _Tp*)
{
// concept requirements -- iterators already checked
- glibcpp_function_requires(BinaryPredicateConcept<_BinaryPredicate, _Tp, _Tp>);
+ __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPredicate, _Tp, _Tp>);
_Tp __value = *__first;
*__result = __value;
@@ -818,7 +818,7 @@ _ForwardIter __unique_copy(_InputIter __
forward_iterator_tag)
{
// concept requirements -- iterators already checked
- glibcpp_function_requires(BinaryPredicateConcept<_BinaryPredicate,
+ __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
typename iterator_traits<_ForwardIter>::value_type,
typename iterator_traits<_InputIter>::value_type>);
@@ -834,8 +834,8 @@ inline _OutputIter unique_copy(_InputIte
_BinaryPredicate __binary_pred)
{
// concept requirements -- predicates checked later
- glibcpp_function_requires(InputIteratorConcept<_InputIter>);
- glibcpp_function_requires(OutputIteratorConcept<_OutputIter,
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
typename iterator_traits<_InputIter>::value_type>);
if (__first == __last) return __result;
@@ -847,8 +847,8 @@ template <class _ForwardIter>
_ForwardIter unique(_ForwardIter __first, _ForwardIter __last)
{
// concept requirements
- glibcpp_function_requires(Mutable_ForwardIteratorConcept<_ForwardIter>);
- glibcpp_function_requires(EqualityComparableConcept<
+ __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>);
+ __glibcpp_function_requires(_EqualityComparableConcept<
typename iterator_traits<_ForwardIter>::value_type>);
__first = adjacent_find(__first, __last);
@@ -860,8 +860,8 @@ _ForwardIter unique(_ForwardIter __first
_BinaryPredicate __binary_pred)
{
// concept requirements
- glibcpp_function_requires(Mutable_ForwardIteratorConcept<_ForwardIter>);
- glibcpp_function_requires(BinaryPredicateConcept<_BinaryPredicate,
+ __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>);
+ __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
typename iterator_traits<_ForwardIter>::value_type,
typename iterator_traits<_ForwardIter>::value_type>);
@@ -892,7 +892,7 @@ template <class _BidirectionalIter>
inline void reverse(_BidirectionalIter __first, _BidirectionalIter __last)
{
// concept requirements
- glibcpp_function_requires(Mutable_BidirectionalIteratorConcept<
+ __glibcpp_function_requires(_Mutable_BidirectionalIteratorConcept<
_BidirectionalIter>);
__reverse(__first, __last, __iterator_category(__first));
}
@@ -903,8 +903,8 @@ _OutputIter reverse_copy(_BidirectionalI
_OutputIter __result)
{
// concept requirements
- glibcpp_function_requires(BidirectionalIteratorConcept<_BidirectionalIter>);
- glibcpp_function_requires(OutputIteratorConcept<_OutputIter,
+ __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter>);
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
typename iterator_traits<_BidirectionalIter>::value_type>);
while (__first != __last) {
@@ -972,7 +972,7 @@ _BidirectionalIter __rotate(_Bidirection
bidirectional_iterator_tag)
{
// concept requirements
- glibcpp_function_requires(Mutable_BidirectionalIteratorConcept<
+ __glibcpp_function_requires(_Mutable_BidirectionalIteratorConcept<
_BidirectionalIter>);
if (__first == __middle)
@@ -1003,7 +1003,7 @@ _RandomAccessIter __rotate(_RandomAccess
_Distance *, _Tp *)
{
// concept requirements
- glibcpp_function_requires(Mutable_RandomAccessIteratorConcept<
+ __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
_RandomAccessIter>);
_Distance __n = __last - __first;
@@ -1061,7 +1061,7 @@ inline _ForwardIter rotate(_ForwardIter
_ForwardIter __last)
{
// concept requirements
- glibcpp_function_requires(Mutable_ForwardIteratorConcept<_ForwardIter>);
+ __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>);
return __rotate(__first, __middle, __last,
__distance_type(__first),
@@ -1073,8 +1073,8 @@ _OutputIter rotate_copy(_ForwardIter __f
_ForwardIter __last, _OutputIter __result)
{
// concept requirements
- glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>);
- glibcpp_function_requires(OutputIteratorConcept<_OutputIter,
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
typename iterator_traits<_ForwardIter>::value_type>);
return copy(__first, __middle, copy(__middle, __last, __result));
@@ -1100,7 +1100,7 @@ inline void random_shuffle(_RandomAccess
_RandomAccessIter __last)
{
// concept requirements
- glibcpp_function_requires(Mutable_RandomAccessIteratorConcept<
+ __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
_RandomAccessIter>);
if (__first == __last) return;
@@ -1113,7 +1113,7 @@ void random_shuffle(_RandomAccessIter __
_RandomNumberGenerator& __rand)
{
// concept requirements
- glibcpp_function_requires(Mutable_RandomAccessIteratorConcept<
+ __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
_RandomAccessIter>);
if (__first == __last) return;
@@ -1128,8 +1128,8 @@ _OutputIter random_sample_n(_ForwardIter
_OutputIter __out, const _Distance __n)
{
// concept requirements
- glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>);
- glibcpp_function_requires(OutputIteratorConcept<_OutputIter,
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
typename iterator_traits<_ForwardIter>::value_type>);
_Distance __remaining = 0;
@@ -1156,10 +1156,10 @@ _OutputIter random_sample_n(_ForwardIter
_RandomNumberGenerator& __rand)
{
// concept requirements
- glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>);
- glibcpp_function_requires(OutputIteratorConcept<_OutputIter,
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
typename iterator_traits<_ForwardIter>::value_type>);
- glibcpp_function_requires(UnaryFunctionConcept<
+ __glibcpp_function_requires(_UnaryFunctionConcept<
_RandomNumberGenerator, _Distance, _Distance>);
_Distance __remaining = 0;
@@ -1208,7 +1208,7 @@ _RandomAccessIter __random_sample(_Input
const _Distance __n)
{
// concept requirements
- glibcpp_function_requires(UnaryFunctionConcept<
+ __glibcpp_function_requires(_UnaryFunctionConcept<
_RandomNumberGenerator, _Distance, _Distance>);
_Distance __m = 0;
@@ -1233,8 +1233,8 @@ random_sample(_InputIter __first, _Input
_RandomAccessIter __out_first, _RandomAccessIter __out_last)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter>);
- glibcpp_function_requires(Mutable_RandomAccessIteratorConcept<
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
+ __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
_RandomAccessIter>);
return __random_sample(__first, __last,
@@ -1250,8 +1250,8 @@ random_sample(_InputIter __first, _Input
_RandomNumberGenerator& __rand)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter>);
- glibcpp_function_requires(Mutable_RandomAccessIteratorConcept<
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
+ __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
_RandomAccessIter>);
return __random_sample(__first, __last,
@@ -1316,8 +1316,8 @@ inline _ForwardIter partition(_ForwardIt
_Predicate __pred)
{
// concept requirements
- glibcpp_function_requires(Mutable_ForwardIteratorConcept<_ForwardIter>);
- glibcpp_function_requires(UnaryPredicateConcept<_Predicate,
+ __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>);
+ __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
typename iterator_traits<_ForwardIter>::value_type>);
return __partition(__first, __last, __pred, __iterator_category(__first));
@@ -1397,8 +1397,8 @@ inline _ForwardIter stable_partition(_Fo
_Predicate __pred)
{
// concept requirements
- glibcpp_function_requires(Mutable_ForwardIteratorConcept<_ForwardIter>);
- glibcpp_function_requires(UnaryPredicateConcept<_Predicate,
+ __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>);
+ __glibcpp_function_requires(_UnaryPredicateConcept<_Predicate,
typename iterator_traits<_ForwardIter>::value_type>);
if (__first == __last)
@@ -1630,9 +1630,9 @@ template <class _RandomAccessIter>
inline void sort(_RandomAccessIter __first, _RandomAccessIter __last)
{
// concept requirements
- glibcpp_function_requires(Mutable_RandomAccessIteratorConcept<
+ __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
_RandomAccessIter>);
- glibcpp_function_requires(LessThanComparableConcept<
+ __glibcpp_function_requires(_LessThanComparableConcept<
typename iterator_traits<_RandomAccessIter>::value_type>);
if (__first != __last) {
@@ -1648,9 +1648,9 @@ inline void sort(_RandomAccessIter __fir
_Compare __comp)
{
// concept requirements
- glibcpp_function_requires(Mutable_RandomAccessIteratorConcept<
+ __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
_RandomAccessIter>);
- glibcpp_function_requires(BinaryPredicateConcept<_Compare,
+ __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
typename iterator_traits<_RandomAccessIter>::value_type,
typename iterator_traits<_RandomAccessIter>::value_type>);
@@ -1881,9 +1881,9 @@ inline void stable_sort(_RandomAccessIte
_RandomAccessIter __last)
{
// concept requirements
- glibcpp_function_requires(Mutable_RandomAccessIteratorConcept<
+ __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
_RandomAccessIter>);
- glibcpp_function_requires(LessThanComparableConcept<
+ __glibcpp_function_requires(_LessThanComparableConcept<
typename iterator_traits<_RandomAccessIter>::value_type>);
__stable_sort_aux(__first, __last,
@@ -1896,9 +1896,9 @@ inline void stable_sort(_RandomAccessIte
_RandomAccessIter __last, _Compare __comp)
{
// concept requirements
- glibcpp_function_requires(Mutable_RandomAccessIteratorConcept<
+ __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
_RandomAccessIter>);
- glibcpp_function_requires(BinaryPredicateConcept<_Compare,
+ __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
typename iterator_traits<_RandomAccessIter>::value_type,
typename iterator_traits<_RandomAccessIter>::value_type>);
@@ -1928,9 +1928,9 @@ inline void partial_sort(_RandomAccessIt
_RandomAccessIter __last)
{
// concept requirements
- glibcpp_function_requires(Mutable_RandomAccessIteratorConcept<
+ __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
_RandomAccessIter>);
- glibcpp_function_requires(LessThanComparableConcept<
+ __glibcpp_function_requires(_LessThanComparableConcept<
typename iterator_traits<_RandomAccessIter>::value_type>);
__partial_sort(__first, __middle, __last, __value_type(__first));
@@ -1954,9 +1954,9 @@ inline void partial_sort(_RandomAccessIt
_RandomAccessIter __last, _Compare __comp)
{
// concept requirements
- glibcpp_function_requires(Mutable_RandomAccessIteratorConcept<
+ __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
_RandomAccessIter>);
- glibcpp_function_requires(BinaryPredicateConcept<_Compare,
+ __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
typename iterator_traits<_RandomAccessIter>::value_type,
typename iterator_traits<_RandomAccessIter>::value_type>);
@@ -1997,13 +1997,13 @@ partial_sort_copy(_InputIter __first, _I
_RandomAccessIter __result_last)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter>);
- glibcpp_function_requires(ConvertibleConcept<
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
+ __glibcpp_function_requires(_ConvertibleConcept<
typename iterator_traits<_InputIter>::value_type,
typename iterator_traits<_RandomAccessIter>::value_type>);
- glibcpp_function_requires(LessThanComparableConcept<
+ __glibcpp_function_requires(_LessThanComparableConcept<
typename iterator_traits<_RandomAccessIter>::value_type>);
- glibcpp_function_requires(LessThanComparableConcept<
+ __glibcpp_function_requires(_LessThanComparableConcept<
typename iterator_traits<_InputIter>::value_type>);
return __partial_sort_copy(__first, __last, __result_first, __result_last,
@@ -2046,13 +2046,13 @@ partial_sort_copy(_InputIter __first, _I
_RandomAccessIter __result_last, _Compare __comp)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter>);
- glibcpp_function_requires(Mutable_RandomAccessIteratorConcept<
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
+ __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
_RandomAccessIter>);
- glibcpp_function_requires(ConvertibleConcept<
+ __glibcpp_function_requires(_ConvertibleConcept<
typename iterator_traits<_InputIter>::value_type,
typename iterator_traits<_RandomAccessIter>::value_type>);
- glibcpp_function_requires(BinaryPredicateConcept<_Compare,
+ __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
typename iterator_traits<_RandomAccessIter>::value_type,
typename iterator_traits<_RandomAccessIter>::value_type>);
@@ -2087,9 +2087,9 @@ inline void nth_element(_RandomAccessIte
_RandomAccessIter __last)
{
// concept requirements
- glibcpp_function_requires(Mutable_RandomAccessIteratorConcept<
+ __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
_RandomAccessIter>);
- glibcpp_function_requires(LessThanComparableConcept<
+ __glibcpp_function_requires(_LessThanComparableConcept<
typename iterator_traits<_RandomAccessIter>::value_type>);
__nth_element(__first, __nth, __last, __value_type(__first));
@@ -2120,9 +2120,9 @@ inline void nth_element(_RandomAccessIte
_RandomAccessIter __last, _Compare __comp)
{
// concept requirements
- glibcpp_function_requires(Mutable_RandomAccessIteratorConcept<
+ __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
_RandomAccessIter>);
- glibcpp_function_requires(BinaryPredicateConcept<_Compare,
+ __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
typename iterator_traits<_RandomAccessIter>::value_type,
typename iterator_traits<_RandomAccessIter>::value_type>);
@@ -2161,10 +2161,10 @@ inline _ForwardIter lower_bound(_Forward
const _Tp& __val)
{
// concept requirements
- glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>);
- glibcpp_function_requires(SameTypeConcept<_Tp,
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
+ __glibcpp_function_requires(_SameTypeConcept<_Tp,
typename iterator_traits<_ForwardIter>::value_type>);
- glibcpp_function_requires(LessThanComparableConcept<_Tp>);
+ __glibcpp_function_requires(_LessThanComparableConcept<_Tp>);
return __lower_bound(__first, __last, __val,
__distance_type(__first));
@@ -2199,10 +2199,10 @@ inline _ForwardIter lower_bound(_Forward
const _Tp& __val, _Compare __comp)
{
// concept requirements
- glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>);
- glibcpp_function_requires(SameTypeConcept<_Tp,
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
+ __glibcpp_function_requires(_SameTypeConcept<_Tp,
typename iterator_traits<_ForwardIter>::value_type>);
- glibcpp_function_requires(BinaryPredicateConcept<_Compare, _Tp, _Tp>);
+ __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, _Tp, _Tp>);
return __lower_bound(__first, __last, __val, __comp,
__distance_type(__first));
@@ -2237,10 +2237,10 @@ inline _ForwardIter upper_bound(_Forward
const _Tp& __val)
{
// concept requirements
- glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>);
- glibcpp_function_requires(SameTypeConcept<_Tp,
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
+ __glibcpp_function_requires(_SameTypeConcept<_Tp,
typename iterator_traits<_ForwardIter>::value_type>);
- glibcpp_function_requires(LessThanComparableConcept<_Tp>);
+ __glibcpp_function_requires(_LessThanComparableConcept<_Tp>);
return __upper_bound(__first, __last, __val,
__distance_type(__first));
@@ -2275,10 +2275,10 @@ inline _ForwardIter upper_bound(_Forward
const _Tp& __val, _Compare __comp)
{
// concept requirements
- glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>);
- glibcpp_function_requires(SameTypeConcept<_Tp,
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
+ __glibcpp_function_requires(_SameTypeConcept<_Tp,
typename iterator_traits<_ForwardIter>::value_type>);
- glibcpp_function_requires(BinaryPredicateConcept<_Compare, _Tp, _Tp>);
+ __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, _Tp, _Tp>);
return __upper_bound(__first, __last, __val, __comp,
__distance_type(__first));
@@ -2320,10 +2320,10 @@ inline pair<_ForwardIter, _ForwardIter>
equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val)
{
// concept requirements
- glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>);
- glibcpp_function_requires(SameTypeConcept<_Tp,
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
+ __glibcpp_function_requires(_SameTypeConcept<_Tp,
typename iterator_traits<_ForwardIter>::value_type>);
- glibcpp_function_requires(LessThanComparableConcept<_Tp>);
+ __glibcpp_function_requires(_LessThanComparableConcept<_Tp>);
return __equal_range(__first, __last, __val,
__distance_type(__first));
@@ -2366,10 +2366,10 @@ equal_range(_ForwardIter __first, _Forwa
_Compare __comp)
{
// concept requirements
- glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>);
- glibcpp_function_requires(SameTypeConcept<_Tp,
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
+ __glibcpp_function_requires(_SameTypeConcept<_Tp,
typename iterator_traits<_ForwardIter>::value_type>);
- glibcpp_function_requires(BinaryPredicateConcept<_Compare, _Tp, _Tp>);
+ __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, _Tp, _Tp>);
return __equal_range(__first, __last, __val, __comp,
__distance_type(__first));
@@ -2380,10 +2380,10 @@ bool binary_search(_ForwardIter __first,
const _Tp& __val)
{
// concept requirements
- glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>);
- glibcpp_function_requires(SameTypeConcept<_Tp,
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
+ __glibcpp_function_requires(_SameTypeConcept<_Tp,
typename iterator_traits<_ForwardIter>::value_type>);
- glibcpp_function_requires(LessThanComparableConcept<_Tp>);
+ __glibcpp_function_requires(_LessThanComparableConcept<_Tp>);
_ForwardIter __i = lower_bound(__first, __last, __val);
return __i != __last && !(__val < *__i);
@@ -2395,10 +2395,10 @@ bool binary_search(_ForwardIter __first,
_Compare __comp)
{
// concept requirements
- glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>);
- glibcpp_function_requires(SameTypeConcept<_Tp,
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
+ __glibcpp_function_requires(_SameTypeConcept<_Tp,
typename iterator_traits<_ForwardIter>::value_type>);
- glibcpp_function_requires(BinaryPredicateConcept<_Compare, _Tp, _Tp>);
+ __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, _Tp, _Tp>);
_ForwardIter __i = lower_bound(__first, __last, __val, __comp);
return __i != __last && !__comp(__val, *__i);
@@ -2412,14 +2412,14 @@ _OutputIter merge(_InputIter1 __first1,
_OutputIter __result)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter1>);
- glibcpp_function_requires(InputIteratorConcept<_InputIter2>);
- glibcpp_function_requires(OutputIteratorConcept<_OutputIter,
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>);
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>);
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
typename iterator_traits<_InputIter1>::value_type>);
- glibcpp_function_requires(SameTypeConcept<
+ __glibcpp_function_requires(_SameTypeConcept<
typename iterator_traits<_InputIter1>::value_type,
typename iterator_traits<_InputIter2>::value_type>);
- glibcpp_function_requires(LessThanComparableConcept<
+ __glibcpp_function_requires(_LessThanComparableConcept<
typename iterator_traits<_InputIter1>::value_type>);
while (__first1 != __last1 && __first2 != __last2) {
@@ -2443,14 +2443,14 @@ _OutputIter merge(_InputIter1 __first1,
_OutputIter __result, _Compare __comp)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter1>);
- glibcpp_function_requires(InputIteratorConcept<_InputIter2>);
- glibcpp_function_requires(SameTypeConcept<
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>);
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>);
+ __glibcpp_function_requires(_SameTypeConcept<
typename iterator_traits<_InputIter1>::value_type,
typename iterator_traits<_InputIter2>::value_type>);
- glibcpp_function_requires(OutputIteratorConcept<_OutputIter,
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
typename iterator_traits<_InputIter1>::value_type>);
- glibcpp_function_requires(BinaryPredicateConcept<_Compare,
+ __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
typename iterator_traits<_InputIter1>::value_type,
typename iterator_traits<_InputIter2>::value_type>);
@@ -2762,9 +2762,9 @@ inline void inplace_merge(_Bidirectional
_BidirectionalIter __last)
{
// concept requirements
- glibcpp_function_requires(Mutable_BidirectionalIteratorConcept<
+ __glibcpp_function_requires(_Mutable_BidirectionalIteratorConcept<
_BidirectionalIter>);
- glibcpp_function_requires(LessThanComparableConcept<
+ __glibcpp_function_requires(_LessThanComparableConcept<
typename iterator_traits<_BidirectionalIter>::value_type>);
if (__first == __middle || __middle == __last)
@@ -2779,9 +2779,9 @@ inline void inplace_merge(_Bidirectional
_BidirectionalIter __last, _Compare __comp)
{
// concept requirements
- glibcpp_function_requires(Mutable_BidirectionalIteratorConcept<
+ __glibcpp_function_requires(_Mutable_BidirectionalIteratorConcept<
_BidirectionalIter>);
- glibcpp_function_requires(BinaryPredicateConcept<_Compare,
+ __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
typename iterator_traits<_BidirectionalIter>::value_type,
typename iterator_traits<_BidirectionalIter>::value_type>);
@@ -2802,12 +2802,12 @@ bool includes(_InputIter1 __first1, _Inp
_InputIter2 __first2, _InputIter2 __last2)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter1>);
- glibcpp_function_requires(InputIteratorConcept<_InputIter2>);
- glibcpp_function_requires(SameTypeConcept<
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>);
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>);
+ __glibcpp_function_requires(_SameTypeConcept<
typename iterator_traits<_InputIter1>::value_type,
typename iterator_traits<_InputIter2>::value_type>);
- glibcpp_function_requires(LessThanComparableConcept<
+ __glibcpp_function_requires(_LessThanComparableConcept<
typename iterator_traits<_InputIter1>::value_type>);
while (__first1 != __last1 && __first2 != __last2)
@@ -2826,12 +2826,12 @@ bool includes(_InputIter1 __first1, _Inp
_InputIter2 __first2, _InputIter2 __last2, _Compare __comp)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter1>);
- glibcpp_function_requires(InputIteratorConcept<_InputIter2>);
- glibcpp_function_requires(SameTypeConcept<
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>);
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>);
+ __glibcpp_function_requires(_SameTypeConcept<
typename iterator_traits<_InputIter1>::value_type,
typename iterator_traits<_InputIter2>::value_type>);
- glibcpp_function_requires(BinaryPredicateConcept<_Compare,
+ __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
typename iterator_traits<_InputIter1>::value_type,
typename iterator_traits<_InputIter2>::value_type>);
@@ -2852,14 +2852,14 @@ _OutputIter set_union(_InputIter1 __firs
_OutputIter __result)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter1>);
- glibcpp_function_requires(InputIteratorConcept<_InputIter2>);
- glibcpp_function_requires(OutputIteratorConcept<_OutputIter,
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>);
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>);
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
typename iterator_traits<_InputIter1>::value_type>);
- glibcpp_function_requires(SameTypeConcept<
+ __glibcpp_function_requires(_SameTypeConcept<
typename iterator_traits<_InputIter1>::value_type,
typename iterator_traits<_InputIter2>::value_type>);
- glibcpp_function_requires(LessThanComparableConcept<
+ __glibcpp_function_requires(_LessThanComparableConcept<
typename iterator_traits<_InputIter1>::value_type>);
while (__first1 != __last1 && __first2 != __last2) {
@@ -2888,14 +2888,14 @@ _OutputIter set_union(_InputIter1 __firs
_OutputIter __result, _Compare __comp)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter1>);
- glibcpp_function_requires(InputIteratorConcept<_InputIter2>);
- glibcpp_function_requires(SameTypeConcept<
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>);
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>);
+ __glibcpp_function_requires(_SameTypeConcept<
typename iterator_traits<_InputIter1>::value_type,
typename iterator_traits<_InputIter2>::value_type>);
- glibcpp_function_requires(OutputIteratorConcept<_OutputIter,
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
typename iterator_traits<_InputIter1>::value_type>);
- glibcpp_function_requires(BinaryPredicateConcept<_Compare,
+ __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
typename iterator_traits<_InputIter1>::value_type,
typename iterator_traits<_InputIter2>::value_type>);
@@ -2924,14 +2924,14 @@ _OutputIter set_intersection(_InputIter1
_OutputIter __result)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter1>);
- glibcpp_function_requires(InputIteratorConcept<_InputIter2>);
- glibcpp_function_requires(OutputIteratorConcept<_OutputIter,
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>);
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>);
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
typename iterator_traits<_InputIter1>::value_type>);
- glibcpp_function_requires(SameTypeConcept<
+ __glibcpp_function_requires(_SameTypeConcept<
typename iterator_traits<_InputIter1>::value_type,
typename iterator_traits<_InputIter2>::value_type>);
- glibcpp_function_requires(LessThanComparableConcept<
+ __glibcpp_function_requires(_LessThanComparableConcept<
typename iterator_traits<_InputIter1>::value_type>);
while (__first1 != __last1 && __first2 != __last2)
@@ -2955,14 +2955,14 @@ _OutputIter set_intersection(_InputIter1
_OutputIter __result, _Compare __comp)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter1>);
- glibcpp_function_requires(InputIteratorConcept<_InputIter2>);
- glibcpp_function_requires(SameTypeConcept<
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>);
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>);
+ __glibcpp_function_requires(_SameTypeConcept<
typename iterator_traits<_InputIter1>::value_type,
typename iterator_traits<_InputIter2>::value_type>);
- glibcpp_function_requires(OutputIteratorConcept<_OutputIter,
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
typename iterator_traits<_InputIter1>::value_type>);
- glibcpp_function_requires(BinaryPredicateConcept<_Compare,
+ __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
typename iterator_traits<_InputIter1>::value_type,
typename iterator_traits<_InputIter2>::value_type>);
@@ -2986,14 +2986,14 @@ _OutputIter set_difference(_InputIter1 _
_OutputIter __result)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter1>);
- glibcpp_function_requires(InputIteratorConcept<_InputIter2>);
- glibcpp_function_requires(OutputIteratorConcept<_OutputIter,
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>);
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>);
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
typename iterator_traits<_InputIter1>::value_type>);
- glibcpp_function_requires(SameTypeConcept<
+ __glibcpp_function_requires(_SameTypeConcept<
typename iterator_traits<_InputIter1>::value_type,
typename iterator_traits<_InputIter2>::value_type>);
- glibcpp_function_requires(LessThanComparableConcept<
+ __glibcpp_function_requires(_LessThanComparableConcept<
typename iterator_traits<_InputIter1>::value_type>);
while (__first1 != __last1 && __first2 != __last2)
@@ -3018,14 +3018,14 @@ _OutputIter set_difference(_InputIter1 _
_OutputIter __result, _Compare __comp)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter1>);
- glibcpp_function_requires(InputIteratorConcept<_InputIter2>);
- glibcpp_function_requires(SameTypeConcept<
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>);
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>);
+ __glibcpp_function_requires(_SameTypeConcept<
typename iterator_traits<_InputIter1>::value_type,
typename iterator_traits<_InputIter2>::value_type>);
- glibcpp_function_requires(OutputIteratorConcept<_OutputIter,
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
typename iterator_traits<_InputIter1>::value_type>);
- glibcpp_function_requires(BinaryPredicateConcept<_Compare,
+ __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
typename iterator_traits<_InputIter1>::value_type,
typename iterator_traits<_InputIter2>::value_type>);
@@ -3051,14 +3051,14 @@ set_symmetric_difference(_InputIter1 __f
_OutputIter __result)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter1>);
- glibcpp_function_requires(InputIteratorConcept<_InputIter2>);
- glibcpp_function_requires(OutputIteratorConcept<_OutputIter,
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>);
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>);
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
typename iterator_traits<_InputIter1>::value_type>);
- glibcpp_function_requires(SameTypeConcept<
+ __glibcpp_function_requires(_SameTypeConcept<
typename iterator_traits<_InputIter1>::value_type,
typename iterator_traits<_InputIter2>::value_type>);
- glibcpp_function_requires(LessThanComparableConcept<
+ __glibcpp_function_requires(_LessThanComparableConcept<
typename iterator_traits<_InputIter1>::value_type>);
while (__first1 != __last1 && __first2 != __last2)
@@ -3088,14 +3088,14 @@ set_symmetric_difference(_InputIter1 __f
_Compare __comp)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter1>);
- glibcpp_function_requires(InputIteratorConcept<_InputIter2>);
- glibcpp_function_requires(SameTypeConcept<
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>);
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>);
+ __glibcpp_function_requires(_SameTypeConcept<
typename iterator_traits<_InputIter1>::value_type,
typename iterator_traits<_InputIter2>::value_type>);
- glibcpp_function_requires(OutputIteratorConcept<_OutputIter,
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
typename iterator_traits<_InputIter1>::value_type>);
- glibcpp_function_requires(BinaryPredicateConcept<_Compare,
+ __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
typename iterator_traits<_InputIter1>::value_type,
typename iterator_traits<_InputIter2>::value_type>);
@@ -3124,8 +3124,8 @@ template <class _ForwardIter>
_ForwardIter max_element(_ForwardIter __first, _ForwardIter __last)
{
// concept requirements
- glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>);
- glibcpp_function_requires(LessThanComparableConcept<
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
+ __glibcpp_function_requires(_LessThanComparableConcept<
typename iterator_traits<_ForwardIter>::value_type>);
if (__first == __last) return __first;
@@ -3141,8 +3141,8 @@ _ForwardIter max_element(_ForwardIter __
_Compare __comp)
{
// concept requirements
- glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>);
- glibcpp_function_requires(BinaryPredicateConcept<_Compare,
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
+ __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
typename iterator_traits<_ForwardIter>::value_type,
typename iterator_traits<_ForwardIter>::value_type>);
@@ -3157,8 +3157,8 @@ template <class _ForwardIter>
_ForwardIter min_element(_ForwardIter __first, _ForwardIter __last)
{
// concept requirements
- glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>);
- glibcpp_function_requires(LessThanComparableConcept<
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
+ __glibcpp_function_requires(_LessThanComparableConcept<
typename iterator_traits<_ForwardIter>::value_type>);
if (__first == __last) return __first;
@@ -3174,8 +3174,8 @@ _ForwardIter min_element(_ForwardIter __
_Compare __comp)
{
// concept requirements
- glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>);
- glibcpp_function_requires(BinaryPredicateConcept<_Compare,
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
+ __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
typename iterator_traits<_ForwardIter>::value_type,
typename iterator_traits<_ForwardIter>::value_type>);
@@ -3194,8 +3194,8 @@ template <class _BidirectionalIter>
bool next_permutation(_BidirectionalIter __first, _BidirectionalIter __last)
{
// concept requirements
- glibcpp_function_requires(BidirectionalIteratorConcept<_BidirectionalIter>);
- glibcpp_function_requires(LessThanComparableConcept<
+ __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter>);
+ __glibcpp_function_requires(_LessThanComparableConcept<
typename iterator_traits<_BidirectionalIter>::value_type>);
if (__first == __last)
@@ -3230,8 +3230,8 @@ bool next_permutation(_BidirectionalIter
_Compare __comp)
{
// concept requirements
- glibcpp_function_requires(BidirectionalIteratorConcept<_BidirectionalIter>);
- glibcpp_function_requires(BinaryPredicateConcept<_Compare,
+ __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter>);
+ __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
typename iterator_traits<_BidirectionalIter>::value_type,
typename iterator_traits<_BidirectionalIter>::value_type>);
@@ -3266,8 +3266,8 @@ template <class _BidirectionalIter>
bool prev_permutation(_BidirectionalIter __first, _BidirectionalIter __last)
{
// concept requirements
- glibcpp_function_requires(BidirectionalIteratorConcept<_BidirectionalIter>);
- glibcpp_function_requires(LessThanComparableConcept<
+ __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter>);
+ __glibcpp_function_requires(_LessThanComparableConcept<
typename iterator_traits<_BidirectionalIter>::value_type>);
if (__first == __last)
@@ -3302,8 +3302,8 @@ bool prev_permutation(_BidirectionalIter
_Compare __comp)
{
// concept requirements
- glibcpp_function_requires(BidirectionalIteratorConcept<_BidirectionalIter>);
- glibcpp_function_requires(BinaryPredicateConcept<_Compare,
+ __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter>);
+ __glibcpp_function_requires(_BinaryPredicateConcept<_Compare,
typename iterator_traits<_BidirectionalIter>::value_type,
typename iterator_traits<_BidirectionalIter>::value_type>);
@@ -3341,9 +3341,9 @@ _InputIter find_first_of(_InputIter __fi
_ForwardIter __first2, _ForwardIter __last2)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter>);
- glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>);
- glibcpp_function_requires(EqualOpConcept<
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
+ __glibcpp_function_requires(_EqualOpConcept<
typename iterator_traits<_InputIter>::value_type,
typename iterator_traits<_ForwardIter>::value_type>);
@@ -3360,12 +3360,12 @@ _InputIter find_first_of(_InputIter __fi
_BinaryPredicate __comp)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter>);
- glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>);
- glibcpp_function_requires(EqualOpConcept<
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
+ __glibcpp_function_requires(_EqualOpConcept<
typename iterator_traits<_InputIter>::value_type,
typename iterator_traits<_ForwardIter>::value_type>);
- glibcpp_function_requires(BinaryPredicateConcept<_BinaryPredicate,
+ __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
typename iterator_traits<_InputIter>::value_type,
typename iterator_traits<_ForwardIter>::value_type>);
@@ -3439,8 +3439,8 @@ __find_end(_BidirectionalIter1 __first1,
bidirectional_iterator_tag, bidirectional_iterator_tag)
{
// concept requirements
- glibcpp_function_requires(BidirectionalIteratorConcept<_BidirectionalIter1>);
- glibcpp_function_requires(BidirectionalIteratorConcept<_BidirectionalIter2>);
+ __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter1>);
+ __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter2>);
typedef reverse_iterator<_BidirectionalIter1> _RevIter1;
typedef reverse_iterator<_BidirectionalIter2> _RevIter2;
@@ -3468,8 +3468,8 @@ __find_end(_BidirectionalIter1 __first1,
_BinaryPredicate __comp)
{
// concept requirements
- glibcpp_function_requires(BidirectionalIteratorConcept<_BidirectionalIter1>);
- glibcpp_function_requires(BidirectionalIteratorConcept<_BidirectionalIter2>);
+ __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter1>);
+ __glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIter2>);
typedef reverse_iterator<_BidirectionalIter1> _RevIter1;
typedef reverse_iterator<_BidirectionalIter2> _RevIter2;
@@ -3497,9 +3497,9 @@ find_end(_ForwardIter1 __first1, _Forwar
_ForwardIter2 __first2, _ForwardIter2 __last2)
{
// concept requirements
- glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter1>);
- glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter2>);
- glibcpp_function_requires(EqualOpConcept<
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter1>);
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter2>);
+ __glibcpp_function_requires(_EqualOpConcept<
typename iterator_traits<_ForwardIter1>::value_type,
typename iterator_traits<_ForwardIter2>::value_type>);
@@ -3516,9 +3516,9 @@ find_end(_ForwardIter1 __first1, _Forwar
_BinaryPredicate __comp)
{
// concept requirements
- glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter1>);
- glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter2>);
- glibcpp_function_requires(BinaryPredicateConcept<_BinaryPredicate,
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter1>);
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter2>);
+ __glibcpp_function_requires(_BinaryPredicateConcept<_BinaryPredicate,
typename iterator_traits<_ForwardIter1>::value_type,
typename iterator_traits<_ForwardIter2>::value_type>);
@@ -3563,8 +3563,8 @@ template <class _RandomAccessIter>
inline bool is_heap(_RandomAccessIter __first, _RandomAccessIter __last)
{
// concept requirements
- glibcpp_function_requires(RandomAccessIteratorConcept<_RandomAccessIter>);
- glibcpp_function_requires(LessThanComparableConcept<
+ __glibcpp_function_requires(_RandomAccessIteratorConcept<_RandomAccessIter>);
+ __glibcpp_function_requires(_LessThanComparableConcept<
typename iterator_traits<_RandomAccessIter>::value_type>);
return __is_heap(__first, __last - __first);
@@ -3576,8 +3576,8 @@ inline bool is_heap(_RandomAccessIter __
_StrictWeakOrdering __comp)
{
// concept requirements
- glibcpp_function_requires(RandomAccessIteratorConcept<_RandomAccessIter>);
- glibcpp_function_requires(BinaryPredicateConcept<_StrictWeakOrdering,
+ __glibcpp_function_requires(_RandomAccessIteratorConcept<_RandomAccessIter>);
+ __glibcpp_function_requires(_BinaryPredicateConcept<_StrictWeakOrdering,
typename iterator_traits<_RandomAccessIter>::value_type,
typename iterator_traits<_RandomAccessIter>::value_type>);
@@ -3592,8 +3592,8 @@ template <class _ForwardIter>
bool is_sorted(_ForwardIter __first, _ForwardIter __last)
{
// concept requirements
- glibcpp_function_requires(ForwardIteratorConcept<_ForwardIter>);
- glibcpp_function_requires(LessThanComparableConcept<
+ __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>);
+ __glibcpp_function_requires(_LessThanComparableConcept<
typename iterator_traits<_ForwardIter>::value_type>);
if (__first == __last)
@@ -3613,8 +3613,8 @@ bool is_sorted(_ForwardIter __first, _Fo
_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>);
Index: include/bits/stl_algobase.h
===================================================================
RCS file: /cvs/gcc/gcc/libstdc++-v3/include/bits/stl_algobase.h,v
retrieving revision 1.7
diff -u -3 -p -r1.7 stl_algobase.h
--- stl_algobase.h 2001/04/06 22:21:29 1.7
+++ stl_algobase.h 2001/04/13 08:45:55
@@ -68,12 +68,12 @@ template <class _ForwardIter1, class _Fo
inline void iter_swap(_ForwardIter1 __a, _ForwardIter2 __b)
{
// concept requirements
- glibcpp_function_requires(Mutable_ForwardIteratorConcept<_ForwardIter1>);
- glibcpp_function_requires(Mutable_ForwardIteratorConcept<_ForwardIter2>);
- glibcpp_function_requires(ConvertibleConcept<
+ __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter1>);
+ __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter2>);
+ __glibcpp_function_requires(_ConvertibleConcept<
typename iterator_traits<_ForwardIter1>::value_type,
typename iterator_traits<_ForwardIter2>::value_type>);
- glibcpp_function_requires(ConvertibleConcept<
+ __glibcpp_function_requires(_ConvertibleConcept<
typename iterator_traits<_ForwardIter2>::value_type,
typename iterator_traits<_ForwardIter1>::value_type>);
@@ -84,7 +84,7 @@ template <class _Tp>
inline void swap(_Tp& __a, _Tp& __b)
{
// concept requirements
- glibcpp_function_requires(SGIAssignableConcept<_Tp>);
+ __glibcpp_function_requires(_SGIAssignableConcept<_Tp>);
_Tp __tmp = __a;
__a = __b;
@@ -100,7 +100,7 @@ inline void swap(_Tp& __a, _Tp& __b)
template <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;
}
@@ -108,7 +108,7 @@ inline const _Tp& min(const _Tp& __a, co
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;
}
@@ -244,8 +244,8 @@ inline _OutputIter copy(_InputIter __fir
_OutputIter __result)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter>);
- glibcpp_function_requires(OutputIteratorConcept<_OutputIter,
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
typename iterator_traits<_InputIter>::value_type>);
typedef typename _Is_normal_iterator<_InputIter>::_Normal __Normal;
@@ -362,9 +362,9 @@ template <typename _BI1, typename _BI2>
inline _BI2 copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
{
// concept requirements
- glibcpp_function_requires(BidirectionalIteratorConcept<_BI1>);
- glibcpp_function_requires(Mutable_BidirectionalIteratorConcept<_BI2>);
- glibcpp_function_requires(ConvertibleConcept<
+ __glibcpp_function_requires(_BidirectionalIteratorConcept<_BI1>);
+ __glibcpp_function_requires(_Mutable_BidirectionalIteratorConcept<_BI2>);
+ __glibcpp_function_requires(_ConvertibleConcept<
typename iterator_traits<_BI1>::value_type,
typename iterator_traits<_BI2>::value_type>);
@@ -409,8 +409,8 @@ inline pair<_InputIter, _OutputIter>
copy_n(_InputIter __first, _Size __count, _OutputIter __result)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter>);
- glibcpp_function_requires(OutputIteratorConcept<_OutputIter,
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,
typename iterator_traits<_InputIter>::value_type>);
return __copy_n(__first, __count, __result);
@@ -424,7 +424,7 @@ template <class _ForwardIter, class _Tp>
void fill(_ForwardIter __first, _ForwardIter __last, const _Tp& __value)
{
// concept requirements
- glibcpp_function_requires(Mutable_ForwardIteratorConcept<_ForwardIter>);
+ __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>);
for ( ; __first != __last; ++__first)
*__first = __value;
@@ -434,7 +434,7 @@ template <class _OutputIter, class _Size
_OutputIter fill_n(_OutputIter __first, _Size __n, const _Tp& __value)
{
// concept requirements
- glibcpp_function_requires(OutputIteratorConcept<_OutputIter,_Tp>);
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIter,_Tp>);
for ( ; __n > 0; --__n, ++__first)
*__first = __value;
@@ -496,11 +496,11 @@ pair<_InputIter1, _InputIter2> mismatch(
_InputIter2 __first2)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter1>);
- glibcpp_function_requires(InputIteratorConcept<_InputIter2>);
- glibcpp_function_requires(EqualityComparableConcept<
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>);
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>);
+ __glibcpp_function_requires(_EqualityComparableConcept<
typename iterator_traits<_InputIter1>::value_type>);
- glibcpp_function_requires(EqualityComparableConcept<
+ __glibcpp_function_requires(_EqualityComparableConcept<
typename iterator_traits<_InputIter2>::value_type>);
while (__first1 != __last1 && *__first1 == *__first2) {
@@ -517,8 +517,8 @@ pair<_InputIter1, _InputIter2> mismatch(
_BinaryPredicate __binary_pred)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter1>);
- glibcpp_function_requires(InputIteratorConcept<_InputIter2>);
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>);
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>);
while (__first1 != __last1 && __binary_pred(*__first1, *__first2)) {
++__first1;
@@ -532,11 +532,11 @@ inline bool equal(_InputIter1 __first1,
_InputIter2 __first2)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter1>);
- glibcpp_function_requires(InputIteratorConcept<_InputIter2>);
- glibcpp_function_requires(EqualityComparableConcept<
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>);
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>);
+ __glibcpp_function_requires(_EqualityComparableConcept<
typename iterator_traits<_InputIter1>::value_type>);
- glibcpp_function_requires(EqualityComparableConcept<
+ __glibcpp_function_requires(_EqualityComparableConcept<
typename iterator_traits<_InputIter2>::value_type>);
for ( ; __first1 != __last1; ++__first1, ++__first2)
@@ -550,8 +550,8 @@ inline bool equal(_InputIter1 __first1,
_InputIter2 __first2, _BinaryPredicate __binary_pred)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter1>);
- glibcpp_function_requires(InputIteratorConcept<_InputIter2>);
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>);
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>);
for ( ; __first1 != __last1; ++__first1, ++__first2)
if (!__binary_pred(*__first1, *__first2))
@@ -568,11 +568,11 @@ bool lexicographical_compare(_InputIter1
_InputIter2 __first2, _InputIter2 __last2)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter1>);
- glibcpp_function_requires(InputIteratorConcept<_InputIter2>);
- glibcpp_function_requires(LessThanComparableConcept<
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>);
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>);
+ __glibcpp_function_requires(_LessThanComparableConcept<
typename iterator_traits<_InputIter1>::value_type>);
- glibcpp_function_requires(LessThanComparableConcept<
+ __glibcpp_function_requires(_LessThanComparableConcept<
typename iterator_traits<_InputIter2>::value_type>);
for ( ; __first1 != __last1 && __first2 != __last2
@@ -591,8 +591,8 @@ bool lexicographical_compare(_InputIter1
_Compare __comp)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter1>);
- glibcpp_function_requires(InputIteratorConcept<_InputIter2>);
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter1>);
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter2>);
for ( ; __first1 != __last1 && __first2 != __last2
; ++__first1, ++__first2) {
@@ -688,11 +688,11 @@ int lexicographical_compare_3way(_InputI
_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);
Index: include/bits/stl_deque.h
===================================================================
RCS file: /cvs/gcc/gcc/libstdc++-v3/include/bits/stl_deque.h,v
retrieving revision 1.4
diff -u -3 -p -r1.4 stl_deque.h
--- stl_deque.h 2001/04/03 00:26:57 1.4
+++ stl_deque.h 2001/04/13 08:45:55
@@ -357,7 +357,7 @@ template <class _Tp, class _Alloc = allo
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
Index: include/bits/stl_heap.h
===================================================================
RCS file: /cvs/gcc/gcc/libstdc++-v3/include/bits/stl_heap.h,v
retrieving revision 1.3
diff -u -3 -p -r1.3 stl_heap.h
--- stl_heap.h 2001/04/03 00:26:57 1.3
+++ stl_heap.h 2001/04/13 08:45:55
@@ -63,9 +63,9 @@ inline void
push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
{
// concept requirements
- glibcpp_function_requires(Mutable_RandomAccessIteratorConcept<
+ __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
_RandomAccessIterator>);
- glibcpp_function_requires(LessThanComparableConcept<
+ __glibcpp_function_requires(_LessThanComparableConcept<
typename iterator_traits<_RandomAccessIterator>::value_type>);
__push_heap_aux(__first, __last,
@@ -104,7 +104,7 @@ push_heap(_RandomAccessIterator __first,
_Compare __comp)
{
// concept requirements
- glibcpp_function_requires(Mutable_RandomAccessIteratorConcept<
+ __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
_RandomAccessIterator>);
__push_heap_aux(__first, __last, __comp,
@@ -155,9 +155,9 @@ inline void pop_heap(_RandomAccessIterat
_RandomAccessIterator __last)
{
// concept requirements
- glibcpp_function_requires(Mutable_RandomAccessIteratorConcept<
+ __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
_RandomAccessIterator>);
- glibcpp_function_requires(LessThanComparableConcept<
+ __glibcpp_function_requires(_LessThanComparableConcept<
typename iterator_traits<_RandomAccessIterator>::value_type>);
__pop_heap_aux(__first, __last, __value_type(__first));
@@ -212,7 +212,7 @@ pop_heap(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
{
// concept requirements
- glibcpp_function_requires(Mutable_RandomAccessIteratorConcept<
+ __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
_RandomAccessIterator>);
__pop_heap_aux(__first, __last, __value_type(__first), __comp);
@@ -239,9 +239,9 @@ inline void
make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
{
// concept requirements
- glibcpp_function_requires(Mutable_RandomAccessIteratorConcept<
+ __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
_RandomAccessIterator>);
- glibcpp_function_requires(LessThanComparableConcept<
+ __glibcpp_function_requires(_LessThanComparableConcept<
typename iterator_traits<_RandomAccessIterator>::value_type>);
__make_heap(__first, __last,
@@ -272,7 +272,7 @@ make_heap(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
{
// concept requirements
- glibcpp_function_requires(Mutable_RandomAccessIteratorConcept<
+ __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
_RandomAccessIterator>);
__make_heap(__first, __last, __comp,
@@ -283,9 +283,9 @@ template <class _RandomAccessIterator>
void sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
{
// concept requirements
- glibcpp_function_requires(Mutable_RandomAccessIteratorConcept<
+ __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
_RandomAccessIterator>);
- glibcpp_function_requires(LessThanComparableConcept<
+ __glibcpp_function_requires(_LessThanComparableConcept<
typename iterator_traits<_RandomAccessIterator>::value_type>);
while (__last - __first > 1)
@@ -298,7 +298,7 @@ sort_heap(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
{
// concept requirements
- glibcpp_function_requires(Mutable_RandomAccessIteratorConcept<
+ __glibcpp_function_requires(_Mutable_RandomAccessIteratorConcept<
_RandomAccessIterator>);
while (__last - __first > 1)
Index: include/bits/stl_iterator_base_funcs.h
===================================================================
RCS file: /cvs/gcc/gcc/libstdc++-v3/include/bits/stl_iterator_base_funcs.h,v
retrieving revision 1.1
diff -u -3 -p -r1.1 stl_iterator_base_funcs.h
--- stl_iterator_base_funcs.h 2001/04/03 00:26:57 1.1
+++ stl_iterator_base_funcs.h 2001/04/13 08:45:55
@@ -51,7 +51,7 @@ inline void __distance(_InputIterator __
_Distance& __n, input_iterator_tag)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIterator>);
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>);
while (__first != __last) { ++__first; ++__n; }
}
@@ -61,7 +61,7 @@ inline void __distance(_RandomAccessIter
_Distance& __n, random_access_iterator_tag)
{
// concept requirements
- glibcpp_function_requires(RandomAccessIteratorConcept<_RandomAccessIterator>);
+ __glibcpp_function_requires(_RandomAccessIteratorConcept<_RandomAccessIterator>);
__n += __last - __first;
}
@@ -78,7 +78,7 @@ inline typename iterator_traits<_InputIt
__distance(_InputIterator __first, _InputIterator __last, input_iterator_tag)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIterator>);
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>);
typename iterator_traits<_InputIterator>::difference_type __n = 0;
while (__first != __last) {
++__first; ++__n;
@@ -92,7 +92,7 @@ __distance(_RandomAccessIterator __first
random_access_iterator_tag)
{
// concept requirements
- glibcpp_function_requires(RandomAccessIteratorConcept<_RandomAccessIterator>);
+ __glibcpp_function_requires(_RandomAccessIteratorConcept<_RandomAccessIterator>);
return __last - __first;
}
@@ -110,7 +110,7 @@ template <class _InputIter, class _Dista
inline void __advance(_InputIter& __i, _Distance __n, input_iterator_tag)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIter>);
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIter>);
while (__n--) ++__i;
}
@@ -119,7 +119,7 @@ inline void __advance(_BidirectionalIter
bidirectional_iterator_tag)
{
// concept requirements
-glibcpp_function_requires(BidirectionalIteratorConcept<_BidirectionalIterator>);
+__glibcpp_function_requires(_BidirectionalIteratorConcept<_BidirectionalIterator>);
if (__n >= 0)
while (__n--) ++__i;
else
@@ -131,7 +131,7 @@ inline void __advance(_RandomAccessItera
random_access_iterator_tag)
{
// concept requirements
- glibcpp_function_requires(RandomAccessIteratorConcept<_RandomAccessIterator>);
+ __glibcpp_function_requires(_RandomAccessIteratorConcept<_RandomAccessIterator>);
__i += __n;
}
Index: include/bits/stl_list.h
===================================================================
RCS file: /cvs/gcc/gcc/libstdc++-v3/include/bits/stl_list.h,v
retrieving revision 1.3
diff -u -3 -p -r1.3 stl_list.h
--- stl_list.h 2001/04/03 00:26:57 1.3
+++ stl_list.h 2001/04/13 08:45:55
@@ -201,7 +201,7 @@ template <class _Tp, class _Alloc = allo
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:
Index: include/bits/stl_map.h
===================================================================
RCS file: /cvs/gcc/gcc/libstdc++-v3/include/bits/stl_map.h,v
retrieving revision 1.3
diff -u -3 -p -r1.3 stl_map.h
--- stl_map.h 2001/04/03 00:26:57 1.3
+++ stl_map.h 2001/04/13 08:45:55
@@ -41,8 +41,8 @@ template <class _Key, class _Tp, class _
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:
Index: include/bits/stl_multimap.h
===================================================================
RCS file: /cvs/gcc/gcc/libstdc++-v3/include/bits/stl_multimap.h,v
retrieving revision 1.3
diff -u -3 -p -r1.3 stl_multimap.h
--- stl_multimap.h 2001/04/03 00:26:57 1.3
+++ stl_multimap.h 2001/04/13 08:45:55
@@ -55,8 +55,8 @@ template <class _Key, class _Tp, class _
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:
Index: include/bits/stl_multiset.h
===================================================================
RCS file: /cvs/gcc/gcc/libstdc++-v3/include/bits/stl_multiset.h,v
retrieving revision 1.3
diff -u -3 -p -r1.3 stl_multiset.h
--- stl_multiset.h 2001/04/03 00:26:57 1.3
+++ stl_multiset.h 2001/04/13 08:45:55
@@ -54,8 +54,8 @@ template <class _Key, class _Compare, cl
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:
Index: include/bits/stl_numeric.h
===================================================================
RCS file: /cvs/gcc/gcc/libstdc++-v3/include/bits/stl_numeric.h,v
retrieving revision 1.3
diff -u -3 -p -r1.3 stl_numeric.h
--- stl_numeric.h 2001/04/03 00:26:57 1.3
+++ stl_numeric.h 2001/04/13 08:45:56
@@ -39,7 +39,7 @@ template <class _InputIterator, class _T
_Tp accumulate(_InputIterator __first, _InputIterator __last, _Tp __init)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIterator>);
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>);
for ( ; __first != __last; ++__first)
__init = __init + *__first;
@@ -51,7 +51,7 @@ _Tp accumulate(_InputIterator __first, _
_BinaryOperation __binary_op)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIterator>);
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>);
for ( ; __first != __last; ++__first)
__init = __binary_op(__init, *__first);
@@ -63,8 +63,8 @@ _Tp inner_product(_InputIterator1 __firs
_InputIterator2 __first2, _Tp __init)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIterator1>);
- glibcpp_function_requires(InputIteratorConcept<_InputIterator2>);
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>);
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>);
for ( ; __first1 != __last1; ++__first1, ++__first2)
__init = __init + (*__first1 * *__first2);
@@ -79,8 +79,8 @@ _Tp inner_product(_InputIterator1 __firs
_BinaryOperation2 __binary_op2)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIterator1>);
- glibcpp_function_requires(InputIteratorConcept<_InputIterator2>);
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator1>);
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator2>);
for ( ; __first1 != __last1; ++__first1, ++__first2)
__init = __binary_op1(__init, __binary_op2(*__first1, *__first2));
@@ -106,8 +106,8 @@ partial_sum(_InputIterator __first, _Inp
_OutputIterator __result)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIterator>);
- glibcpp_function_requires(OutputIteratorConcept<_OutputIterator,
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>);
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
typename iterator_traits<_InputIterator>::value_type>);
if (__first == __last) return __result;
@@ -135,8 +135,8 @@ partial_sum(_InputIterator __first, _Inp
_OutputIterator __result, _BinaryOperation __binary_op)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIterator>);
- glibcpp_function_requires(OutputIteratorConcept<_OutputIterator,
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>);
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
typename iterator_traits<_InputIterator>::value_type>);
if (__first == __last) return __result;
@@ -165,8 +165,8 @@ adjacent_difference(_InputIterator __fir
_InputIterator __last, _OutputIterator __result)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIterator>);
- glibcpp_function_requires(OutputIteratorConcept<_OutputIterator,
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>);
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
typename iterator_traits<_InputIterator>::value_type>);
if (__first == __last) return __result;
@@ -196,8 +196,8 @@ adjacent_difference(_InputIterator __fir
_OutputIterator __result, _BinaryOperation __binary_op)
{
// concept requirements
- glibcpp_function_requires(InputIteratorConcept<_InputIterator>);
- glibcpp_function_requires(OutputIteratorConcept<_OutputIterator,
+ __glibcpp_function_requires(_InputIteratorConcept<_InputIterator>);
+ __glibcpp_function_requires(_OutputIteratorConcept<_OutputIterator,
typename iterator_traits<_InputIterator>::value_type>);
if (__first == __last) return __result;
@@ -262,8 +262,8 @@ void
iota(_ForwardIter __first, _ForwardIter __last, _Tp __value)
{
// concept requirements
- glibcpp_function_requires(Mutable_ForwardIteratorConcept<_ForwardIter>);
- glibcpp_function_requires(ConvertibleConcept<_Tp,
+ __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>);
+ __glibcpp_function_requires(_ConvertibleConcept<_Tp,
typename iterator_traits<_ForwardIter>::value_type>);
while (__first != __last)
Index: include/bits/stl_queue.h
===================================================================
RCS file: /cvs/gcc/gcc/libstdc++-v3/include/bits/stl_queue.h,v
retrieving revision 1.3
diff -u -3 -p -r1.3 stl_queue.h
--- stl_queue.h 2001/04/03 00:26:57 1.3
+++ stl_queue.h 2001/04/13 08:45:56
@@ -53,11 +53,11 @@ template <class _Tp, class _Sequence>
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>&,
@@ -136,12 +136,12 @@ template <class _Tp,
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;
Index: include/bits/stl_set.h
===================================================================
RCS file: /cvs/gcc/gcc/libstdc++-v3/include/bits/stl_set.h,v
retrieving revision 1.3
diff -u -3 -p -r1.3 stl_set.h
--- stl_set.h 2001/04/03 00:26:57 1.3
+++ stl_set.h 2001/04/13 08:45:56
@@ -55,8 +55,8 @@ template <class _Key, class _Compare, cl
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:
Index: include/bits/stl_stack.h
===================================================================
RCS file: /cvs/gcc/gcc/libstdc++-v3/include/bits/stl_stack.h,v
retrieving revision 1.3
diff -u -3 -p -r1.3 stl_stack.h
--- stl_stack.h 2001/04/03 00:26:57 1.3
+++ stl_stack.h 2001/04/13 08:45:56
@@ -53,10 +53,10 @@ template <class _Tp, class _Sequence>
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>&,
Index: include/bits/stl_vector.h
===================================================================
RCS file: /cvs/gcc/gcc/libstdc++-v3/include/bits/stl_vector.h,v
retrieving revision 1.4
diff -u -3 -p -r1.4 stl_vector.h
--- stl_vector.h 2001/04/03 00:26:57 1.4
+++ stl_vector.h 2001/04/13 08:45:56
@@ -118,7 +118,7 @@ template <class _Tp, class _Alloc = allo
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;
Index: include/ext/hash_map
===================================================================
RCS file: /cvs/gcc/gcc/libstdc++-v3/include/ext/hash_map,v
retrieving revision 1.3
diff -u -3 -p -r1.3 hash_map
--- hash_map 2001/04/03 00:26:57 1.3
+++ hash_map 2001/04/13 08:45:56
@@ -204,10 +204,10 @@ template <class _Key, class _Tp, class _
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,
Index: include/ext/hash_set
===================================================================
RCS file: /cvs/gcc/gcc/libstdc++-v3/include/ext/hash_set,v
retrieving revision 1.3
diff -u -3 -p -r1.3 hash_set
--- hash_set 2001/04/03 00:26:57 1.3
+++ hash_set 2001/04/13 08:45:56
@@ -54,9 +54,9 @@ template <class _Value, class _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>,
@@ -205,9 +205,9 @@ template <class _Value, class _HashFcn,
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>,
Index: include/ext/slist
===================================================================
RCS file: /cvs/gcc/gcc/libstdc++-v3/include/ext/slist,v
retrieving revision 1.3
diff -u -3 -p -r1.3 slist
--- slist 2001/04/03 00:26:57 1.3
+++ slist 2001/04/13 08:45:56
@@ -258,7 +258,7 @@ template <class _Tp, class _Alloc = allo
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;