concept_archetype.hpp File Reference

#include <boost/config.hpp>
#include <boost/iterator.hpp>
#include <boost/mpl/identity.hpp>
#include <functional>

Include dependency graph for concept_archetype.hpp:

This graph shows which files directly or indirectly include this file:

Classes
class	boost::detail::dummy_constructor
class	boost::null_archetype< T >
class	boost::static_object< T >
class	boost::default_constructible_archetype< Base >
class	boost::assignable_archetype< Base >
class	boost::copy_constructible_archetype< Base >
class	boost::sgi_assignable_archetype< Base >
struct	boost::default_archetype_base
class	boost::convertible_to_archetype< T, Base >
class	boost::convertible_from_archetype< T, Base >
class	boost::boolean_archetype
class	boost::equality_comparable_archetype< Base >
class	boost::equality_comparable2_first_archetype< Base >
class	boost::equality_comparable2_second_archetype< Base >
class	boost::less_than_comparable_archetype< Base >
class	boost::comparable_archetype< Base >
struct	boost::optag1
struct	boost::optag2
struct	boost::optag3
class	boost::equal_op_first_archetype< Base, Tag >
class	boost::equal_op_second_archetype< Base, Tag >
class	boost::not_equal_op_first_archetype< Base, Tag >
class	boost::not_equal_op_second_archetype< Base, Tag >
class	boost::less_than_op_first_archetype< Base, Tag >
class	boost::less_than_op_second_archetype< Base, Tag >
class	boost::less_equal_op_first_archetype< Base, Tag >
class	boost::less_equal_op_second_archetype< Base, Tag >
class	boost::greater_than_op_first_archetype< Base, Tag >
class	boost::greater_than_op_second_archetype< Base, Tag >
class	boost::greater_equal_op_first_archetype< Base, Tag >
class	boost::greater_equal_op_second_archetype< Base, Tag >
class	boost::addable_archetype< Base >
class	boost::subtractable_archetype< Base >
class	boost::multipliable_archetype< Base >
class	boost::dividable_archetype< Base >
class	boost::modable_archetype< Base >
class	boost::plus_op_first_archetype< Return, Base >
class	boost::plus_op_second_archetype< Return, Base >
class	boost::time_op_first_archetype< Return, Base >
class	boost::time_op_second_archetype< Return, Base >
class	boost::divide_op_first_archetype< Return, Base >
class	boost::divide_op_second_archetype< Return, Base >
class	boost::subtract_op_first_archetype< Return, Base >
class	boost::subtract_op_second_archetype< Return, Base >
class	boost::mod_op_first_archetype< Return, Base >
class	boost::mod_op_second_archetype< Return, Base >
class	boost::generator_archetype< Return >
class	boost::void_generator_archetype
class	boost::unary_function_archetype< Arg, Return >
class	boost::binary_function_archetype< Arg1, Arg2, Return >
class	boost::unary_predicate_archetype< Arg >
class	boost::binary_predicate_archetype< Arg1, Arg2, Base >
class	boost::input_iterator_archetype< T, I >
struct	boost::input_iterator_archetype< T, I >::reference
class	boost::input_iterator_archetype_no_proxy< T >
struct	boost::output_proxy< T >
class	boost::output_iterator_archetype< T >
class	boost::input_output_iterator_archetype< T >
struct	boost::input_output_iterator_archetype< T >::reference
class	boost::forward_iterator_archetype< T >
class	boost::mutable_forward_iterator_archetype< T >
class	boost::bidirectional_iterator_archetype< T >
class	boost::mutable_bidirectional_iterator_archetype< T >
class	boost::random_access_iterator_archetype< T >
class	boost::mutable_random_access_iterator_archetype< T >

Namespaces
	boost
	Duration formatting facet for input.
	boost::detail

