Boost  v1.57.0
doxygen for www.boost.org
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
Classes | Namespaces | Macros
operators.hpp File Reference
#include <boost/config.hpp>
#include <boost/iterator.hpp>
#include <boost/detail/workaround.hpp>
Include dependency graph for operators.hpp:
This graph shows which files directly or indirectly include this file:

Classes

class  boost::detail::empty_base< T >
 
struct  boost::less_than_comparable2< T, U, B >
 
struct  boost::less_than_comparable1< T, B >
 
struct  boost::equality_comparable2< T, U, B >
 
struct  boost::equality_comparable1< T, B >
 
struct  boost::multipliable2< T, U, B >
 
struct  boost::multipliable1< T, B >
 
struct  boost::addable2< T, U, B >
 
struct  boost::addable1< T, B >
 
struct  boost::subtractable2< T, U, B >
 
struct  boost::subtractable2_left< T, U, B >
 
struct  boost::subtractable1< T, B >
 
struct  boost::dividable2< T, U, B >
 
struct  boost::dividable2_left< T, U, B >
 
struct  boost::dividable1< T, B >
 
struct  boost::modable2< T, U, B >
 
struct  boost::modable2_left< T, U, B >
 
struct  boost::modable1< T, B >
 
struct  boost::xorable2< T, U, B >
 
struct  boost::xorable1< T, B >
 
struct  boost::andable2< T, U, B >
 
struct  boost::andable1< T, B >
 
struct  boost::orable2< T, U, B >
 
struct  boost::orable1< T, B >
 
struct  boost::incrementable< T, B >
 
struct  boost::decrementable< T, B >
 
struct  boost::dereferenceable< T, P, B >
 
struct  boost::indexable< T, I, R, B >
 
struct  boost::left_shiftable2< T, U, B >
 
struct  boost::left_shiftable1< T, B >
 
struct  boost::right_shiftable2< T, U, B >
 
struct  boost::right_shiftable1< T, B >
 
struct  boost::equivalent2< T, U, B >
 
struct  boost::equivalent1< T, B >
 
struct  boost::partially_ordered2< T, U, B >
 
struct  boost::partially_ordered1< T, B >
 
struct  boost::totally_ordered2< T, U, B >
 
struct  boost::totally_ordered1< T, B >
 
struct  boost::additive2< T, U, B >
 
struct  boost::additive1< T, B >
 
struct  boost::multiplicative2< T, U, B >
 
struct  boost::multiplicative1< T, B >
 
struct  boost::integer_multiplicative2< T, U, B >
 
struct  boost::integer_multiplicative1< T, B >
 
struct  boost::arithmetic2< T, U, B >
 
struct  boost::arithmetic1< T, B >
 
struct  boost::integer_arithmetic2< T, U, B >
 
struct  boost::integer_arithmetic1< T, B >
 
struct  boost::bitwise2< T, U, B >
 
struct  boost::bitwise1< T, B >
 
struct  boost::unit_steppable< T, B >
 
struct  boost::shiftable2< T, U, B >
 
struct  boost::shiftable1< T, B >
 
struct  boost::ring_operators2< T, U, B >
 
struct  boost::ring_operators1< T, B >
 
struct  boost::ordered_ring_operators2< T, U, B >
 
struct  boost::ordered_ring_operators1< T, B >
 
struct  boost::field_operators2< T, U, B >
 
struct  boost::field_operators1< T, B >
 
struct  boost::ordered_field_operators2< T, U, B >
 
struct  boost::ordered_field_operators1< T, B >
 
struct  boost::euclidian_ring_operators2< T, U, B >
 
struct  boost::euclidian_ring_operators1< T, B >
 
struct  boost::ordered_euclidian_ring_operators2< T, U, B >
 
struct  boost::ordered_euclidian_ring_operators1< T, B >
 
struct  boost::euclidean_ring_operators2< T, U, B >
 
struct  boost::euclidean_ring_operators1< T, B >
 
