src/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/config.hpp>
  19 #include <boost/iterator.hpp>
  20 #include <boost/type_traits/conversion_traits.hpp>
  21 #include <utility>
  22 #include <boost/type_traits/conversion_traits.hpp>
  23 #include <boost/static_assert.hpp>
  24 #include <boost/mpl/identity.hpp>
  25
  26
  27 #if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(__BORLANDC__)
  28 #define BOOST_FPTR
  29 #else
  30 #define BOOST_FPTR &
  31 #endif
  32
  33 namespace boost {
  34
  35 /*
  36   "inline" is used for ignore_unused_variable_warning()
  37    and function_requires() to make sure there is no
  38    overhead with g++.
  39  */
  40
  41 template <class T> inline void ignore_unused_variable_warning(const T&) { }
  42
  43 // the unused, defaulted parameter is a workaround for MSVC and Compaq C++
  44 template <class Concept>
  45 inline void function_requires(mpl::identity<Concept>* = 0)
  46 {
  47 #if !defined(NDEBUG)
  48   void (Concept::*x)() = BOOST_FPTR Concept::constraints;
  49   ignore_unused_variable_warning(x);
  50 #endif
  51 }
  52
  53 #define BOOST_CLASS_REQUIRE(type_var, ns, concept) \
  54   typedef void (ns::concept <type_var>::* func##type_var##concept)(); \
  55   template <func##type_var##concept Tp1_> \
  56   struct concept_checking_##type_var##concept { }; \
  57   typedef concept_checking_##type_var##concept< \
  58     BOOST_FPTR ns::concept<type_var>::constraints> \
  59     concept_checking_typedef_##type_var##concept
  60
  61 #define BOOST_CLASS_REQUIRE2(type_var1, type_var2, ns, concept) \
  62   typedef void (ns::concept <type_var1,type_var2>::* \
  63      func##type_var1##type_var2##concept)(); \
  64   template <func##type_var1##type_var2##concept Tp1_> \
  65   struct concept_checking_##type_var1##type_var2##concept { }; \
  66   typedef concept_checking_##type_var1##type_var2##concept< \
  67     BOOST_FPTR ns::concept<type_var1,type_var2>::constraints> \
  68     concept_checking_typedef_##type_var1##type_var2##concept
  69
  70 #define BOOST_CLASS_REQUIRE3(tv1, tv2, tv3, ns, concept) \
  71   typedef void (ns::concept <tv1,tv2,tv3>::* \
  72      func##tv1##tv2##tv3##concept)(); \
  73   template <func##tv1##tv2##tv3##concept Tp1_> \
  74   struct concept_checking_##tv1##tv2##tv3##concept { }; \
  75   typedef concept_checking_##tv1##tv2##tv3##concept< \
  76     BOOST_FPTR ns::concept<tv1,tv2,tv3>::constraints> \
  77     concept_checking_typedef_##tv1##tv2##tv3##concept
  78
  79 #define BOOST_CLASS_REQUIRE4(tv1, tv2, tv3, tv4, ns, concept) \
  80   typedef void (ns::concept <tv1,tv2,tv3,tv4>::* \
  81      func##tv1##tv2##tv3##tv4##concept)(); \
  82   template <func##tv1##tv2##tv3##tv4##concept Tp1_> \
  83   struct concept_checking_##tv1##tv2##tv3##tv4##concept { }; \
  84   typedef concept_checking_##tv1##tv2##tv3##tv4##concept< \
  85     BOOST_FPTR ns::concept<tv1,tv2,tv3,tv4>::constraints> \
  86     concept_checking_typedef_##tv1##tv2##tv3##tv4##concept
  87
  88 // NOTE: The BOOST_CLASS_REQUIRES (with an 'S' at the end) is deprecated.
  89
  90 // The BOOST_CLASS_REQUIRES macros use function pointers as
  91 // template parameters, which VC++ does not support.
  92
  93 #if defined(BOOST_NO_FUNCTION_PTR_TEMPLATE_PARAMETERS)
  94
  95 #define BOOST_CLASS_REQUIRES(type_var, concept)
  96 #define BOOST_CLASS_REQUIRES2(type_var1, type_var2, concept)
  97 #define BOOST_CLASS_REQUIRES3(type_var1, type_var2, type_var3, concept)
  98 #define BOOST_CLASS_REQUIRES4(type_var1, type_var2, type_var3, type_var4, concept)
  99
 100 #else
 101
 102 #define BOOST_CLASS_REQUIRES(type_var, concept) \
 103   typedef void (concept <type_var>::* func##type_var##concept)(); \
 104   template <func##type_var##concept Tp1_> \
 105   struct concept_checking_##type_var##concept { }; \
 106   typedef concept_checking_##type_var##concept< \
 107     BOOST_FPTR concept <type_var>::constraints> \
 108     concept_checking_typedef_##type_var##concept
 109
 110 #define BOOST_CLASS_REQUIRES2(type_var1, type_var2, concept) \
 111   typedef void (concept <type_var1,type_var2>::* func##type_var1##type_var2##concept)(); \
 112   template <func##type_var1##type_var2##concept Tp1_> \
 113   struct concept_checking_##type_var1##type_var2##concept { }; \
 114   typedef concept_checking_##type_var1##type_var2##concept< \
 115     BOOST_FPTR concept <type_var1,type_var2>::constraints> \
 116     concept_checking_typedef_##type_var1##type_var2##concept
 117
 118 #define BOOST_CLASS_REQUIRES3(type_var1, type_var2, type_var3, concept) \
 119   typedef void (concept <type_var1,type_var2,type_var3>::* func##type_var1##type_var2##type_var3##concept)(); \
 120   template <func##type_var1##type_var2##type_var3##concept Tp1_> \
 121   struct concept_checking_##type_var1##type_var2##type_var3##concept { }; \
 122   typedef concept_checking_##type_var1##type_var2##type_var3##concept< \
 123     BOOST_FPTR concept <type_var1,type_var2,type_var3>::constraints>  \
 124   concept_checking_typedef_##type_var1##type_var2##type_var3##concept
 125
 126 #define BOOST_CLASS_REQUIRES4(type_var1, type_var2, type_var3, type_var4, concept) \
 127   typedef void (concept <type_var1,type_var2,type_var3,type_var4>::* func##type_var1##type_var2##type_var3##type_var4##concept)(); \
 128   template <func##type_var1##type_var2##type_var3##type_var4##concept Tp1_> \
 129   struct concept_checking_##type_var1##type_var2##type_var3##type_var4##concept { }; \
 130   typedef concept_checking_##type_var1##type_var2##type_var3##type_var4##concept< \
 131     BOOST_FPTR concept <type_var1,type_var2,type_var3,type_var4>::constraints>  \
 132     concept_checking_typedef_##type_var1##type_var2##type_var3##type_var4##concept
 133
 134
 135 #endif
 136
 137 #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 138 template <class T, class U>
 139 struct require_same { };
 140
 141 template <class T>
 142 struct require_same<T,T> { typedef T type; };
 143 #else
 144 // This version does not perform checking, but will not do any harm.
 145 template <class T, class U>
 146 struct require_same { typedef T type; };
 147 #endif
 148
 149   template <class T>
 150   struct IntegerConcept {
 151     void constraints() {
 152 #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 153       x.error_type_must_be_an_integer_type();
 154 #endif
 155     }
 156     T x;
 157   };
 158 #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 159   template <> struct IntegerConcept<short> { void constraints() {} };
 160   template <> struct IntegerConcept<unsigned short> { void constraints() {} };
 161   template <> struct IntegerConcept<int> { void constraints() {} };
 162   template <> struct IntegerConcept<unsigned int> { void constraints() {} };
 163   template <> struct IntegerConcept<long> { void constraints() {} };
 164   template <> struct IntegerConcept<unsigned long> { void constraints() {} };
 165   // etc.
 166 #endif
 167
 168   template <class T>
 169   struct SignedIntegerConcept {
 170     void constraints() {
 171 #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 172       x.error_type_must_be_a_signed_integer_type();
 173 #endif
 174     }
 175     T x;
 176   };
 177 #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 178   template <> struct SignedIntegerConcept<short> { void constraints() {} };
 179   template <> struct SignedIntegerConcept<int> { void constraints() {} };
 180   template <> struct SignedIntegerConcept<long> { void constraints() {} };
 181 # if defined(BOOST_HAS_LONG_LONG)
 182   template <> struct SignedIntegerConcept< ::boost::long_long_type> { void constraints() {} };
 183 # endif
 184   // etc.
 185 #endif
 186
 187   template <class T>
 188   struct UnsignedIntegerConcept {
 189     void constraints() {
 190 #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 191       x.error_type_must_be_an_unsigned_integer_type();
 192 #endif
 193     }
 194     T x;
 195   };
 196 #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 197   template <> struct UnsignedIntegerConcept<unsigned short>
 198     { void constraints() {} };
 199   template <> struct UnsignedIntegerConcept<unsigned int>
 200     { void constraints() {} };
 201   template <> struct UnsignedIntegerConcept<unsigned long>
 202     { void constraints() {} };
 203   // etc.
 204 #endif
 205
 206   //===========================================================================
 207   // Basic Concepts
 208
 209   template <class TT>
 210   struct DefaultConstructibleConcept
 211   {
 212     void constraints() {
 213       TT a;               // require default constructor
 214       ignore_unused_variable_warning(a);
 215     }
 216   };
 217
 218   template <class TT>
 219   struct AssignableConcept
 220   {
 221     void constraints() {
 222 #if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL
 223       a = a;              // require assignment operator
 224 #endif
 225       const_constraints(a);
 226     }
 227     void const_constraints(const TT& b) {
 228 #if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL
 229       a = b;              // const required for argument to assignment
 230 #endif
 231     }
 232     TT a;
 233   };
 234
 235   template <class TT>
 236   struct CopyConstructibleConcept
 237   {
 238     void constraints() {
 239       TT a(b);            // require copy constructor
 240       TT* ptr = &a;       // require address of operator
 241       const_constraints(a);
 242       ignore_unused_variable_warning(ptr);
 243     }
 244     void const_constraints(const TT& a) {
 245       TT c(a);            // require const copy constructor
 246       const TT* ptr = &a; // require const address of operator
 247       ignore_unused_variable_warning(c);
 248       ignore_unused_variable_warning(ptr);
 249     }
 250     TT b;
 251   };
 252
 253   // The SGI STL version of Assignable requires copy constructor and operator=
 254   template <class TT>
 255   struct SGIAssignableConcept
 256   {
 257     void constraints() {
 258       TT b(a);
 259 #if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL
 260       a = a;              // require assignment operator
 261 #endif
 262       const_constraints(a);
 263       ignore_unused_variable_warning(b);
 264     }
 265     void const_constraints(const TT& b) {
 266       TT c(b);
 267 #if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL
 268       a = b;              // const required for argument to assignment
 269 #endif
 270       ignore_unused_variable_warning(c);
 271     }
 272     TT a;
 273   };
 274
 275   template <class X, class Y>
 276   struct ConvertibleConcept
 277   {
 278     void constraints() {
 279       Y y = x;
 280       ignore_unused_variable_warning(y);
 281     }
 282     X x;
 283   };
 284
 285   // The C++ standard requirements for many concepts talk about return
 286   // types that must be "convertible to bool".  The problem with this
 287   // requirement is that it leaves the door open for evil proxies that
 288   // define things like operator|| with strange return types.  Two
 289   // possible solutions are:
 290   // 1) require the return type to be exactly bool
 291   // 2) stay with convertible to bool, and also
 292   //    specify stuff about all the logical operators.
 293   // For now we just test for convertible to bool.
 294   template <class TT>
 295   void require_boolean_expr(const TT& t) {
 296     bool x = t;
 297     ignore_unused_variable_warning(x);
 298   }
 299
 300   template <class TT>
 301   struct EqualityComparableConcept
 302   {
 303     void constraints() {
 304       require_boolean_expr(a == b);
 305       require_boolean_expr(a != b);
 306     }
 307     TT a, b;
 308   };
 309
 310   template <class TT>
 311   struct LessThanComparableConcept
 312   {
 313     void constraints() {
 314       require_boolean_expr(a < b);
 315     }
 316     TT a, b;
 317   };
 318
 319   // This is equivalent to SGI STL's LessThanComparable.
 320   template <class TT>
 321   struct ComparableConcept
 322   {
 323     void constraints() {
 324       require_boolean_expr(a < b);
 325       require_boolean_expr(a > b);
 326       require_boolean_expr(a <= b);
 327       require_boolean_expr(a >= b);
 328     }
 329     TT a, b;
 330   };
 331
 332 #define BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(OP,NAME) \
 333   template <class First, class Second> \
 334   struct NAME { \
 335     void constraints() { (void)constraints_(); } \
 336     bool constraints_() {  \
 337       return  a OP b; \
 338     } \
 339     First a; \
 340     Second b; \
 341   }
 342
 343 #define BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(OP,NAME) \
 344   template <class Ret, class First, class Second> \
 345   struct NAME { \
 346     void constraints() { (void)constraints_(); } \
 347     Ret constraints_() {  \
 348       return a OP b; \
 349     } \
 350     First a; \
 351     Second b; \
 352   }
 353
 354   BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(==, EqualOpConcept);
 355   BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(!=, NotEqualOpConcept);
 356   BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<, LessThanOpConcept);
 357   BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<=, LessEqualOpConcept);
 358   BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>, GreaterThanOpConcept);
 359   BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>=, GreaterEqualOpConcept);
 360
 361   BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(+, PlusOpConcept);
 362   BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(*, TimesOpConcept);
 363   BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(/, DivideOpConcept);
 364   BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(-, SubtractOpConcept);
 365   BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(%, ModOpConcept);
 366
 367   //===========================================================================
 368   // Function Object Concepts
 369
 370   template <class Func, class Return>
 371   struct GeneratorConcept
 372   {
 373     void constraints() {
 374       const Return& r = f();   // require operator() member function
 375       ignore_unused_variable_warning(r);
 376     }
 377     Func f;
 378   };
 379
 380
 381 #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 382   template <class Func>
 383   struct GeneratorConcept<Func,void>
 384   {
 385     void constraints() {
 386       f();              // require operator() member function
 387     }
 388     Func f;
 389   };
 390 #endif
 391
 392   template <class Func, class Return, class Arg>
 393   struct UnaryFunctionConcept
 394   {
 395     // required in case any of our template args are const-qualified:
 396     UnaryFunctionConcept();
 397
 398     void constraints() {
 399       r = f(arg); // require operator()
 400     }
 401     Func f;
 402     Arg arg;
 403     Return r;
 404   };
 405
 406 #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 407   template <class Func, class Arg>
 408   struct UnaryFunctionConcept<Func, void, Arg> {
 409     void constraints() {
 410       f(arg);                 // require operator()
 411     }
 412     Func f;
 413     Arg arg;
 414   };
 415 #endif
 416
 417   template <class Func, class Return, class First, class Second>
 418   struct BinaryFunctionConcept
 419   {
 420     void constraints() {
 421       r = f(first, second); // require operator()
 422     }
 423     Func f;
 424     First first;
 425     Second second;
 426     Return r;
 427   };
 428
 429 #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 430   template <class Func, class First, class Second>
 431   struct BinaryFunctionConcept<Func, void, First, Second>
 432   {
 433     void constraints() {
 434       f(first, second); // require operator()
 435     }
 436     Func f;
 437     First first;
 438     Second second;
 439   };
 440 #endif
 441
 442   template <class Func, class Arg>
 443   struct UnaryPredicateConcept
 444   {
 445     void constraints() {
 446       require_boolean_expr(f(arg)); // require operator() returning bool
 447     }
 448     Func f;
 449     Arg arg;
 450   };
 451
 452   template <class Func, class First, class Second>
 453   struct BinaryPredicateConcept
 454   {
 455     void constraints() {
 456       require_boolean_expr(f(a, b)); // require operator() returning bool
 457     }
 458     Func f;
 459     First a;
 460     Second b;
 461   };
 462
 463   // use this when functor is used inside a container class like std::set
 464   template <class Func, class First, class Second>
 465   struct Const_BinaryPredicateConcept {
 466     void constraints() {
 467       const_constraints(f);
 468     }
 469     void const_constraints(const Func& fun) {
 470       function_requires<BinaryPredicateConcept<Func, First, Second> >();
 471       // operator() must be a const member function
 472       require_boolean_expr(fun(a, b));
 473     }
 474     Func f;
 475     First a;
 476     Second b;
 477   };
 478
 479   template <class Func, class Return>
 480   struct AdaptableGeneratorConcept
 481   {
 482     void constraints() {
 483       typedef typename Func::result_type result_type;
 484       BOOST_STATIC_ASSERT((is_convertible<result_type, Return>::value));
 485       function_requires< GeneratorConcept<Func, result_type> >();
 486     }
 487   };
 488
 489   template <class Func, class Return, class Arg>
 490   struct AdaptableUnaryFunctionConcept
 491   {
 492     void constraints() {
 493       typedef typename Func::argument_type argument_type;
 494       typedef typename Func::result_type result_type;
 495       BOOST_STATIC_ASSERT((is_convertible<result_type, Return>::value));
 496       BOOST_STATIC_ASSERT((is_convertible<Arg, argument_type>::value));
 497       function_requires< UnaryFunctionConcept<Func, result_type, argument_type> >();
 498     }
 499   };
 500
 501   template <class Func, class Return, class First, class Second>
 502   struct AdaptableBinaryFunctionConcept
 503   {
 504     void constraints() {
 505       typedef typename Func::first_argument_type first_argument_type;
 506       typedef typename Func::second_argument_type second_argument_type;
 507       typedef typename Func::result_type result_type;
 508       BOOST_STATIC_ASSERT((is_convertible<result_type, Return>::value));
 509       BOOST_STATIC_ASSERT((is_convertible<First, first_argument_type>::value));
 510       BOOST_STATIC_ASSERT((is_convertible<Second, second_argument_type>::value));
 511       function_requires< BinaryFunctionConcept<Func, result_type,
 512         first_argument_type, second_argument_type> >();
 513     }
 514   };
 515
 516   template <class Func, class Arg>
 517   struct AdaptablePredicateConcept
 518   {
 519     void constraints() {
 520       function_requires< UnaryPredicateConcept<Func, Arg> >();
 521       function_requires< AdaptableUnaryFunctionConcept<Func, bool, Arg> >();
 522     }
 523   };
 524
 525   template <class Func, class First, class Second>
 526   struct AdaptableBinaryPredicateConcept
 527   {
 528     void constraints() {
 529       function_requires< BinaryPredicateConcept<Func, First, Second> >();
 530       function_requires< AdaptableBinaryFunctionConcept<Func, bool, First, Second> >();
 531     }
 532   };
 533
 534   //===========================================================================
 535   // Iterator Concepts
 536
 537   template <class TT>
 538   struct InputIteratorConcept
 539   {
 540     void constraints() {
 541       function_requires< AssignableConcept<TT> >();
 542       function_requires< EqualityComparableConcept<TT> >();
 543       TT j(i);
 544       (void)*i;           // require dereference operator
 545 #ifndef BOOST_NO_STD_ITERATOR_TRAITS
 546       // require iterator_traits typedef's
 547       typedef typename std::iterator_traits<TT>::difference_type D;
 548       // Hmm, the following is a bit fragile
 549       //function_requires< SignedIntegerConcept<D> >();
 550       typedef typename std::iterator_traits<TT>::reference R;
 551       typedef typename std::iterator_traits<TT>::pointer P;
 552       typedef typename std::iterator_traits<TT>::iterator_category C;
 553       function_requires< ConvertibleConcept<C, std::input_iterator_tag> >();
 554 #endif
 555       ++j;                // require preincrement operator
 556       i++;                // require postincrement operator
 557     }
 558     TT i;
 559   };
 560
 561   template <class TT, class ValueT>
 562   struct OutputIteratorConcept
 563   {
 564     void constraints() {
 565       function_requires< AssignableConcept<TT> >();
 566       ++i;                // require preincrement operator
 567       i++;                // require postincrement operator
 568       *i++ = t;           // require postincrement and assignment
 569     }
 570     TT i, j;
 571     ValueT t;
 572   };
 573
 574   template <class TT>
 575   struct ForwardIteratorConcept
 576   {
 577     void constraints() {
 578       function_requires< InputIteratorConcept<TT> >();
 579 #ifndef BOOST_NO_STD_ITERATOR_TRAITS
 580       typedef typename std::iterator_traits<TT>::iterator_category C;
 581       function_requires< ConvertibleConcept<C, std::forward_iterator_tag> >();
 582       typedef typename std::iterator_traits<TT>::reference reference;
 583       reference r = *i;
 584       ignore_unused_variable_warning(r);
 585 #endif
 586     }
 587     TT i;
 588   };
 589
 590   template <class TT>
 591   struct Mutable_ForwardIteratorConcept
 592   {
 593     void constraints() {
 594       function_requires< ForwardIteratorConcept<TT> >();
 595       *i++ = *i;         // require postincrement and assignment
 596     }
 597     TT i;
 598   };
 599
 600   template <class TT>
 601   struct BidirectionalIteratorConcept
 602   {
 603     void constraints() {
 604       function_requires< ForwardIteratorConcept<TT> >();
 605 #ifndef BOOST_NO_STD_ITERATOR_TRAITS
 606       typedef typename std::iterator_traits<TT>::iterator_category C;
 607       function_requires< ConvertibleConcept<C,
 608         std::bidirectional_iterator_tag> >();
 609 #endif
 610       --i;                // require predecrement operator
 611       i--;                // require postdecrement operator
 612     }
 613     TT i;
 614   };
 615
 616   template <class TT>
 617   struct Mutable_BidirectionalIteratorConcept
 618   {
 619     void constraints() {
 620       function_requires< BidirectionalIteratorConcept<TT> >();
 621       function_requires< Mutable_ForwardIteratorConcept<TT> >();
 622       *i-- = *i;                  // require postdecrement and assignment
 623     }
 624     TT i;
 625   };
 626
 627
 628   template <class TT>
 629   struct RandomAccessIteratorConcept
 630   {
 631     void constraints() {
 632       function_requires< BidirectionalIteratorConcept<TT> >();
 633       function_requires< ComparableConcept<TT> >();
 634 #ifndef BOOST_NO_STD_ITERATOR_TRAITS
 635       typedef typename std::iterator_traits<TT>::iterator_category C;
 636       function_requires< ConvertibleConcept< C,
 637         std::random_access_iterator_tag> >();
 638       typedef typename std::iterator_traits<TT>::reference R;
 639 #endif
 640
 641       i += n;             // require assignment addition operator
 642       i = i + n; i = n + i; // require addition with difference type
 643       i -= n;             // require assignment subtraction operator
 644       i = i - n;                  // require subtraction with difference type
 645       n = i - j;                  // require difference operator
 646       (void)i[n];                 // require element access operator
 647     }
 648     TT a, b;
 649     TT i, j;
 650 #ifndef BOOST_NO_STD_ITERATOR_TRAITS
 651     typename std::iterator_traits<TT>::difference_type n;
 652 #else
 653     std::ptrdiff_t n;
 654 #endif
 655   };
 656
 657   template <class TT>
 658   struct Mutable_RandomAccessIteratorConcept
 659   {
 660     void constraints() {
 661       function_requires< RandomAccessIteratorConcept<TT> >();
 662       function_requires< Mutable_BidirectionalIteratorConcept<TT> >();
 663       i[n] = *i;                  // require element access and assignment
 664     }
 665     TT i;
 666 #ifndef BOOST_NO_STD_ITERATOR_TRAITS
 667     typename std::iterator_traits<TT>::difference_type n;
 668 #else
 669     std::ptrdiff_t n;
 670 #endif
 671   };
 672
 673   //===========================================================================
 674   // Container Concepts
 675
 676   template <class Container>
 677   struct ContainerConcept
 678   {
 679     typedef typename Container::value_type value_type;
 680     typedef typename Container::difference_type difference_type;
 681     typedef typename Container::size_type size_type;
 682     typedef typename Container::const_reference const_reference;
 683     typedef typename Container::const_pointer const_pointer;
 684     typedef typename Container::const_iterator const_iterator;
 685
 686     void constraints() {
 687       function_requires< InputIteratorConcept<const_iterator> >();
 688       function_requires< AssignableConcept<Container> >();
 689       const_constraints(c);
 690     }
 691     void const_constraints(const Container& cc) {
 692       i = cc.begin();
 693       i = cc.end();
 694       n = cc.size();
 695       n = cc.max_size();
 696       b = cc.empty();
 697     }
 698     Container c;
 699     bool b;
 700     const_iterator i;
 701     size_type n;
 702   };
 703
 704   template <class Container>
 705   struct Mutable_ContainerConcept
 706   {
 707     typedef typename Container::value_type value_type;
 708     typedef typename Container::reference reference;
 709     typedef typename Container::iterator iterator;
 710     typedef typename Container::pointer pointer;
 711
 712     void constraints() {
 713       function_requires< ContainerConcept<Container> >();
 714       function_requires< AssignableConcept<value_type> >();
 715       function_requires< InputIteratorConcept<iterator> >();
 716
 717       i = c.begin();
 718       i = c.end();
 719       c.swap(c2);
 720     }
 721     iterator i;
 722     Container c, c2;
 723   };
 724
 725   template <class ForwardContainer>
 726   struct ForwardContainerConcept
 727   {
 728     void constraints() {
 729       function_requires< ContainerConcept<ForwardContainer> >();
 730       typedef typename ForwardContainer::const_iterator const_iterator;
 731       function_requires< ForwardIteratorConcept<const_iterator> >();
 732     }
 733   };
 734
 735   template <class ForwardContainer>
 736   struct Mutable_ForwardContainerConcept
 737   {
 738     void constraints() {
 739       function_requires< ForwardContainerConcept<ForwardContainer> >();
 740       function_requires< Mutable_ContainerConcept<ForwardContainer> >();
 741       typedef typename ForwardContainer::iterator iterator;
 742       function_requires< Mutable_ForwardIteratorConcept<iterator> >();
 743     }
 744   };
 745
 746   template <class ReversibleContainer>
 747   struct ReversibleContainerConcept
 748   {
 749     typedef typename ReversibleContainer::const_iterator const_iterator;
 750     typedef typename ReversibleContainer::const_reverse_iterator
 751       const_reverse_iterator;
 752
 753     void constraints() {
 754       function_requires< ForwardContainerConcept<ReversibleContainer> >();
 755       function_requires< BidirectionalIteratorConcept<const_iterator> >();
 756       function_requires<
 757         BidirectionalIteratorConcept<const_reverse_iterator> >();
 758       const_constraints(c);
 759     }
 760     void const_constraints(const ReversibleContainer& cc) {
 761       const_reverse_iterator i = cc.rbegin();
 762       i = cc.rend();
 763     }
 764     ReversibleContainer c;
 765   };
 766
 767   template <class ReversibleContainer>
 768   struct Mutable_ReversibleContainerConcept
 769   {
 770     typedef typename ReversibleContainer::iterator iterator;
 771     typedef typename ReversibleContainer::reverse_iterator reverse_iterator;
 772
 773     void constraints() {
 774       function_requires< ReversibleContainerConcept<ReversibleContainer> >();
 775       function_requires<
 776         Mutable_ForwardContainerConcept<ReversibleContainer> >();
 777       function_requires< Mutable_BidirectionalIteratorConcept<iterator> >();
 778       function_requires<
 779         Mutable_BidirectionalIteratorConcept<reverse_iterator> >();
 780
 781       reverse_iterator i = c.rbegin();
 782       i = c.rend();
 783     }
 784     ReversibleContainer c;
 785   };
 786
 787   template <class RandomAccessContainer>
 788   struct RandomAccessContainerConcept
 789   {
 790     typedef typename RandomAccessContainer::size_type size_type;
 791     typedef typename RandomAccessContainer::const_reference const_reference;
 792     typedef typename RandomAccessContainer::const_iterator const_iterator;
 793     typedef typename RandomAccessContainer::const_reverse_iterator
 794       const_reverse_iterator;
 795
 796     void constraints() {
 797       function_requires< ReversibleContainerConcept<RandomAccessContainer> >();
 798       function_requires< RandomAccessIteratorConcept<const_iterator> >();
 799       function_requires<
 800         RandomAccessIteratorConcept<const_reverse_iterator> >();
 801
 802       const_constraints(c);
 803     }
 804     void const_constraints(const RandomAccessContainer& cc) {
 805       const_reference r = cc[n];
 806       ignore_unused_variable_warning(r);
 807     }
 808     RandomAccessContainer c;
 809     size_type n;
 810   };
 811
 812   template <class RandomAccessContainer>
 813   struct Mutable_RandomAccessContainerConcept
 814   {
 815     typedef typename RandomAccessContainer::size_type size_type;
 816     typedef typename RandomAccessContainer::reference reference;
 817     typedef typename RandomAccessContainer::iterator iterator;
 818     typedef typename RandomAccessContainer::reverse_iterator reverse_iterator;
 819
 820     void constraints() {
 821       function_requires<
 822         RandomAccessContainerConcept<RandomAccessContainer> >();
 823       function_requires<
 824         Mutable_ReversibleContainerConcept<RandomAccessContainer> >();
 825       function_requires< Mutable_RandomAccessIteratorConcept<iterator> >();
 826       function_requires<
 827         Mutable_RandomAccessIteratorConcept<reverse_iterator> >();
 828
 829       reference r = c[i];
 830       ignore_unused_variable_warning(r);
 831     }
 832     size_type i;
 833     RandomAccessContainer c;
 834   };
 835
 836   // A Sequence is inherently mutable
 837   template <class Sequence>
 838   struct SequenceConcept
 839   {
 840
 841     typedef typename Sequence::reference reference;
 842     typedef typename Sequence::const_reference const_reference;
 843
 844     void constraints() {
 845       // Matt Austern's book puts DefaultConstructible here, the C++
 846       // standard places it in Container
 847       //    function_requires< DefaultConstructible<Sequence> >();
 848       function_requires< Mutable_ForwardContainerConcept<Sequence> >();
 849       function_requires< DefaultConstructibleConcept<Sequence> >();
 850
 851       Sequence
 852         c(n),
 853         c2(n, t),
 854         c3(first, last);
 855
 856       c.insert(p, t);
 857       c.insert(p, n, t);
 858       c.insert(p, first, last);
 859
 860       c.erase(p);
 861       c.erase(p, q);
 862
 863       reference r = c.front();
 864
 865       ignore_unused_variable_warning(c);
 866       ignore_unused_variable_warning(c2);
 867       ignore_unused_variable_warning(c3);
 868       ignore_unused_variable_warning(r);
 869       const_constraints(c);
 870     }
 871     void const_constraints(const Sequence& c) {
 872       const_reference r = c.front();
 873       ignore_unused_variable_warning(r);
 874     }
 875     typename Sequence::value_type t;
 876     typename Sequence::size_type n;
 877     typename Sequence::value_type* first, *last;
 878     typename Sequence::iterator p, q;
 879   };
 880
 881   template <class FrontInsertionSequence>
 882   struct FrontInsertionSequenceConcept
 883   {
 884     void constraints() {
 885       function_requires< SequenceConcept<FrontInsertionSequence> >();
 886
 887       c.push_front(t);
 888       c.pop_front();
 889     }
 890     FrontInsertionSequence c;
 891     typename FrontInsertionSequence::value_type t;
 892   };
 893
 894   template <class BackInsertionSequence>
 895   struct BackInsertionSequenceConcept
 896   {
 897     typedef typename BackInsertionSequence::reference reference;
 898     typedef typename BackInsertionSequence::const_reference const_reference;
 899
 900     void constraints() {
 901       function_requires< SequenceConcept<BackInsertionSequence> >();
 902
 903       c.push_back(t);
 904       c.pop_back();
 905       reference r = c.back();
 906       ignore_unused_variable_warning(r);
 907     }
 908     void const_constraints(const BackInsertionSequence& cc) {
 909       const_reference r = cc.back();
 910       ignore_unused_variable_warning(r);
 911     };
 912     BackInsertionSequence c;
 913     typename BackInsertionSequence::value_type t;
 914   };
 915
 916   template <class AssociativeContainer>
 917   struct AssociativeContainerConcept
 918   {
 919     void constraints() {
 920       function_requires< ForwardContainerConcept<AssociativeContainer> >();
 921       function_requires< DefaultConstructibleConcept<AssociativeContainer> >();
 922
 923       i = c.find(k);
 924       r = c.equal_range(k);
 925       c.erase(k);
 926       c.erase(i);
 927       c.erase(r.first, r.second);
 928       const_constraints(c);
 929     }
 930     void const_constraints(const AssociativeContainer& cc) {
 931       ci = cc.find(k);
 932       n = cc.count(k);
 933       cr = cc.equal_range(k);
 934     }
 935     typedef typename AssociativeContainer::iterator iterator;
 936     typedef typename AssociativeContainer::const_iterator const_iterator;
 937
 938     AssociativeContainer c;
 939     iterator i;
 940     std::pair<iterator,iterator> r;
 941     const_iterator ci;
 942     std::pair<const_iterator,const_iterator> cr;
 943     typename AssociativeContainer::key_type k;
 944     typename AssociativeContainer::size_type n;
 945   };
 946
 947   template <class UniqueAssociativeContainer>
 948   struct UniqueAssociativeContainerConcept
 949   {
 950     void constraints() {
 951       function_requires< AssociativeContainerConcept<UniqueAssociativeContainer> >();
 952
 953       UniqueAssociativeContainer c(first, last);
 954
 955       pos_flag = c.insert(t);
 956       c.insert(first, last);
 957
 958       ignore_unused_variable_warning(c);
 959     }
 960     std::pair<typename UniqueAssociativeContainer::iterator, bool> pos_flag;
 961     typename UniqueAssociativeContainer::value_type t;
 962     typename UniqueAssociativeContainer::value_type* first, *last;
 963   };
 964
 965   template <class MultipleAssociativeContainer>
 966   struct MultipleAssociativeContainerConcept
 967   {
 968     void constraints() {
 969       function_requires< AssociativeContainerConcept<MultipleAssociativeContainer> >();
 970
 971       MultipleAssociativeContainer c(first, last);
 972
 973       pos = c.insert(t);
 974       c.insert(first, last);
 975
 976       ignore_unused_variable_warning(c);
 977       ignore_unused_variable_warning(pos);
 978     }
 979     typename MultipleAssociativeContainer::iterator pos;
 980     typename MultipleAssociativeContainer::value_type t;
 981     typename MultipleAssociativeContainer::value_type* first, *last;
 982   };
 983
 984   template <class SimpleAssociativeContainer>
 985   struct SimpleAssociativeContainerConcept
 986   {
 987     void constraints() {
 988       function_requires< AssociativeContainerConcept<SimpleAssociativeContainer> >();
 989       typedef typename SimpleAssociativeContainer::key_type key_type;
 990       typedef typename SimpleAssociativeContainer::value_type value_type;
 991       typedef typename require_same<key_type, value_type>::type req;
 992     }
 993   };
 994
 995   template <class SimpleAssociativeContainer>
 996   struct PairAssociativeContainerConcept
 997   {
 998     void constraints() {
 999       function_requires< AssociativeContainerConcept<SimpleAssociativeContainer> >();
1000       typedef typename SimpleAssociativeContainer::key_type key_type;
1001       typedef typename SimpleAssociativeContainer::value_type value_type;
1002       typedef typename SimpleAssociativeContainer::mapped_type mapped_type;
1003       typedef std::pair<const key_type, mapped_type> required_value_type;
1004       typedef typename require_same<value_type, required_value_type>::type req;
1005     }
1006   };
1007
1008   template <class SortedAssociativeContainer>
1009   struct SortedAssociativeContainerConcept
1010   {
1011     void constraints() {
1012       function_requires< AssociativeContainerConcept<SortedAssociativeContainer> >();
1013       function_requires< ReversibleContainerConcept<SortedAssociativeContainer> >();
1014
1015       SortedAssociativeContainer
1016         c(kc),
1017         c2(first, last),
1018         c3(first, last, kc);
1019
1020       p = c.upper_bound(k);
1021       p = c.lower_bound(k);
1022       r = c.equal_range(k);
1023
1024       c.insert(p, t);
1025
1026       ignore_unused_variable_warning(c);
1027       ignore_unused_variable_warning(c2);
1028       ignore_unused_variable_warning(c3);
1029     }
1030     void const_constraints(const SortedAssociativeContainer& c) {
1031       kc = c.key_comp();
1032       vc = c.value_comp();
1033
1034       cp = c.upper_bound(k);
1035       cp = c.lower_bound(k);
1036       cr = c.equal_range(k);
1037     }
1038     typename SortedAssociativeContainer::key_compare kc;
1039     typename SortedAssociativeContainer::value_compare vc;
1040     typename SortedAssociativeContainer::value_type t;
1041     typename SortedAssociativeContainer::key_type k;
1042     typedef typename SortedAssociativeContainer::iterator iterator;
1043     typedef typename SortedAssociativeContainer::const_iterator const_iterator;
1044     iterator p;
1045     const_iterator cp;
1046     std::pair<iterator,iterator> r;
1047     std::pair<const_iterator,const_iterator> cr;
1048     typename SortedAssociativeContainer::value_type* first, *last;
1049   };
1050
1051   // HashedAssociativeContainer
1052
1053 } // namespace boost
1054
1055 #endif // BOOST_CONCEPT_CHECKS_HPP
1056