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