struct  boost::ordered_euclidean_ring_operators2< T, U, B >
 
struct  boost::ordered_euclidean_ring_operators1< T, B >
 
struct  boost::input_iteratable< T, P, B >
 
struct  boost::output_iteratable< T, B >
 
struct  boost::forward_iteratable< T, P, B >
 
struct  boost::bidirectional_iteratable< T, P, B >
 
struct  boost::random_access_iteratable< T, P, D, R, B >
 
struct  boost::detail::true_t
 
struct  boost::detail::false_t
 
struct  boost::is_chained_base< T >
 
struct  boost::less_than_comparable< T, U, B, O >
 
struct  boost::less_than_comparable< T, U, B,::boost::detail::true_t >
 
struct  boost::less_than_comparable< T, T, B,::boost::detail::false_t >
 
struct  boost::is_chained_base< ::boost::less_than_comparable< T, U, B, O > >
 
struct  boost::is_chained_base< ::boost::less_than_comparable2< T, U, B > >
 
struct  boost::is_chained_base< ::boost::less_than_comparable1< T, B > >
 
struct  boost::equality_comparable< T, U, B, O >
 
struct  boost::equality_comparable< T, U, B,::boost::detail::true_t >
 
struct  boost::equality_comparable< T, T, B,::boost::detail::false_t >
 
struct  boost::is_chained_base< ::boost::equality_comparable< T, U, B, O > >
 
struct  boost::is_chained_base< ::boost::equality_comparable2< T, U, B > >
 
struct  boost::is_chained_base< ::boost::equality_comparable1< T, B > >
 
struct  boost::multipliable< T, U, B, O >
 
struct  boost::multipliable< T, U, B,::boost::detail::true_t >
 
struct  boost::multipliable< T, T, B,::boost::detail::false_t >
 
struct  boost::is_chained_base< ::boost::multipliable< T, U, B, O > >
 
struct  boost::is_chained_base< ::boost::multipliable2< T, U, B > >
 
struct  boost::is_chained_base< ::boost::multipliable1< T, B > >
 
struct  boost::addable< T, U, B, O >
 
struct  boost::addable< T, U, B,::boost::detail::true_t >
 
struct  boost::addable< T, T, B,::boost::detail::false_t >
 
struct  boost::is_chained_base< ::boost::addable< T, U, B, O > >
 
struct  boost::is_chained_base< ::boost::addable2< T, U, B > >
 
struct  boost::is_chained_base< ::boost::addable1< T, B > >
 
struct  boost::subtractable< T, U, B, O >
 
struct  boost::subtractable< T, U, B,::boost::detail::true_t >
 
struct  boost::subtractable< T, T, B,::boost::detail::false_t >
 
struct  boost::is_chained_base< ::boost::subtractable< T, U, B, O > >
 
struct  boost::is_chained_base< ::boost::subtractable2< T, U, B > >
 
struct  boost::is_chained_base< ::boost::subtractable1< T, B > >
 
struct  boost::is_chained_base< ::boost::subtractable2_left< T, U, B > >
 
struct  boost::dividable< T, U, B, O >
 
struct  boost::dividable< T, U, B,::boost::detail::true_t >
 
struct  boost::dividable< T, T, B,::boost::detail::false_t >
 
struct  boost::is_chained_base< ::boost::dividable< T, U, B, O > >
 
struct  boost::is_chained_base< ::boost::dividable2< T, U, B > >
 
struct  boost::is_chained_base< ::boost::dividable1< T, B > >
 
struct  boost::is_chained_base< ::boost::dividable2_left< T, U, B > >
 
struct  boost::modable< T, U, B, O >
 
struct  boost::modable< T, U, B,::boost::detail::true_t >
 
struct  boost::modable< T, T, B,::boost::detail::false_t >
 
struct  boost::is_chained_base< ::boost::modable< T, U, B, O > >
 
struct  boost::is_chained_base< ::boost::modable2< T, U, B > >
 
struct  boost::is_chained_base< ::boost::modable1< T, B > >
 
