#include <boost/concept/assert.hpp>
#include <boost/iterator.hpp>
#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/detail/iterator.hpp>
#include <boost/concept/usage.hpp>
#include <boost/concept/detail/concept_def.hpp>
#include <boost/concept/detail/concept_undef.hpp>

Include dependency graph for concept_check.hpp:

Classes
struct	boost::Integer< char >

struct	boost::Integer< signed char >

struct	boost::Integer< unsigned char >

struct	boost::Integer< short >

struct	boost::Integer< unsigned short >

struct	boost::Integer< int >

struct	boost::Integer< unsigned int >

struct	boost::Integer< long >

struct	boost::Integer< unsigned long >

struct	boost::SignedInteger< signed char >

struct	boost::SignedInteger< short >

struct	boost::SignedInteger< int >

struct	boost::SignedInteger< long >

struct	boost::UnsignedInteger< unsigned char >

struct	boost::UnsignedInteger< unsigned short >

struct	boost::UnsignedInteger< unsigned int >

struct	boost::UnsignedInteger< unsigned long >

Namespaces
	boost
	Duration formatting facet for input.

Macros
#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>))

#define	BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(OP, NAME)

#define	BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(OP, NAME)

Functions
template<class Model >
void	boost::function_requires (Model *=0)

template<class T >
void	boost::ignore_unused_variable_warning (T const &)

	boost::BOOST_concept (Integer,(T))

	boost::BOOST_concept (SignedInteger,(T))

	boost::BOOST_concept (UnsignedInteger,(T))

	boost::BOOST_concept (DefaultConstructible,(TT))

	boost::BOOST_concept (Assignable,(TT))

	boost::BOOST_concept (CopyConstructible,(TT))

	boost::BOOST_concept (SGIAssignable,(TT))

	boost::BOOST_concept (Convertible,(X)(Y))

template<class TT >
void	boost::require_boolean_expr (const TT &t)

	boost::BOOST_concept (EqualityComparable,(TT))

	boost::BOOST_concept (LessThanComparable,(TT))

	boost::BOOST_concept (Comparable,(TT))

	boost::BOOST_concept (EqualOp,(First)(Second))

	boost::BOOST_concept (NotEqualOp,(First)(Second))

	boost::BOOST_concept (LessThanOp,(First)(Second))

	boost::BOOST_concept (LessEqualOp,(First)(Second))

	boost::BOOST_concept (GreaterThanOp,(First)(Second))

	boost::BOOST_concept (GreaterEqualOp,(First)(Second))

	boost::BOOST_concept (PlusOp,(Ret)(First)(Second))

	boost::BOOST_concept (TimesOp,(Ret)(First)(Second))

	boost::BOOST_concept (DivideOp,(Ret)(First)(Second))

	boost::BOOST_concept (SubtractOp,(Ret)(First)(Second))

	boost::BOOST_concept (ModOp,(Ret)(First)(Second))

	boost::BOOST_concept (Generator,(Func)(Return))

	boost::BOOST_concept (UnaryFunction,(Func)(Return)(Arg))

	boost::BOOST_concept (BinaryFunction,(Func)(Return)(First)(Second))

	boost::BOOST_concept (UnaryPredicate,(Func)(Arg))

	boost::BOOST_concept (BinaryPredicate,(Func)(First)(Second))

	boost::BOOST_concept (Const_BinaryPredicate,(Func)(First)(Second))

	boost::BOOST_concept (AdaptableGenerator,(Func)(Return))

	boost::BOOST_concept (AdaptableUnaryFunction,(Func)(Return)(Arg))

	boost::BOOST_concept (AdaptableBinaryFunction,(Func)(Return)(First)(Second))

	boost::BOOST_concept (AdaptablePredicate,(Func)(Arg))

	boost::BOOST_concept (AdaptableBinaryPredicate,(Func)(First)(Second))

	boost::BOOST_concept (InputIterator,(TT))

	boost::BOOST_concept (OutputIterator,(TT)(ValueT))

	boost::BOOST_concept (ForwardIterator,(TT))

	boost::BOOST_concept (Mutable_ForwardIterator,(TT))

	boost::BOOST_concept (BidirectionalIterator,(TT))

	boost::BOOST_concept (Mutable_BidirectionalIterator,(TT))

	boost::BOOST_concept (RandomAccessIterator,(TT))

	boost::BOOST_concept (Mutable_RandomAccessIterator,(TT))

	boost::BOOST_concept (Container,(C))

	boost::BOOST_concept (Mutable_Container,(C))

	boost::BOOST_concept (ForwardContainer,(C))

	boost::BOOST_concept (Mutable_ForwardContainer,(C))

	boost::BOOST_concept (ReversibleContainer,(C))

	boost::BOOST_concept (Mutable_ReversibleContainer,(C))

	boost::BOOST_concept (RandomAccessContainer,(C))

	boost::BOOST_concept (Mutable_RandomAccessContainer,(C))

	boost::BOOST_concept (Sequence,(S))

	boost::BOOST_concept (FrontInsertionSequence,(S))

	boost::BOOST_concept (BackInsertionSequence,(S))

	boost::BOOST_concept (AssociativeContainer,(C))

	boost::BOOST_concept (UniqueAssociativeContainer,(C))

	boost::BOOST_concept (MultipleAssociativeContainer,(C))

	boost::BOOST_concept (SimpleAssociativeContainer,(C))

	boost::BOOST_concept (PairAssociativeContainer,(C))

	boost::BOOST_concept (SortedAssociativeContainer,(C))

	boost::BOOST_concept (Collection,(C))

Macro Definition Documentation

#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>))

#define BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT	(	OP,
		NAME
	)

Value:

BOOST_concept(NAME, (Ret)(First)(Second))                 \
  {                                                         \
      BOOST_CONCEPT_USAGE(NAME) { (void)constraints_(); }                     \
  private:                                                  \
      Ret constraints_() { return a OP b; }                 \
      First a;                                              \
      Second b;                                             \
  }

#define BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT	(	OP,
		NAME
	)

Value:

BOOST_concept(NAME, (First)(Second))                          \
  {                                                             \
      BOOST_CONCEPT_USAGE(NAME) { (void)constraints_(); }                         \
     private:                                                   \
        bool constraints_() { return a OP b; }                  \
        First a;                                                \
        Second b;                                               \
  }

Classes

Namespaces

Macros

Functions

Macro Definition Documentation