00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00016 #ifndef _GLIBCPP_BOOST_CONCEPT_CHECK
00017 #define _GLIBCPP_BOOST_CONCEPT_CHECK 1
00018
00019 #pragma GCC system_header
00020 #include <cstddef>
00021 #include <bits/stl_iterator_base_types.h>
00022 #include <utility>
00023
00024
00025 namespace __gnu_cxx
00026 {
00027
00028 #define _IsUnused __attribute__ ((__unused__))
00029
00030
00031
00032
00033 template <class _Concept>
00034 inline void __function_requires()
00035 {
00036 void (_Concept::*__x)() _IsUnused = &_Concept::__constraints;
00037 }
00038
00039
00040
00041 #define _GLIBCPP_CLASS_REQUIRES(_type_var, _ns, _concept) \
00042 typedef void (_ns::_concept <_type_var>::* _func##_type_var##_concept)(); \
00043 template <_func##_type_var##_concept _Tp1> \
00044 struct _concept_checking##_type_var##_concept { }; \
00045 typedef _concept_checking##_type_var##_concept< \
00046 &_ns::_concept <_type_var>::__constraints> \
00047 _concept_checking_typedef##_type_var##_concept
00048
00049 #define _GLIBCPP_CLASS_REQUIRES2(_type_var1, _type_var2, _ns, _concept) \
00050 typedef void (_ns::_concept <_type_var1,_type_var2>::* _func##_type_var1##_type_var2##_concept)(); \
00051 template <_func##_type_var1##_type_var2##_concept _Tp1> \
00052 struct _concept_checking##_type_var1##_type_var2##_concept { }; \
00053 typedef _concept_checking##_type_var1##_type_var2##_concept< \
00054 &_ns::_concept <_type_var1,_type_var2>::__constraints> \
00055 _concept_checking_typedef##_type_var1##_type_var2##_concept
00056
00057 #define _GLIBCPP_CLASS_REQUIRES3(_type_var1, _type_var2, _type_var3, _ns, _concept) \
00058 typedef void (_ns::_concept <_type_var1,_type_var2,_type_var3>::* _func##_type_var1##_type_var2##_type_var3##_concept)(); \
00059 template <_func##_type_var1##_type_var2##_type_var3##_concept _Tp1> \
00060 struct _concept_checking##_type_var1##_type_var2##_type_var3##_concept { }; \
00061 typedef _concept_checking##_type_var1##_type_var2##_type_var3##_concept< \
00062 &_ns::_concept <_type_var1,_type_var2,_type_var3>::__constraints> \
00063 _concept_checking_typedef##_type_var1##_type_var2##_type_var3##_concept
00064
00065 #define _GLIBCPP_CLASS_REQUIRES4(_type_var1, _type_var2, _type_var3, _type_var4, _ns, _concept) \
00066 typedef void (_ns::_concept <_type_var1,_type_var2,_type_var3,_type_var4>::* _func##_type_var1##_type_var2##_type_var3##_type_var4##_concept)(); \
00067 template <_func##_type_var1##_type_var2##_type_var3##_type_var4##_concept _Tp1> \
00068 struct _concept_checking##_type_var1##_type_var2##_type_var3##_type_var4##_concept { }; \
00069 typedef _concept_checking##_type_var1##_type_var2##_type_var3##_type_var4##_concept< \
00070 &_ns::_concept <_type_var1,_type_var2,_type_var3,_type_var4>::__constraints> \
00071 _concept_checking_typedef##_type_var1##_type_var2##_type_var3##_type_var4##_concept
00072
00073
00074 template <class _Tp1, class _Tp2>
00075 struct _Aux_require_same { };
00076
00077 template <class _Tp>
00078 struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
00079
00080 template <class _Tp1, class _Tp2>
00081 struct _SameTypeConcept
00082 {
00083 void __constraints() {
00084 typedef typename _Aux_require_same<_Tp1, _Tp2>::_Type _Required;
00085 }
00086 };
00087
00088 template <class _Tp>
00089 struct _IntegerConcept {
00090 void __constraints() {
00091 __error_type_must_be_an_integer_type();
00092 }
00093 };
00094 template <> struct _IntegerConcept<short> { void __constraints() {} };
00095 template <> struct _IntegerConcept<unsigned short> { void __constraints(){} };
00096 template <> struct _IntegerConcept<int> { void __constraints() {} };
00097 template <> struct _IntegerConcept<unsigned int> { void __constraints() {} };
00098 template <> struct _IntegerConcept<long> { void __constraints() {} };
00099 template <> struct _IntegerConcept<unsigned long> { void __constraints() {} };
00100 template <> struct _IntegerConcept<long long> { void __constraints() {} };
00101 template <> struct _IntegerConcept<unsigned long long>
00102 { void __constraints() {} };
00103
00104 template <class _Tp>
00105 struct _SignedIntegerConcept {
00106 void __constraints() {
00107 __error_type_must_be_a_signed_integer_type();
00108 }
00109 };
00110 template <> struct _SignedIntegerConcept<short> { void __constraints() {} };
00111 template <> struct _SignedIntegerConcept<int> { void __constraints() {} };
00112 template <> struct _SignedIntegerConcept<long> { void __constraints() {} };
00113 template <> struct _SignedIntegerConcept<long long> { void __constraints(){}};
00114
00115 template <class _Tp>
00116 struct _UnsignedIntegerConcept {
00117 void __constraints() {
00118 __error_type_must_be_an_unsigned_integer_type();
00119 }
00120 };
00121 template <> struct _UnsignedIntegerConcept<unsigned short>
00122 { void __constraints() {} };
00123 template <> struct _UnsignedIntegerConcept<unsigned int>
00124 { void __constraints() {} };
00125 template <> struct _UnsignedIntegerConcept<unsigned long>
00126 { void __constraints() {} };
00127 template <> struct _UnsignedIntegerConcept<unsigned long long>
00128 { void __constraints() {} };
00129
00130
00131
00132
00133 template <class _Tp>
00134 struct _DefaultConstructibleConcept
00135 {
00136 void __constraints() {
00137 _Tp __a _IsUnused;
00138 }
00139 };
00140
00141 template <class _Tp>
00142 struct _AssignableConcept
00143 {
00144 void __constraints() {
00145 __a = __a;
00146 __const_constraints(__a);
00147 }
00148 void __const_constraints(const _Tp& __b) {
00149 __a = __b;
00150 }
00151 _Tp __a;
00152 };
00153
00154 template <class _Tp>
00155 struct _CopyConstructibleConcept
00156 {
00157 void __constraints() {
00158 _Tp __a(__b);
00159 _Tp* __ptr _IsUnused = &__a;
00160 __const_constraints(__a);
00161 }
00162 void __const_constraints(const _Tp& __a) {
00163 _Tp __c(__a) _IsUnused;
00164 const _Tp* __ptr _IsUnused = &__a;
00165 }
00166 _Tp __b;
00167 };
00168
00169
00170 template <class _Tp>
00171 struct _SGIAssignableConcept
00172 {
00173 void __constraints() {
00174 _Tp __b(__a) _IsUnused;
00175 __a = __a;
00176 __const_constraints(__a);
00177 }
00178 void __const_constraints(const _Tp& __b) {
00179 _Tp __c(__b) _IsUnused;
00180 __a = __b;
00181 }
00182 _Tp __a;
00183 };
00184
00185 template <class _From, class _To>
00186 struct _ConvertibleConcept
00187 {
00188 void __constraints() {
00189 _To __y _IsUnused = __x;
00190 }
00191 _From __x;
00192 };
00193
00194
00195
00196
00197
00198
00199
00200
00201
00202
00203 template <class _Tp>
00204 void __aux_require_boolean_expr(const _Tp& __t) {
00205 bool __x _IsUnused = __t;
00206 }
00207
00208
00209 template <class _Tp>
00210 struct _EqualityComparableConcept
00211 {
00212 void __constraints() {
00213 __aux_require_boolean_expr(__a == __b);
00214 __aux_require_boolean_expr(__a != __b);
00215 }
00216 _Tp __a, __b;
00217 };
00218
00219 template <class _Tp>
00220 struct _LessThanComparableConcept
00221 {
00222 void __constraints() {
00223 __aux_require_boolean_expr(__a < __b);
00224 }
00225 _Tp __a, __b;
00226 };
00227
00228
00229 template <class _Tp>
00230 struct _ComparableConcept
00231 {
00232 void __constraints() {
00233 __aux_require_boolean_expr(__a < __b);
00234 __aux_require_boolean_expr(__a > __b);
00235 __aux_require_boolean_expr(__a <= __b);
00236 __aux_require_boolean_expr(__a >= __b);
00237 }
00238 _Tp __a, __b;
00239 };
00240
00241 #define _GLIBCPP_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(_OP,_NAME) \
00242 template <class _First, class _Second> \
00243 struct _NAME { \
00244 void __constraints() { (void)__constraints_(); } \
00245 bool __constraints_() { \
00246 return __a _OP __b; \
00247 } \
00248 _First __a; \
00249 _Second __b; \
00250 }
00251
00252 #define _GLIBCPP_DEFINE_BINARY_OPERATOR_CONSTRAINT(_OP,_NAME) \
00253 template <class _Ret, class _First, class _Second> \
00254 struct _NAME { \
00255 void __constraints() { (void)__constraints_(); } \
00256 _Ret __constraints_() { \
00257 return __a _OP __b; \
00258 } \
00259 _First __a; \
00260 _Second __b; \
00261 }
00262
00263 _GLIBCPP_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(==, _EqualOpConcept);
00264 _GLIBCPP_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(!=, _NotEqualOpConcept);
00265 _GLIBCPP_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<, _LessThanOpConcept);
00266 _GLIBCPP_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<=, _LessEqualOpConcept);
00267 _GLIBCPP_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>, _GreaterThanOpConcept);
00268 _GLIBCPP_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>=, _GreaterEqualOpConcept);
00269
00270 _GLIBCPP_DEFINE_BINARY_OPERATOR_CONSTRAINT(+, _PlusOpConcept);
00271 _GLIBCPP_DEFINE_BINARY_OPERATOR_CONSTRAINT(*, _TimesOpConcept);
00272 _GLIBCPP_DEFINE_BINARY_OPERATOR_CONSTRAINT(/, _DivideOpConcept);
00273 _GLIBCPP_DEFINE_BINARY_OPERATOR_CONSTRAINT(-, _SubtractOpConcept);
00274 _GLIBCPP_DEFINE_BINARY_OPERATOR_CONSTRAINT(%, _ModOpConcept);
00275
00276 #undef _GLIBCPP_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT
00277 #undef _GLIBCPP_DEFINE_BINARY_OPERATOR_CONSTRAINT
00278
00279
00280
00281
00282 template <class _Func, class _Return>
00283 struct _GeneratorConcept
00284 {
00285 void __constraints() {
00286 const _Return& __r _IsUnused = __f();
00287 }
00288 _Func __f;
00289 };
00290
00291
00292 template <class _Func>
00293 struct _GeneratorConcept<_Func,void>
00294 {
00295 void __constraints() {
00296 __f();
00297 }
00298 _Func __f;
00299 };
00300
00301 template <class _Func, class _Return, class _Arg>
00302 struct _UnaryFunctionConcept
00303 {
00304 void __constraints() {
00305 __r = __f(__arg);
00306 }
00307 _Func __f;
00308 _Arg __arg;
00309 _Return __r;
00310 };
00311
00312 template <class _Func, class _Arg>
00313 struct _UnaryFunctionConcept<_Func, void, _Arg> {
00314 void __constraints() {
00315 __f(__arg);
00316 }
00317 _Func __f;
00318 _Arg __arg;
00319 };
00320
00321 template <class _Func, class _Return, class _First, class _Second>
00322 struct _BinaryFunctionConcept
00323 {
00324 void __constraints() {
00325 __r = __f(__first, __second);
00326 }
00327 _Func __f;
00328 _First __first;
00329 _Second __second;
00330 _Return __r;
00331 };
00332
00333 template <class _Func, class _First, class _Second>
00334 struct _BinaryFunctionConcept<_Func, void, _First, _Second>
00335 {
00336 void __constraints() {
00337 __f(__first, __second);
00338 }
00339 _Func __f;
00340 _First __first;
00341 _Second __second;
00342 };
00343
00344 template <class _Func, class _Arg>
00345 struct _UnaryPredicateConcept
00346 {
00347 void __constraints() {
00348 __aux_require_boolean_expr(__f(__arg));
00349 }
00350 _Func __f;
00351 _Arg __arg;
00352 };
00353
00354 template <class _Func, class _First, class _Second>
00355 struct _BinaryPredicateConcept
00356 {
00357 void __constraints() {
00358 __aux_require_boolean_expr(__f(__a, __b));
00359 }
00360 _Func __f;
00361 _First __a;
00362 _Second __b;
00363 };
00364
00365
00366 template <class _Func, class _First, class _Second>
00367 struct _Const_BinaryPredicateConcept {
00368 void __constraints() {
00369 __const_constraints(__f);
00370 }
00371 void __const_constraints(const _Func& __fun) {
00372 __function_requires<_BinaryPredicateConcept<_Func, _First, _Second> >();
00373
00374 __aux_require_boolean_expr(__fun(__a, __b));
00375 }
00376 _Func __f;
00377 _First __a;
00378 _Second __b;
00379 };
00380
00381
00382
00383
00384 template <class _Tp>
00385 struct _TrivialIteratorConcept
00386 {
00387 void __constraints() {
00388 __function_requires< _DefaultConstructibleConcept<_Tp> >();
00389 __function_requires< _AssignableConcept<_Tp> >();
00390 __function_requires< _EqualityComparableConcept<_Tp> >();
00391
00392 (void)*__i;
00393 }
00394 _Tp __i;
00395 };
00396
00397 template <class _Tp>
00398 struct _Mutable_TrivialIteratorConcept
00399 {
00400 void __constraints() {
00401 __function_requires< _TrivialIteratorConcept<_Tp> >();
00402 *__i = *__j;
00403 }
00404 _Tp __i, __j;
00405 };
00406
00407 template <class _Tp>
00408 struct _InputIteratorConcept
00409 {
00410 void __constraints() {
00411 __function_requires< _TrivialIteratorConcept<_Tp> >();
00412
00413 typedef typename std::iterator_traits<_Tp>::difference_type _D;
00414
00415 typedef typename std::iterator_traits<_Tp>::reference _R;
00416 typedef typename std::iterator_traits<_Tp>::pointer _Pt;
00417 typedef typename std::iterator_traits<_Tp>::iterator_category _Cat;
00418 __function_requires< _ConvertibleConcept<
00419 typename std::iterator_traits<_Tp>::iterator_category,
00420 std::input_iterator_tag> >();
00421 ++__i;
00422 __i++;
00423 }
00424 _Tp __i;
00425 };
00426
00427 template <class _Tp, class _ValueT>
00428 struct _OutputIteratorConcept
00429 {
00430 void __constraints() {
00431 __function_requires< _AssignableConcept<_Tp> >();
00432 ++__i;
00433 __i++;
00434 *__i++ = __t;
00435 }
00436 _Tp __i;
00437 _ValueT __t;
00438 };
00439
00440 template <class _Tp>
00441 struct _ForwardIteratorConcept
00442 {
00443 void __constraints() {
00444 __function_requires< _InputIteratorConcept<_Tp> >();
00445 __function_requires< _ConvertibleConcept<
00446 typename std::iterator_traits<_Tp>::iterator_category,
00447 std::forward_iterator_tag> >();
00448 typedef typename std::iterator_traits<_Tp>::reference _R;
00449 _R __r _IsUnused = *__i;
00450 }
00451 _Tp __i;
00452 };
00453
00454 template <class _Tp>
00455 struct _Mutable_ForwardIteratorConcept
00456 {
00457 void __constraints() {
00458 __function_requires< _ForwardIteratorConcept<_Tp> >();
00459 *__i++ = *__i;
00460 }
00461 _Tp __i;
00462 };
00463
00464 template <class _Tp>
00465 struct _BidirectionalIteratorConcept
00466 {
00467 void __constraints() {
00468 __function_requires< _ForwardIteratorConcept<_Tp> >();
00469 __function_requires< _ConvertibleConcept<
00470 typename std::iterator_traits<_Tp>::iterator_category,
00471 std::bidirectional_iterator_tag> >();
00472 --__i;
00473 __i--;
00474 }
00475 _Tp __i;
00476 };
00477
00478 template <class _Tp>
00479 struct _Mutable_BidirectionalIteratorConcept
00480 {
00481 void __constraints() {
00482 __function_requires< _BidirectionalIteratorConcept<_Tp> >();
00483 __function_requires< _Mutable_ForwardIteratorConcept<_Tp> >();
00484 *__i-- = *__i;
00485 }
00486 _Tp __i;
00487 };
00488
00489
00490 template <class _Tp>
00491 struct _RandomAccessIteratorConcept
00492 {
00493 void __constraints() {
00494 __function_requires< _BidirectionalIteratorConcept<_Tp> >();
00495 __function_requires< _ComparableConcept<_Tp> >();
00496 __function_requires< _ConvertibleConcept<
00497 typename std::iterator_traits<_Tp>::iterator_category,
00498 std::random_access_iterator_tag> >();
00499
00500 typedef typename std::iterator_traits<_Tp>::reference _R;
00501
00502 __i += __n;
00503 __i = __i + __n; __i = __n + __i;
00504 __i -= __n;
00505 __i = __i - __n;
00506
00507 __n = __i - __j;
00508 (void)__i[__n];
00509 }
00510 _Tp __a, __b;
00511 _Tp __i, __j;
00512 typename std::iterator_traits<_Tp>::difference_type __n;
00513 };
00514
00515 template <class _Tp>
00516 struct _Mutable_RandomAccessIteratorConcept
00517 {
00518 void __constraints() {
00519 __function_requires< _RandomAccessIteratorConcept<_Tp> >();
00520 __function_requires< _Mutable_BidirectionalIteratorConcept<_Tp> >();
00521 __i[__n] = *__i;
00522 }
00523 _Tp __i;
00524 typename std::iterator_traits<_Tp>::difference_type __n;
00525 };
00526
00527
00528
00529
00530 template <class _Container>
00531 struct _ContainerConcept
00532 {
00533 typedef typename _Container::value_type _Value_type;
00534 typedef typename _Container::difference_type _Difference_type;
00535 typedef typename _Container::size_type _Size_type;
00536 typedef typename _Container::const_reference _Const_reference;
00537 typedef typename _Container::const_pointer _Const_pointer;
00538 typedef typename _Container::const_iterator _Const_iterator;
00539
00540 void __constraints() {
00541 __function_requires< _InputIteratorConcept<_Const_iterator> >();
00542 __function_requires< _AssignableConcept<_Container> >();
00543 const _Container __c;
00544 __i = __c.begin();
00545 __i = __c.end();
00546 __n = __c.size();
00547 __n = __c.max_size();
00548 __b = __c.empty();
00549 }
00550 bool __b;
00551 _Const_iterator __i;
00552 _Size_type __n;
00553 };
00554
00555 template <class _Container>
00556 struct _Mutable_ContainerConcept
00557 {
00558 typedef typename _Container::value_type _Value_type;
00559 typedef typename _Container::reference _Reference;
00560 typedef typename _Container::iterator _Iterator;
00561 typedef typename _Container::pointer _Pointer;
00562
00563 void __constraints() {
00564 __function_requires< _ContainerConcept<_Container> >();
00565 __function_requires< _AssignableConcept<_Value_type> >();
00566 __function_requires< _InputIteratorConcept<_Iterator> >();
00567
00568 __i = __c.begin();
00569 __i = __c.end();
00570 __c.swap(__c2);
00571 }
00572 _Iterator __i;
00573 _Container __c, __c2;
00574 };
00575
00576 template <class _ForwardContainer>
00577 struct _ForwardContainerConcept
00578 {
00579 void __constraints() {
00580 __function_requires< _ContainerConcept<_ForwardContainer> >();
00581 typedef typename _ForwardContainer::const_iterator _Const_iterator;
00582 __function_requires< _ForwardIteratorConcept<_Const_iterator> >();
00583 }
00584 };
00585
00586 template <class _ForwardContainer>
00587 struct _Mutable_ForwardContainerConcept
00588 {
00589 void __constraints() {
00590 __function_requires< _ForwardContainerConcept<_ForwardContainer> >();
00591 __function_requires< _Mutable_ContainerConcept<_ForwardContainer> >();
00592 typedef typename _ForwardContainer::iterator _Iterator;
00593 __function_requires< _Mutable_ForwardIteratorConcept<_Iterator> >();
00594 }
00595 };
00596
00597 template <class _ReversibleContainer>
00598 struct _ReversibleContainerConcept
00599 {
00600 typedef typename _ReversibleContainer::const_iterator _Const_iterator;
00601 typedef typename _ReversibleContainer::const_reverse_iterator
00602 _Const_reverse_iterator;
00603
00604 void __constraints() {
00605 __function_requires< _ForwardContainerConcept<_ReversibleContainer> >();
00606 __function_requires< _BidirectionalIteratorConcept<_Const_iterator> >();
00607 __function_requires<
00608 _BidirectionalIteratorConcept<_Const_reverse_iterator> >();
00609
00610 const _ReversibleContainer __c;
00611 _Const_reverse_iterator __i = __c.rbegin();
00612 __i = __c.rend();
00613 }
00614 };
00615
00616 template <class _ReversibleContainer>
00617 struct _Mutable_ReversibleContainerConcept
00618 {
00619 typedef typename _ReversibleContainer::iterator _Iterator;
00620 typedef typename _ReversibleContainer::reverse_iterator _Reverse_iterator;
00621
00622 void __constraints() {
00623 __function_requires<_ReversibleContainerConcept<_ReversibleContainer> >();
00624 __function_requires<
00625 _Mutable_ForwardContainerConcept<_ReversibleContainer> >();
00626 __function_requires<_Mutable_BidirectionalIteratorConcept<_Iterator> >();
00627 __function_requires<
00628 _Mutable_BidirectionalIteratorConcept<_Reverse_iterator> >();
00629
00630 _Reverse_iterator __i = __c.rbegin();
00631 __i = __c.rend();
00632 }
00633 _ReversibleContainer __c;
00634 };
00635
00636 template <class _RandomAccessContainer>
00637 struct _RandomAccessContainerConcept
00638 {
00639 typedef typename _RandomAccessContainer::size_type _Size_type;
00640 typedef typename _RandomAccessContainer::const_reference _Const_reference;
00641 typedef typename _RandomAccessContainer::const_iterator _Const_iterator;
00642 typedef typename _RandomAccessContainer::const_reverse_iterator
00643 _Const_reverse_iterator;
00644
00645 void __constraints() {
00646 __function_requires<
00647 _ReversibleContainerConcept<_RandomAccessContainer> >();
00648 __function_requires< _RandomAccessIteratorConcept<_Const_iterator> >();
00649 __function_requires<
00650 _RandomAccessIteratorConcept<_Const_reverse_iterator> >();
00651
00652 const _RandomAccessContainer __c;
00653 _Const_reference __r _IsUnused = __c[__n];
00654 }
00655 _Size_type __n;
00656 };
00657
00658 template <class _RandomAccessContainer>
00659 struct _Mutable_RandomAccessContainerConcept
00660 {
00661 typedef typename _RandomAccessContainer::size_type _Size_type;
00662 typedef typename _RandomAccessContainer::reference _Reference;
00663 typedef typename _RandomAccessContainer::iterator _Iterator;
00664 typedef typename _RandomAccessContainer::reverse_iterator _Reverse_iterator;
00665
00666 void __constraints() {
00667 __function_requires<
00668 _RandomAccessContainerConcept<_RandomAccessContainer> >();
00669 __function_requires<
00670 _Mutable_ReversibleContainerConcept<_RandomAccessContainer> >();
00671 __function_requires< _Mutable_RandomAccessIteratorConcept<_Iterator> >();
00672 __function_requires<
00673 _Mutable_RandomAccessIteratorConcept<_Reverse_iterator> >();
00674
00675 _Reference __r _IsUnused = __c[__i];
00676 }
00677 _Size_type __i;
00678 _RandomAccessContainer __c;
00679 };
00680
00681
00682 template <class _Sequence>
00683 struct _SequenceConcept
00684 {
00685 typedef typename _Sequence::reference _Reference;
00686 typedef typename _Sequence::const_reference _Const_reference;
00687
00688 void __constraints() {
00689
00690
00691
00692 __function_requires< _Mutable_ForwardContainerConcept<_Sequence> >();
00693 __function_requires< _DefaultConstructibleConcept<_Sequence> >();
00694
00695 _Sequence
00696 __c(__n) _IsUnused,
00697 __c2(__n, __t) _IsUnused,
00698 __c3(__first, __last) _IsUnused;
00699
00700 __c.insert(__p, __t);
00701 __c.insert(__p, __n, __t);
00702 __c.insert(__p, __first, __last);
00703
00704 __c.erase(__p);
00705 __c.erase(__p, __q);
00706
00707 _Reference __r _IsUnused = __c.front();
00708
00709 __const_constraints(__c);
00710 }
00711 void __const_constraints(const _Sequence& __c) {
00712 _Const_reference __r _IsUnused = __c.front();
00713 }
00714 typename _Sequence::value_type __t;
00715 typename _Sequence::size_type __n;
00716 typename _Sequence::value_type *__first, *__last;
00717 typename _Sequence::iterator __p, __q;
00718 };
00719
00720 template <class _FrontInsertionSequence>
00721 struct _FrontInsertionSequenceConcept
00722 {
00723 void __constraints() {
00724 __function_requires< _SequenceConcept<_FrontInsertionSequence> >();
00725
00726 __c.push_front(__t);
00727 __c.pop_front();
00728 }
00729 _FrontInsertionSequence __c;
00730 typename _FrontInsertionSequence::value_type __t;
00731 };
00732
00733 template <class _BackInsertionSequence>
00734 struct _BackInsertionSequenceConcept
00735 {
00736 typedef typename _BackInsertionSequence::reference _Reference;
00737 typedef typename _BackInsertionSequence::const_reference _Const_reference;
00738
00739 void __constraints() {
00740 __function_requires< _SequenceConcept<_BackInsertionSequence> >();
00741
00742 __c.push_back(__t);
00743 __c.pop_back();
00744 _Reference __r _IsUnused = __c.back();
00745 }
00746 void __const_constraints(const _BackInsertionSequence& __c) {
00747 _Const_reference __r _IsUnused = __c.back();
00748 };
00749 _BackInsertionSequence __c;
00750 typename _BackInsertionSequence::value_type __t;
00751 };
00752
00753 template <class _AssociativeContainer>
00754 struct _AssociativeContainerConcept
00755 {
00756 void __constraints() {
00757 __function_requires< _ForwardContainerConcept<_AssociativeContainer> >();
00758 __function_requires<
00759 _DefaultConstructibleConcept<_AssociativeContainer> >();
00760
00761 __i = __c.find(__k);
00762 __r = __c.equal_range(__k);
00763 __c.erase(__k);
00764 __c.erase(__i);
00765 __c.erase(__r.first, __r.second);
00766 __const_constraints(__c);
00767 }
00768 void __const_constraints(const _AssociativeContainer& __c) {
00769 __ci = __c.find(__k);
00770 __n = __c.count(__k);
00771 __cr = __c.equal_range(__k);
00772 }
00773 typedef typename _AssociativeContainer::iterator _Iterator;
00774 typedef typename _AssociativeContainer::const_iterator _Const_iterator;
00775
00776 _AssociativeContainer __c;
00777 _Iterator __i;
00778 std::pair<_Iterator,_Iterator> __r;
00779 _Const_iterator __ci;
00780 std::pair<_Const_iterator,_Const_iterator> __cr;
00781 typename _AssociativeContainer::key_type __k;
00782 typename _AssociativeContainer::size_type __n;
00783 };
00784
00785 template <class _UniqueAssociativeContainer>
00786 struct _UniqueAssociativeContainerConcept
00787 {
00788 void __constraints() {
00789 __function_requires<
00790 _AssociativeContainerConcept<_UniqueAssociativeContainer> >();
00791
00792 _UniqueAssociativeContainer __c(__first, __last);
00793
00794 __pos_flag = __c.insert(__t);
00795 __c.insert(__first, __last);
00796 }
00797 std::pair<typename _UniqueAssociativeContainer::iterator, bool> __pos_flag;
00798 typename _UniqueAssociativeContainer::value_type __t;
00799 typename _UniqueAssociativeContainer::value_type *__first, *__last;
00800 };
00801
00802 template <class _MultipleAssociativeContainer>
00803 struct _MultipleAssociativeContainerConcept
00804 {
00805 void __constraints() {
00806 __function_requires<
00807 _AssociativeContainerConcept<_MultipleAssociativeContainer> >();
00808
00809 _MultipleAssociativeContainer __c(__first, __last);
00810
00811 __pos = __c.insert(__t);
00812 __c.insert(__first, __last);
00813
00814 }
00815 typename _MultipleAssociativeContainer::iterator __pos _IsUnused;
00816 typename _MultipleAssociativeContainer::value_type __t;
00817 typename _MultipleAssociativeContainer::value_type *__first, *__last;
00818 };
00819
00820 template <class _SimpleAssociativeContainer>
00821 struct _SimpleAssociativeContainerConcept
00822 {
00823 void __constraints() {
00824 __function_requires<
00825 _AssociativeContainerConcept<_SimpleAssociativeContainer> >();
00826 typedef typename _SimpleAssociativeContainer::key_type _Key_type;
00827 typedef typename _SimpleAssociativeContainer::value_type _Value_type;
00828 typedef typename _Aux_require_same<_Key_type, _Value_type>::_Type
00829 _Requqired;
00830 }
00831 };
00832
00833 template <class _SimpleAssociativeContainer>
00834 struct _PairAssociativeContainerConcept
00835 {
00836 void __constraints() {
00837 __function_requires<
00838 _AssociativeContainerConcept<_SimpleAssociativeContainer> >();
00839 typedef typename _SimpleAssociativeContainer::key_type _Key_type;
00840 typedef typename _SimpleAssociativeContainer::value_type _Value_type;
00841 typedef typename _SimpleAssociativeContainer::mapped_type _Mapped_type;
00842 typedef std::pair<const _Key_type, _Mapped_type> _Required_value_type;
00843 typedef typename _Aux_require_same<_Value_type,
00844 _Required_value_type>::_Type _Required;
00845 }
00846 };
00847
00848 template <class _SortedAssociativeContainer>
00849 struct _SortedAssociativeContainerConcept
00850 {
00851 void __constraints() {
00852 __function_requires<
00853 _AssociativeContainerConcept<_SortedAssociativeContainer> >();
00854 __function_requires<
00855 _ReversibleContainerConcept<_SortedAssociativeContainer> >();
00856
00857 _SortedAssociativeContainer
00858 __c(__kc) _IsUnused,
00859 __c2(__first, __last) _IsUnused,
00860 __c3(__first, __last, __kc) _IsUnused;
00861
00862 __p = __c.upper_bound(__k);
00863 __p = __c.lower_bound(__k);
00864 __r = __c.equal_range(__k);
00865
00866 __c.insert(__p, __t);
00867 }
00868 void __const_constraints(const _SortedAssociativeContainer& __c) {
00869 __kc = __c.key_comp();
00870 __vc = __c.value_comp();
00871
00872 __cp = __c.upper_bound(__k);
00873 __cp = __c.lower_bound(__k);
00874 __cr = __c.equal_range(__k);
00875 }
00876 typename _SortedAssociativeContainer::key_compare __kc;
00877 typename _SortedAssociativeContainer::value_compare __vc;
00878 typename _SortedAssociativeContainer::value_type __t;
00879 typename _SortedAssociativeContainer::key_type __k;
00880 typedef typename _SortedAssociativeContainer::iterator _Iterator;
00881 typedef typename _SortedAssociativeContainer::const_iterator
00882 _Const_iterator;
00883
00884 _Iterator __p;
00885 _Const_iterator __cp;
00886 std::pair<_Iterator,_Iterator> __r;
00887 std::pair<_Const_iterator,_Const_iterator> __cr;
00888 typename _SortedAssociativeContainer::value_type *__first, *__last;
00889 };
00890
00891
00892
00893 }
00894
00895 #undef _IsUnused
00896
00897 #endif // _GLIBCPP_BOOST_CONCEPT_CHECK
00898
00899