Merge c:/dyninst/pc_bluegene/dyninst into dyn_pc_integration
[dyninst.git] / external / boost / concept_check.hpp
1 //
2 // (C) Copyright Jeremy Siek 2000.
3 // Distributed under the Boost Software License, Version 1.0. (See
4 // accompanying file LICENSE_1_0.txt or copy at
5 // http://www.boost.org/LICENSE_1_0.txt)
6 //
7 // Revision History:
8 //   05 May   2001: Workarounds for HP aCC from Thomas Matelich. (Jeremy Siek)
9 //   02 April 2001: Removed limits header altogether. (Jeremy Siek)
10 //   01 April 2001: Modified to use new <boost/limits.hpp> header. (JMaddock)
11 //
12
13 // See http://www.boost.org/libs/concept_check for documentation.
14
15 #ifndef BOOST_CONCEPT_CHECKS_HPP
16 # define BOOST_CONCEPT_CHECKS_HPP
17
18 # include <boost/concept/assert.hpp>
19
20 # include <boost/iterator.hpp>
21 # include <boost/type_traits/conversion_traits.hpp>
22 # include <utility>
23 # include <boost/type_traits/is_same.hpp>
24 # include <boost/type_traits/is_void.hpp>
25 # include <boost/mpl/assert.hpp>
26 # include <boost/mpl/bool.hpp>
27 # include <boost/detail/workaround.hpp>
28 # include <boost/detail/iterator.hpp>
29
30 # include <boost/concept/usage.hpp>
31 # include <boost/concept/detail/concept_def.hpp>
32
33 namespace boost
34 {
35
36   //
37   // Backward compatibility
38   //
39   
40   template <class Model>
41   inline void function_requires(Model* = 0)
42   {
43       BOOST_CONCEPT_ASSERT((Model));
44   }    
45   template <class T> inline void ignore_unused_variable_warning(T const&) {}
46   
47 #  define BOOST_CLASS_REQUIRE(type_var, ns, concept)    \
48     BOOST_CONCEPT_ASSERT((ns::concept<type_var>))
49
50 #  define BOOST_CLASS_REQUIRE2(type_var1, type_var2, ns, concept)   \
51     BOOST_CONCEPT_ASSERT((ns::concept<type_var1,type_var2>))
52
53 #  define BOOST_CLASS_REQUIRE3(tv1, tv2, tv3, ns, concept)  \
54     BOOST_CONCEPT_ASSERT((ns::concept<tv1,tv2,tv3>))
55
56 #  define BOOST_CLASS_REQUIRE4(tv1, tv2, tv3, tv4, ns, concept) \
57     BOOST_CONCEPT_ASSERT((ns::concept<tv1,tv2,tv3,tv4>))
58
59   
60   //
61   // Begin concept definitions
62   //
63   BOOST_concept(Integer, (T))
64   {
65       BOOST_CONCEPT_USAGE(Integer)
66         { 
67             x.error_type_must_be_an_integer_type();
68         }
69    private:
70       T x;
71   };
72
73   template <> struct Integer<signed char> {};
74   template <> struct Integer<unsigned char> {};
75   template <> struct Integer<short> {};
76   template <> struct Integer<unsigned short> {};
77   template <> struct Integer<int> {};
78   template <> struct Integer<unsigned int> {};
79   template <> struct Integer<long> {};
80   template <> struct Integer<unsigned long> {};
81 # if defined(BOOST_HAS_LONG_LONG)
82   template <> struct Integer< ::boost::long_long_type> {};
83   template <> struct Integer< ::boost::ulong_long_type> {};
84 # elif defined(BOOST_HAS_MS_INT64)
85   template <> struct Integer<__int64> {};
86   template <> struct Integer<unsigned __int64> {};
87 # endif
88
89   BOOST_concept(SignedInteger,(T)) {
90     BOOST_CONCEPT_USAGE(SignedInteger) { 
91       x.error_type_must_be_a_signed_integer_type();
92     }
93    private:
94     T x;
95   };
96   template <> struct SignedInteger<signed char> { };
97   template <> struct SignedInteger<short> {};
98   template <> struct SignedInteger<int> {};
99   template <> struct SignedInteger<long> {};
100 # if defined(BOOST_HAS_LONG_LONG)
101   template <> struct SignedInteger< ::boost::long_long_type> {};
102 # elif defined(BOOST_HAS_MS_INT64)
103   template <> struct SignedInteger<__int64> {};
104 # endif      
105
106   BOOST_concept(UnsignedInteger,(T)) {
107     BOOST_CONCEPT_USAGE(UnsignedInteger) { 
108       x.error_type_must_be_an_unsigned_integer_type();
109     }
110    private:
111     T x;
112   };
113   
114   template <> struct UnsignedInteger<unsigned char> {};
115   template <> struct UnsignedInteger<unsigned short> {};
116   template <> struct UnsignedInteger<unsigned int> {};
117   template <> struct UnsignedInteger<unsigned long> {};
118 # if defined(BOOST_HAS_LONG_LONG)
119   template <> struct UnsignedInteger< ::boost::ulong_long_type> {};
120 # elif defined(BOOST_HAS_MS_INT64)
121   template <> struct UnsignedInteger<unsigned __int64> {};
122 # endif
123
124   //===========================================================================
125   // Basic Concepts
126
127   BOOST_concept(DefaultConstructible,(TT))
128   {
129     BOOST_CONCEPT_USAGE(DefaultConstructible) {
130       TT a;               // require default constructor
131       ignore_unused_variable_warning(a);
132     }
133   };
134
135   BOOST_concept(Assignable,(TT))
136   {
137     BOOST_CONCEPT_USAGE(Assignable) {
138 #if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL
139       a = a;             // require assignment operator
140 #endif
141       const_constraints(a);
142     }
143    private:
144     void const_constraints(const TT& b) {
145 #if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL
146       a = b;              // const required for argument to assignment
147 #endif
148     }
149    private:
150     TT a;
151   };
152
153   
154   BOOST_concept(CopyConstructible,(TT))
155   {
156     BOOST_CONCEPT_USAGE(CopyConstructible) {
157       TT a(b);            // require copy constructor
158       TT* ptr = &a;       // require address of operator
159       const_constraints(a);
160       ignore_unused_variable_warning(ptr);
161     }
162    private:
163     void const_constraints(const TT& a) {
164       TT c(a);            // require const copy constructor
165       const TT* ptr = &a; // require const address of operator
166       ignore_unused_variable_warning(c);
167       ignore_unused_variable_warning(ptr);
168     }
169     TT b;
170   };
171
172   // The SGI STL version of Assignable requires copy constructor and operator=
173   BOOST_concept(SGIAssignable,(TT))
174   {
175     BOOST_CONCEPT_USAGE(SGIAssignable) {
176       TT b(a);
177 #if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL
178       a = a;              // require assignment operator
179 #endif
180       const_constraints(a);
181       ignore_unused_variable_warning(b);
182     }
183    private:
184     void const_constraints(const TT& b) {
185       TT c(b);
186 #if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL
187       a = b;              // const required for argument to assignment
188 #endif
189       ignore_unused_variable_warning(c);
190     }
191     TT a;
192   };
193
194   BOOST_concept(Convertible,(X)(Y))
195   {
196     BOOST_CONCEPT_USAGE(Convertible) {
197       Y y = x;
198       ignore_unused_variable_warning(y);
199     }
200    private:
201     X x;
202   };
203
204   // The C++ standard requirements for many concepts talk about return
205   // types that must be "convertible to bool".  The problem with this
206   // requirement is that it leaves the door open for evil proxies that
207   // define things like operator|| with strange return types.  Two
208   // possible solutions are:
209   // 1) require the return type to be exactly bool
210   // 2) stay with convertible to bool, and also
211   //    specify stuff about all the logical operators.
212   // For now we just test for convertible to bool.
213   template <class TT>
214   void require_boolean_expr(const TT& t) {
215     bool x = t;
216     ignore_unused_variable_warning(x);
217   }
218
219   BOOST_concept(EqualityComparable,(TT))
220   {
221     BOOST_CONCEPT_USAGE(EqualityComparable) {
222       require_boolean_expr(a == b);
223       require_boolean_expr(a != b);
224     }
225    private:
226     TT a, b;
227   };
228
229   BOOST_concept(LessThanComparable,(TT))
230   {
231     BOOST_CONCEPT_USAGE(LessThanComparable) {
232       require_boolean_expr(a < b);
233     }
234    private:
235     TT a, b;
236   };
237
238   // This is equivalent to SGI STL's LessThanComparable.
239   BOOST_concept(Comparable,(TT))
240   {
241     BOOST_CONCEPT_USAGE(Comparable) {
242       require_boolean_expr(a < b);
243       require_boolean_expr(a > b);
244       require_boolean_expr(a <= b);
245       require_boolean_expr(a >= b);
246     }
247    private:
248     TT a, b;
249   };
250
251 #define BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(OP,NAME)    \
252   BOOST_concept(NAME, (First)(Second))                          \
253   {                                                             \
254       BOOST_CONCEPT_USAGE(NAME) { (void)constraints_(); }                         \
255      private:                                                   \
256         bool constraints_() { return a OP b; }                  \
257         First a;                                                \
258         Second b;                                               \
259   }
260
261 #define BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(OP,NAME)    \
262   BOOST_concept(NAME, (Ret)(First)(Second))                 \
263   {                                                         \
264       BOOST_CONCEPT_USAGE(NAME) { (void)constraints_(); }                     \
265   private:                                                  \
266       Ret constraints_() { return a OP b; }                 \
267       First a;                                              \
268       Second b;                                             \
269   }
270
271   BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(==, EqualOp);
272   BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(!=, NotEqualOp);
273   BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<, LessThanOp);
274   BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<=, LessEqualOp);
275   BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>, GreaterThanOp);
276   BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>=, GreaterEqualOp);
277
278   BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(+, PlusOp);
279   BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(*, TimesOp);
280   BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(/, DivideOp);
281   BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(-, SubtractOp);
282   BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(%, ModOp);
283
284   //===========================================================================
285   // Function Object Concepts
286
287   BOOST_concept(Generator,(Func)(Return))
288   {
289       BOOST_CONCEPT_USAGE(Generator) { test(is_void<Return>()); }
290       
291    private:
292       void test(boost::mpl::false_)
293       {
294           // Do we really want a reference here?
295           const Return& r = f();
296           ignore_unused_variable_warning(r);
297       }
298
299       void test(boost::mpl::true_)
300       {
301           f();
302       }
303       
304       Func f;
305   };
306
307   BOOST_concept(UnaryFunction,(Func)(Return)(Arg))
308   {
309       BOOST_CONCEPT_USAGE(UnaryFunction) { test(is_void<Return>()); }
310       
311    private:
312       void test(boost::mpl::false_)
313       {
314           f(arg);               // "priming the pump" this way keeps msvc6 happy (ICE)
315           Return r = f(arg);
316           ignore_unused_variable_warning(r); 
317       }
318       
319       void test(boost::mpl::true_)
320       {
321           f(arg);
322       }
323       
324       Func f;
325       Arg arg;
326   };
327
328   BOOST_concept(BinaryFunction,(Func)(Return)(First)(Second))
329   {
330       BOOST_CONCEPT_USAGE(BinaryFunction) { test(is_void<Return>()); }
331    private:
332       void test(boost::mpl::false_)
333       {
334           f(first,second);
335           Return r = f(first, second); // require operator()
336           (void)r;
337       }
338       
339       void test(boost::mpl::true_)
340       {
341           f(first,second);
342       }
343       
344       Func f;
345       First first;
346       Second second;
347   };
348
349   BOOST_concept(UnaryPredicate,(Func)(Arg))
350   {
351     BOOST_CONCEPT_USAGE(UnaryPredicate) {
352       require_boolean_expr(f(arg)); // require operator() returning bool
353     }
354    private:
355     Func f;
356     Arg arg;
357   };
358
359   BOOST_concept(BinaryPredicate,(Func)(First)(Second))
360   {
361     BOOST_CONCEPT_USAGE(BinaryPredicate) {
362       require_boolean_expr(f(a, b)); // require operator() returning bool
363     }
364    private:
365     Func f;
366     First a;
367     Second b;
368   };
369
370   // use this when functor is used inside a container class like std::set
371   BOOST_concept(Const_BinaryPredicate,(Func)(First)(Second))
372     : BinaryPredicate<Func, First, Second>
373   {
374     BOOST_CONCEPT_USAGE(Const_BinaryPredicate) { 
375       const_constraints(f);
376     }
377    private:
378     void const_constraints(const Func& fun) {
379       // operator() must be a const member function
380       require_boolean_expr(fun(a, b));
381     }
382     Func f;
383     First a;
384     Second b;
385   };
386
387   BOOST_concept(AdaptableGenerator,(Func)(Return))
388     : Generator<Func, typename Func::result_type>
389   {
390       typedef typename Func::result_type result_type;
391       
392       BOOST_CONCEPT_USAGE(AdaptableGenerator)
393       {
394           BOOST_CONCEPT_ASSERT((Convertible<result_type, Return>));
395       }
396   };
397
398   BOOST_concept(AdaptableUnaryFunction,(Func)(Return)(Arg))
399     : UnaryFunction<Func, typename Func::result_type, typename Func::argument_type>
400   {
401       typedef typename Func::argument_type argument_type;
402       typedef typename Func::result_type result_type;
403
404       ~AdaptableUnaryFunction()
405       {
406           BOOST_CONCEPT_ASSERT((Convertible<result_type, Return>));
407           BOOST_CONCEPT_ASSERT((Convertible<Arg, argument_type>));
408       }
409   };
410
411   BOOST_concept(AdaptableBinaryFunction,(Func)(Return)(First)(Second))
412     : BinaryFunction<
413           Func
414         , typename Func::result_type
415         , typename Func::first_argument_type
416         , typename Func::second_argument_type
417       >
418   {
419       typedef typename Func::first_argument_type first_argument_type;
420       typedef typename Func::second_argument_type second_argument_type;
421       typedef typename Func::result_type result_type;
422       
423       ~AdaptableBinaryFunction()
424       {
425           BOOST_CONCEPT_ASSERT((Convertible<result_type, Return>));
426           BOOST_CONCEPT_ASSERT((Convertible<First, first_argument_type>));
427           BOOST_CONCEPT_ASSERT((Convertible<Second, second_argument_type>));
428       }
429   };
430
431   BOOST_concept(AdaptablePredicate,(Func)(Arg))
432     : UnaryPredicate<Func, Arg>
433     , AdaptableUnaryFunction<Func, bool, Arg>
434   {
435   };
436
437   BOOST_concept(AdaptableBinaryPredicate,(Func)(First)(Second))
438     : BinaryPredicate<Func, First, Second>
439     , AdaptableBinaryFunction<Func, bool, First, Second>
440   {
441   };
442
443   //===========================================================================
444   // Iterator Concepts
445
446   BOOST_concept(InputIterator,(TT))
447     : Assignable<TT>
448     , EqualityComparable<TT>
449   {
450       typedef typename boost::detail::iterator_traits<TT>::value_type value_type;
451       typedef typename boost::detail::iterator_traits<TT>::difference_type difference_type;
452       typedef typename boost::detail::iterator_traits<TT>::reference reference;
453       typedef typename boost::detail::iterator_traits<TT>::pointer pointer;
454       typedef typename boost::detail::iterator_traits<TT>::iterator_category iterator_category;
455
456       BOOST_CONCEPT_USAGE(InputIterator)
457       {
458         BOOST_CONCEPT_ASSERT((SignedInteger<difference_type>));
459         BOOST_CONCEPT_ASSERT((Convertible<iterator_category, std::input_iterator_tag>));
460         
461         TT j(i);
462         (void)*i;           // require dereference operator
463         ++j;                // require preincrement operator
464         i++;                // require postincrement operator
465       }
466    private:
467     TT i;
468   };
469
470   BOOST_concept(OutputIterator,(TT)(ValueT))
471     : Assignable<TT>
472   {
473     BOOST_CONCEPT_USAGE(OutputIterator) {
474       
475       ++i;                // require preincrement operator
476       i++;                // require postincrement operator
477       *i++ = t;           // require postincrement and assignment
478     }
479    private:
480     TT i, j;
481     ValueT t;
482   };
483
484   BOOST_concept(ForwardIterator,(TT))
485     : InputIterator<TT>
486   {
487       BOOST_CONCEPT_USAGE(ForwardIterator)
488       {
489           BOOST_CONCEPT_ASSERT((Convertible<
490               BOOST_DEDUCED_TYPENAME ForwardIterator::iterator_category
491             , std::forward_iterator_tag
492           >));
493           
494           typename InputIterator<TT>::reference r = *i;
495           ignore_unused_variable_warning(r);
496       }
497       
498    private:
499       TT i;
500   };
501
502   BOOST_concept(Mutable_ForwardIterator,(TT))
503     : ForwardIterator<TT>
504   {
505       BOOST_CONCEPT_USAGE(Mutable_ForwardIterator) {
506         *i++ = *i;         // require postincrement and assignment
507       }
508    private:
509       TT i;
510   };
511
512   BOOST_concept(BidirectionalIterator,(TT))
513     : ForwardIterator<TT>
514   {
515       BOOST_CONCEPT_USAGE(BidirectionalIterator)
516       {
517           BOOST_CONCEPT_ASSERT((Convertible<
518               BOOST_DEDUCED_TYPENAME BidirectionalIterator::iterator_category
519             , std::bidirectional_iterator_tag
520           >));
521
522           --i;                // require predecrement operator
523           i--;                // require postdecrement operator
524       }
525    private:
526       TT i;
527   };
528
529   BOOST_concept(Mutable_BidirectionalIterator,(TT))
530     : BidirectionalIterator<TT>
531     , Mutable_ForwardIterator<TT>
532   {
533       BOOST_CONCEPT_USAGE(Mutable_BidirectionalIterator)
534       {
535           *i-- = *i;                  // require postdecrement and assignment
536       }
537    private:
538       TT i;
539   };
540
541   BOOST_concept(RandomAccessIterator,(TT))
542     : BidirectionalIterator<TT>
543     , Comparable<TT>
544   {
545       BOOST_CONCEPT_USAGE(RandomAccessIterator)
546       {
547           BOOST_CONCEPT_ASSERT((Convertible<
548               BOOST_DEDUCED_TYPENAME BidirectionalIterator<TT>::iterator_category
549             , std::random_access_iterator_tag
550           >));
551
552           i += n;             // require assignment addition operator
553           i = i + n; i = n + i; // require addition with difference type
554           i -= n;             // require assignment subtraction operator
555           i = i - n;                  // require subtraction with difference type
556           n = i - j;                  // require difference operator
557           (void)i[n];                 // require element access operator
558       }
559       
560    private:
561     TT a, b;
562     TT i, j;
563       typename boost::detail::iterator_traits<TT>::difference_type n;
564   };
565
566   BOOST_concept(Mutable_RandomAccessIterator,(TT))
567     : RandomAccessIterator<TT>
568     , Mutable_BidirectionalIterator<TT>
569   {
570       BOOST_CONCEPT_USAGE(Mutable_RandomAccessIterator)
571       {
572           i[n] = *i;                  // require element access and assignment
573       }
574    private:
575     TT i;
576     typename boost::detail::iterator_traits<TT>::difference_type n;
577   };
578
579   //===========================================================================
580   // Container s
581
582   BOOST_concept(Container,(C))
583     : Assignable<C>
584   {
585     typedef typename C::value_type value_type;
586     typedef typename C::difference_type difference_type;
587     typedef typename C::size_type size_type;
588     typedef typename C::const_reference const_reference;
589     typedef typename C::const_pointer const_pointer;
590     typedef typename C::const_iterator const_iterator;
591
592       BOOST_CONCEPT_USAGE(Container)
593       {
594           BOOST_CONCEPT_ASSERT((InputIterator<const_iterator>));
595           const_constraints(c);
596       }
597       
598    private:
599       void const_constraints(const C& cc) {
600           i = cc.begin();
601           i = cc.end();
602           n = cc.size();
603           n = cc.max_size();
604           b = cc.empty();
605       }
606       C c;
607       bool b;
608       const_iterator i;
609       size_type n;
610   };
611
612   BOOST_concept(Mutable_Container,(C))
613     : Container<C>
614   {
615       typedef typename C::reference reference;
616       typedef typename C::iterator iterator;
617       typedef typename C::pointer pointer;
618     
619       BOOST_CONCEPT_USAGE(Mutable_Container)
620       {
621           BOOST_CONCEPT_ASSERT((
622                Assignable<typename Mutable_Container::value_type>));
623           
624           BOOST_CONCEPT_ASSERT((InputIterator<iterator>));
625           
626           i = c.begin();
627           i = c.end();
628           c.swap(c2);
629       }
630       
631    private:
632       iterator i;
633       C c, c2;
634   };
635
636   BOOST_concept(ForwardContainer,(C))
637     : Container<C>
638   {
639       BOOST_CONCEPT_USAGE(ForwardContainer)
640       {
641           BOOST_CONCEPT_ASSERT((
642                ForwardIterator<
643                     typename ForwardContainer::const_iterator
644                >));
645       }
646   };  
647
648   BOOST_concept(Mutable_ForwardContainer,(C))
649     : ForwardContainer<C>
650     , Mutable_Container<C>
651   {
652       BOOST_CONCEPT_USAGE(Mutable_ForwardContainer)
653       {
654           BOOST_CONCEPT_ASSERT((
655                Mutable_ForwardIterator<
656                    typename Mutable_ForwardContainer::iterator
657                >));
658       }
659   };  
660
661   BOOST_concept(ReversibleContainer,(C))
662     : ForwardContainer<C>
663   {
664       typedef typename
665         C::const_reverse_iterator
666       const_reverse_iterator;
667
668       BOOST_CONCEPT_USAGE(ReversibleContainer)
669       {
670           BOOST_CONCEPT_ASSERT((
671               BidirectionalIterator<
672                   typename ReversibleContainer::const_iterator>));
673           
674           BOOST_CONCEPT_ASSERT((BidirectionalIterator<const_reverse_iterator>));
675           
676           const_constraints(c);
677       }
678    private:
679       void const_constraints(const C& cc)
680       {
681           const_reverse_iterator i = cc.rbegin();
682           i = cc.rend();
683       }
684       C c;
685   };
686
687   BOOST_concept(Mutable_ReversibleContainer,(C))
688     : Mutable_ForwardContainer<C>
689     , ReversibleContainer<C>
690   {
691       typedef typename C::reverse_iterator reverse_iterator;
692       
693       BOOST_CONCEPT_USAGE(Mutable_ReversibleContainer)
694       {
695           typedef typename Mutable_ForwardContainer<C>::iterator iterator;
696           BOOST_CONCEPT_ASSERT((Mutable_BidirectionalIterator<iterator>));
697           BOOST_CONCEPT_ASSERT((Mutable_BidirectionalIterator<reverse_iterator>));
698           
699           reverse_iterator i = c.rbegin();
700           i = c.rend();
701       }
702    private:  
703       C c;
704   };
705
706   BOOST_concept(RandomAccessContainer,(C))
707     : ReversibleContainer<C>
708   {
709       typedef typename C::size_type size_type;
710       typedef typename C::const_reference const_reference;
711
712       BOOST_CONCEPT_USAGE(RandomAccessContainer)
713       {
714           BOOST_CONCEPT_ASSERT((
715               RandomAccessIterator<
716                   typename RandomAccessContainer::const_iterator
717               >));
718           
719           const_constraints(c);
720       }
721    private:
722       void const_constraints(const C& cc)
723       {
724           const_reference r = cc[n];
725           ignore_unused_variable_warning(r);
726       }
727     
728       C c;
729       size_type n;
730   };
731
732   BOOST_concept(Mutable_RandomAccessContainer,(C))
733     : Mutable_ReversibleContainer<C>
734     , RandomAccessContainer<C>
735   {
736    private:
737       typedef Mutable_RandomAccessContainer self;
738    public:
739       BOOST_CONCEPT_USAGE(Mutable_RandomAccessContainer)
740       {
741           BOOST_CONCEPT_ASSERT((Mutable_RandomAccessIterator<typename self::iterator>));
742           BOOST_CONCEPT_ASSERT((Mutable_RandomAccessIterator<typename self::reverse_iterator>));
743           
744           typename self::reference r = c[i];
745           ignore_unused_variable_warning(r);
746       }
747       
748    private:
749       typename Mutable_ReversibleContainer<C>::size_type i;
750       C c;
751   };
752
753   // A Sequence is inherently mutable
754   BOOST_concept(Sequence,(S))
755     : Mutable_ForwardContainer<S>
756       // Matt Austern's book puts DefaultConstructible here, the C++
757       // standard places it in Container --JGS
758       // ... so why aren't we following the standard?  --DWA
759     , DefaultConstructible<S>
760   {
761       BOOST_CONCEPT_USAGE(Sequence)
762       {
763           S 
764               c(n),
765               c2(n, t),
766               c3(first, last);
767
768           c.insert(p, t);
769           c.insert(p, n, t);
770           c.insert(p, first, last);
771
772           c.erase(p);
773           c.erase(p, q);
774
775           typename Sequence::reference r = c.front();
776
777           ignore_unused_variable_warning(c);
778           ignore_unused_variable_warning(c2);
779           ignore_unused_variable_warning(c3);
780           ignore_unused_variable_warning(r);
781           const_constraints(c);
782       }
783    private:
784       void const_constraints(const S& c) {
785           typename Sequence::const_reference r = c.front();
786           ignore_unused_variable_warning(r);
787       }
788     
789       typename S::value_type t;
790       typename S::size_type n;
791       typename S::value_type* first, *last;
792       typename S::iterator p, q;
793   };
794
795   BOOST_concept(FrontInsertionSequence,(S))
796     : Sequence<S>
797   {
798       BOOST_CONCEPT_USAGE(FrontInsertionSequence)
799       {
800           c.push_front(t);
801           c.pop_front();
802       }
803    private:
804       S c;
805       typename S::value_type t;
806   };
807
808   BOOST_concept(BackInsertionSequence,(S))
809     : Sequence<S>
810   {
811       BOOST_CONCEPT_USAGE(BackInsertionSequence)
812       {
813           c.push_back(t);
814           c.pop_back();
815           typename BackInsertionSequence::reference r = c.back();
816           ignore_unused_variable_warning(r);
817           const_constraints(c);
818       }
819    private:
820       void const_constraints(const S& cc) {
821           typename BackInsertionSequence::const_reference
822               r = cc.back();
823           ignore_unused_variable_warning(r);
824       };
825       S c;
826       typename S::value_type t;
827   };
828
829   BOOST_concept(AssociativeContainer,(C))
830     : ForwardContainer<C>
831     , DefaultConstructible<C>
832   {
833       typedef typename C::key_type key_type;
834       typedef typename C::key_compare key_compare;
835       typedef typename C::value_compare value_compare;
836       typedef typename C::iterator iterator;
837
838       BOOST_CONCEPT_USAGE(AssociativeContainer)
839       {
840           i = c.find(k);
841           r = c.equal_range(k);
842           c.erase(k);
843           c.erase(i);
844           c.erase(r.first, r.second);
845           const_constraints(c);
846           BOOST_CONCEPT_ASSERT((BinaryPredicate<key_compare,key_type,key_type>));
847           
848           typedef typename AssociativeContainer::value_type value_type_;
849           BOOST_CONCEPT_ASSERT((BinaryPredicate<value_compare,value_type_,value_type_>));
850       }
851       
852       // Redundant with the base concept, but it helps below.
853       typedef typename C::const_iterator const_iterator;
854    private:
855       void const_constraints(const C& cc)
856       {
857           ci = cc.find(k);
858           n = cc.count(k);
859           cr = cc.equal_range(k);
860       }
861
862       C c;
863       iterator i;
864       std::pair<iterator,iterator> r;
865       const_iterator ci;
866       std::pair<const_iterator,const_iterator> cr;
867       typename C::key_type k;
868       typename C::size_type n;
869   };
870
871   BOOST_concept(UniqueAssociativeContainer,(C))
872     : AssociativeContainer<C>
873   {
874       BOOST_CONCEPT_USAGE(UniqueAssociativeContainer)
875       {
876           C c(first, last);
877       
878           pos_flag = c.insert(t);
879           c.insert(first, last);
880
881           ignore_unused_variable_warning(c);
882       }
883    private:
884       std::pair<typename C::iterator, bool> pos_flag;
885       typename C::value_type t;
886       typename C::value_type* first, *last;
887   };
888
889   BOOST_concept(MultipleAssociativeContainer,(C))
890     : AssociativeContainer<C>
891   {
892       BOOST_CONCEPT_USAGE(MultipleAssociativeContainer)
893       {
894           C c(first, last);
895       
896           pos = c.insert(t);
897           c.insert(first, last);
898
899           ignore_unused_variable_warning(c);
900           ignore_unused_variable_warning(pos);
901       }
902    private:
903       typename C::iterator pos;
904       typename C::value_type t;
905       typename C::value_type* first, *last;
906   };
907
908   BOOST_concept(SimpleAssociativeContainer,(C))
909     : AssociativeContainer<C>
910   {
911       BOOST_CONCEPT_USAGE(SimpleAssociativeContainer)
912       {
913           typedef typename C::key_type key_type;
914           typedef typename C::value_type value_type;
915           BOOST_MPL_ASSERT((boost::is_same<key_type,value_type>));
916       }
917   };
918
919   BOOST_concept(PairAssociativeContainer,(C))
920     : AssociativeContainer<C>
921   {
922       BOOST_CONCEPT_USAGE(PairAssociativeContainer)
923       {
924           typedef typename C::key_type key_type;
925           typedef typename C::value_type value_type;
926           typedef typename C::mapped_type mapped_type;
927           typedef std::pair<const key_type, mapped_type> required_value_type;
928           BOOST_MPL_ASSERT((boost::is_same<value_type,required_value_type>));
929       }
930   };
931
932   BOOST_concept(SortedAssociativeContainer,(C))
933     : AssociativeContainer<C>
934     , ReversibleContainer<C>
935   {
936       BOOST_CONCEPT_USAGE(SortedAssociativeContainer)
937       {
938           C 
939               c(kc),
940               c2(first, last),
941               c3(first, last, kc);
942
943           p = c.upper_bound(k);
944           p = c.lower_bound(k);
945           r = c.equal_range(k);
946       
947           c.insert(p, t);
948       
949           ignore_unused_variable_warning(c);
950           ignore_unused_variable_warning(c2);
951           ignore_unused_variable_warning(c3);
952           const_constraints(c);
953       }
954       
955       void const_constraints(const C& c)
956       {
957           kc = c.key_comp();
958           vc = c.value_comp();
959
960           cp = c.upper_bound(k);
961           cp = c.lower_bound(k);
962           cr = c.equal_range(k);
963       }
964       
965    private:
966       typename C::key_compare kc;
967       typename C::value_compare vc;
968       typename C::value_type t;
969       typename C::key_type k;
970       typedef typename C::iterator iterator;
971       typedef typename C::const_iterator const_iterator;
972
973       typedef SortedAssociativeContainer self;
974       iterator p;
975       const_iterator cp;
976       std::pair<typename self::iterator,typename self::iterator> r;
977       std::pair<typename self::const_iterator,typename self::const_iterator> cr;
978       typename C::value_type* first, *last;
979   };
980
981   // HashedAssociativeContainer
982
983 } // namespace boost
984
985 # include <boost/concept/detail/concept_undef.hpp>
986
987 #endif // BOOST_CONCEPT_CHECKS_HPP
988