diff options
Diffstat (limited to 'contrib/src/boost/concept_check.hpp')
| -rw-r--r-- | contrib/src/boost/concept_check.hpp | 2164 |
1 files changed, 1082 insertions, 1082 deletions
diff --git a/contrib/src/boost/concept_check.hpp b/contrib/src/boost/concept_check.hpp index d1c5a15..25f118b 100644 --- a/contrib/src/boost/concept_check.hpp +++ b/contrib/src/boost/concept_check.hpp @@ -1,1082 +1,1082 @@ -//
-// (C) Copyright Jeremy Siek 2000.
-// Copyright 2002 The Trustees of Indiana University.
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-// Revision History:
-// 05 May 2001: Workarounds for HP aCC from Thomas Matelich. (Jeremy Siek)
-// 02 April 2001: Removed limits header altogether. (Jeremy Siek)
-// 01 April 2001: Modified to use new <boost/limits.hpp> header. (JMaddock)
-//
-
-// See http://www.boost.org/libs/concept_check for documentation.
-
-#ifndef BOOST_CONCEPT_CHECKS_HPP
-# define BOOST_CONCEPT_CHECKS_HPP
-
-# include <boost/concept/assert.hpp>
-
-# include <iterator>
-# include <boost/type_traits/conversion_traits.hpp>
-# include <utility>
-# include <boost/type_traits/is_same.hpp>
-# include <boost/type_traits/is_void.hpp>
-# include <boost/mpl/assert.hpp>
-# include <boost/mpl/bool.hpp>
-# include <boost/detail/workaround.hpp>
-
-# include <boost/concept/usage.hpp>
-# include <boost/concept/detail/concept_def.hpp>
-
-#if (defined _MSC_VER)
-# pragma warning( push )
-# pragma warning( disable : 4510 ) // default constructor could not be generated
-# pragma warning( disable : 4610 ) // object 'class' can never be instantiated - user-defined constructor required
-#endif
-
-namespace boost
-{
-
- //
- // Backward compatibility
- //
-
- template <class Model>
- inline void function_requires(Model* = 0)
- {
- BOOST_CONCEPT_ASSERT((Model));
- }
- template <class T> inline void ignore_unused_variable_warning(T const&) {}
-
-# define BOOST_CLASS_REQUIRE(type_var, ns, concept) \
- BOOST_CONCEPT_ASSERT((ns::concept<type_var>))
-
-# define BOOST_CLASS_REQUIRE2(type_var1, type_var2, ns, concept) \
- BOOST_CONCEPT_ASSERT((ns::concept<type_var1,type_var2>))
-
-# define BOOST_CLASS_REQUIRE3(tv1, tv2, tv3, ns, concept) \
- BOOST_CONCEPT_ASSERT((ns::concept<tv1,tv2,tv3>))
-
-# define BOOST_CLASS_REQUIRE4(tv1, tv2, tv3, tv4, ns, concept) \
- BOOST_CONCEPT_ASSERT((ns::concept<tv1,tv2,tv3,tv4>))
-
-
- //
- // Begin concept definitions
- //
- BOOST_concept(Integer, (T))
- {
- BOOST_CONCEPT_USAGE(Integer)
- {
- x.error_type_must_be_an_integer_type();
- }
- private:
- T x;
- };
-
- template <> struct Integer<char> {};
- template <> struct Integer<signed char> {};
- template <> struct Integer<unsigned char> {};
- template <> struct Integer<short> {};
- template <> struct Integer<unsigned short> {};
- template <> struct Integer<int> {};
- template <> struct Integer<unsigned int> {};
- template <> struct Integer<long> {};
- template <> struct Integer<unsigned long> {};
-# if defined(BOOST_HAS_LONG_LONG)
- template <> struct Integer< ::boost::long_long_type> {};
- template <> struct Integer< ::boost::ulong_long_type> {};
-# elif defined(BOOST_HAS_MS_INT64)
- template <> struct Integer<__int64> {};
- template <> struct Integer<unsigned __int64> {};
-# endif
-
- BOOST_concept(SignedInteger,(T)) {
- BOOST_CONCEPT_USAGE(SignedInteger) {
- x.error_type_must_be_a_signed_integer_type();
- }
- private:
- T x;
- };
- template <> struct SignedInteger<signed char> { };
- template <> struct SignedInteger<short> {};
- template <> struct SignedInteger<int> {};
- template <> struct SignedInteger<long> {};
-# if defined(BOOST_HAS_LONG_LONG)
- template <> struct SignedInteger< ::boost::long_long_type> {};
-# elif defined(BOOST_HAS_MS_INT64)
- template <> struct SignedInteger<__int64> {};
-# endif
-
- BOOST_concept(UnsignedInteger,(T)) {
- BOOST_CONCEPT_USAGE(UnsignedInteger) {
- x.error_type_must_be_an_unsigned_integer_type();
- }
- private:
- T x;
- };
-
- template <> struct UnsignedInteger<unsigned char> {};
- template <> struct UnsignedInteger<unsigned short> {};
- template <> struct UnsignedInteger<unsigned int> {};
- template <> struct UnsignedInteger<unsigned long> {};
-# if defined(BOOST_HAS_LONG_LONG)
- template <> struct UnsignedInteger< ::boost::ulong_long_type> {};
-# elif defined(BOOST_HAS_MS_INT64)
- template <> struct UnsignedInteger<unsigned __int64> {};
-# endif
-
- //===========================================================================
- // Basic Concepts
-
- BOOST_concept(DefaultConstructible,(TT))
- {
- BOOST_CONCEPT_USAGE(DefaultConstructible) {
- TT a; // require default constructor
- ignore_unused_variable_warning(a);
- }
- };
-
- BOOST_concept(Assignable,(TT))
- {
- BOOST_CONCEPT_USAGE(Assignable) {
-#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL
- a = b; // require assignment operator
-#endif
- const_constraints(b);
- }
- private:
- void const_constraints(const TT& x) {
-#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL
- a = x; // const required for argument to assignment
-#else
- ignore_unused_variable_warning(x);
-#endif
- }
- private:
- TT a;
- TT b;
- };
-
-
- BOOST_concept(CopyConstructible,(TT))
- {
- BOOST_CONCEPT_USAGE(CopyConstructible) {
- TT a(b); // require copy constructor
- TT* ptr = &a; // require address of operator
- const_constraints(a);
- ignore_unused_variable_warning(ptr);
- }
- private:
- void const_constraints(const TT& a) {
- TT c(a); // require const copy constructor
- const TT* ptr = &a; // require const address of operator
- ignore_unused_variable_warning(c);
- ignore_unused_variable_warning(ptr);
- }
- TT b;
- };
-
- // The SGI STL version of Assignable requires copy constructor and operator=
- BOOST_concept(SGIAssignable,(TT))
- {
- BOOST_CONCEPT_USAGE(SGIAssignable) {
- TT c(a);
-#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL
- a = b; // require assignment operator
-#endif
- const_constraints(b);
- ignore_unused_variable_warning(c);
- }
- private:
- void const_constraints(const TT& x) {
- TT c(x);
-#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL
- a = x; // const required for argument to assignment
-#endif
- ignore_unused_variable_warning(c);
- }
- TT a;
- TT b;
- };
-
- BOOST_concept(Convertible,(X)(Y))
- {
- BOOST_CONCEPT_USAGE(Convertible) {
- Y y = x;
- ignore_unused_variable_warning(y);
- }
- private:
- X x;
- };
-
- // The C++ standard requirements for many concepts talk about return
- // types that must be "convertible to bool". The problem with this
- // requirement is that it leaves the door open for evil proxies that
- // define things like operator|| with strange return types. Two
- // possible solutions are:
- // 1) require the return type to be exactly bool
- // 2) stay with convertible to bool, and also
- // specify stuff about all the logical operators.
- // For now we just test for convertible to bool.
- template <class TT>
- void require_boolean_expr(const TT& t) {
- bool x = t;
- ignore_unused_variable_warning(x);
- }
-
- BOOST_concept(EqualityComparable,(TT))
- {
- BOOST_CONCEPT_USAGE(EqualityComparable) {
- require_boolean_expr(a == b);
- require_boolean_expr(a != b);
- }
- private:
- TT a, b;
- };
-
- BOOST_concept(LessThanComparable,(TT))
- {
- BOOST_CONCEPT_USAGE(LessThanComparable) {
- require_boolean_expr(a < b);
- }
- private:
- TT a, b;
- };
-
- // This is equivalent to SGI STL's LessThanComparable.
- BOOST_concept(Comparable,(TT))
- {
- BOOST_CONCEPT_USAGE(Comparable) {
- require_boolean_expr(a < b);
- require_boolean_expr(a > b);
- require_boolean_expr(a <= b);
- require_boolean_expr(a >= b);
- }
- private:
- TT a, b;
- };
-
-#define BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(OP,NAME) \
- BOOST_concept(NAME, (First)(Second)) \
- { \
- BOOST_CONCEPT_USAGE(NAME) { (void)constraints_(); } \
- private: \
- bool constraints_() { return a OP b; } \
- First a; \
- Second b; \
- }
-
-#define BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(OP,NAME) \
- BOOST_concept(NAME, (Ret)(First)(Second)) \
- { \
- BOOST_CONCEPT_USAGE(NAME) { (void)constraints_(); } \
- private: \
- Ret constraints_() { return a OP b; } \
- First a; \
- Second b; \
- }
-
- BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(==, EqualOp);
- BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(!=, NotEqualOp);
- BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<, LessThanOp);
- BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<=, LessEqualOp);
- BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>, GreaterThanOp);
- BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>=, GreaterEqualOp);
-
- BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(+, PlusOp);
- BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(*, TimesOp);
- BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(/, DivideOp);
- BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(-, SubtractOp);
- BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(%, ModOp);
-
- //===========================================================================
- // Function Object Concepts
-
- BOOST_concept(Generator,(Func)(Return))
- {
- BOOST_CONCEPT_USAGE(Generator) { test(is_void<Return>()); }
-
- private:
- void test(boost::mpl::false_)
- {
- // Do we really want a reference here?
- const Return& r = f();
- ignore_unused_variable_warning(r);
- }
-
- void test(boost::mpl::true_)
- {
- f();
- }
-
- Func f;
- };
-
- BOOST_concept(UnaryFunction,(Func)(Return)(Arg))
- {
- BOOST_CONCEPT_USAGE(UnaryFunction) { test(is_void<Return>()); }
-
- private:
- void test(boost::mpl::false_)
- {
- f(arg); // "priming the pump" this way keeps msvc6 happy (ICE)
- Return r = f(arg);
- ignore_unused_variable_warning(r);
- }
-
- void test(boost::mpl::true_)
- {
- f(arg);
- }
-
-#if (BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(4) \
- && BOOST_WORKAROUND(__GNUC__, > 3)))
- // Declare a dummy construktor to make gcc happy.
- // It seems the compiler can not generate a sensible constructor when this is instantiated with a refence type.
- // (warning: non-static reference "const double& boost::UnaryFunction<YourClassHere>::arg"
- // in class without a constructor [-Wuninitialized])
- UnaryFunction();
-#endif
-
- Func f;
- Arg arg;
- };
-
- BOOST_concept(BinaryFunction,(Func)(Return)(First)(Second))
- {
- BOOST_CONCEPT_USAGE(BinaryFunction) { test(is_void<Return>()); }
- private:
- void test(boost::mpl::false_)
- {
- f(first,second);
- Return r = f(first, second); // require operator()
- (void)r;
- }
-
- void test(boost::mpl::true_)
- {
- f(first,second);
- }
-
-#if (BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(4) \
- && BOOST_WORKAROUND(__GNUC__, > 3)))
- // Declare a dummy constructor to make gcc happy.
- // It seems the compiler can not generate a sensible constructor when this is instantiated with a refence type.
- // (warning: non-static reference "const double& boost::BinaryFunction<YourClassHere>::arg"
- // in class without a constructor [-Wuninitialized])
- BinaryFunction();
-#endif
-
- Func f;
- First first;
- Second second;
- };
-
- BOOST_concept(UnaryPredicate,(Func)(Arg))
- {
- BOOST_CONCEPT_USAGE(UnaryPredicate) {
- require_boolean_expr(f(arg)); // require operator() returning bool
- }
- private:
-#if (BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(4) \
- && BOOST_WORKAROUND(__GNUC__, > 3)))
- // Declare a dummy constructor to make gcc happy.
- // It seems the compiler can not generate a sensible constructor when this is instantiated with a refence type.
- // (warning: non-static reference "const double& boost::UnaryPredicate<YourClassHere>::arg"
- // in class without a constructor [-Wuninitialized])
- UnaryPredicate();
-#endif
-
- Func f;
- Arg arg;
- };
-
- BOOST_concept(BinaryPredicate,(Func)(First)(Second))
- {
- BOOST_CONCEPT_USAGE(BinaryPredicate) {
- require_boolean_expr(f(a, b)); // require operator() returning bool
- }
- private:
-#if (BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(4) \
- && BOOST_WORKAROUND(__GNUC__, > 3)))
- // Declare a dummy constructor to make gcc happy.
- // It seems the compiler can not generate a sensible constructor when this is instantiated with a refence type.
- // (warning: non-static reference "const double& boost::BinaryPredicate<YourClassHere>::arg"
- // in class without a constructor [-Wuninitialized])
- BinaryPredicate();
-#endif
- Func f;
- First a;
- Second b;
- };
-
- // use this when functor is used inside a container class like std::set
- BOOST_concept(Const_BinaryPredicate,(Func)(First)(Second))
- : BinaryPredicate<Func, First, Second>
- {
- BOOST_CONCEPT_USAGE(Const_BinaryPredicate) {
- const_constraints(f);
- }
- private:
- void const_constraints(const Func& fun) {
- // operator() must be a const member function
- require_boolean_expr(fun(a, b));
- }
-#if (BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(4) \
- && BOOST_WORKAROUND(__GNUC__, > 3)))
- // Declare a dummy constructor to make gcc happy.
- // It seems the compiler can not generate a sensible constructor when this is instantiated with a refence type.
- // (warning: non-static reference "const double& boost::Const_BinaryPredicate<YourClassHere>::arg"
- // in class without a constructor [-Wuninitialized])
- Const_BinaryPredicate();
-#endif
-
- Func f;
- First a;
- Second b;
- };
-
- BOOST_concept(AdaptableGenerator,(Func)(Return))
- : Generator<Func, typename Func::result_type>
- {
- typedef typename Func::result_type result_type;
-
- BOOST_CONCEPT_USAGE(AdaptableGenerator)
- {
- BOOST_CONCEPT_ASSERT((Convertible<result_type, Return>));
- }
- };
-
- BOOST_concept(AdaptableUnaryFunction,(Func)(Return)(Arg))
- : UnaryFunction<Func, typename Func::result_type, typename Func::argument_type>
- {
- typedef typename Func::argument_type argument_type;
- typedef typename Func::result_type result_type;
-
- ~AdaptableUnaryFunction()
- {
- BOOST_CONCEPT_ASSERT((Convertible<result_type, Return>));
- BOOST_CONCEPT_ASSERT((Convertible<Arg, argument_type>));
- }
- };
-
- BOOST_concept(AdaptableBinaryFunction,(Func)(Return)(First)(Second))
- : BinaryFunction<
- Func
- , typename Func::result_type
- , typename Func::first_argument_type
- , typename Func::second_argument_type
- >
- {
- typedef typename Func::first_argument_type first_argument_type;
- typedef typename Func::second_argument_type second_argument_type;
- typedef typename Func::result_type result_type;
-
- ~AdaptableBinaryFunction()
- {
- BOOST_CONCEPT_ASSERT((Convertible<result_type, Return>));
- BOOST_CONCEPT_ASSERT((Convertible<First, first_argument_type>));
- BOOST_CONCEPT_ASSERT((Convertible<Second, second_argument_type>));
- }
- };
-
- BOOST_concept(AdaptablePredicate,(Func)(Arg))
- : UnaryPredicate<Func, Arg>
- , AdaptableUnaryFunction<Func, bool, Arg>
- {
- };
-
- BOOST_concept(AdaptableBinaryPredicate,(Func)(First)(Second))
- : BinaryPredicate<Func, First, Second>
- , AdaptableBinaryFunction<Func, bool, First, Second>
- {
- };
-
- //===========================================================================
- // Iterator Concepts
-
- BOOST_concept(InputIterator,(TT))
- : Assignable<TT>
- , EqualityComparable<TT>
- {
- typedef typename std::iterator_traits<TT>::value_type value_type;
- typedef typename std::iterator_traits<TT>::difference_type difference_type;
- typedef typename std::iterator_traits<TT>::reference reference;
- typedef typename std::iterator_traits<TT>::pointer pointer;
- typedef typename std::iterator_traits<TT>::iterator_category iterator_category;
-
- BOOST_CONCEPT_USAGE(InputIterator)
- {
- BOOST_CONCEPT_ASSERT((SignedInteger<difference_type>));
- BOOST_CONCEPT_ASSERT((Convertible<iterator_category, std::input_iterator_tag>));
-
- TT j(i);
- (void)*i; // require dereference operator
- ++j; // require preincrement operator
- i++; // require postincrement operator
- }
- private:
- TT i;
- };
-
- BOOST_concept(OutputIterator,(TT)(ValueT))
- : Assignable<TT>
- {
- BOOST_CONCEPT_USAGE(OutputIterator) {
-
- ++i; // require preincrement operator
- i++; // require postincrement operator
- *i++ = t; // require postincrement and assignment
- }
- private:
- TT i, j;
- ValueT t;
- };
-
- BOOST_concept(ForwardIterator,(TT))
- : InputIterator<TT>
- {
- BOOST_CONCEPT_USAGE(ForwardIterator)
- {
- BOOST_CONCEPT_ASSERT((Convertible<
- BOOST_DEDUCED_TYPENAME ForwardIterator::iterator_category
- , std::forward_iterator_tag
- >));
-
- typename InputIterator<TT>::reference r = *i;
- ignore_unused_variable_warning(r);
- }
-
- private:
- TT i;
- };
-
- BOOST_concept(Mutable_ForwardIterator,(TT))
- : ForwardIterator<TT>
- {
- BOOST_CONCEPT_USAGE(Mutable_ForwardIterator) {
- *i++ = *j; // require postincrement and assignment
- }
- private:
- TT i, j;
- };
-
- BOOST_concept(BidirectionalIterator,(TT))
- : ForwardIterator<TT>
- {
- BOOST_CONCEPT_USAGE(BidirectionalIterator)
- {
- BOOST_CONCEPT_ASSERT((Convertible<
- BOOST_DEDUCED_TYPENAME BidirectionalIterator::iterator_category
- , std::bidirectional_iterator_tag
- >));
-
- --i; // require predecrement operator
- i--; // require postdecrement operator
- }
- private:
- TT i;
- };
-
- BOOST_concept(Mutable_BidirectionalIterator,(TT))
- : BidirectionalIterator<TT>
- , Mutable_ForwardIterator<TT>
- {
- BOOST_CONCEPT_USAGE(Mutable_BidirectionalIterator)
- {
- *i-- = *j; // require postdecrement and assignment
- }
- private:
- TT i, j;
- };
-
- BOOST_concept(RandomAccessIterator,(TT))
- : BidirectionalIterator<TT>
- , Comparable<TT>
- {
- BOOST_CONCEPT_USAGE(RandomAccessIterator)
- {
- BOOST_CONCEPT_ASSERT((Convertible<
- BOOST_DEDUCED_TYPENAME BidirectionalIterator<TT>::iterator_category
- , std::random_access_iterator_tag
- >));
-
- i += n; // require assignment addition operator
- i = i + n; i = n + i; // require addition with difference type
- i -= n; // require assignment subtraction operator
- i = i - n; // require subtraction with difference type
- n = i - j; // require difference operator
- (void)i[n]; // require element access operator
- }
-
- private:
- TT a, b;
- TT i, j;
- typename std::iterator_traits<TT>::difference_type n;
- };
-
- BOOST_concept(Mutable_RandomAccessIterator,(TT))
- : RandomAccessIterator<TT>
- , Mutable_BidirectionalIterator<TT>
- {
- BOOST_CONCEPT_USAGE(Mutable_RandomAccessIterator)
- {
- i[n] = *i; // require element access and assignment
- }
- private:
- TT i;
- typename std::iterator_traits<TT>::difference_type n;
- };
-
- //===========================================================================
- // Container s
-
- BOOST_concept(Container,(C))
- : Assignable<C>
- {
- typedef typename C::value_type value_type;
- typedef typename C::difference_type difference_type;
- typedef typename C::size_type size_type;
- typedef typename C::const_reference const_reference;
- typedef typename C::const_pointer const_pointer;
- typedef typename C::const_iterator const_iterator;
-
- BOOST_CONCEPT_USAGE(Container)
- {
- BOOST_CONCEPT_ASSERT((InputIterator<const_iterator>));
- const_constraints(c);
- }
-
- private:
- void const_constraints(const C& cc) {
- i = cc.begin();
- i = cc.end();
- n = cc.size();
- n = cc.max_size();
- b = cc.empty();
- }
- C c;
- bool b;
- const_iterator i;
- size_type n;
- };
-
- BOOST_concept(Mutable_Container,(C))
- : Container<C>
- {
- typedef typename C::reference reference;
- typedef typename C::iterator iterator;
- typedef typename C::pointer pointer;
-
- BOOST_CONCEPT_USAGE(Mutable_Container)
- {
- BOOST_CONCEPT_ASSERT((
- Assignable<typename Mutable_Container::value_type>));
-
- BOOST_CONCEPT_ASSERT((InputIterator<iterator>));
-
- i = c.begin();
- i = c.end();
- c.swap(c2);
- }
-
- private:
- iterator i;
- C c, c2;
- };
-
- BOOST_concept(ForwardContainer,(C))
- : Container<C>
- {
- BOOST_CONCEPT_USAGE(ForwardContainer)
- {
- BOOST_CONCEPT_ASSERT((
- ForwardIterator<
- typename ForwardContainer::const_iterator
- >));
- }
- };
-
- BOOST_concept(Mutable_ForwardContainer,(C))
- : ForwardContainer<C>
- , Mutable_Container<C>
- {
- BOOST_CONCEPT_USAGE(Mutable_ForwardContainer)
- {
- BOOST_CONCEPT_ASSERT((
- Mutable_ForwardIterator<
- typename Mutable_ForwardContainer::iterator
- >));
- }
- };
-
- BOOST_concept(ReversibleContainer,(C))
- : ForwardContainer<C>
- {
- typedef typename
- C::const_reverse_iterator
- const_reverse_iterator;
-
- BOOST_CONCEPT_USAGE(ReversibleContainer)
- {
- BOOST_CONCEPT_ASSERT((
- BidirectionalIterator<
- typename ReversibleContainer::const_iterator>));
-
- BOOST_CONCEPT_ASSERT((BidirectionalIterator<const_reverse_iterator>));
-
- const_constraints(c);
- }
- private:
- void const_constraints(const C& cc)
- {
- const_reverse_iterator i = cc.rbegin();
- i = cc.rend();
- }
- C c;
- };
-
- BOOST_concept(Mutable_ReversibleContainer,(C))
- : Mutable_ForwardContainer<C>
- , ReversibleContainer<C>
- {
- typedef typename C::reverse_iterator reverse_iterator;
-
- BOOST_CONCEPT_USAGE(Mutable_ReversibleContainer)
- {
- typedef typename Mutable_ForwardContainer<C>::iterator iterator;
- BOOST_CONCEPT_ASSERT((Mutable_BidirectionalIterator<iterator>));
- BOOST_CONCEPT_ASSERT((Mutable_BidirectionalIterator<reverse_iterator>));
-
- reverse_iterator i = c.rbegin();
- i = c.rend();
- }
- private:
- C c;
- };
-
- BOOST_concept(RandomAccessContainer,(C))
- : ReversibleContainer<C>
- {
- typedef typename C::size_type size_type;
- typedef typename C::const_reference const_reference;
-
- BOOST_CONCEPT_USAGE(RandomAccessContainer)
- {
- BOOST_CONCEPT_ASSERT((
- RandomAccessIterator<
- typename RandomAccessContainer::const_iterator
- >));
-
- const_constraints(c);
- }
- private:
- void const_constraints(const C& cc)
- {
- const_reference r = cc[n];
- ignore_unused_variable_warning(r);
- }
-
- C c;
- size_type n;
- };
-
- BOOST_concept(Mutable_RandomAccessContainer,(C))
- : Mutable_ReversibleContainer<C>
- , RandomAccessContainer<C>
- {
- private:
- typedef Mutable_RandomAccessContainer self;
- public:
- BOOST_CONCEPT_USAGE(Mutable_RandomAccessContainer)
- {
- BOOST_CONCEPT_ASSERT((Mutable_RandomAccessIterator<typename self::iterator>));
- BOOST_CONCEPT_ASSERT((Mutable_RandomAccessIterator<typename self::reverse_iterator>));
-
- typename self::reference r = c[i];
- ignore_unused_variable_warning(r);
- }
-
- private:
- typename Mutable_ReversibleContainer<C>::size_type i;
- C c;
- };
-
- // A Sequence is inherently mutable
- BOOST_concept(Sequence,(S))
- : Mutable_ForwardContainer<S>
- // Matt Austern's book puts DefaultConstructible here, the C++
- // standard places it in Container --JGS
- // ... so why aren't we following the standard? --DWA
- , DefaultConstructible<S>
- {
- BOOST_CONCEPT_USAGE(Sequence)
- {
- S
- c(n, t),
- c2(first, last);
-
- c.insert(p, t);
- c.insert(p, n, t);
- c.insert(p, first, last);
-
- c.erase(p);
- c.erase(p, q);
-
- typename Sequence::reference r = c.front();
-
- ignore_unused_variable_warning(c);
- ignore_unused_variable_warning(c2);
- ignore_unused_variable_warning(r);
- const_constraints(c);
- }
- private:
- void const_constraints(const S& c) {
- typename Sequence::const_reference r = c.front();
- ignore_unused_variable_warning(r);
- }
-
- typename S::value_type t;
- typename S::size_type n;
- typename S::value_type* first, *last;
- typename S::iterator p, q;
- };
-
- BOOST_concept(FrontInsertionSequence,(S))
- : Sequence<S>
- {
- BOOST_CONCEPT_USAGE(FrontInsertionSequence)
- {
- c.push_front(t);
- c.pop_front();
- }
- private:
- S c;
- typename S::value_type t;
- };
-
- BOOST_concept(BackInsertionSequence,(S))
- : Sequence<S>
- {
- BOOST_CONCEPT_USAGE(BackInsertionSequence)
- {
- c.push_back(t);
- c.pop_back();
- typename BackInsertionSequence::reference r = c.back();
- ignore_unused_variable_warning(r);
- const_constraints(c);
- }
- private:
- void const_constraints(const S& cc) {
- typename BackInsertionSequence::const_reference
- r = cc.back();
- ignore_unused_variable_warning(r);
- }
- S c;
- typename S::value_type t;
- };
-
- BOOST_concept(AssociativeContainer,(C))
- : ForwardContainer<C>
- , DefaultConstructible<C>
- {
- typedef typename C::key_type key_type;
- typedef typename C::key_compare key_compare;
- typedef typename C::value_compare value_compare;
- typedef typename C::iterator iterator;
-
- BOOST_CONCEPT_USAGE(AssociativeContainer)
- {
- i = c.find(k);
- r = c.equal_range(k);
- c.erase(k);
- c.erase(i);
- c.erase(r.first, r.second);
- const_constraints(c);
- BOOST_CONCEPT_ASSERT((BinaryPredicate<key_compare,key_type,key_type>));
-
- typedef typename AssociativeContainer::value_type value_type_;
- BOOST_CONCEPT_ASSERT((BinaryPredicate<value_compare,value_type_,value_type_>));
- }
-
- // Redundant with the base concept, but it helps below.
- typedef typename C::const_iterator const_iterator;
- private:
- void const_constraints(const C& cc)
- {
- ci = cc.find(k);
- n = cc.count(k);
- cr = cc.equal_range(k);
- }
-
- C c;
- iterator i;
- std::pair<iterator,iterator> r;
- const_iterator ci;
- std::pair<const_iterator,const_iterator> cr;
- typename C::key_type k;
- typename C::size_type n;
- };
-
- BOOST_concept(UniqueAssociativeContainer,(C))
- : AssociativeContainer<C>
- {
- BOOST_CONCEPT_USAGE(UniqueAssociativeContainer)
- {
- C c(first, last);
-
- pos_flag = c.insert(t);
- c.insert(first, last);
-
- ignore_unused_variable_warning(c);
- }
- private:
- std::pair<typename C::iterator, bool> pos_flag;
- typename C::value_type t;
- typename C::value_type* first, *last;
- };
-
- BOOST_concept(MultipleAssociativeContainer,(C))
- : AssociativeContainer<C>
- {
- BOOST_CONCEPT_USAGE(MultipleAssociativeContainer)
- {
- C c(first, last);
-
- pos = c.insert(t);
- c.insert(first, last);
-
- ignore_unused_variable_warning(c);
- ignore_unused_variable_warning(pos);
- }
- private:
- typename C::iterator pos;
- typename C::value_type t;
- typename C::value_type* first, *last;
- };
-
- BOOST_concept(SimpleAssociativeContainer,(C))
- : AssociativeContainer<C>
- {
- BOOST_CONCEPT_USAGE(SimpleAssociativeContainer)
- {
- typedef typename C::key_type key_type;
- typedef typename C::value_type value_type;
- BOOST_MPL_ASSERT((boost::is_same<key_type,value_type>));
- }
- };
-
- BOOST_concept(PairAssociativeContainer,(C))
- : AssociativeContainer<C>
- {
- BOOST_CONCEPT_USAGE(PairAssociativeContainer)
- {
- typedef typename C::key_type key_type;
- typedef typename C::value_type value_type;
- typedef typename C::mapped_type mapped_type;
- typedef std::pair<const key_type, mapped_type> required_value_type;
- BOOST_MPL_ASSERT((boost::is_same<value_type,required_value_type>));
- }
- };
-
- BOOST_concept(SortedAssociativeContainer,(C))
- : AssociativeContainer<C>
- , ReversibleContainer<C>
- {
- BOOST_CONCEPT_USAGE(SortedAssociativeContainer)
- {
- C
- c(kc),
- c2(first, last),
- c3(first, last, kc);
-
- p = c.upper_bound(k);
- p = c.lower_bound(k);
- r = c.equal_range(k);
-
- c.insert(p, t);
-
- ignore_unused_variable_warning(c);
- ignore_unused_variable_warning(c2);
- ignore_unused_variable_warning(c3);
- const_constraints(c);
- }
-
- void const_constraints(const C& c)
- {
- kc = c.key_comp();
- vc = c.value_comp();
-
- cp = c.upper_bound(k);
- cp = c.lower_bound(k);
- cr = c.equal_range(k);
- }
-
- private:
- typename C::key_compare kc;
- typename C::value_compare vc;
- typename C::value_type t;
- typename C::key_type k;
- typedef typename C::iterator iterator;
- typedef typename C::const_iterator const_iterator;
-
- typedef SortedAssociativeContainer self;
- iterator p;
- const_iterator cp;
- std::pair<typename self::iterator,typename self::iterator> r;
- std::pair<typename self::const_iterator,typename self::const_iterator> cr;
- typename C::value_type* first, *last;
- };
-
- // HashedAssociativeContainer
-
- BOOST_concept(Collection,(C))
- {
- BOOST_CONCEPT_USAGE(Collection)
- {
- boost::function_requires<boost::InputIteratorConcept<iterator> >();
- boost::function_requires<boost::InputIteratorConcept<const_iterator> >();
- boost::function_requires<boost::CopyConstructibleConcept<value_type> >();
- const_constraints(c);
- i = c.begin();
- i = c.end();
- c.swap(c);
- }
-
- void const_constraints(const C& cc) {
- ci = cc.begin();
- ci = cc.end();
- n = cc.size();
- b = cc.empty();
- }
-
- private:
- typedef typename C::value_type value_type;
- typedef typename C::iterator iterator;
- typedef typename C::const_iterator const_iterator;
- typedef typename C::reference reference;
- typedef typename C::const_reference const_reference;
- // typedef typename C::pointer pointer;
- typedef typename C::difference_type difference_type;
- typedef typename C::size_type size_type;
-
- C c;
- bool b;
- iterator i;
- const_iterator ci;
- size_type n;
- };
-} // namespace boost
-
-#if (defined _MSC_VER)
-# pragma warning( pop )
-#endif
-
-# include <boost/concept/detail/concept_undef.hpp>
-
-#endif // BOOST_CONCEPT_CHECKS_HPP
-
+// +// (C) Copyright Jeremy Siek 2000. +// Copyright 2002 The Trustees of Indiana University. +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// Revision History: +// 05 May 2001: Workarounds for HP aCC from Thomas Matelich. (Jeremy Siek) +// 02 April 2001: Removed limits header altogether. (Jeremy Siek) +// 01 April 2001: Modified to use new <boost/limits.hpp> header. (JMaddock) +// + +// See http://www.boost.org/libs/concept_check for documentation. + +#ifndef BOOST_CONCEPT_CHECKS_HPP +# define BOOST_CONCEPT_CHECKS_HPP + +# include <boost/concept/assert.hpp> + +# include <iterator> +# include <boost/type_traits/conversion_traits.hpp> +# include <utility> +# include <boost/type_traits/is_same.hpp> +# include <boost/type_traits/is_void.hpp> +# include <boost/mpl/assert.hpp> +# include <boost/mpl/bool.hpp> +# include <boost/detail/workaround.hpp> + +# include <boost/concept/usage.hpp> +# include <boost/concept/detail/concept_def.hpp> + +#if (defined _MSC_VER) +# pragma warning( push ) +# pragma warning( disable : 4510 ) // default constructor could not be generated +# pragma warning( disable : 4610 ) // object 'class' can never be instantiated - user-defined constructor required +#endif + +namespace boost +{ + + // + // Backward compatibility + // + + template <class Model> + inline void function_requires(Model* = 0) + { + BOOST_CONCEPT_ASSERT((Model)); + } + template <class T> inline void ignore_unused_variable_warning(T const&) {} + +# define BOOST_CLASS_REQUIRE(type_var, ns, concept) \ + BOOST_CONCEPT_ASSERT((ns::concept<type_var>)) + +# define BOOST_CLASS_REQUIRE2(type_var1, type_var2, ns, concept) \ + BOOST_CONCEPT_ASSERT((ns::concept<type_var1,type_var2>)) + +# define BOOST_CLASS_REQUIRE3(tv1, tv2, tv3, ns, concept) \ + BOOST_CONCEPT_ASSERT((ns::concept<tv1,tv2,tv3>)) + +# define BOOST_CLASS_REQUIRE4(tv1, tv2, tv3, tv4, ns, concept) \ + BOOST_CONCEPT_ASSERT((ns::concept<tv1,tv2,tv3,tv4>)) + + + // + // Begin concept definitions + // + BOOST_concept(Integer, (T)) + { + BOOST_CONCEPT_USAGE(Integer) + { + x.error_type_must_be_an_integer_type(); + } + private: + T x; + }; + + template <> struct Integer<char> {}; + template <> struct Integer<signed char> {}; + template <> struct Integer<unsigned char> {}; + template <> struct Integer<short> {}; + template <> struct Integer<unsigned short> {}; + template <> struct Integer<int> {}; + template <> struct Integer<unsigned int> {}; + template <> struct Integer<long> {}; + template <> struct Integer<unsigned long> {}; +# if defined(BOOST_HAS_LONG_LONG) + template <> struct Integer< ::boost::long_long_type> {}; + template <> struct Integer< ::boost::ulong_long_type> {}; +# elif defined(BOOST_HAS_MS_INT64) + template <> struct Integer<__int64> {}; + template <> struct Integer<unsigned __int64> {}; +# endif + + BOOST_concept(SignedInteger,(T)) { + BOOST_CONCEPT_USAGE(SignedInteger) { + x.error_type_must_be_a_signed_integer_type(); + } + private: + T x; + }; + template <> struct SignedInteger<signed char> { }; + template <> struct SignedInteger<short> {}; + template <> struct SignedInteger<int> {}; + template <> struct SignedInteger<long> {}; +# if defined(BOOST_HAS_LONG_LONG) + template <> struct SignedInteger< ::boost::long_long_type> {}; +# elif defined(BOOST_HAS_MS_INT64) + template <> struct SignedInteger<__int64> {}; +# endif + + BOOST_concept(UnsignedInteger,(T)) { + BOOST_CONCEPT_USAGE(UnsignedInteger) { + x.error_type_must_be_an_unsigned_integer_type(); + } + private: + T x; + }; + + template <> struct UnsignedInteger<unsigned char> {}; + template <> struct UnsignedInteger<unsigned short> {}; + template <> struct UnsignedInteger<unsigned int> {}; + template <> struct UnsignedInteger<unsigned long> {}; +# if defined(BOOST_HAS_LONG_LONG) + template <> struct UnsignedInteger< ::boost::ulong_long_type> {}; +# elif defined(BOOST_HAS_MS_INT64) + template <> struct UnsignedInteger<unsigned __int64> {}; +# endif + + //=========================================================================== + // Basic Concepts + + BOOST_concept(DefaultConstructible,(TT)) + { + BOOST_CONCEPT_USAGE(DefaultConstructible) { + TT a; // require default constructor + ignore_unused_variable_warning(a); + } + }; + + BOOST_concept(Assignable,(TT)) + { + BOOST_CONCEPT_USAGE(Assignable) { +#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL + a = b; // require assignment operator +#endif + const_constraints(b); + } + private: + void const_constraints(const TT& x) { +#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL + a = x; // const required for argument to assignment +#else + ignore_unused_variable_warning(x); +#endif + } + private: + TT a; + TT b; + }; + + + BOOST_concept(CopyConstructible,(TT)) + { + BOOST_CONCEPT_USAGE(CopyConstructible) { + TT a(b); // require copy constructor + TT* ptr = &a; // require address of operator + const_constraints(a); + ignore_unused_variable_warning(ptr); + } + private: + void const_constraints(const TT& a) { + TT c(a); // require const copy constructor + const TT* ptr = &a; // require const address of operator + ignore_unused_variable_warning(c); + ignore_unused_variable_warning(ptr); + } + TT b; + }; + + // The SGI STL version of Assignable requires copy constructor and operator= + BOOST_concept(SGIAssignable,(TT)) + { + BOOST_CONCEPT_USAGE(SGIAssignable) { + TT c(a); +#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL + a = b; // require assignment operator +#endif + const_constraints(b); + ignore_unused_variable_warning(c); + } + private: + void const_constraints(const TT& x) { + TT c(x); +#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL + a = x; // const required for argument to assignment +#endif + ignore_unused_variable_warning(c); + } + TT a; + TT b; + }; + + BOOST_concept(Convertible,(X)(Y)) + { + BOOST_CONCEPT_USAGE(Convertible) { + Y y = x; + ignore_unused_variable_warning(y); + } + private: + X x; + }; + + // The C++ standard requirements for many concepts talk about return + // types that must be "convertible to bool". The problem with this + // requirement is that it leaves the door open for evil proxies that + // define things like operator|| with strange return types. Two + // possible solutions are: + // 1) require the return type to be exactly bool + // 2) stay with convertible to bool, and also + // specify stuff about all the logical operators. + // For now we just test for convertible to bool. + template <class TT> + void require_boolean_expr(const TT& t) { + bool x = t; + ignore_unused_variable_warning(x); + } + + BOOST_concept(EqualityComparable,(TT)) + { + BOOST_CONCEPT_USAGE(EqualityComparable) { + require_boolean_expr(a == b); + require_boolean_expr(a != b); + } + private: + TT a, b; + }; + + BOOST_concept(LessThanComparable,(TT)) + { + BOOST_CONCEPT_USAGE(LessThanComparable) { + require_boolean_expr(a < b); + } + private: + TT a, b; + }; + + // This is equivalent to SGI STL's LessThanComparable. + BOOST_concept(Comparable,(TT)) + { + BOOST_CONCEPT_USAGE(Comparable) { + require_boolean_expr(a < b); + require_boolean_expr(a > b); + require_boolean_expr(a <= b); + require_boolean_expr(a >= b); + } + private: + TT a, b; + }; + +#define BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(OP,NAME) \ + BOOST_concept(NAME, (First)(Second)) \ + { \ + BOOST_CONCEPT_USAGE(NAME) { (void)constraints_(); } \ + private: \ + bool constraints_() { return a OP b; } \ + First a; \ + Second b; \ + } + +#define BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(OP,NAME) \ + BOOST_concept(NAME, (Ret)(First)(Second)) \ + { \ + BOOST_CONCEPT_USAGE(NAME) { (void)constraints_(); } \ + private: \ + Ret constraints_() { return a OP b; } \ + First a; \ + Second b; \ + } + + BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(==, EqualOp); + BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(!=, NotEqualOp); + BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<, LessThanOp); + BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<=, LessEqualOp); + BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>, GreaterThanOp); + BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>=, GreaterEqualOp); + + BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(+, PlusOp); + BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(*, TimesOp); + BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(/, DivideOp); + BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(-, SubtractOp); + BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(%, ModOp); + + //=========================================================================== + // Function Object Concepts + + BOOST_concept(Generator,(Func)(Return)) + { + BOOST_CONCEPT_USAGE(Generator) { test(is_void<Return>()); } + + private: + void test(boost::mpl::false_) + { + // Do we really want a reference here? + const Return& r = f(); + ignore_unused_variable_warning(r); + } + + void test(boost::mpl::true_) + { + f(); + } + + Func f; + }; + + BOOST_concept(UnaryFunction,(Func)(Return)(Arg)) + { + BOOST_CONCEPT_USAGE(UnaryFunction) { test(is_void<Return>()); } + + private: + void test(boost::mpl::false_) + { + f(arg); // "priming the pump" this way keeps msvc6 happy (ICE) + Return r = f(arg); + ignore_unused_variable_warning(r); + } + + void test(boost::mpl::true_) + { + f(arg); + } + +#if (BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(4) \ + && BOOST_WORKAROUND(__GNUC__, > 3))) + // Declare a dummy construktor to make gcc happy. + // It seems the compiler can not generate a sensible constructor when this is instantiated with a refence type. + // (warning: non-static reference "const double& boost::UnaryFunction<YourClassHere>::arg" + // in class without a constructor [-Wuninitialized]) + UnaryFunction(); +#endif + + Func f; + Arg arg; + }; + + BOOST_concept(BinaryFunction,(Func)(Return)(First)(Second)) + { + BOOST_CONCEPT_USAGE(BinaryFunction) { test(is_void<Return>()); } + private: + void test(boost::mpl::false_) + { + f(first,second); + Return r = f(first, second); // require operator() + (void)r; + } + + void test(boost::mpl::true_) + { + f(first,second); + } + +#if (BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(4) \ + && BOOST_WORKAROUND(__GNUC__, > 3))) + // Declare a dummy constructor to make gcc happy. + // It seems the compiler can not generate a sensible constructor when this is instantiated with a refence type. + // (warning: non-static reference "const double& boost::BinaryFunction<YourClassHere>::arg" + // in class without a constructor [-Wuninitialized]) + BinaryFunction(); +#endif + + Func f; + First first; + Second second; + }; + + BOOST_concept(UnaryPredicate,(Func)(Arg)) + { + BOOST_CONCEPT_USAGE(UnaryPredicate) { + require_boolean_expr(f(arg)); // require operator() returning bool + } + private: +#if (BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(4) \ + && BOOST_WORKAROUND(__GNUC__, > 3))) + // Declare a dummy constructor to make gcc happy. + // It seems the compiler can not generate a sensible constructor when this is instantiated with a refence type. + // (warning: non-static reference "const double& boost::UnaryPredicate<YourClassHere>::arg" + // in class without a constructor [-Wuninitialized]) + UnaryPredicate(); +#endif + + Func f; + Arg arg; + }; + + BOOST_concept(BinaryPredicate,(Func)(First)(Second)) + { + BOOST_CONCEPT_USAGE(BinaryPredicate) { + require_boolean_expr(f(a, b)); // require operator() returning bool + } + private: +#if (BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(4) \ + && BOOST_WORKAROUND(__GNUC__, > 3))) + // Declare a dummy constructor to make gcc happy. + // It seems the compiler can not generate a sensible constructor when this is instantiated with a refence type. + // (warning: non-static reference "const double& boost::BinaryPredicate<YourClassHere>::arg" + // in class without a constructor [-Wuninitialized]) + BinaryPredicate(); +#endif + Func f; + First a; + Second b; + }; + + // use this when functor is used inside a container class like std::set + BOOST_concept(Const_BinaryPredicate,(Func)(First)(Second)) + : BinaryPredicate<Func, First, Second> + { + BOOST_CONCEPT_USAGE(Const_BinaryPredicate) { + const_constraints(f); + } + private: + void const_constraints(const Func& fun) { + // operator() must be a const member function + require_boolean_expr(fun(a, b)); + } +#if (BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(4) \ + && BOOST_WORKAROUND(__GNUC__, > 3))) + // Declare a dummy constructor to make gcc happy. + // It seems the compiler can not generate a sensible constructor when this is instantiated with a refence type. + // (warning: non-static reference "const double& boost::Const_BinaryPredicate<YourClassHere>::arg" + // in class without a constructor [-Wuninitialized]) + Const_BinaryPredicate(); +#endif + + Func f; + First a; + Second b; + }; + + BOOST_concept(AdaptableGenerator,(Func)(Return)) + : Generator<Func, typename Func::result_type> + { + typedef typename Func::result_type result_type; + + BOOST_CONCEPT_USAGE(AdaptableGenerator) + { + BOOST_CONCEPT_ASSERT((Convertible<result_type, Return>)); + } + }; + + BOOST_concept(AdaptableUnaryFunction,(Func)(Return)(Arg)) + : UnaryFunction<Func, typename Func::result_type, typename Func::argument_type> + { + typedef typename Func::argument_type argument_type; + typedef typename Func::result_type result_type; + + ~AdaptableUnaryFunction() + { + BOOST_CONCEPT_ASSERT((Convertible<result_type, Return>)); + BOOST_CONCEPT_ASSERT((Convertible<Arg, argument_type>)); + } + }; + + BOOST_concept(AdaptableBinaryFunction,(Func)(Return)(First)(Second)) + : BinaryFunction< + Func + , typename Func::result_type + , typename Func::first_argument_type + , typename Func::second_argument_type + > + { + typedef typename Func::first_argument_type first_argument_type; + typedef typename Func::second_argument_type second_argument_type; + typedef typename Func::result_type result_type; + + ~AdaptableBinaryFunction() + { + BOOST_CONCEPT_ASSERT((Convertible<result_type, Return>)); + BOOST_CONCEPT_ASSERT((Convertible<First, first_argument_type>)); + BOOST_CONCEPT_ASSERT((Convertible<Second, second_argument_type>)); + } + }; + + BOOST_concept(AdaptablePredicate,(Func)(Arg)) + : UnaryPredicate<Func, Arg> + , AdaptableUnaryFunction<Func, bool, Arg> + { + }; + + BOOST_concept(AdaptableBinaryPredicate,(Func)(First)(Second)) + : BinaryPredicate<Func, First, Second> + , AdaptableBinaryFunction<Func, bool, First, Second> + { + }; + + //=========================================================================== + // Iterator Concepts + + BOOST_concept(InputIterator,(TT)) + : Assignable<TT> + , EqualityComparable<TT> + { + typedef typename std::iterator_traits<TT>::value_type value_type; + typedef typename std::iterator_traits<TT>::difference_type difference_type; + typedef typename std::iterator_traits<TT>::reference reference; + typedef typename std::iterator_traits<TT>::pointer pointer; + typedef typename std::iterator_traits<TT>::iterator_category iterator_category; + + BOOST_CONCEPT_USAGE(InputIterator) + { + BOOST_CONCEPT_ASSERT((SignedInteger<difference_type>)); + BOOST_CONCEPT_ASSERT((Convertible<iterator_category, std::input_iterator_tag>)); + + TT j(i); + (void)*i; // require dereference operator + ++j; // require preincrement operator + i++; // require postincrement operator + } + private: + TT i; + }; + + BOOST_concept(OutputIterator,(TT)(ValueT)) + : Assignable<TT> + { + BOOST_CONCEPT_USAGE(OutputIterator) { + + ++i; // require preincrement operator + i++; // require postincrement operator + *i++ = t; // require postincrement and assignment + } + private: + TT i, j; + ValueT t; + }; + + BOOST_concept(ForwardIterator,(TT)) + : InputIterator<TT> + { + BOOST_CONCEPT_USAGE(ForwardIterator) + { + BOOST_CONCEPT_ASSERT((Convertible< + BOOST_DEDUCED_TYPENAME ForwardIterator::iterator_category + , std::forward_iterator_tag + >)); + + typename InputIterator<TT>::reference r = *i; + ignore_unused_variable_warning(r); + } + + private: + TT i; + }; + + BOOST_concept(Mutable_ForwardIterator,(TT)) + : ForwardIterator<TT> + { + BOOST_CONCEPT_USAGE(Mutable_ForwardIterator) { + *i++ = *j; // require postincrement and assignment + } + private: + TT i, j; + }; + + BOOST_concept(BidirectionalIterator,(TT)) + : ForwardIterator<TT> + { + BOOST_CONCEPT_USAGE(BidirectionalIterator) + { + BOOST_CONCEPT_ASSERT((Convertible< + BOOST_DEDUCED_TYPENAME BidirectionalIterator::iterator_category + , std::bidirectional_iterator_tag + >)); + + --i; // require predecrement operator + i--; // require postdecrement operator + } + private: + TT i; + }; + + BOOST_concept(Mutable_BidirectionalIterator,(TT)) + : BidirectionalIterator<TT> + , Mutable_ForwardIterator<TT> + { + BOOST_CONCEPT_USAGE(Mutable_BidirectionalIterator) + { + *i-- = *j; // require postdecrement and assignment + } + private: + TT i, j; + }; + + BOOST_concept(RandomAccessIterator,(TT)) + : BidirectionalIterator<TT> + , Comparable<TT> + { + BOOST_CONCEPT_USAGE(RandomAccessIterator) + { + BOOST_CONCEPT_ASSERT((Convertible< + BOOST_DEDUCED_TYPENAME BidirectionalIterator<TT>::iterator_category + , std::random_access_iterator_tag + >)); + + i += n; // require assignment addition operator + i = i + n; i = n + i; // require addition with difference type + i -= n; // require assignment subtraction operator + i = i - n; // require subtraction with difference type + n = i - j; // require difference operator + (void)i[n]; // require element access operator + } + + private: + TT a, b; + TT i, j; + typename std::iterator_traits<TT>::difference_type n; + }; + + BOOST_concept(Mutable_RandomAccessIterator,(TT)) + : RandomAccessIterator<TT> + , Mutable_BidirectionalIterator<TT> + { + BOOST_CONCEPT_USAGE(Mutable_RandomAccessIterator) + { + i[n] = *i; // require element access and assignment + } + private: + TT i; + typename std::iterator_traits<TT>::difference_type n; + }; + + //=========================================================================== + // Container s + + BOOST_concept(Container,(C)) + : Assignable<C> + { + typedef typename C::value_type value_type; + typedef typename C::difference_type difference_type; + typedef typename C::size_type size_type; + typedef typename C::const_reference const_reference; + typedef typename C::const_pointer const_pointer; + typedef typename C::const_iterator const_iterator; + + BOOST_CONCEPT_USAGE(Container) + { + BOOST_CONCEPT_ASSERT((InputIterator<const_iterator>)); + const_constraints(c); + } + + private: + void const_constraints(const C& cc) { + i = cc.begin(); + i = cc.end(); + n = cc.size(); + n = cc.max_size(); + b = cc.empty(); + } + C c; + bool b; + const_iterator i; + size_type n; + }; + + BOOST_concept(Mutable_Container,(C)) + : Container<C> + { + typedef typename C::reference reference; + typedef typename C::iterator iterator; + typedef typename C::pointer pointer; + + BOOST_CONCEPT_USAGE(Mutable_Container) + { + BOOST_CONCEPT_ASSERT(( + Assignable<typename Mutable_Container::value_type>)); + + BOOST_CONCEPT_ASSERT((InputIterator<iterator>)); + + i = c.begin(); + i = c.end(); + c.swap(c2); + } + + private: + iterator i; + C c, c2; + }; + + BOOST_concept(ForwardContainer,(C)) + : Container<C> + { + BOOST_CONCEPT_USAGE(ForwardContainer) + { + BOOST_CONCEPT_ASSERT(( + ForwardIterator< + typename ForwardContainer::const_iterator + >)); + } + }; + + BOOST_concept(Mutable_ForwardContainer,(C)) + : ForwardContainer<C> + , Mutable_Container<C> + { + BOOST_CONCEPT_USAGE(Mutable_ForwardContainer) + { + BOOST_CONCEPT_ASSERT(( + Mutable_ForwardIterator< + typename Mutable_ForwardContainer::iterator + >)); + } + }; + + BOOST_concept(ReversibleContainer,(C)) + : ForwardContainer<C> + { + typedef typename + C::const_reverse_iterator + const_reverse_iterator; + + BOOST_CONCEPT_USAGE(ReversibleContainer) + { + BOOST_CONCEPT_ASSERT(( + BidirectionalIterator< + typename ReversibleContainer::const_iterator>)); + + BOOST_CONCEPT_ASSERT((BidirectionalIterator<const_reverse_iterator>)); + + const_constraints(c); + } + private: + void const_constraints(const C& cc) + { + const_reverse_iterator i = cc.rbegin(); + i = cc.rend(); + } + C c; + }; + + BOOST_concept(Mutable_ReversibleContainer,(C)) + : Mutable_ForwardContainer<C> + , ReversibleContainer<C> + { + typedef typename C::reverse_iterator reverse_iterator; + + BOOST_CONCEPT_USAGE(Mutable_ReversibleContainer) + { + typedef typename Mutable_ForwardContainer<C>::iterator iterator; + BOOST_CONCEPT_ASSERT((Mutable_BidirectionalIterator<iterator>)); + BOOST_CONCEPT_ASSERT((Mutable_BidirectionalIterator<reverse_iterator>)); + + reverse_iterator i = c.rbegin(); + i = c.rend(); + } + private: + C c; + }; + + BOOST_concept(RandomAccessContainer,(C)) + : ReversibleContainer<C> + { + typedef typename C::size_type size_type; + typedef typename C::const_reference const_reference; + + BOOST_CONCEPT_USAGE(RandomAccessContainer) + { + BOOST_CONCEPT_ASSERT(( + RandomAccessIterator< + typename RandomAccessContainer::const_iterator + >)); + + const_constraints(c); + } + private: + void const_constraints(const C& cc) + { + const_reference r = cc[n]; + ignore_unused_variable_warning(r); + } + + C c; + size_type n; + }; + + BOOST_concept(Mutable_RandomAccessContainer,(C)) + : Mutable_ReversibleContainer<C> + , RandomAccessContainer<C> + { + private: + typedef Mutable_RandomAccessContainer self; + public: + BOOST_CONCEPT_USAGE(Mutable_RandomAccessContainer) + { + BOOST_CONCEPT_ASSERT((Mutable_RandomAccessIterator<typename self::iterator>)); + BOOST_CONCEPT_ASSERT((Mutable_RandomAccessIterator<typename self::reverse_iterator>)); + + typename self::reference r = c[i]; + ignore_unused_variable_warning(r); + } + + private: + typename Mutable_ReversibleContainer<C>::size_type i; + C c; + }; + + // A Sequence is inherently mutable + BOOST_concept(Sequence,(S)) + : Mutable_ForwardContainer<S> + // Matt Austern's book puts DefaultConstructible here, the C++ + // standard places it in Container --JGS + // ... so why aren't we following the standard? --DWA + , DefaultConstructible<S> + { + BOOST_CONCEPT_USAGE(Sequence) + { + S + c(n, t), + c2(first, last); + + c.insert(p, t); + c.insert(p, n, t); + c.insert(p, first, last); + + c.erase(p); + c.erase(p, q); + + typename Sequence::reference r = c.front(); + + ignore_unused_variable_warning(c); + ignore_unused_variable_warning(c2); + ignore_unused_variable_warning(r); + const_constraints(c); + } + private: + void const_constraints(const S& c) { + typename Sequence::const_reference r = c.front(); + ignore_unused_variable_warning(r); + } + + typename S::value_type t; + typename S::size_type n; + typename S::value_type* first, *last; + typename S::iterator p, q; + }; + + BOOST_concept(FrontInsertionSequence,(S)) + : Sequence<S> + { + BOOST_CONCEPT_USAGE(FrontInsertionSequence) + { + c.push_front(t); + c.pop_front(); + } + private: + S c; + typename S::value_type t; + }; + + BOOST_concept(BackInsertionSequence,(S)) + : Sequence<S> + { + BOOST_CONCEPT_USAGE(BackInsertionSequence) + { + c.push_back(t); + c.pop_back(); + typename BackInsertionSequence::reference r = c.back(); + ignore_unused_variable_warning(r); + const_constraints(c); + } + private: + void const_constraints(const S& cc) { + typename BackInsertionSequence::const_reference + r = cc.back(); + ignore_unused_variable_warning(r); + } + S c; + typename S::value_type t; + }; + + BOOST_concept(AssociativeContainer,(C)) + : ForwardContainer<C> + , DefaultConstructible<C> + { + typedef typename C::key_type key_type; + typedef typename C::key_compare key_compare; + typedef typename C::value_compare value_compare; + typedef typename C::iterator iterator; + + BOOST_CONCEPT_USAGE(AssociativeContainer) + { + i = c.find(k); + r = c.equal_range(k); + c.erase(k); + c.erase(i); + c.erase(r.first, r.second); + const_constraints(c); + BOOST_CONCEPT_ASSERT((BinaryPredicate<key_compare,key_type,key_type>)); + + typedef typename AssociativeContainer::value_type value_type_; + BOOST_CONCEPT_ASSERT((BinaryPredicate<value_compare,value_type_,value_type_>)); + } + + // Redundant with the base concept, but it helps below. + typedef typename C::const_iterator const_iterator; + private: + void const_constraints(const C& cc) + { + ci = cc.find(k); + n = cc.count(k); + cr = cc.equal_range(k); + } + + C c; + iterator i; + std::pair<iterator,iterator> r; + const_iterator ci; + std::pair<const_iterator,const_iterator> cr; + typename C::key_type k; + typename C::size_type n; + }; + + BOOST_concept(UniqueAssociativeContainer,(C)) + : AssociativeContainer<C> + { + BOOST_CONCEPT_USAGE(UniqueAssociativeContainer) + { + C c(first, last); + + pos_flag = c.insert(t); + c.insert(first, last); + + ignore_unused_variable_warning(c); + } + private: + std::pair<typename C::iterator, bool> pos_flag; + typename C::value_type t; + typename C::value_type* first, *last; + }; + + BOOST_concept(MultipleAssociativeContainer,(C)) + : AssociativeContainer<C> + { + BOOST_CONCEPT_USAGE(MultipleAssociativeContainer) + { + C c(first, last); + + pos = c.insert(t); + c.insert(first, last); + + ignore_unused_variable_warning(c); + ignore_unused_variable_warning(pos); + } + private: + typename C::iterator pos; + typename C::value_type t; + typename C::value_type* first, *last; + }; + + BOOST_concept(SimpleAssociativeContainer,(C)) + : AssociativeContainer<C> + { + BOOST_CONCEPT_USAGE(SimpleAssociativeContainer) + { + typedef typename C::key_type key_type; + typedef typename C::value_type value_type; + BOOST_MPL_ASSERT((boost::is_same<key_type,value_type>)); + } + }; + + BOOST_concept(PairAssociativeContainer,(C)) + : AssociativeContainer<C> + { + BOOST_CONCEPT_USAGE(PairAssociativeContainer) + { + typedef typename C::key_type key_type; + typedef typename C::value_type value_type; + typedef typename C::mapped_type mapped_type; + typedef std::pair<const key_type, mapped_type> required_value_type; + BOOST_MPL_ASSERT((boost::is_same<value_type,required_value_type>)); + } + }; + + BOOST_concept(SortedAssociativeContainer,(C)) + : AssociativeContainer<C> + , ReversibleContainer<C> + { + BOOST_CONCEPT_USAGE(SortedAssociativeContainer) + { + C + c(kc), + c2(first, last), + c3(first, last, kc); + + p = c.upper_bound(k); + p = c.lower_bound(k); + r = c.equal_range(k); + + c.insert(p, t); + + ignore_unused_variable_warning(c); + ignore_unused_variable_warning(c2); + ignore_unused_variable_warning(c3); + const_constraints(c); + } + + void const_constraints(const C& c) + { + kc = c.key_comp(); + vc = c.value_comp(); + + cp = c.upper_bound(k); + cp = c.lower_bound(k); + cr = c.equal_range(k); + } + + private: + typename C::key_compare kc; + typename C::value_compare vc; + typename C::value_type t; + typename C::key_type k; + typedef typename C::iterator iterator; + typedef typename C::const_iterator const_iterator; + + typedef SortedAssociativeContainer self; + iterator p; + const_iterator cp; + std::pair<typename self::iterator,typename self::iterator> r; + std::pair<typename self::const_iterator,typename self::const_iterator> cr; + typename C::value_type* first, *last; + }; + + // HashedAssociativeContainer + + BOOST_concept(Collection,(C)) + { + BOOST_CONCEPT_USAGE(Collection) + { + boost::function_requires<boost::InputIteratorConcept<iterator> >(); + boost::function_requires<boost::InputIteratorConcept<const_iterator> >(); + boost::function_requires<boost::CopyConstructibleConcept<value_type> >(); + const_constraints(c); + i = c.begin(); + i = c.end(); + c.swap(c); + } + + void const_constraints(const C& cc) { + ci = cc.begin(); + ci = cc.end(); + n = cc.size(); + b = cc.empty(); + } + + private: + typedef typename C::value_type value_type; + typedef typename C::iterator iterator; + typedef typename C::const_iterator const_iterator; + typedef typename C::reference reference; + typedef typename C::const_reference const_reference; + // typedef typename C::pointer pointer; + typedef typename C::difference_type difference_type; + typedef typename C::size_type size_type; + + C c; + bool b; + iterator i; + const_iterator ci; + size_type n; + }; +} // namespace boost + +#if (defined _MSC_VER) +# pragma warning( pop ) +#endif + +# include <boost/concept/detail/concept_undef.hpp> + +#endif // BOOST_CONCEPT_CHECKS_HPP + |