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