Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  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.  
  791.