struct  boost::is_chained_base< ::boost::modable2_left< T, U, B > >
 
struct  boost::xorable< T, U, B, O >
 
struct  boost::xorable< T, U, B,::boost::detail::true_t >
 
struct  boost::xorable< T, T, B,::boost::detail::false_t >
 
struct  boost::is_chained_base< ::boost::xorable< T, U, B, O > >
 
struct  boost::is_chained_base< ::boost::xorable2< T, U, B > >
 
struct  boost::is_chained_base< ::boost::xorable1< T, B > >
 
struct  boost::andable< T, U, B, O >
 
struct  boost::andable< T, U, B,::boost::detail::true_t >
 
struct  boost::andable< T, T, B,::boost::detail::false_t >
 
struct  boost::is_chained_base< ::boost::andable< T, U, B, O > >
 
struct  boost::is_chained_base< ::boost::andable2< T, U, B > >
 
struct  boost::is_chained_base< ::boost::andable1< T, B > >
 
struct  boost::orable< T, U, B, O >
 
struct  boost::orable< T, U, B,::boost::detail::true_t >
 
struct  boost::orable< T, T, B,::boost::detail::false_t >
 
struct  boost::is_chained_base< ::boost::orable< T, U, B, O > >
 
struct  boost::is_chained_base< ::boost::orable2< T, U, B > >
 
struct  boost::is_chained_base< ::boost::orable1< T, B > >
 
struct  boost::is_chained_base< ::boost::incrementable< T, B > >
 
struct  boost::is_chained_base< ::boost::decrementable< T, B > >
 
struct  boost::is_chained_base< ::boost::dereferenceable< T, U, B > >
 
struct  boost::is_chained_base< ::boost::indexable< T, U, V, B > >
 
struct  boost::left_shiftable< T, U, B, O >
 
struct  boost::left_shiftable< T, U, B,::boost::detail::true_t >
 
struct  boost::left_shiftable< T, T, B,::boost::detail::false_t >
 
struct  boost::is_chained_base< ::boost::left_shiftable< T, U, B, O > >
 
struct  boost::is_chained_base< ::boost::left_shiftable2< T, U, B > >
 
struct  boost::is_chained_base< ::boost::left_shiftable1< T, B > >
 
struct  boost::right_shiftable< T, U, B, O >
 
struct  boost::right_shiftable< T, U, B,::boost::detail::true_t >
 
struct  boost::right_shiftable< T, T, B,::boost::detail::false_t >
 
struct  boost::is_chained_base< ::boost::right_shiftable< T, U, B, O > >
 
struct  boost::is_chained_base< ::boost::right_shiftable2< T, U, B > >
 
struct  boost::is_chained_base< ::boost::right_shiftable1< T, B > >
 
struct  boost::equivalent< T, U, B, O >
 
struct  boost::equivalent< T, U, B,::boost::detail::true_t >
 
struct  boost::equivalent< T, T, B,::boost::detail::false_t >
 
struct  boost::is_chained_base< ::boost::equivalent< T, U, B, O > >
 
struct  boost::is_chained_base< ::boost::equivalent2< T, U, B > >
 
struct  boost::is_chained_base< ::boost::equivalent1< T, B > >
 
struct  boost::partially_ordered< T, U, B, O >
 
struct  boost::partially_ordered< T, U, B,::boost::detail::true_t >
 
struct  boost::partially_ordered< T, T, B,::boost::detail::false_t >
 
struct  boost::is_chained_base< ::boost::partially_ordered< T, U, B, O > >
 
struct  boost::is_chained_base< ::boost::partially_ordered2< T, U, B > >
 
struct  boost::is_chained_base< ::boost::partially_ordered1< T, B > >
 
struct  boost::totally_ordered< T, U, B, O >
 
struct  boost::totally_ordered< T, U, B,::boost::detail::true_t >
 
struct  boost::totally_ordered< T, T, B,::boost::detail::false_t >
 
