Boost Concept Checking Reference

## Reference

1. Functions
2. Macros
3. Basic Concept Checking Classes
4. Iterator Concept Checking Classes
5. Function Object Concept Checking Classes
6. Container Concept Checking Classes
7. Basic Archetype Classes
8. Iterator Archetype Classes
9. Function Object Archetype Classes
10. Container Archetype Classes

### Functions

      template <class Concept>
      void function_requires();

### Macros

      // Apply concept checks in class definitions.
      BOOST_CLASS_REQUIRE(type, namespace-of-concept, concept);
      BOOST_CLASS_REQUIRE2(type1, type2, namespace-of-concept, concept);
      BOOST_CLASS_REQUIRE3(type1, type2, type3, namespace-of-concept, concept);
      BOOST_CLASS_REQUIRE4(type1, type2, type3, type4, namespace-of-concept, concept);

Deprecated macros:

      // Apply concept checks in class definitions.
      BOOST_CLASS_REQUIRES(type, concept);
      BOOST_CLASS_REQUIRES2(type1, type2, concept);
      BOOST_CLASS_REQUIRES3(type1, type2, type3, concept);
      BOOST_CLASS_REQUIRES4(type1, type2, type3, type4, concept);

### Basic Concept Checking Classes

      template <class T>
      struct IntegerConcept; // Is T a built-in integer type?

      template <class T>
      struct SignedIntegerConcept; // Is T a built-in signed integer type?

      template <class T>
      struct UnsignedIntegerConcept; // Is T a built-in unsigned integer type?

      template <class X, class Y>
      struct ConvertibleConcept; // Is X convertible to Y?

      template <class T>
      struct AssignableConcept; // Standard ref 23.1

      template <class T>
      struct SGIAssignableConcept;

      template <class T>
      struct DefaultConstructibleConcept;

      template <class T>
      struct CopyConstructibleConcept; // Standard ref 20.1.3

      template <class T>
      struct EqualityComparableConcept; // Standard ref 20.1.1

      template <class T>
      struct LessThanComparableConcept; // Standard ref 20.1.2

      template <class T>
      struct ComparableConcept; // The SGI STL LessThanComparable concept

### Iterator Concept Checking Classes

      template <class Iter>
      struct InputIteratorConcept; // Standard ref 24.1.1 Table 72

      template <class Iter, class T>
      struct OutputIteratorConcept; // Standard ref 24.1.2 Table 73

      template <class Iter>
      struct ForwardIteratorConcept; // Standard ref 24.1.3 Table 74

      template <class Iter>
      struct Mutable_ForwardIteratorConcept;

      template <class Iter>
      struct BidirectionalIteratorConcept; // Standard ref 24.1.4 Table 75

      template <class Iter>
      struct Mutable_BidirectionalIteratorConcept;

      template <class Iter>
      struct RandomAccessIteratorConcept; // Standard ref 24.1.5 Table 76

      template <class Iter>
      struct Mutable_RandomAccessIteratorConcept;

### Function Object Concept Checking Classes

      template <class Func, class Return>
      struct GeneratorConcept;

      template <class Func, class Return, class Arg>
      struct UnaryFunctionConcept;

      template <class Func, class Return, class First, class Second>
      struct BinaryFunctionConcept;

      template <class Func, class Arg>
      struct UnaryPredicateConcept;

      template <class Func, class First, class Second>
      struct BinaryPredicateConcept;

      template <class Func, class First, class Second>
      struct Const_BinaryPredicateConcept;

      template <class Func, class Return>
      struct AdaptableGeneratorConcept;

      template <class Func, class Return, class Arg>
      struct AdaptableUnaryFunctionConcept;

      template <class Func, class First, class Second>
      struct AdaptableBinaryFunctionConcept;

      template <class Func, class Arg>
      struct AdaptablePredicateConcept;

      template <class Func, class First, class Second>
      struct AdaptableBinaryPredicateConcept;

### Container Concept Checking Classes

      template <class C>
      struct ContainerConcept; // Standard ref 23.1 Table 65

      template <class C>
      struct Mutable_ContainerConcept;

      template <class C>
      struct ForwardContainerConcept;

      template <class C>
      struct Mutable_ForwardContainerConcept;

      template <class C>
      struct ReversibleContainerConcept; // Standard ref 23.1 Table 66

      template <class C>
      struct Mutable_ReversibleContainerConcept;

      template <class C>
      struct RandomAccessContainerConcept;

      template <class C>
      struct Mutable_RandomAccessContainerConcept;

      template <class C>
      struct SequenceConcept; // Standard ref 23.1.1

      template <class C>
      struct FrontInsertionSequenceConcept;

      template <class C>
      struct BackInsertionSequenceConcept;

      template <class C>
      struct AssociativeContainerConcept; // Standard ref 23.1.2 Table 69

      template <class C>
      struct UniqueAssociativeContainerConcept;

      template <class C>
      struct MultipleAssociativeContainerConcept;

      template <class C>
      struct SimpleAssociativeContainerConcept;

      template <class C>
      struct PairAssociativeContainerConcept;

      template <class C>
      struct SortedAssociativeContainerConcept;

### Basic Archetype Classes

      template <class T = int>
      class null_archetype; // A type that models no concepts.

      template <class Base = null_archetype>
      class default_constructible_archetype;

      template <class Base = null_archetype>
      class assignable_archetype;

      template <class Base = null_archetype>
      class copy_constructible_archetype;

      template <class Base = null_archetype>
      class equality_comparable_archetype;

      template <class T, class Base = null_archetype>
      class convertible_to_archetype;

### Iterator Archetype Classes

      template <class ValueType>
      class trivial_iterator_archetype;

      template <class ValueType>
      class mutable_trivial_iterator_archetype;

      template <class ValueType>
      class input_iterator_archetype;

      template <class ValueType>
      class forward_iterator_archetype;

      template <class ValueType>
      class bidirectional_iterator_archetype;

      template <class ValueType>
      class random_access_iterator_archetype;

### Function Object Archetype Classes

      template <class Arg, class Return>
      class unary_function_archetype;

      template <class Arg1, class Arg2, class Return>
      class binary_function_archetype;

      template <class Arg>
      class predicate_archetype;

      template <class Arg1, class Arg2>
      class binary_predicate_archetype;

### Container Archetype Classes

    UNDER CONSTRUCTION

Back to Introduction
Prev: Implementation

Copyright © 2000 | Jeremy Siek(jsiek@osl.iu.edu) Andrew Lumsdaine(lums@osl.iu.edu)