Macros
#define	BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE(OP, NAME)
#define	BOOST_DEFINE_OPERATOR_ARCHETYPE(OP, NAME)
#define	BOOST_DEFINE_BINARY_OPERATOR_ARCHETYPE(OP, NAME)

Functions
template<class Base >
boolean_archetype	boost::operator== (const equality_comparable_archetype< Base > &, const equality_comparable_archetype< Base > &)
template<class Base >
boolean_archetype	boost::operator!= (const equality_comparable_archetype< Base > &, const equality_comparable_archetype< Base > &)
template<class Base1 , class Base2 >
boolean_archetype	boost::operator== (const equality_comparable2_first_archetype< Base1 > &, const equality_comparable2_second_archetype< Base2 > &)
template<class Base1 , class Base2 >
boolean_archetype	boost::operator!= (const equality_comparable2_first_archetype< Base1 > &, const equality_comparable2_second_archetype< Base2 > &)
template<class Base >
boolean_archetype	boost::operator< (const less_than_comparable_archetype< Base > &, const less_than_comparable_archetype< Base > &)
template<class Base >
boolean_archetype	boost::operator< (const comparable_archetype< Base > &, const comparable_archetype< Base > &)
template<class Base >
boolean_archetype	boost::operator<= (const comparable_archetype< Base > &, const comparable_archetype< Base > &)
template<class Base >
boolean_archetype	boost::operator> (const comparable_archetype< Base > &, const comparable_archetype< Base > &)
template<class Base >
boolean_archetype	boost::operator>= (const comparable_archetype< Base > &, const comparable_archetype< Base > &)
template<class BaseFirst , class BaseSecond , class Tag >
boolean_archetype	boost::operator== (const equal_op_first_archetype< BaseFirst, Tag > &, const equal_op_second_archetype< BaseSecond, Tag > &)
template<class BaseFirst , class BaseSecond , class Tag >
boolean_archetype	boost::operator!= (const not_equal_op_first_archetype< BaseFirst, Tag > &, const not_equal_op_second_archetype< BaseSecond, Tag > &)
template<class BaseFirst , class BaseSecond , class Tag >
boolean_archetype	boost::operator< (const less_than_op_first_archetype< BaseFirst, Tag > &, const less_than_op_second_archetype< BaseSecond, Tag > &)
template<class BaseFirst , class BaseSecond , class Tag >
boolean_archetype	boost::operator<= (const less_equal_op_first_archetype< BaseFirst, Tag > &, const less_equal_op_second_archetype< BaseSecond, Tag > &)
template<class BaseFirst , class BaseSecond , class Tag >
boolean_archetype	boost::operator> (const greater_than_op_first_archetype< BaseFirst, Tag > &, const greater_than_op_second_archetype< BaseSecond, Tag > &)
template<class BaseFirst , class BaseSecond , class Tag >
boolean_archetype	boost::operator>= (const greater_equal_op_first_archetype< BaseFirst, Tag > &, const greater_equal_op_second_archetype< BaseSecond, Tag > &)
template<class Base >
addable_archetype< Base >	boost::operator+ (const addable_archetype< Base > &, const addable_archetype< Base > &)
template<class Base >
subtractable_archetype< Base >	boost::operator- (const subtractable_archetype< Base > &, const subtractable_archetype< Base > &)
template<class Base >
multipliable_archetype< Base >	boost::operator* (const multipliable_archetype< Base > &, const multipliable_archetype< Base > &)
template<class Base >
dividable_archetype< Base >	boost::operator/ (const dividable_archetype< Base > &, const dividable_archetype< Base > &)
template<class Base >
modable_archetype< Base >	boost::operator% (const modable_archetype< Base > &, const modable_archetype< Base > &)
template<class Return , class BaseFirst , class BaseSecond >
Return	boost::operator+ (const plus_op_first_archetype< Return, BaseFirst > &, const plus_op_second_archetype< Return, BaseSecond > &)
template<class Return , class BaseFirst , class BaseSecond >
Return	boost::operator* (const time_op_first_archetype< Return, BaseFirst > &, const time_op_second_archetype< Return, BaseSecond > &)
template<class Return , class BaseFirst , class BaseSecond >
Return	boost::operator/ (const divide_op_first_archetype< Return, BaseFirst > &, const divide_op_second_archetype< Return, BaseSecond > &)
template<class Return , class BaseFirst , class BaseSecond >
Return	boost::operator- (const subtract_op_first_archetype< Return, BaseFirst > &, const subtract_op_second_archetype< Return, BaseSecond > &)
template<class Return , class BaseFirst , class BaseSecond >
Return	boost::operator% (const mod_op_first_archetype< Return, BaseFirst > &, const mod_op_second_archetype< Return, BaseSecond > &)
template<class T >
random_access_iterator_archetype < T >	boost::operator+ (typename random_access_iterator_archetype< T >::difference_type, const random_access_iterator_archetype< T > &x)
template<class T >
mutable_random_access_iterator_archetype < T >	boost::operator+ (typename mutable_random_access_iterator_archetype< T >::difference_type, const mutable_random_access_iterator_archetype< T > &x)

