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

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