libstdc++-v3/include/bits/boost_concept_check.h

   1 //
   2 // (C) Copyright Jeremy Siek 2000. Permission to copy, use, modify,
   3 // sell and distribute this software is granted provided this
   4 // copyright notice appears in all copies. This software is provided
   5 // "as is" without express or implied warranty, and with no claim as
   6 // to its suitability for any purpose.
   7 //
   8
   9 // GCC Note:  based on version 1.12.0 of the Boost library.
  10
  11 /** @file boost_concept_check.h
  12  *  This is an internal header file, included by other library headers.
  13  *  You should not attempt to use it directly.
  14  */
  15
  16 #ifndef _GLIBCPP_BOOST_CONCEPT_CHECK
  17 #define _GLIBCPP_BOOST_CONCEPT_CHECK 1
  18
  19 #pragma GCC system_header
  20 #include <cstddef>                // for ptrdiff_t, used next
  21 #include <bits/stl_iterator_base_types.h>    // for traits and tags
  22 #include <utility>                           // for pair<>
  23
  24
  25 namespace __gnu_cxx
  26 {
  27
  28 #define _IsUnused __attribute__ ((__unused__))
  29
  30 // When the C-C code is in use, we would like this function to do as little
  31 // as possible at runtime, use as few resources as possible, and hopefully
  32 // be elided out of existence... hmmm.
  33 template <class _Concept>
  34 inline void __function_requires()
  35 {
  36   void (_Concept::*__x)() _IsUnused = &_Concept::__constraints;
  37 }
  38
  39
  40 // ??? Should the "concept_checking*" structs begin with more than _ ?
  41 #define _GLIBCPP_CLASS_REQUIRES(_type_var, _ns, _concept) \
  42   typedef void (_ns::_concept <_type_var>::* _func##_type_var##_concept)(); \
  43   template <_func##_type_var##_concept _Tp1> \
  44   struct _concept_checking##_type_var##_concept { }; \
  45   typedef _concept_checking##_type_var##_concept< \
  46     &_ns::_concept <_type_var>::__constraints> \
  47     _concept_checking_typedef##_type_var##_concept
  48
  49 #define _GLIBCPP_CLASS_REQUIRES2(_type_var1, _type_var2, _ns, _concept) \
  50   typedef void (_ns::_concept <_type_var1,_type_var2>::* _func##_type_var1##_type_var2##_concept)(); \
  51   template <_func##_type_var1##_type_var2##_concept _Tp1> \
  52   struct _concept_checking##_type_var1##_type_var2##_concept { }; \
  53   typedef _concept_checking##_type_var1##_type_var2##_concept< \
  54     &_ns::_concept <_type_var1,_type_var2>::__constraints> \
  55     _concept_checking_typedef##_type_var1##_type_var2##_concept
  56
  57 #define _GLIBCPP_CLASS_REQUIRES3(_type_var1, _type_var2, _type_var3, _ns, _concept) \
  58   typedef void (_ns::_concept <_type_var1,_type_var2,_type_var3>::* _func##_type_var1##_type_var2##_type_var3##_concept)(); \
  59   template <_func##_type_var1##_type_var2##_type_var3##_concept _Tp1> \
  60   struct _concept_checking##_type_var1##_type_var2##_type_var3##_concept { }; \
  61   typedef _concept_checking##_type_var1##_type_var2##_type_var3##_concept< \
  62     &_ns::_concept <_type_var1,_type_var2,_type_var3>::__constraints>  \
  63   _concept_checking_typedef##_type_var1##_type_var2##_type_var3##_concept
  64
  65 #define _GLIBCPP_CLASS_REQUIRES4(_type_var1, _type_var2, _type_var3, _type_var4, _ns, _concept) \
  66   typedef void (_ns::_concept <_type_var1,_type_var2,_type_var3,_type_var4>::* _func##_type_var1##_type_var2##_type_var3##_type_var4##_concept)(); \
  67   template <_func##_type_var1##_type_var2##_type_var3##_type_var4##_concept _Tp1> \
  68   struct _concept_checking##_type_var1##_type_var2##_type_var3##_type_var4##_concept { }; \
  69   typedef _concept_checking##_type_var1##_type_var2##_type_var3##_type_var4##_concept< \
  70   &_ns::_concept <_type_var1,_type_var2,_type_var3,_type_var4>::__constraints> \
  71     _concept_checking_typedef##_type_var1##_type_var2##_type_var3##_type_var4##_concept
  72
  73
  74 template <class _Tp1, class _Tp2>
  75 struct _Aux_require_same { };
  76
  77 template <class _Tp>
  78 struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
  79
  80   template <class _Tp1, class _Tp2>
  81   struct _SameTypeConcept
  82   {
  83     void __constraints() {
  84       typedef typename _Aux_require_same<_Tp1, _Tp2>::_Type _Required;
  85     }
  86   };
  87
  88   template <class _Tp>
  89   struct _IntegerConcept {
  90     void __constraints() {
  91       __error_type_must_be_an_integer_type();
  92     }
  93   };
  94   template <> struct _IntegerConcept<short> { void __constraints() {} };
  95   template <> struct _IntegerConcept<unsigned short> { void __constraints(){} };
  96   template <> struct _IntegerConcept<int> { void __constraints() {} };
  97   template <> struct _IntegerConcept<unsigned int> { void __constraints() {} };
  98   template <> struct _IntegerConcept<long> { void __constraints() {} };
  99   template <> struct _IntegerConcept<unsigned long> { void __constraints() {} };
 100   template <> struct _IntegerConcept<long long> { void __constraints() {} };
 101   template <> struct _IntegerConcept<unsigned long long>
 102                                                 { void __constraints() {} };
 103
 104   template <class _Tp>
 105   struct _SignedIntegerConcept {
 106     void __constraints() {
 107       __error_type_must_be_a_signed_integer_type();
 108     }
 109   };
 110   template <> struct _SignedIntegerConcept<short> { void __constraints() {} };
 111   template <> struct _SignedIntegerConcept<int> { void __constraints() {} };
 112   template <> struct _SignedIntegerConcept<long> { void __constraints() {} };
 113   template <> struct _SignedIntegerConcept<long long> { void __constraints(){}};
 114
 115   template <class _Tp>
 116   struct _UnsignedIntegerConcept {
 117     void __constraints() {
 118       __error_type_must_be_an_unsigned_integer_type();
 119     }
 120   };
 121   template <> struct _UnsignedIntegerConcept<unsigned short>
 122     { void __constraints() {} };
 123   template <> struct _UnsignedIntegerConcept<unsigned int>
 124     { void __constraints() {} };
 125   template <> struct _UnsignedIntegerConcept<unsigned long>
 126     { void __constraints() {} };
 127   template <> struct _UnsignedIntegerConcept<unsigned long long>
 128     { void __constraints() {} };
 129
 130   //===========================================================================
 131   // Basic Concepts
 132
 133   template <class _Tp>
 134   struct _DefaultConstructibleConcept
 135   {
 136     void __constraints() {
 137       _Tp __a _IsUnused;                // require default constructor
 138     }
 139   };
 140
 141   template <class _Tp>
 142   struct _AssignableConcept
 143   {
 144     void __constraints() {
 145       __a = __a;                        // require assignment operator
 146       __const_constraints(__a);
 147     }
 148     void __const_constraints(const _Tp& __b) {
 149       __a = __b;                   // const required for argument to assignment
 150     }
 151     _Tp __a;
 152   };
 153
 154   template <class _Tp>
 155   struct _CopyConstructibleConcept
 156   {
 157     void __constraints() {
 158       _Tp __a(__b);                     // require copy constructor
 159       _Tp* __ptr _IsUnused = &__a;      // require address of operator
 160       __const_constraints(__a);
 161     }
 162     void __const_constraints(const _Tp& __a) {
 163       _Tp __c(__a) _IsUnused;           // require const copy constructor
 164       const _Tp* __ptr _IsUnused = &__a; // require const address of operator
 165     }
 166     _Tp __b;
 167   };
 168
 169   // The SGI STL version of Assignable requires copy constructor and operator=
 170   template <class _Tp>
 171   struct _SGIAssignableConcept
 172   {
 173     void __constraints() {
 174       _Tp __b(__a) _IsUnused;
 175       __a = __a;                        // require assignment operator
 176       __const_constraints(__a);
 177     }
 178     void __const_constraints(const _Tp& __b) {
 179       _Tp __c(__b) _IsUnused;
 180       __a = __b;              // const required for argument to assignment
 181     }
 182     _Tp __a;
 183   };
 184
 185   template <class _From, class _To>
 186   struct _ConvertibleConcept
 187   {
 188     void __constraints() {
 189       _To __y _IsUnused = __x;
 190     }
 191     _From __x;
 192   };
 193
 194   // The C++ standard requirements for many concepts talk about return
 195   // types that must be "convertible to bool".  The problem with this
 196   // requirement is that it leaves the door open for evil proxies that
 197   // define things like operator|| with strange return types.  Two
 198   // possible solutions are:
 199   // 1) require the return type to be exactly bool
 200   // 2) stay with convertible to bool, and also
 201   //    specify stuff about all the logical operators.
 202   // For now we just test for convertible to bool.
 203   template <class _Tp>
 204   void __aux_require_boolean_expr(const _Tp& __t) {
 205     bool __x _IsUnused = __t;
 206   }
 207
 208 // FIXME
 209   template <class _Tp>
 210   struct _EqualityComparableConcept
 211   {
 212     void __constraints() {
 213       __aux_require_boolean_expr(__a == __b);
 214       __aux_require_boolean_expr(__a != __b);
 215     }
 216     _Tp __a, __b;
 217   };
 218
 219   template <class _Tp>
 220   struct _LessThanComparableConcept
 221   {
 222     void __constraints() {
 223       __aux_require_boolean_expr(__a < __b);
 224     }
 225     _Tp __a, __b;
 226   };
 227
 228   // This is equivalent to SGI STL's LessThanComparable.
 229   template <class _Tp>
 230   struct _ComparableConcept
 231   {
 232     void __constraints() {
 233       __aux_require_boolean_expr(__a < __b);
 234       __aux_require_boolean_expr(__a > __b);
 235       __aux_require_boolean_expr(__a <= __b);
 236       __aux_require_boolean_expr(__a >= __b);
 237     }
 238     _Tp __a, __b;
 239   };
 240
 241 #define _GLIBCPP_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(_OP,_NAME) \
 242   template <class _First, class _Second> \
 243   struct _NAME { \
 244     void __constraints() { (void)__constraints_(); } \
 245     bool __constraints_() {  \
 246       return  __a _OP __b; \
 247     } \
 248     _First __a; \
 249     _Second __b; \
 250   }
 251
 252 #define _GLIBCPP_DEFINE_BINARY_OPERATOR_CONSTRAINT(_OP,_NAME) \
 253   template <class _Ret, class _First, class _Second> \
 254   struct _NAME { \
 255     void __constraints() { (void)__constraints_(); } \
 256     _Ret __constraints_() {  \
 257       return __a _OP __b; \
 258     } \
 259     _First __a; \
 260     _Second __b; \
 261   }
 262
 263   _GLIBCPP_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(==, _EqualOpConcept);
 264   _GLIBCPP_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(!=, _NotEqualOpConcept);
 265   _GLIBCPP_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<, _LessThanOpConcept);
 266   _GLIBCPP_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<=, _LessEqualOpConcept);
 267   _GLIBCPP_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>, _GreaterThanOpConcept);
 268   _GLIBCPP_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>=, _GreaterEqualOpConcept);
 269
 270   _GLIBCPP_DEFINE_BINARY_OPERATOR_CONSTRAINT(+, _PlusOpConcept);
 271   _GLIBCPP_DEFINE_BINARY_OPERATOR_CONSTRAINT(*, _TimesOpConcept);
 272   _GLIBCPP_DEFINE_BINARY_OPERATOR_CONSTRAINT(/, _DivideOpConcept);
 273   _GLIBCPP_DEFINE_BINARY_OPERATOR_CONSTRAINT(-, _SubtractOpConcept);
 274   _GLIBCPP_DEFINE_BINARY_OPERATOR_CONSTRAINT(%, _ModOpConcept);
 275
 276 #undef _GLIBCPP_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT
 277 #undef _GLIBCPP_DEFINE_BINARY_OPERATOR_CONSTRAINT
 278
 279   //===========================================================================
 280   // Function Object Concepts
 281
 282   template <class _Func, class _Return>
 283   struct _GeneratorConcept
 284   {
 285     void __constraints() {
 286       const _Return& __r _IsUnused = __f();// require operator() member function
 287     }
 288     _Func __f;
 289   };
 290
 291
 292   template <class _Func>
 293   struct _GeneratorConcept<_Func,void>
 294   {
 295     void __constraints() {
 296       __f();                            // require operator() member function
 297     }
 298     _Func __f;
 299   };
 300
 301   template <class _Func, class _Return, class _Arg>
 302   struct _UnaryFunctionConcept
 303   {
 304     void __constraints() {
 305       __r = __f(__arg);                  // require operator()
 306     }
 307     _Func __f;
 308     _Arg __arg;
 309     _Return __r;
 310   };
 311
 312   template <class _Func, class _Arg>
 313   struct _UnaryFunctionConcept<_Func, void, _Arg> {
 314     void __constraints() {
 315       __f(__arg);                       // require operator()
 316     }
 317     _Func __f;
 318     _Arg __arg;
 319   };
 320
 321   template <class _Func, class _Return, class _First, class _Second>
 322   struct _BinaryFunctionConcept
 323   {
 324     void __constraints() {
 325       __r = __f(__first, __second);     // require operator()
 326     }
 327     _Func __f;
 328     _First __first;
 329     _Second __second;
 330     _Return __r;
 331   };
 332
 333   template <class _Func, class _First, class _Second>
 334   struct _BinaryFunctionConcept<_Func, void, _First, _Second>
 335   {
 336     void __constraints() {
 337       __f(__first, __second);           // require operator()
 338     }
 339     _Func __f;
 340     _First __first;
 341     _Second __second;
 342   };
 343
 344   template <class _Func, class _Arg>
 345   struct _UnaryPredicateConcept
 346   {
 347     void __constraints() {
 348       __aux_require_boolean_expr(__f(__arg)); // require op() returning bool
 349     }
 350     _Func __f;
 351     _Arg __arg;
 352   };
 353
 354   template <class _Func, class _First, class _Second>
 355   struct _BinaryPredicateConcept
 356   {
 357     void __constraints() {
 358       __aux_require_boolean_expr(__f(__a, __b)); // require op() returning bool
 359     }
 360     _Func __f;
 361     _First __a;
 362     _Second __b;
 363   };
 364
 365   // use this when functor is used inside a container class like std::set
 366   template <class _Func, class _First, class _Second>
 367   struct _Const_BinaryPredicateConcept {
 368     void __constraints() {
 369       __const_constraints(__f);
 370     }
 371     void __const_constraints(const _Func& __fun) {
 372       __function_requires<_BinaryPredicateConcept<_Func, _First, _Second> >();
 373       // operator() must be a const member function
 374       __aux_require_boolean_expr(__fun(__a, __b));
 375     }
 376     _Func __f;
 377     _First __a;
 378     _Second __b;
 379   };
 380
 381   //===========================================================================
 382   // Iterator Concepts
 383
 384   template <class _Tp>
 385   struct _TrivialIteratorConcept
 386   {
 387     void __constraints() {
 388       __function_requires< _DefaultConstructibleConcept<_Tp> >();
 389       __function_requires< _AssignableConcept<_Tp> >();
 390       __function_requires< _EqualityComparableConcept<_Tp> >();
 391 //      typedef typename std::iterator_traits<_Tp>::value_type _V;
 392       (void)*__i;                       // require dereference operator
 393     }
 394     _Tp __i;
 395   };
 396
 397   template <class _Tp>
 398   struct _Mutable_TrivialIteratorConcept
 399   {
 400     void __constraints() {
 401       __function_requires< _TrivialIteratorConcept<_Tp> >();
 402       *__i = *__j;                      // require dereference and assignment
 403     }
 404     _Tp __i, __j;
 405   };
 406
 407   template <class _Tp>
 408   struct _InputIteratorConcept
 409   {
 410     void __constraints() {
 411       __function_requires< _TrivialIteratorConcept<_Tp> >();
 412       // require iterator_traits typedef's
 413       typedef typename std::iterator_traits<_Tp>::difference_type _D;
 414 //      __function_requires< _SignedIntegerConcept<_D> >();
 415       typedef typename std::iterator_traits<_Tp>::reference _R;
 416       typedef typename std::iterator_traits<_Tp>::pointer _Pt;
 417       typedef typename std::iterator_traits<_Tp>::iterator_category _Cat;
 418       __function_requires< _ConvertibleConcept<
 419         typename std::iterator_traits<_Tp>::iterator_category,
 420         std::input_iterator_tag> >();
 421       ++__i;                            // require preincrement operator
 422       __i++;                            // require postincrement operator
 423     }
 424     _Tp __i;
 425   };
 426
 427   template <class _Tp, class _ValueT>
 428   struct _OutputIteratorConcept
 429   {
 430     void __constraints() {
 431       __function_requires< _AssignableConcept<_Tp> >();
 432       ++__i;                            // require preincrement operator
 433       __i++;                            // require postincrement operator
 434       *__i++ = __t;                     // require postincrement and assignment
 435     }
 436     _Tp __i;
 437     _ValueT __t;
 438   };
 439
 440   template <class _Tp>
 441   struct _ForwardIteratorConcept
 442   {
 443     void __constraints() {
 444       __function_requires< _InputIteratorConcept<_Tp> >();
 445       __function_requires< _ConvertibleConcept<
 446         typename std::iterator_traits<_Tp>::iterator_category,
 447         std::forward_iterator_tag> >();
 448       typedef typename std::iterator_traits<_Tp>::reference _R;
 449       _R __r _IsUnused = *__i;
 450     }
 451     _Tp __i;
 452   };
 453
 454   template <class _Tp>
 455   struct _Mutable_ForwardIteratorConcept
 456   {
 457     void __constraints() {
 458       __function_requires< _ForwardIteratorConcept<_Tp> >();
 459       *__i++ = *__i;                    // require postincrement and assignment
 460     }
 461     _Tp __i;
 462   };
 463
 464   template <class _Tp>
 465   struct _BidirectionalIteratorConcept
 466   {
 467     void __constraints() {
 468       __function_requires< _ForwardIteratorConcept<_Tp> >();
 469       __function_requires< _ConvertibleConcept<
 470         typename std::iterator_traits<_Tp>::iterator_category,
 471         std::bidirectional_iterator_tag> >();
 472       --__i;                            // require predecrement operator
 473       __i--;                            // require postdecrement operator
 474     }
 475     _Tp __i;
 476   };
 477
 478   template <class _Tp>
 479   struct _Mutable_BidirectionalIteratorConcept
 480   {
 481     void __constraints() {
 482       __function_requires< _BidirectionalIteratorConcept<_Tp> >();
 483       __function_requires< _Mutable_ForwardIteratorConcept<_Tp> >();
 484       *__i-- = *__i;                    // require postdecrement and assignment
 485     }
 486     _Tp __i;
 487   };
 488
 489
 490   template <class _Tp>
 491   struct _RandomAccessIteratorConcept
 492   {
 493     void __constraints() {
 494       __function_requires< _BidirectionalIteratorConcept<_Tp> >();
 495       __function_requires< _ComparableConcept<_Tp> >();
 496       __function_requires< _ConvertibleConcept<
 497         typename std::iterator_traits<_Tp>::iterator_category,
 498         std::random_access_iterator_tag> >();
 499       // ??? We don't use _R, are we just checking for "referenceability"?
 500       typedef typename std::iterator_traits<_Tp>::reference _R;
 501
 502       __i += __n;                       // require assignment addition operator
 503       __i = __i + __n; __i = __n + __i; // require addition with difference type
 504       __i -= __n;                       // require assignment subtraction op
 505       __i = __i - __n;                  // require subtraction with
 506                                         //            difference type
 507       __n = __i - __j;                  // require difference operator
 508       (void)__i[__n];                   // require element access operator
 509     }
 510     _Tp __a, __b;
 511     _Tp __i, __j;
 512     typename std::iterator_traits<_Tp>::difference_type __n;
 513   };
 514
 515   template <class _Tp>
 516   struct _Mutable_RandomAccessIteratorConcept
 517   {
 518     void __constraints() {
 519       __function_requires< _RandomAccessIteratorConcept<_Tp> >();
 520       __function_requires< _Mutable_BidirectionalIteratorConcept<_Tp> >();
 521       __i[__n] = *__i;                  // require element access and assignment
 522     }
 523     _Tp __i;
 524     typename std::iterator_traits<_Tp>::difference_type __n;
 525   };
 526
 527   //===========================================================================
 528   // Container Concepts
 529
 530   template <class _Container>
 531   struct _ContainerConcept
 532   {
 533     typedef typename _Container::value_type _Value_type;
 534     typedef typename _Container::difference_type _Difference_type;
 535     typedef typename _Container::size_type _Size_type;
 536     typedef typename _Container::const_reference _Const_reference;
 537     typedef typename _Container::const_pointer _Const_pointer;
 538     typedef typename _Container::const_iterator _Const_iterator;
 539
 540     void __constraints() {
 541       __function_requires< _InputIteratorConcept<_Const_iterator> >();
 542       __function_requires< _AssignableConcept<_Container> >();
 543       const _Container __c;
 544       __i = __c.begin();
 545       __i = __c.end();
 546       __n = __c.size();
 547       __n = __c.max_size();
 548       __b = __c.empty();
 549     }
 550     bool __b;
 551     _Const_iterator __i;
 552     _Size_type __n;
 553   };
 554
 555   template <class _Container>
 556   struct _Mutable_ContainerConcept
 557   {
 558     typedef typename _Container::value_type _Value_type;
 559     typedef typename _Container::reference _Reference;
 560     typedef typename _Container::iterator _Iterator;
 561     typedef typename _Container::pointer _Pointer;
 562
 563     void __constraints() {
 564       __function_requires< _ContainerConcept<_Container> >();
 565       __function_requires< _AssignableConcept<_Value_type> >();
 566       __function_requires< _InputIteratorConcept<_Iterator> >();
 567
 568       __i = __c.begin();
 569       __i = __c.end();
 570       __c.swap(__c2);
 571     }
 572     _Iterator __i;
 573     _Container __c, __c2;
 574   };
 575
 576   template <class _ForwardContainer>
 577   struct _ForwardContainerConcept
 578   {
 579     void __constraints() {
 580       __function_requires< _ContainerConcept<_ForwardContainer> >();
 581       typedef typename _ForwardContainer::const_iterator _Const_iterator;
 582       __function_requires< _ForwardIteratorConcept<_Const_iterator> >();
 583     }
 584   };
 585
 586   template <class _ForwardContainer>
 587   struct _Mutable_ForwardContainerConcept
 588   {
 589     void __constraints() {
 590       __function_requires< _ForwardContainerConcept<_ForwardContainer> >();
 591       __function_requires< _Mutable_ContainerConcept<_ForwardContainer> >();
 592       typedef typename _ForwardContainer::iterator _Iterator;
 593       __function_requires< _Mutable_ForwardIteratorConcept<_Iterator> >();
 594     }
 595   };
 596
 597   template <class _ReversibleContainer>
 598   struct _ReversibleContainerConcept
 599   {
 600     typedef typename _ReversibleContainer::const_iterator _Const_iterator;
 601     typedef typename _ReversibleContainer::const_reverse_iterator
 602       _Const_reverse_iterator;
 603
 604     void __constraints() {
 605       __function_requires< _ForwardContainerConcept<_ReversibleContainer> >();
 606       __function_requires< _BidirectionalIteratorConcept<_Const_iterator> >();
 607       __function_requires<
 608         _BidirectionalIteratorConcept<_Const_reverse_iterator> >();
 609
 610       const _ReversibleContainer __c;
 611       _Const_reverse_iterator __i = __c.rbegin();
 612       __i = __c.rend();
 613     }
 614   };
 615
 616   template <class _ReversibleContainer>
 617   struct _Mutable_ReversibleContainerConcept
 618   {
 619     typedef typename _ReversibleContainer::iterator _Iterator;
 620     typedef typename _ReversibleContainer::reverse_iterator _Reverse_iterator;
 621
 622     void __constraints() {
 623       __function_requires<_ReversibleContainerConcept<_ReversibleContainer> >();
 624       __function_requires<
 625         _Mutable_ForwardContainerConcept<_ReversibleContainer> >();
 626       __function_requires<_Mutable_BidirectionalIteratorConcept<_Iterator> >();
 627       __function_requires<
 628         _Mutable_BidirectionalIteratorConcept<_Reverse_iterator> >();
 629
 630       _Reverse_iterator __i = __c.rbegin();
 631       __i = __c.rend();
 632     }
 633     _ReversibleContainer __c;
 634   };
 635
 636   template <class _RandomAccessContainer>
 637   struct _RandomAccessContainerConcept
 638   {
 639     typedef typename _RandomAccessContainer::size_type _Size_type;
 640     typedef typename _RandomAccessContainer::const_reference _Const_reference;
 641     typedef typename _RandomAccessContainer::const_iterator _Const_iterator;
 642     typedef typename _RandomAccessContainer::const_reverse_iterator
 643       _Const_reverse_iterator;
 644
 645     void __constraints() {
 646       __function_requires<
 647         _ReversibleContainerConcept<_RandomAccessContainer> >();
 648       __function_requires< _RandomAccessIteratorConcept<_Const_iterator> >();
 649       __function_requires<
 650         _RandomAccessIteratorConcept<_Const_reverse_iterator> >();
 651
 652       const _RandomAccessContainer __c;
 653       _Const_reference __r _IsUnused = __c[__n];
 654     }
 655     _Size_type __n;
 656   };
 657
 658   template <class _RandomAccessContainer>
 659   struct _Mutable_RandomAccessContainerConcept
 660   {
 661     typedef typename _RandomAccessContainer::size_type _Size_type;
 662     typedef typename _RandomAccessContainer::reference _Reference;
 663     typedef typename _RandomAccessContainer::iterator _Iterator;
 664     typedef typename _RandomAccessContainer::reverse_iterator _Reverse_iterator;
 665
 666     void __constraints() {
 667       __function_requires<
 668         _RandomAccessContainerConcept<_RandomAccessContainer> >();
 669       __function_requires<
 670         _Mutable_ReversibleContainerConcept<_RandomAccessContainer> >();
 671       __function_requires< _Mutable_RandomAccessIteratorConcept<_Iterator> >();
 672       __function_requires<
 673         _Mutable_RandomAccessIteratorConcept<_Reverse_iterator> >();
 674
 675       _Reference __r _IsUnused = __c[__i];
 676     }
 677     _Size_type __i;
 678     _RandomAccessContainer __c;
 679   };
 680
 681   // A Sequence is inherently mutable
 682   template <class _Sequence>
 683   struct _SequenceConcept
 684   {
 685     typedef typename _Sequence::reference _Reference;
 686     typedef typename _Sequence::const_reference _Const_reference;
 687
 688     void __constraints() {
 689       // Matt Austern's book puts DefaultConstructible here, the C++
 690       // standard places it in Container
 691       //    function_requires< DefaultConstructible<Sequence> >();
 692       __function_requires< _Mutable_ForwardContainerConcept<_Sequence> >();
 693       __function_requires< _DefaultConstructibleConcept<_Sequence> >();
 694
 695       _Sequence
 696         __c(__n) _IsUnused,
 697         __c2(__n, __t) _IsUnused,
 698         __c3(__first, __last) _IsUnused;
 699
 700       __c.insert(__p, __t);
 701       __c.insert(__p, __n, __t);
 702       __c.insert(__p, __first, __last);
 703
 704       __c.erase(__p);
 705       __c.erase(__p, __q);
 706
 707       _Reference __r _IsUnused = __c.front();
 708
 709       __const_constraints(__c);
 710     }
 711     void __const_constraints(const _Sequence& __c) {
 712       _Const_reference __r _IsUnused = __c.front();
 713     }
 714     typename _Sequence::value_type __t;
 715     typename _Sequence::size_type __n;
 716     typename _Sequence::value_type *__first, *__last;
 717     typename _Sequence::iterator __p, __q;
 718   };
 719
 720   template <class _FrontInsertionSequence>
 721   struct _FrontInsertionSequenceConcept
 722   {
 723     void __constraints() {
 724       __function_requires< _SequenceConcept<_FrontInsertionSequence> >();
 725
 726       __c.push_front(__t);
 727       __c.pop_front();
 728     }
 729     _FrontInsertionSequence __c;
 730     typename _FrontInsertionSequence::value_type __t;
 731   };
 732
 733   template <class _BackInsertionSequence>
 734   struct _BackInsertionSequenceConcept
 735   {
 736     typedef typename _BackInsertionSequence::reference _Reference;
 737     typedef typename _BackInsertionSequence::const_reference _Const_reference;
 738
 739     void __constraints() {
 740       __function_requires< _SequenceConcept<_BackInsertionSequence> >();
 741
 742       __c.push_back(__t);
 743       __c.pop_back();
 744       _Reference __r _IsUnused = __c.back();
 745     }
 746     void __const_constraints(const _BackInsertionSequence& __c) {
 747       _Const_reference __r _IsUnused = __c.back();
 748     };
 749     _BackInsertionSequence __c;
 750     typename _BackInsertionSequence::value_type __t;
 751   };
 752
 753   template <class _AssociativeContainer>
 754   struct _AssociativeContainerConcept
 755   {
 756     void __constraints() {
 757       __function_requires< _ForwardContainerConcept<_AssociativeContainer> >();
 758       __function_requires<
 759         _DefaultConstructibleConcept<_AssociativeContainer> >();
 760
 761       __i = __c.find(__k);
 762       __r = __c.equal_range(__k);
 763       __c.erase(__k);
 764       __c.erase(__i);
 765       __c.erase(__r.first, __r.second);
 766       __const_constraints(__c);
 767     }
 768     void __const_constraints(const _AssociativeContainer& __c) {
 769       __ci = __c.find(__k);
 770       __n = __c.count(__k);
 771       __cr = __c.equal_range(__k);
 772     }
 773     typedef typename _AssociativeContainer::iterator _Iterator;
 774     typedef typename _AssociativeContainer::const_iterator _Const_iterator;
 775
 776     _AssociativeContainer __c;
 777     _Iterator __i;
 778     std::pair<_Iterator,_Iterator> __r;
 779     _Const_iterator __ci;
 780     std::pair<_Const_iterator,_Const_iterator> __cr;
 781     typename _AssociativeContainer::key_type __k;
 782     typename _AssociativeContainer::size_type __n;
 783   };
 784
 785   template <class _UniqueAssociativeContainer>
 786   struct _UniqueAssociativeContainerConcept
 787   {
 788     void __constraints() {
 789       __function_requires<
 790         _AssociativeContainerConcept<_UniqueAssociativeContainer> >();
 791
 792       _UniqueAssociativeContainer __c(__first, __last);
 793
 794       __pos_flag = __c.insert(__t);
 795       __c.insert(__first, __last);
 796     }
 797     std::pair<typename _UniqueAssociativeContainer::iterator, bool> __pos_flag;
 798     typename _UniqueAssociativeContainer::value_type __t;
 799     typename _UniqueAssociativeContainer::value_type *__first, *__last;
 800   };
 801
 802   template <class _MultipleAssociativeContainer>
 803   struct _MultipleAssociativeContainerConcept
 804   {
 805     void __constraints() {
 806       __function_requires<
 807         _AssociativeContainerConcept<_MultipleAssociativeContainer> >();
 808
 809       _MultipleAssociativeContainer __c(__first, __last);
 810
 811       __pos = __c.insert(__t);
 812       __c.insert(__first, __last);
 813
 814     }
 815     typename _MultipleAssociativeContainer::iterator __pos _IsUnused;
 816     typename _MultipleAssociativeContainer::value_type __t;
 817     typename _MultipleAssociativeContainer::value_type *__first, *__last;
 818   };
 819
 820   template <class _SimpleAssociativeContainer>
 821   struct _SimpleAssociativeContainerConcept
 822   {
 823     void __constraints() {
 824       __function_requires<
 825         _AssociativeContainerConcept<_SimpleAssociativeContainer> >();
 826       typedef typename _SimpleAssociativeContainer::key_type _Key_type;
 827       typedef typename _SimpleAssociativeContainer::value_type _Value_type;
 828       typedef typename _Aux_require_same<_Key_type, _Value_type>::_Type
 829         _Requqired;
 830     }
 831   };
 832
 833   template <class _SimpleAssociativeContainer>
 834   struct _PairAssociativeContainerConcept
 835   {
 836     void __constraints() {
 837       __function_requires<
 838         _AssociativeContainerConcept<_SimpleAssociativeContainer> >();
 839       typedef typename _SimpleAssociativeContainer::key_type _Key_type;
 840       typedef typename _SimpleAssociativeContainer::value_type _Value_type;
 841       typedef typename _SimpleAssociativeContainer::mapped_type _Mapped_type;
 842       typedef std::pair<const _Key_type, _Mapped_type> _Required_value_type;
 843       typedef typename _Aux_require_same<_Value_type,
 844         _Required_value_type>::_Type _Required;
 845     }
 846   };
 847
 848   template <class _SortedAssociativeContainer>
 849   struct _SortedAssociativeContainerConcept
 850   {
 851     void __constraints() {
 852       __function_requires<
 853         _AssociativeContainerConcept<_SortedAssociativeContainer> >();
 854       __function_requires<
 855         _ReversibleContainerConcept<_SortedAssociativeContainer> >();
 856
 857       _SortedAssociativeContainer
 858         __c(__kc) _IsUnused,
 859         __c2(__first, __last) _IsUnused,
 860         __c3(__first, __last, __kc) _IsUnused;
 861
 862       __p = __c.upper_bound(__k);
 863       __p = __c.lower_bound(__k);
 864       __r = __c.equal_range(__k);
 865
 866       __c.insert(__p, __t);
 867     }
 868     void __const_constraints(const _SortedAssociativeContainer& __c) {
 869       __kc = __c.key_comp();
 870       __vc = __c.value_comp();
 871
 872       __cp = __c.upper_bound(__k);
 873       __cp = __c.lower_bound(__k);
 874       __cr = __c.equal_range(__k);
 875     }
 876     typename _SortedAssociativeContainer::key_compare __kc;
 877     typename _SortedAssociativeContainer::value_compare __vc;
 878     typename _SortedAssociativeContainer::value_type __t;
 879     typename _SortedAssociativeContainer::key_type __k;
 880     typedef typename _SortedAssociativeContainer::iterator _Iterator;
 881     typedef typename _SortedAssociativeContainer::const_iterator
 882       _Const_iterator;
 883
 884     _Iterator __p;
 885     _Const_iterator __cp;
 886     std::pair<_Iterator,_Iterator> __r;
 887     std::pair<_Const_iterator,_Const_iterator> __cr;
 888     typename _SortedAssociativeContainer::value_type *__first, *__last;
 889   };
 890
 891   // HashedAssociativeContainer
 892
 893 } // namespace __gnu_cxx
 894
 895 #undef _IsUnused
 896
 897 #endif // _GLIBCPP_BOOST_CONCEPT_CHECK
 898
 899