Macro Definition Documentation

#define BOOST_DEFINE_BINARY_OPERATOR_ARCHETYPE	(		OP,
			NAME
	)

Value:

template <class Return, class Base = null_archetype<> > \
  class NAME##_first_archetype : public Base { \
  public: \
    NAME##_first_archetype(detail::dummy_constructor x) : Base(x) { } \
  }; \
  \
  template <class Return, class Base = null_archetype<> > \
  class NAME##_second_archetype : public Base { \
  public: \
    NAME##_second_archetype(detail::dummy_constructor x) : Base(x) { } \
  }; \
  \
  template <class Return, class BaseFirst, class BaseSecond> \
  Return \
  operator OP (const NAME##_first_archetype<Return, BaseFirst>&, \
               const NAME##_second_archetype<Return, BaseSecond>&) \
  { \
    return Return(static_object<detail::dummy_constructor>::get()); \
  }

#define BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE	(		OP,
			NAME
	)

Value:

template <class Base = null_archetype<>, class Tag = optag1 >                 \
  class NAME##_first_archetype : public Base {                                  \
  public:                                                                       \
    NAME##_first_archetype(detail::dummy_constructor x) : Base(x) { }           \
  };                                                                            \
                                                                                \
  template <class Base = null_archetype<>, class Tag = optag1 >                 \
  class NAME##_second_archetype : public Base {                                 \
  public:                                                                       \
    NAME##_second_archetype(detail::dummy_constructor x) : Base(x) { }          \
  };                                                                            \
                                                                                \
  template <class BaseFirst, class BaseSecond, class Tag>                       \
  boolean_archetype                                                             \
  operator OP (const NAME##_first_archetype<BaseFirst, Tag>&,                   \
               const NAME##_second_archetype<BaseSecond, Tag>&)                 \
  {                                                                             \
   return boolean_archetype(static_object<detail::dummy_constructor>::get());   \
  }

#define BOOST_DEFINE_OPERATOR_ARCHETYPE	(		OP,
			NAME
	)

Value:

template <class Base = null_archetype<> > \
  class NAME##_archetype : public Base { \
  public: \
    NAME##_archetype(detail::dummy_constructor x) : Base(x) { } \
    NAME##_archetype(const NAME##_archetype&)  \
      : Base(static_object<detail::dummy_constructor>::get()) { } \
    NAME##_archetype& operator=(const NAME##_archetype&) { return *this; } \
  }; \
  template <class Base> \
  NAME##_archetype<Base> \
  operator OP (const NAME##_archetype<Base>&,\
               const NAME##_archetype<Base>&)  \
  { \
    return \
     NAME##_archetype<Base>(static_object<detail::dummy_constructor>::get()); \
  }