struct  boost::is_chained_base< ::boost::totally_ordered< T, U, B, O > >
 
struct  boost::is_chained_base< ::boost::totally_ordered2< T, U, B > >
 
struct  boost::is_chained_base< ::boost::totally_ordered1< T, B > >
 
struct  boost::additive< T, U, B, O >
 
struct  boost::additive< T, U, B,::boost::detail::true_t >
 
struct  boost::additive< T, T, B,::boost::detail::false_t >
 
struct  boost::is_chained_base< ::boost::additive< T, U, B, O > >
 
struct  boost::is_chained_base< ::boost::additive2< T, U, B > >
 
struct  boost::is_chained_base< ::boost::additive1< T, B > >
 
struct  boost::multiplicative< T, U, B, O >
 
struct  boost::multiplicative< T, U, B,::boost::detail::true_t >
 
struct  boost::multiplicative< T, T, B,::boost::detail::false_t >
 
struct  boost::is_chained_base< ::boost::multiplicative< T, U, B, O > >
 
struct  boost::is_chained_base< ::boost::multiplicative2< T, U, B > >
 
struct  boost::is_chained_base< ::boost::multiplicative1< T, B > >
 
struct  boost::integer_multiplicative< T, U, B, O >
 
struct  boost::integer_multiplicative< T, U, B,::boost::detail::true_t >
 
struct  boost::integer_multiplicative< T, T, B,::boost::detail::false_t >
 
struct  boost::is_chained_base< ::boost::integer_multiplicative< T, U, B, O > >
 
struct  boost::is_chained_base< ::boost::integer_multiplicative2< T, U, B > >
 
struct  boost::is_chained_base< ::boost::integer_multiplicative1< T, B > >
 
struct  boost::arithmetic< T, U, B, O >
 
struct  boost::arithmetic< T, U, B,::boost::detail::true_t >
 
struct  boost::arithmetic< T, T, B,::boost::detail::false_t >
 
struct  boost::is_chained_base< ::boost::arithmetic< T, U, B, O > >
 
struct  boost::is_chained_base< ::boost::arithmetic2< T, U, B > >
 
struct  boost::is_chained_base< ::boost::arithmetic1< T, B > >
 
struct  boost::integer_arithmetic< T, U, B, O >
 
struct  boost::integer_arithmetic< T, U, B,::boost::detail::true_t >
 
struct  boost::integer_arithmetic< T, T, B,::boost::detail::false_t >
 
struct  boost::is_chained_base< ::boost::integer_arithmetic< T, U, B, O > >
 
struct  boost::is_chained_base< ::boost::integer_arithmetic2< T, U, B > >
 
struct  boost::is_chained_base< ::boost::integer_arithmetic1< T, B > >
 
struct  boost::bitwise< T, U, B, O >
 
struct  boost::bitwise< T, U, B,::boost::detail::true_t >
 
struct  boost::bitwise< T, T, B,::boost::detail::false_t >
 
struct  boost::is_chained_base< ::boost::bitwise< T, U, B, O > >
 
struct  boost::is_chained_base< ::boost::bitwise2< T, U, B > >
 
struct  boost::is_chained_base< ::boost::bitwise1< T, B > >
 
struct  boost::is_chained_base< ::boost::unit_steppable< T, B > >
 
struct  boost::shiftable< T, U, B, O >
 
struct  boost::shiftable< T, U, B,::boost::detail::true_t >
 
struct  boost::shiftable< T, T, B,::boost::detail::false_t >
 
struct  boost::is_chained_base< ::boost::shiftable< T, U, B, O > >
 
struct  boost::is_chained_base< ::boost::shiftable2< T, U, B > >
 
struct  boost::is_chained_base< ::boost::shiftable1< T, B > >
 
struct  boost::ring_operators< T, U, B, O >
 
struct  boost::ring_operators< T, U, B,::boost::detail::true_t >
 
struct  boost::ring_operators< T, T, B,::boost::detail::false_t >
 
