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