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