struct  boost::is_chained_base< ::boost::ring_operators< T, U, B, O > >
 
struct  boost::is_chained_base< ::boost::ring_operators2< T, U, B > >
 
struct  boost::is_chained_base< ::boost::ring_operators1< T, B > >
 
struct  boost::ordered_ring_operators< T, U, B, O >
 
struct  boost::ordered_ring_operators< T, U, B,::boost::detail::true_t >
 
struct  boost::ordered_ring_operators< T, T, B,::boost::detail::false_t >
 
struct  boost::is_chained_base< ::boost::ordered_ring_operators< T, U, B, O > >
 
struct  boost::is_chained_base< ::boost::ordered_ring_operators2< T, U, B > >
 
struct  boost::is_chained_base< ::boost::ordered_ring_operators1< T, B > >
 
struct  boost::field_operators< T, U, B, O >
 
struct  boost::field_operators< T, U, B,::boost::detail::true_t >
 
struct  boost::field_operators< T, T, B,::boost::detail::false_t >
 
struct  boost::is_chained_base< ::boost::field_operators< T, U, B, O > >
 
struct  boost::is_chained_base< ::boost::field_operators2< T, U, B > >
 
struct  boost::is_chained_base< ::boost::field_operators1< T, B > >
 
struct  boost::ordered_field_operators< T, U, B, O >
 
struct  boost::ordered_field_operators< T, U, B,::boost::detail::true_t >
 
struct  boost::ordered_field_operators< T, T, B,::boost::detail::false_t >
 
struct  boost::is_chained_base< ::boost::ordered_field_operators< T, U, B, O > >
 
struct  boost::is_chained_base< ::boost::ordered_field_operators2< T, U, B > >
 
struct  boost::is_chained_base< ::boost::ordered_field_operators1< T, B > >
 
struct  boost::euclidian_ring_operators< T, U, B, O >
 
struct  boost::euclidian_ring_operators< T, U, B,::boost::detail::true_t >
 
struct  boost::euclidian_ring_operators< T, T, B,::boost::detail::false_t >
 
struct  boost::is_chained_base< ::boost::euclidian_ring_operators< T, U, B, O > >
 
struct  boost::is_chained_base< ::boost::euclidian_ring_operators2< T, U, B > >
 
struct  boost::is_chained_base< ::boost::euclidian_ring_operators1< T, B > >
 
struct  boost::ordered_euclidian_ring_operators< T, U, B, O >
 
struct  boost::ordered_euclidian_ring_operators< T, U, B,::boost::detail::true_t >
 
struct  boost::ordered_euclidian_ring_operators< T, T, B,::boost::detail::false_t >
 
struct  boost::is_chained_base< ::boost::ordered_euclidian_ring_operators< T, U, B, O > >
 
struct  boost::is_chained_base< ::boost::ordered_euclidian_ring_operators2< T, U, B > >
 
struct  boost::is_chained_base< ::boost::ordered_euclidian_ring_operators1< T, B > >
 
struct  boost::euclidean_ring_operators< T, U, B, O >
 
struct  boost::euclidean_ring_operators< T, U, B,::boost::detail::true_t >
 
struct  boost::euclidean_ring_operators< T, T, B,::boost::detail::false_t >
 
struct  boost::is_chained_base< ::boost::euclidean_ring_operators< T, U, B, O > >
 
struct  boost::is_chained_base< ::boost::euclidean_ring_operators2< T, U, B > >
 
struct  boost::is_chained_base< ::boost::euclidean_ring_operators1< T, B > >
 
struct  boost::ordered_euclidean_ring_operators< T, U, B, O >
 
struct  boost::ordered_euclidean_ring_operators< T, U, B,::boost::detail::true_t >
 
struct  boost::ordered_euclidean_ring_operators< T, T, B,::boost::detail::false_t >
 
struct  boost::is_chained_base< ::boost::ordered_euclidean_ring_operators< T, U, B, O > >
 
