Skip to content

R
riscv-gcc-1
Commit 62bb0c97 by Phil Edwards
Options

boost_concept_check.h: Uglify, fork from Boost. 

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.

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