struct  boost::is_chained_base< ::boost::ordered_euclidean_ring_operators2< T, U, B > >
 
struct  boost::is_chained_base< ::boost::ordered_euclidean_ring_operators1< T, B > >
 
struct  boost::is_chained_base< ::boost::input_iteratable< T, U, B > >
 
struct  boost::is_chained_base< ::boost::output_iteratable< T, B > >
 
struct  boost::is_chained_base< ::boost::forward_iteratable< T, U, B > >
 
struct  boost::is_chained_base< ::boost::bidirectional_iteratable< T, U, B > >
 
struct  boost::is_chained_base< ::boost::random_access_iteratable< T, U, V, W, B > >
 
struct  boost::operators2< T, U >
 
struct  boost::operators< T, U >
 
struct  boost::operators< T, T >
 
struct  boost::input_iterator_helper< T, V, D, P, R >
 
struct  boost::output_iterator_helper< T >
 
struct  boost::forward_iterator_helper< T, V, D, P, R >
 
struct  boost::bidirectional_iterator_helper< T, V, D, P, R >
 
struct  boost::random_access_iterator_helper< T, V, D, P, R >
 

Namespaces

 boost
 Duration formatting facet for input.
 
 boost::detail
 

Macros

#define BOOST_OPERATOR2_LEFT(name)   name##2##_##left
 
#define BOOST_BINARY_OPERATOR_COMMUTATIVE(NAME, OP)
 
#define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE(NAME, OP)
 
#define BOOST_BINARY_OPERATOR(NAME, OP)
 
#define BOOST_IMPORT_TEMPLATE4(template_name)
 
#define BOOST_IMPORT_TEMPLATE3(template_name)
 
#define BOOST_IMPORT_TEMPLATE2(template_name)
 
#define BOOST_IMPORT_TEMPLATE1(template_name)
 
#define BOOST_OPERATOR_TEMPLATE4(template_name4)
 
#define BOOST_OPERATOR_TEMPLATE3(template_name3)
 
#define BOOST_OPERATOR_TEMPLATE2(template_name2)
 
#define BOOST_OPERATOR_TEMPLATE1(template_name1)
 
#define BOOST_OPERATOR_TEMPLATE(template_name)
 

Macro Definition Documentation

#define BOOST_BINARY_OPERATOR (   NAME,
  OP 
)
Value:
template <class T, class U, class B = ::boost::detail::empty_base<T> > \
struct NAME##2 : B \
{ \
friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \
}; \
\
template <class T, class B = ::boost::detail::empty_base<T> > \
struct NAME##1 : B \
{ \
friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \
};
T
T
Definition: mem_fn_cc.hpp:25
#define BOOST_BINARY_OPERATOR_COMMUTATIVE (   NAME,
  OP 
)
Value:
template <class T, class U, class B = ::boost::detail::empty_base<T> > \
struct NAME##2 : B \
{ \
friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \
friend T operator OP( const U& lhs, T rhs ) { return rhs OP##= lhs; } \
}; \
\
template <class T, class B = ::boost::detail::empty_base<T> > \
struct NAME##1 : B \
{ \
friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \
};
T
T
Definition: mem_fn_cc.hpp:25
#define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE (   NAME,
  OP 
)
Value:
template <class T, class U, class B = ::boost::detail::empty_base<T> > \
struct NAME##2 : B \
{ \
friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \
}; \
\
template <class T, class U, class B = ::boost::detail::empty_base<T> > \
struct BOOST_OPERATOR2_LEFT(NAME) : B \
{ \
friend T operator OP( const U& lhs, const T& rhs ) \
{ return T( lhs ) OP##= rhs; } \
}; \
\
template <class T, class B = ::boost::detail::empty_base<T> > \
struct NAME##1 : B \
{ \
friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \
};
BOOST_OPERATOR2_LEFT
#define BOOST_OPERATOR2_LEFT(name)
Definition: operators.hpp:156
T
T
Definition: mem_fn_cc.hpp:25
#define BOOST_IMPORT_TEMPLATE1 (   template_name)
#define BOOST_IMPORT_TEMPLATE2 (   template_name)
#define BOOST_IMPORT_TEMPLATE3 (   template_name)
#define BOOST_IMPORT_TEMPLATE4 (   template_name)
#define BOOST_OPERATOR2_LEFT (   name)    name##2##_##left
#define BOOST_OPERATOR_TEMPLATE (   template_name)
Value:
template <class T \
,class U = T \
,class B = ::boost::detail::empty_base<T> \
,class O = typename is_chained_base<U>::value \
> \
struct template_name : template_name##2<T, U, B> {}; \
\
template<class T, class U, class B> \
struct template_name<T, U, B, ::boost::detail::true_t> \
: template_name##1<T, U> {}; \
\
template <class T, class B> \
struct template_name<T, T, B, ::boost::detail::false_t> \
: template_name##1<T, B> {}; \
\
template<class T, class U, class B, class O> \
struct is_chained_base< ::boost::template_name<T, U, B, O> > { \
typedef ::boost::detail::true_t value; \
}; \
\
BOOST_OPERATOR_TEMPLATE2(template_name##2) \
BOOST_OPERATOR_TEMPLATE1(template_name##1)
BOOST_OPERATOR_TEMPLATE1
#define BOOST_OPERATOR_TEMPLATE1(template_name1)
Definition: operators.hpp:758
T
T
Definition: mem_fn_cc.hpp:25
boost::detail::empty_base
Definition: operators.hpp:100
boost::program_options::value
typed_value< T > * value()
Creates a typed_value instance.
BOOST_OPERATOR_TEMPLATE2
#define BOOST_OPERATOR_TEMPLATE2(template_name2)
Definition: operators.hpp:749
#define BOOST_OPERATOR_TEMPLATE1 (   template_name1)
Value:
BOOST_IMPORT_TEMPLATE1(template_name1) \
template<class T, class B> \
struct is_chained_base< ::boost::template_name1<T, B> > { \
typedef ::boost::detail::true_t value; \
};
BOOST_IMPORT_TEMPLATE1
#define BOOST_IMPORT_TEMPLATE1(template_name)
Definition: operators.hpp:664
boost::program_options::value
typed_value< T > * value()
Creates a typed_value instance.
#define BOOST_OPERATOR_TEMPLATE2 (   template_name2)
Value:
BOOST_IMPORT_TEMPLATE2(template_name2) \
template<class T, class U, class B> \
struct is_chained_base< ::boost::template_name2<T, U, B> > { \
typedef ::boost::detail::true_t value; \
};
boost::program_options::value
typed_value< T > * value()
Creates a typed_value instance.
BOOST_IMPORT_TEMPLATE2
#define BOOST_IMPORT_TEMPLATE2(template_name)
Definition: operators.hpp:663
#define BOOST_OPERATOR_TEMPLATE3 (   template_name3)
Value:
BOOST_IMPORT_TEMPLATE3(template_name3) \
template<class T, class U, class V, class B> \
struct is_chained_base< ::boost::template_name3<T, U, V, B> > { \
typedef ::boost::detail::true_t value; \
};
BOOST_IMPORT_TEMPLATE3
#define BOOST_IMPORT_TEMPLATE3(template_name)
Definition: operators.hpp:662
boost::program_options::value
typed_value< T > * value()
Creates a typed_value instance.
#define BOOST_OPERATOR_TEMPLATE4 (   template_name4)
Value:
BOOST_IMPORT_TEMPLATE4(template_name4) \
template<class T, class U, class V, class W, class B> \
struct is_chained_base< ::boost::template_name4<T, U, V, W, B> > { \
typedef ::boost::detail::true_t value; \
};
BOOST_IMPORT_TEMPLATE4
#define BOOST_IMPORT_TEMPLATE4(template_name)
Definition: operators.hpp:661
boost::program_options::value
typed_value< T > * value()
Creates a typed_value instance.