|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r69478 - in sandbox/type_traits: boost/type_traits boost/type_traits/detail libs/type_traits/doc libs/type_traits/doc/html libs/type_traits/doc/html/boost_typetraits libs/type_traits/doc/html/boost_typetraits/category libs/type_traits/doc/html/boost_typetraits/category/value_traits libs/type_traits/doc/html/boost_typetraits/reference
From: frederic.bron_at_[hidden]
Date: 2011-03-02 07:51:33
Author: bronf
Date: 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
New Revision: 69478
URL: http://svn.boost.org/trac/boost/changeset/69478
Log:
operator traits: improvement of the documentation
Added:
sandbox/type_traits/boost/type_traits/operators.hpp (contents, props changed)
Text files modified:
sandbox/type_traits/boost/type_traits/detail/has_binary_operator.hpp | 68 +++++++++--
sandbox/type_traits/boost/type_traits/detail/has_postfix_operator.hpp | 68 +++++++++--
sandbox/type_traits/boost/type_traits/detail/has_prefix_operator.hpp | 69 +++++++++--
sandbox/type_traits/libs/type_traits/doc/has_operator_bit_and.qbk | 9
sandbox/type_traits/libs/type_traits/doc/has_operator_bit_and_equal.qbk | 9
sandbox/type_traits/libs/type_traits/doc/has_operator_bit_or.qbk | 9
sandbox/type_traits/libs/type_traits/doc/has_operator_bit_or_equal.qbk | 9
sandbox/type_traits/libs/type_traits/doc/has_operator_bit_xor.qbk | 9
sandbox/type_traits/libs/type_traits/doc/has_operator_bit_xor_equal.qbk | 9
sandbox/type_traits/libs/type_traits/doc/has_operator_complement.qbk | 12 +-
sandbox/type_traits/libs/type_traits/doc/has_operator_dereference.qbk | 15 +
sandbox/type_traits/libs/type_traits/doc/has_operator_divides.qbk | 7
sandbox/type_traits/libs/type_traits/doc/has_operator_divides_equal.qbk | 7
sandbox/type_traits/libs/type_traits/doc/has_operator_equal_to.qbk | 11 +
sandbox/type_traits/libs/type_traits/doc/has_operator_greater.qbk | 11 +
sandbox/type_traits/libs/type_traits/doc/has_operator_greater_equal.qbk | 11 +
sandbox/type_traits/libs/type_traits/doc/has_operator_left_shift.qbk | 12 +
sandbox/type_traits/libs/type_traits/doc/has_operator_left_shift_equal.qbk | 9
sandbox/type_traits/libs/type_traits/doc/has_operator_less.qbk | 11 +
sandbox/type_traits/libs/type_traits/doc/has_operator_less_equal.qbk | 11 +
sandbox/type_traits/libs/type_traits/doc/has_operator_logical_and.qbk | 10 +
sandbox/type_traits/libs/type_traits/doc/has_operator_logical_not.qbk | 11 +
sandbox/type_traits/libs/type_traits/doc/has_operator_logical_or.qbk | 10 +
sandbox/type_traits/libs/type_traits/doc/has_operator_minus.qbk | 7
sandbox/type_traits/libs/type_traits/doc/has_operator_minus_equal.qbk | 7
sandbox/type_traits/libs/type_traits/doc/has_operator_modulus.qbk | 7
sandbox/type_traits/libs/type_traits/doc/has_operator_modulus_equal.qbk | 7
sandbox/type_traits/libs/type_traits/doc/has_operator_multiplies.qbk | 7
sandbox/type_traits/libs/type_traits/doc/has_operator_multiplies_equal.qbk | 7
sandbox/type_traits/libs/type_traits/doc/has_operator_not_equal_to.qbk | 11 +
sandbox/type_traits/libs/type_traits/doc/has_operator_plus.qbk | 7
sandbox/type_traits/libs/type_traits/doc/has_operator_plus_equal.qbk | 7
sandbox/type_traits/libs/type_traits/doc/has_operator_postfix_decrement.qbk | 13 +-
sandbox/type_traits/libs/type_traits/doc/has_operator_postfix_increment.qbk | 13 +-
sandbox/type_traits/libs/type_traits/doc/has_operator_prefix_decrement.qbk | 13 +-
sandbox/type_traits/libs/type_traits/doc/has_operator_prefix_increment.qbk | 13 +-
sandbox/type_traits/libs/type_traits/doc/has_operator_right_shift.qbk | 12 +
sandbox/type_traits/libs/type_traits/doc/has_operator_right_shift_equal.qbk | 9
sandbox/type_traits/libs/type_traits/doc/has_operator_unary_minus.qbk | 11 -
sandbox/type_traits/libs/type_traits/doc/has_operator_unary_plus.qbk | 11 -
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/background.html | 22 +-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/transform.html | 2
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/value_traits/operators.html | 228 ++++++++++++++++++++++++++++++++++++++-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/intrinsics.html | 2
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_const.html | 2
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_cv.html | 2
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_pointer.html | 2
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_reference.html | 2
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_volatile.html | 2
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/decay.html | 2
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/floating_point_promotion.html | 2
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/function_traits.html | 4
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_and.html | 20 ++-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_and_equal.html | 19 ++-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_or.html | 20 ++-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_or_equal.html | 19 ++-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_xor.html | 20 ++-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_xor_equal.html | 19 ++-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_complement.html | 23 ++-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_dereference.html | 39 +++++-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_divides.html | 16 +-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_divides_equal.html | 16 +-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_equal_to.html | 25 +++-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_greater.html | 25 +++-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_greater_equal.html | 27 +++-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_left_shift.html | 31 ++++-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_left_shift_equal.html | 19 ++-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_less.html | 25 +++-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_less_equal.html | 27 +++-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_logical_and.html | 25 +++-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_logical_not.html | 27 +++-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_logical_or.html | 25 +++-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_minus.html | 16 +-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_minus_equal.html | 16 +-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_modulus.html | 16 +-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_modulus_equal.html | 16 +-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_multiplies.html | 16 +-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_multiplies_equal.html | 16 +-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_not_equal_to.html | 27 +++-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_plus.html | 16 +-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_plus_equal.html | 16 +-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_postfix_decrement.html | 26 +++-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_postfix_increment.html | 26 +++-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_prefix_decrement.html | 26 +++-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_prefix_increment.html | 26 +++-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_right_shift.html | 31 ++++-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_right_shift_equal.html | 19 ++-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_unary_minus.html | 20 ++-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_unary_plus.html | 20 ++-
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/integral_promotion.html | 2
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/make_signed.html | 2
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/make_unsigned.html | 2
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/member_object.html | 2
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/promote.html | 2
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_all_extents.html | 2
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_const.html | 2
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_cv.html | 2
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_extent.html | 2
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_member_pointer.html | 2
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_pointer.html | 2
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_reference.html | 2
sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_volatile.html | 2
sandbox/type_traits/libs/type_traits/doc/html/index.html | 2
sandbox/type_traits/libs/type_traits/doc/operators.qbk | 207 +++++++++++++++++++++++++++++++++++-
104 files changed, 1420 insertions(+), 472 deletions(-)
Modified: sandbox/type_traits/boost/type_traits/detail/has_binary_operator.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/detail/has_binary_operator.hpp (original)
+++ sandbox/type_traits/boost/type_traits/detail/has_binary_operator.hpp 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -49,37 +49,60 @@
// This namespace ensures that ADL does not mess things up.
namespace BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl) {
-// a type returned from comparison operator when no such operator is found in the
-// type's own namespace
+// 1. a function to have an instance of type T without requiring T to be default
+// constructible
+namespace {
+ template <typename T> T &make();
+}
+
+// 2. we provide our operator definition for types that do not have one already
+
+// a type returned from operator BOOST_TT_TRAIT_OP when no such operator is
+// found in the type's own namespace so that we have a means to know that our
+// operator was used
struct tag { };
-// any soaks up implicit conversions and makes the following
-// comparison operators less-preferred than any other such operators that
-// might be found via ADL.
+// this class allows implicit conversions and makes the following operator
+// definition less-preferred than any other such operators that might be found
+// via argument-dependent name lookup
struct any { template <class T> any(T const&); };
// when operator BOOST_TT_TRAIT_OP is not available, this one is used
tag operator BOOST_TT_TRAIT_OP (const any&, const any&);
-namespace {
- template <typename T>
- T &make();
-}
+// 3. if the return type has to be checked, we need to determine if
+// operator BOOST_TT_TRAIT_OP returns void or not
+// we first redefine "operator," so that we have no compilation error if
+// operator BOOST_TT_TRAIT_OP returns void and we can use the return type of
+// (lhs BOOST_TT_TRAIT_OP rhs, returns_void_t()) to deduce if
+// operator BOOST_TT_TRAIT_OP returns void or not:
+// - operator BOOST_TT_TRAIT_OP returns void -> (lhs BOOST_TT_TRAIT_OP rhs, returns_void_t()) returns returns_void_t
+// - operator BOOST_TT_TRAIT_OP returns !=void -> (lhs BOOST_TT_TRAIT_OP rhs, returns_void_t()) returns int
struct returns_void_t {};
template <typename T> int operator,(T const &, returns_void_t);
+// this intermediate trait has member value of type bool:
+// - value==true -> operator BOOST_TT_TRAIT_OP returns void
+// - value==false -> operator BOOST_TT_TRAIT_OP does not return void
template < typename LHS, typename RHS >
struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_returns_void) {
+ // overloads of function returns_void make the difference
+ // yes_type and no_type have different size by construction
static ::boost::type_traits::yes_type returns_void(returns_void_t);
static ::boost::type_traits::no_type returns_void(int);
BOOST_STATIC_CONSTANT(bool, value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<LHS>() BOOST_TT_TRAIT_OP make<RHS>(),returns_void_t())))));
};
+// 4. check for return type when RET is non void
+
+// this class is used only when RET is non void, therefore it is specialized to
+// have its value==false when the operator returns void
template < typename LHS, typename RHS, typename RET, typename RETURNS_VOID >
struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl2);
-// LHS BOOST_TT_TRAIT_OP RHS does not return void, checks if it is convertible to RET
+// operator BOOST_TT_TRAIT_OP does not return void, checks if it is convertible to
+// RET using the sizeof trick based on overload resolution
template < typename LHS, typename RHS, typename RET >
struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl2)< LHS, RHS, RET, ::boost::false_type > {
static ::boost::type_traits::yes_type is_convertible_to_RET(RET); // this version is preferred for types convertible to RET
@@ -88,12 +111,21 @@
BOOST_STATIC_CONSTANT(bool, value=(sizeof(is_convertible_to_RET(make<LHS>() BOOST_TT_TRAIT_OP make<RHS>()))==sizeof(::boost::type_traits::yes_type)));
};
-// LHS BOOST_TT_TRAIT_OP RHS returns void!=RET
+// operator BOOST_TT_TRAIT_OP returns void!=RET -> specialization to return
+// value==false
template < typename LHS, typename RHS, typename RET >
struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl2)< LHS, RHS, RET, ::boost::true_type > {
BOOST_STATIC_CONSTANT(bool, value = false);
};
+// 5. main struct: to avoid any compilation error, this struct behaves
+// differently when:
+// - RET is void or non void
+// - operator BOOST_TT_TRAIT_OP(LHS, RHS) is forbidden by the standard
+// forbidden_if is a bool that is:
+// - true when the operator BOOST_TT_TRAIT_OP(LHS, RHS) is forbidden by the standard
+// (would yield compilation error if used)
+// - false otherwise
template < typename LHS, typename RHS, typename RET, bool forbidden_if >
struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1);
@@ -102,16 +134,19 @@
BOOST_STATIC_CONSTANT(bool, value = false);
};
-// checks for return type if 3rd template parameter RET is non void
+// checks for return type if template parameter RET is non void: use previously
+// defined struct
template < typename LHS, typename RHS, typename RET >
struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1) < LHS, RHS, RET, false > {
BOOST_STATIC_CONSTANT(bool, value = (BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl2)< LHS, RHS, RET, typename ::boost::integral_constant< bool, BOOST_JOIN(BOOST_TT_TRAIT_NAME,_returns_void)< LHS, RHS >::value > >::value));
};
-// in case we do not want to check for return type
+// in case we do not want to check for return type, we still need to know if our
+// definition of operator BOOST_TT_TRAIT_OP is used or an other existing one;
+// this is done with redefinition of "operator," that returns tag or int
tag operator,(tag, int);
-// do not check for return type if 3rd template parameter RET is void
+// do not check for return type if template parameter RET is void
template < typename LHS, typename RHS >
struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1)< LHS, RHS, void, false > {
static ::boost::type_traits::yes_type check(int); // this version is preferred when operator exists
@@ -120,6 +155,7 @@
BOOST_STATIC_CONSTANT(bool, value = (sizeof(check(((make<LHS>() BOOST_TT_TRAIT_OP make<RHS>()),0)))==sizeof(::boost::type_traits::yes_type)));
};
+// some specializations needs to be declared for the special void case
template < typename RHS, typename RET >
struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1)< void, RHS, RET, false > {
BOOST_STATIC_CONSTANT(bool, value = false);
@@ -150,6 +186,7 @@
BOOST_STATIC_CONSTANT(bool, value = false);
};
+// defines some typedef for convenience
template < typename LHS, typename RHS, typename RET >
struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl) {
typedef typename ::boost::remove_reference<LHS>::type lhs_noref;
@@ -162,7 +199,8 @@
} // namespace impl
} // namespace detail
-BOOST_TT_AUX_BOOL_TRAIT_DEF3(BOOST_TT_TRAIT_NAME,LHS,RHS=LHS,RET=BOOST_TT_DEFAULT_RET,(::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)<LHS,RHS,RET>::value))
+// this is the accessible definition of the trait to end user
+BOOST_TT_AUX_BOOL_TRAIT_DEF3(BOOST_TT_TRAIT_NAME, LHS, RHS=LHS, RET=BOOST_TT_DEFAULT_RET, (::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)< LHS, RHS, RET >::value))
} // namespace boost
Modified: sandbox/type_traits/boost/type_traits/detail/has_postfix_operator.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/detail/has_postfix_operator.hpp (original)
+++ sandbox/type_traits/boost/type_traits/detail/has_postfix_operator.hpp 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -27,37 +27,60 @@
// This namespace ensures that ADL does not mess things up.
namespace BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl) {
-// a type returned from comparison operator when no such operator is found in the
-// type's own namespace
+// 1. a function to have an instance of type T without requiring T to be default
+// constructible
+namespace {
+ template <typename T> T &make();
+}
+
+// 2. we provide our operator definition for types that do not have one already
+
+// a type returned from operator BOOST_TT_TRAIT_OP when no such operator is
+// found in the type's own namespace so that we have a means to know that our
+// operator was used
struct tag { };
-// any soaks up implicit conversions and makes the following
-// comparison operators less-preferred than any other such operators that
-// might be found via ADL.
+// this class allows implicit conversions and makes the following operator
+// definition less-preferred than any other such operators that might be found
+// via argument-dependent name lookup
struct any { template <class T> any(T const&); };
// when operator BOOST_TT_TRAIT_OP is not available, this one is used
tag operator BOOST_TT_TRAIT_OP (const any&, int);
-namespace {
- template <typename T>
- T &make();
-}
+// 3. if the return type has to be checked, we need to determine if
+// operator BOOST_TT_TRAIT_OP returns void or not
+// we first redefine "operator," so that we have no compilation error if
+// operator BOOST_TT_TRAIT_OP returns void and we can use the return type of
+// (lhs BOOST_TT_TRAIT_OP, returns_void_t()) to deduce if
+// operator BOOST_TT_TRAIT_OP returns void or not:
+// - operator BOOST_TT_TRAIT_OP returns void -> (lhs BOOST_TT_TRAIT_OP, returns_void_t()) returns returns_void_t
+// - operator BOOST_TT_TRAIT_OP returns !=void -> (lhs BOOST_TT_TRAIT_OP, returns_void_t()) returns int
struct returns_void_t {};
template <typename T> int operator,(T const &, returns_void_t);
+// this intermediate trait has member value of type bool:
+// - value==true -> operator BOOST_TT_TRAIT_OP returns void
+// - value==false -> operator BOOST_TT_TRAIT_OP does not return void
template < typename LHS >
struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_returns_void) {
+ // overloads of function returns_void make the difference
+ // yes_type and no_type have different size by construction
static ::boost::type_traits::yes_type returns_void(returns_void_t);
static ::boost::type_traits::no_type returns_void(int);
BOOST_STATIC_CONSTANT(bool, value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<LHS>() BOOST_TT_TRAIT_OP,returns_void_t())))));
};
+// 4. check for return type when RET is non void
+
+// this class is used only when RET is non void, therefore it is specialized to
+// have its value==false when the operator returns void
template < typename LHS, typename RET, typename RETURNS_VOID >
struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl2);
-// BOOST_TT_TRAIT_OP LHS does not return void, checks if it is convertible to RET
+// operator BOOST_TT_TRAIT_OP does not return void, checks if it is convertible to
+// RET using the sizeof trick based on overload resolution
template < typename LHS, typename RET >
struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl2)< LHS, RET, ::boost::false_type > {
static ::boost::type_traits::yes_type is_convertible_to_RET(RET); // this version is preferred for types convertible to RET
@@ -66,12 +89,21 @@
BOOST_STATIC_CONSTANT(bool, value = (sizeof(is_convertible_to_RET(make<LHS>() BOOST_TT_TRAIT_OP))==sizeof(::boost::type_traits::yes_type)));
};
-// BOOST_TT_TRAIT_OP LHS returns void!=RET
+// operator BOOST_TT_TRAIT_OP returns void!=RET -> specialization to return
+// value==false
template < typename LHS, typename RET >
struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl2)< LHS, RET, ::boost::true_type > {
BOOST_STATIC_CONSTANT(bool, value = false);
};
+// 5. main struct: to avoid any compilation error, this struct behaves
+// differently when:
+// - RET is void or non void
+// - operator BOOST_TT_TRAIT_OP(LHS) is forbidden by the standard
+// forbidden_if is a bool that is:
+// - true when the operator BOOST_TT_TRAIT_OP(LHS) is forbidden by the standard
+// (would yield compilation error if used)
+// - false otherwise
template < typename LHS, typename RET, bool forbidden_if >
struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1);
@@ -80,16 +112,19 @@
BOOST_STATIC_CONSTANT(bool, value = false);
};
-// checks for return type if 2nd template parameter RET is non void
+// checks for return type if template parameter RET is non void: use previously
+// defined struct
template < typename LHS, typename RET >
struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1) < LHS, RET, false > {
BOOST_STATIC_CONSTANT(bool, value = (BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl2)< LHS, RET, typename ::boost::integral_constant< bool, BOOST_JOIN(BOOST_TT_TRAIT_NAME,_returns_void)< LHS >::value > >::value));
};
-// in case we do not want to check for return type
+// in case we do not want to check for return type, we still need to know if our
+// definition of operator BOOST_TT_TRAIT_OP is used or an other existing one;
+// this is done with redefinition of "operator," that returns tag or int
tag operator,(tag, int);
-// do not check for return type if 2nd template parameter RET is void
+// do not check for return type if template parameter RET is void
template < typename LHS >
struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1)< LHS, void, false > {
static ::boost::type_traits::yes_type check(int); // this version is preferred when operator exists
@@ -98,6 +133,7 @@
BOOST_STATIC_CONSTANT(bool, value = (sizeof(check(((make<LHS>() BOOST_TT_TRAIT_OP),0)))==sizeof(::boost::type_traits::yes_type)));
};
+// some specializations needs to be declared for the special void case
template < typename RET >
struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1)< void, RET, false > {
BOOST_STATIC_CONSTANT(bool, value = false);
@@ -108,6 +144,7 @@
BOOST_STATIC_CONSTANT(bool, value = false);
};
+// defines some typedef for convenience
template < typename LHS, typename RET >
struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl) {
typedef typename ::boost::remove_reference<LHS>::type lhs_noref;
@@ -118,7 +155,8 @@
} // namespace impl
} // namespace detail
-BOOST_TT_AUX_BOOL_TRAIT_DEF2(BOOST_TT_TRAIT_NAME,LHS,RET=BOOST_TT_DEFAULT_RET,(::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)<LHS,RET>::value))
+// this is the accessible definition of the trait to end user
+BOOST_TT_AUX_BOOL_TRAIT_DEF2(BOOST_TT_TRAIT_NAME, LHS, RET=BOOST_TT_DEFAULT_RET, (::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)< LHS, RET >::value))
} // namespace boost
Modified: sandbox/type_traits/boost/type_traits/detail/has_prefix_operator.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/detail/has_prefix_operator.hpp (original)
+++ sandbox/type_traits/boost/type_traits/detail/has_prefix_operator.hpp 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -43,37 +43,60 @@
// This namespace ensures that ADL does not mess things up.
namespace BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl) {
-// a type returned from comparison operator when no such operator is found in the
-// type's own namespace
+// 1. a function to have an instance of type T without requiring T to be default
+// constructible
+namespace {
+ template <typename T> T &make();
+}
+
+// 2. we provide our operator definition for types that do not have one already
+
+// a type returned from operator BOOST_TT_TRAIT_OP when no such operator is
+// found in the type's own namespace so that we have a means to know that our
+// operator was used
struct tag { };
-// any soaks up implicit conversions and makes the following
-// comparison operators less-preferred than any other such operators that
-// might be found via ADL.
+// this class allows implicit conversions and makes the following operator
+// definition less-preferred than any other such operators that might be found
+// via argument-dependent name lookup
struct any { template <class T> any(T const&); };
// when operator BOOST_TT_TRAIT_OP is not available, this one is used
tag operator BOOST_TT_TRAIT_OP (const any&);
-namespace {
- template <typename T>
- T &make();
-}
+// 3. if the return type has to be checked, we need to determine if
+// operator BOOST_TT_TRAIT_OP returns void or not
+// we first redefine "operator," so that we have no compilation error if
+// operator BOOST_TT_TRAIT_OP returns void and we can use the return type of
+// (BOOST_TT_TRAIT_OP rhs, returns_void_t()) to deduce if
+// operator BOOST_TT_TRAIT_OP returns void or not:
+// - operator BOOST_TT_TRAIT_OP returns void -> (BOOST_TT_TRAIT_OP rhs, returns_void_t()) returns returns_void_t
+// - operator BOOST_TT_TRAIT_OP returns !=void -> (BOOST_TT_TRAIT_OP rhs, returns_void_t()) returns int
struct returns_void_t {};
template <typename T> int operator,(T const &, returns_void_t);
+// this intermediate trait has member value of type bool:
+// - value==true -> operator BOOST_TT_TRAIT_OP returns void
+// - value==false -> operator BOOST_TT_TRAIT_OP does not return void
template < typename RHS >
struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_returns_void) {
+ // overloads of function returns_void make the difference
+ // yes_type and no_type have different size by construction
static ::boost::type_traits::yes_type returns_void(returns_void_t);
static ::boost::type_traits::no_type returns_void(int);
BOOST_STATIC_CONSTANT(bool, value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((BOOST_TT_TRAIT_OP make<RHS>(),returns_void_t())))));
};
+// 4. check for return type when RET is non void
+
+// this class is used only when RET is non void, therefore it is specialized to
+// have its value==false when the operator returns void
template < typename RHS, typename RET, typename RETURNS_VOID >
struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl2);
-// BOOST_TT_TRAIT_OP RHS does not return void, checks if it is convertible to RET
+// operator BOOST_TT_TRAIT_OP does not return void, checks if it is convertible to
+// RET using the sizeof trick based on overload resolution
template < typename RHS, typename RET >
struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl2)< RHS, RET, ::boost::false_type > {
static ::boost::type_traits::yes_type is_convertible_to_RET(RET); // this version is preferred for types convertible to RET
@@ -82,30 +105,43 @@
BOOST_STATIC_CONSTANT(bool, value = (sizeof(is_convertible_to_RET(BOOST_TT_TRAIT_OP make<RHS>()))==sizeof(::boost::type_traits::yes_type)));
};
-// BOOST_TT_TRAIT_OP RHS returns void!=RET
+// operator BOOST_TT_TRAIT_OP returns void!=RET -> specialization to return
+// value==false
template < typename RHS, typename RET >
struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl2)< RHS, RET, ::boost::true_type > {
BOOST_STATIC_CONSTANT(bool, value = false);
};
+// 5. main struct: to avoid any compilation error, this struct behaves
+// differently when:
+// - RET is void or non void
+// - operator BOOST_TT_TRAIT_OP(RHS) is forbidden by the standard
+// forbidden_if is a bool that is:
+// - true when the operator BOOST_TT_TRAIT_OP(RHS) is forbidden by the standard
+// (would yield compilation error if used)
+// - false otherwise
template < typename RHS, typename RET, bool forbidden_if >
struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1);
+// specialization to avoid compilation error when forbidden by the standard
template < typename RHS, typename RET >
struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1) < RHS, RET, true > {
BOOST_STATIC_CONSTANT(bool, value = false);
};
-// checks for return type if 2nd template parameter RET is non void
+// checks for return type if template parameter RET is non void: use previously
+// defined struct
template < typename RHS, typename RET >
struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1) < RHS, RET, false > {
BOOST_STATIC_CONSTANT(bool, value = (BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl2)< RHS, RET, typename ::boost::integral_constant< bool, BOOST_JOIN(BOOST_TT_TRAIT_NAME,_returns_void)< RHS >::value > >::value));
};
-// in case we do not want to check for return type
+// in case we do not want to check for return type, we still need to know if our
+// definition of operator BOOST_TT_TRAIT_OP is used or an other existing one;
+// this is done with redefinition of "operator," that returns tag or int
tag operator,(tag, int);
-// do not check for return type if 2nd template parameter RET is void
+// do not check for return type if template parameter RET is void
template < typename RHS >
struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1)< RHS, void, false > {
static ::boost::type_traits::yes_type check(int); // this version is preferred when operator exists
@@ -114,6 +150,7 @@
BOOST_STATIC_CONSTANT(bool, value = (sizeof(check(((BOOST_TT_TRAIT_OP make<RHS>()),0)))==sizeof(::boost::type_traits::yes_type)));
};
+// some specializations needs to be declared for the special void case
template < typename RET >
struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1)< void, RET, false > {
BOOST_STATIC_CONSTANT(bool, value = false);
@@ -124,6 +161,7 @@
BOOST_STATIC_CONSTANT(bool, value = false);
};
+// defines some typedef for convenience
template < typename RHS, typename RET >
struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl) {
typedef typename ::boost::remove_reference<RHS>::type rhs_noref;
@@ -134,7 +172,8 @@
} // namespace impl
} // namespace detail
-BOOST_TT_AUX_BOOL_TRAIT_DEF2(BOOST_TT_TRAIT_NAME,RHS,RET=BOOST_TT_DEFAULT_RET,(::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)<RHS,RET>::value))
+// this is the accessible definition of the trait to end user
+BOOST_TT_AUX_BOOL_TRAIT_DEF2(BOOST_TT_TRAIT_NAME, RHS, RET=BOOST_TT_DEFAULT_RET, (::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)< RHS, RET >::value))
} // namespace boost
Added: sandbox/type_traits/boost/type_traits/operators.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/operators.hpp 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -0,0 +1,50 @@
+// (C) Copyright 2009-2011 Frédéric Bron (frederic.bron_at_[hidden])
+//
+// Use, modification and distribution are subject to 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).
+//
+// See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_OPERATORS_HPP_INCLUDED
+#define BOOST_TT_OPERATORS_HPP_INCLUDED
+
+#include <boost/type_traits/has_operator_bit_and_equal.hpp>
+#include <boost/type_traits/has_operator_bit_and.hpp>
+#include <boost/type_traits/has_operator_bit_or_equal.hpp>
+#include <boost/type_traits/has_operator_bit_or.hpp>
+#include <boost/type_traits/has_operator_bit_xor_equal.hpp>
+#include <boost/type_traits/has_operator_bit_xor.hpp>
+#include <boost/type_traits/has_operator_complement.hpp>
+#include <boost/type_traits/has_operator_dereference.hpp>
+#include <boost/type_traits/has_operator_divides_equal.hpp>
+#include <boost/type_traits/has_operator_divides.hpp>
+#include <boost/type_traits/has_operator_equal_to.hpp>
+#include <boost/type_traits/has_operator_greater_equal.hpp>
+#include <boost/type_traits/has_operator_greater.hpp>
+#include <boost/type_traits/has_operator_left_shift_equal.hpp>
+#include <boost/type_traits/has_operator_left_shift.hpp>
+#include <boost/type_traits/has_operator_less_equal.hpp>
+#include <boost/type_traits/has_operator_less.hpp>
+#include <boost/type_traits/has_operator_logical_and.hpp>
+#include <boost/type_traits/has_operator_logical_not.hpp>
+#include <boost/type_traits/has_operator_logical_or.hpp>
+#include <boost/type_traits/has_operator_minus_equal.hpp>
+#include <boost/type_traits/has_operator_minus.hpp>
+#include <boost/type_traits/has_operator_modulus_equal.hpp>
+#include <boost/type_traits/has_operator_modulus.hpp>
+#include <boost/type_traits/has_operator_multiplies_equal.hpp>
+#include <boost/type_traits/has_operator_multiplies.hpp>
+#include <boost/type_traits/has_operator_not_equal_to.hpp>
+#include <boost/type_traits/has_operator_plus_equal.hpp>
+#include <boost/type_traits/has_operator_plus.hpp>
+#include <boost/type_traits/has_operator_postfix_decrement.hpp>
+#include <boost/type_traits/has_operator_postfix_increment.hpp>
+#include <boost/type_traits/has_operator_prefix_decrement.hpp>
+#include <boost/type_traits/has_operator_prefix_increment.hpp>
+#include <boost/type_traits/has_operator_right_shift_equal.hpp>
+#include <boost/type_traits/has_operator_right_shift.hpp>
+#include <boost/type_traits/has_operator_unary_minus.hpp>
+#include <boost/type_traits/has_operator_unary_plus.hpp>
+
+#endif
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_bit_and.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_bit_and.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_bit_and.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of binary `operator&`.
+Be careful that it does not mean that `operator&` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -25,12 +26,12 @@
f(lhs&rhs); // is valid if has_operator_bit_and<LHS, RHS, RET>::value==true
``
-This trait can not detect whether binary `operator&` is public or not:
+This trait cannot detect whether binary `operator&` is public or not:
if `operator&` is defined as a private member of `LHS` then
instantiating `has_operator_bit_and<LHS>` will produce a compiler error.
-For this reason `has_operator_bit_and` can not be used to determine whether a type has a public `operator&` or not.
+For this reason `has_operator_bit_and` cannot be used to determine whether a type has a public `operator&` or not.
-__header `#include <boost/type_traits/has_operator_bit_and.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_bit_and.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
@@ -41,9 +42,9 @@
[:`has_operator_bit_and<long>` inherits from `__true_type`.]
[:`has_operator_bit_and<int, int, int>` inherits from `__true_type`.]
+[:`has_operator_bit_and<const int, int>` inherits from `__true_type`.]
[:`has_operator_bit_and<int, double, bool>` inherits from `__false_type`.]
-
[:`has_operator_bit_and<int, int, std::string>` inherits from `__false_type`.]
[endsect]
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_bit_and_equal.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_bit_and_equal.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_bit_and_equal.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of binary `operator&=`.
+Be careful that it does not mean that `operator&=` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -25,12 +26,12 @@
f(lhs&=rhs); // is valid if has_operator_bit_and_equal<LHS, RHS, RET>::value==true
``
-This trait can not detect whether binary `operator&=` is public or not:
+This trait cannot detect whether binary `operator&=` is public or not:
if `operator&=` is defined as a private member of `LHS` then
instantiating `has_operator_bit_and_equal<LHS>` will produce a compiler error.
-For this reason `has_operator_bit_and_equal` can not be used to determine whether a type has a public `operator&=` or not.
+For this reason `has_operator_bit_and_equal` cannot be used to determine whether a type has a public `operator&=` or not.
-__header `#include <boost/type_traits/has_operator_bit_and_equal.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_bit_and_equal.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
@@ -42,8 +43,8 @@
[:`has_operator_bit_and_equal<int, int, int>` inherits from `__true_type`.]
+[:`has_operator_bit_and_equal<const int, int>` inherits from `__false_type`.]
[:`has_operator_bit_and_equal<int, double, bool>` inherits from `__false_type`.]
-
[:`has_operator_bit_and_equal<int, int, std::string>` inherits from `__false_type`.]
[endsect]
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_bit_or.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_bit_or.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_bit_or.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of binary `operator|`.
+Be careful that it does not mean that `operator|` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -25,12 +26,12 @@
f(lhs|rhs); // is valid if has_operator_bit_or<LHS, RHS, RET>::value==true
``
-This trait can not detect whether binary `operator|` is public or not:
+This trait cannot detect whether binary `operator|` is public or not:
if `operator|` is defined as a private member of `LHS` then
instantiating `has_operator_bit_or<LHS>` will produce a compiler error.
-For this reason `has_operator_bit_or` can not be used to determine whether a type has a public `operator|` or not.
+For this reason `has_operator_bit_or` cannot be used to determine whether a type has a public `operator|` or not.
-__header `#include <boost/type_traits/has_operator_bit_or.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_bit_or.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
@@ -41,9 +42,9 @@
[:`has_operator_bit_or<long>` inherits from `__true_type`.]
[:`has_operator_bit_or<int, int, int>` inherits from `__true_type`.]
+[:`has_operator_bit_or<const int, int>` inherits from `__true_type`.]
[:`has_operator_bit_or<int, double, bool>` inherits from `__false_type`.]
-
[:`has_operator_bit_or<int, int, std::string>` inherits from `__false_type`.]
[endsect]
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_bit_or_equal.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_bit_or_equal.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_bit_or_equal.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of binary `operator|=`.
+Be careful that it does not mean that `operator|=` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -25,12 +26,12 @@
f(lhs|=rhs); // is valid if has_operator_bit_or_equal<LHS, RHS, RET>::value==true
``
-This trait can not detect whether binary `operator|=` is public or not:
+This trait cannot detect whether binary `operator|=` is public or not:
if `operator|=` is defined as a private member of `LHS` then
instantiating `has_operator_bit_or_equal<LHS>` will produce a compiler error.
-For this reason `has_operator_bit_or_equal` can not be used to determine whether a type has a public `operator|=` or not.
+For this reason `has_operator_bit_or_equal` cannot be used to determine whether a type has a public `operator|=` or not.
-__header `#include <boost/type_traits/has_operator_bit_or_equal.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_bit_or_equal.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
@@ -42,8 +43,8 @@
[:`has_operator_bit_or_equal<int, int, int>` inherits from `__true_type`.]
+[:`has_operator_bit_or_equal<const int, int>` inherits from `__false_type`.]
[:`has_operator_bit_or_equal<int, double, bool>` inherits from `__false_type`.]
-
[:`has_operator_bit_or_equal<int, int, std::string>` inherits from `__false_type`.]
[endsect]
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_bit_xor.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_bit_xor.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_bit_xor.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of binary `operator^`.
+Be careful that it does not mean that `operator^` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -25,12 +26,12 @@
f(lhs^rhs); // is valid if has_operator_bit_xor<LHS, RHS, RET>::value==true
``
-This trait can not detect whether binary `operator^` is public or not:
+This trait cannot detect whether binary `operator^` is public or not:
if `operator^` is defined as a private member of `LHS` then
instantiating `has_operator_bit_xor<LHS>` will produce a compiler error.
-For this reason `has_operator_bit_xor` can not be used to determine whether a type has a public `operator^` or not.
+For this reason `has_operator_bit_xor` cannot be used to determine whether a type has a public `operator^` or not.
-__header `#include <boost/type_traits/has_operator_bit_xor.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_bit_xor.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
@@ -41,9 +42,9 @@
[:`has_operator_bit_xor<long>` inherits from `__true_type`.]
[:`has_operator_bit_xor<int, int, int>` inherits from `__true_type`.]
+[:`has_operator_bit_xor<const int, int>` inherits from `__true_type`.]
[:`has_operator_bit_xor<int, double, bool>` inherits from `__false_type`.]
-
[:`has_operator_bit_xor<int, int, std::string>` inherits from `__false_type`.]
[endsect]
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_bit_xor_equal.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_bit_xor_equal.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_bit_xor_equal.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of binary `operator^=`.
+Be careful that it does not mean that `operator^=` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -25,12 +26,12 @@
f(lhs^=rhs); // is valid if has_operator_bit_xor_equal<LHS, RHS, RET>::value==true
``
-This trait can not detect whether binary `operator^=` is public or not:
+This trait cannot detect whether binary `operator^=` is public or not:
if `operator^=` is defined as a private member of `LHS` then
instantiating `has_operator_bit_xor_equal<LHS>` will produce a compiler error.
-For this reason `has_operator_bit_xor_equal` can not be used to determine whether a type has a public `operator^=` or not.
+For this reason `has_operator_bit_xor_equal` cannot be used to determine whether a type has a public `operator^=` or not.
-__header `#include <boost/type_traits/has_operator_bit_xor_equal.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_bit_xor_equal.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
@@ -42,8 +43,8 @@
[:`has_operator_bit_xor_equal<int, int, int>` inherits from `__true_type`.]
+[:`has_operator_bit_xor_equal<const int, int>` inherits from `__false_type`.]
[:`has_operator_bit_xor_equal<int, double, bool>` inherits from `__false_type`.]
-
[:`has_operator_bit_xor_equal<int, int, std::string>` inherits from `__false_type`.]
[endsect]
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_complement.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_complement.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_complement.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of prefix `operator~`.
+Be careful that it does not mean that `operator~` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -24,12 +25,12 @@
f(~rhs); // is valid if has_operator_complement<RHS, RET>::value==true
``
-This trait can not detect whether prefix `operator~` is public or not:
+This trait cannot detect whether prefix `operator~` is public or not:
if `operator~` is defined as a private member of `RHS` then
instantiating `has_operator_complement<RHS>` will produce a compiler error.
-For this reason `has_operator_complement` can not be used to determine whether a type has a public `operator~` or not.
+For this reason `has_operator_complement` cannot be used to determine whether a type has a public `operator~` or not.
-__header `#include <boost/type_traits/has_operator_complement.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_complement.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
@@ -40,13 +41,12 @@
[:`has_operator_complement<long>` inherits from `__true_type`.]
[:`has_operator_complement<int, int>` inherits from `__true_type`.]
-
[:`has_operator_complement<int, long>` inherits from `__true_type`.]
+[:`has_operator_complement<const int>` inherits from `__true_type`.]
+[:`has_operator_complement<int*>` inherits from `__false_type`.]
[:`has_operator_complement<double, double>` inherits from `__false_type`.]
-
[:`has_operator_complement<double, int>` inherits from `__false_type`.]
-
[:`has_operator_complement<int, std::string>` inherits from `__false_type`.]
[endsect]
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_dereference.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_dereference.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_dereference.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of prefix `operator*`.
+Be careful that it does not mean that `operator*` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -24,12 +25,12 @@
f(*rhs); // is valid if has_operator_dereference<RHS, RET>::value==true
``
-This trait can not detect whether prefix `operator*` is public or not:
+This trait cannot detect whether prefix `operator*` is public or not:
if `operator*` is defined as a private member of `RHS` then
instantiating `has_operator_dereference<RHS>` will produce a compiler error.
-For this reason `has_operator_dereference` can not be used to determine whether a type has a public `operator*` or not.
+For this reason `has_operator_dereference` cannot be used to determine whether a type has a public `operator*` or not.
-__header `#include <boost/type_traits/has_operator_dereference.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_dereference.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
@@ -39,10 +40,16 @@
[:`has_operator_dereference<int*>::value` is a `bool` integral constant expression that evaluates to `true`.]
[:`has_operator_dereference<long*>` inherits from `__true_type`.]
-[:`has_operator_dereference<int>` inherits from `__false_type`.]
+[:`has_operator_dereference<int*, int>` inherits from `__true_type`.]
[:`has_operator_dereference<int*, const int>` inherits from `__true_type`.]
+[:`has_operator_dereference<int const *>` inherits from `__true_type`.]
+[:`has_operator_dereference<int * const>` inherits from `__true_type`.]
+[:`has_operator_dereference<int const * const>` inherits from `__true_type`.]
+[:`has_operator_dereference<int>` inherits from `__false_type`.]
+[:`has_operator_dereference<double>` inherits from `__false_type`.]
+[:`has_operator_dereference<void*>` inherits from `__false_type`.]
[:`has_operator_dereference<const int*, int&>` inherits from `__false_type`.]
[endsect]
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_divides.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_divides.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_divides.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of binary `operator/`.
+Be careful that it does not mean that `operator/` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -25,12 +26,12 @@
f(lhs/rhs); // is valid if has_operator_divides<LHS, RHS, RET>::value==true
``
-This trait can not detect whether binary `operator/` is public or not:
+This trait cannot detect whether binary `operator/` is public or not:
if `operator/` is defined as a private member of `LHS` then
instantiating `has_operator_divides<LHS>` will produce a compiler error.
-For this reason `has_operator_divides` can not be used to determine whether a type has a public `operator/` or not.
+For this reason `has_operator_divides` cannot be used to determine whether a type has a public `operator/` or not.
-__header `#include <boost/type_traits/has_operator_divides.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_divides.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_divides_equal.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_divides_equal.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_divides_equal.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of binary `operator/=`.
+Be careful that it does not mean that `operator/=` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -25,12 +26,12 @@
f(lhs/=rhs); // is valid if has_operator_divides_equal<LHS, RHS, RET>::value==true
``
-This trait can not detect whether binary `operator/=` is public or not:
+This trait cannot detect whether binary `operator/=` is public or not:
if `operator/=` is defined as a private member of `LHS` then
instantiating `has_operator_divides_equal<LHS>` will produce a compiler error.
-For this reason `has_operator_divides_equal` can not be used to determine whether a type has a public `operator/=` or not.
+For this reason `has_operator_divides_equal` cannot be used to determine whether a type has a public `operator/=` or not.
-__header `#include <boost/type_traits/has_operator_divides_equal.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_divides_equal.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_equal_to.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_equal_to.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_equal_to.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of binary `operator==`.
+Be careful that it does not mean that `operator==` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -25,12 +26,12 @@
f(lhs==rhs); // is valid if has_operator_equal_to<LHS, RHS, RET>::value==true
``
-This trait can not detect whether binary `operator==` is public or not:
+This trait cannot detect whether binary `operator==` is public or not:
if `operator==` is defined as a private member of `LHS` then
instantiating `has_operator_equal_to<LHS>` will produce a compiler error.
-For this reason `has_operator_equal_to` can not be used to determine whether a type has a public `operator==` or not.
+For this reason `has_operator_equal_to` cannot be used to determine whether a type has a public `operator==` or not.
-__header `#include <boost/type_traits/has_operator_equal_to.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_equal_to.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
@@ -41,9 +42,11 @@
[:`has_operator_equal_to<long>` inherits from `__true_type`.]
[:`has_operator_equal_to<int, int, bool>` inherits from `__true_type`.]
-
[:`has_operator_equal_to<int, double, bool>` inherits from `__true_type`.]
+[:`has_operator_equal_to<const int>` inherits from `__true_type`.]
+[:`has_operator_equal_to<int*, int>` inherits from `__false_type`.]
+[:`has_operator_equal_to<int*, double*>` inherits from `__false_type`.]
[:`has_operator_equal_to<int, int, std::string>` inherits from `__false_type`.]
[endsect]
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_greater.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_greater.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_greater.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of binary `operator>`.
+Be careful that it does not mean that `operator>` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -25,12 +26,12 @@
f(lhs>rhs); // is valid if has_operator_greater<LHS, RHS, RET>::value==true
``
-This trait can not detect whether binary `operator>` is public or not:
+This trait cannot detect whether binary `operator>` is public or not:
if `operator>` is defined as a private member of `LHS` then
instantiating `has_operator_greater<LHS>` will produce a compiler error.
-For this reason `has_operator_greater` can not be used to determine whether a type has a public `operator>` or not.
+For this reason `has_operator_greater` cannot be used to determine whether a type has a public `operator>` or not.
-__header `#include <boost/type_traits/has_operator_greater.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_greater.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
@@ -41,9 +42,11 @@
[:`has_operator_greater<long>` inherits from `__true_type`.]
[:`has_operator_greater<int, int, bool>` inherits from `__true_type`.]
-
[:`has_operator_greater<int, double, bool>` inherits from `__true_type`.]
+[:`has_operator_greater<const int>` inherits from `__true_type`.]
+[:`has_operator_greater<int*, int>` inherits from `__false_type`.]
+[:`has_operator_greater<int*, double*>` inherits from `__false_type`.]
[:`has_operator_greater<int, int, std::string>` inherits from `__false_type`.]
[endsect]
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_greater_equal.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_greater_equal.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_greater_equal.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of binary `operator>=`.
+Be careful that it does not mean that `operator>=` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -25,12 +26,12 @@
f(lhs>=rhs); // is valid if has_operator_greater_equal<LHS, RHS, RET>::value==true
``
-This trait can not detect whether binary `operator>=` is public or not:
+This trait cannot detect whether binary `operator>=` is public or not:
if `operator>=` is defined as a private member of `LHS` then
instantiating `has_operator_greater_equal<LHS>` will produce a compiler error.
-For this reason `has_operator_greater_equal` can not be used to determine whether a type has a public `operator>=` or not.
+For this reason `has_operator_greater_equal` cannot be used to determine whether a type has a public `operator>=` or not.
-__header `#include <boost/type_traits/has_operator_greater_equal.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_greater_equal.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
@@ -41,9 +42,11 @@
[:`has_operator_greater_equal<long>` inherits from `__true_type`.]
[:`has_operator_greater_equal<int, int, bool>` inherits from `__true_type`.]
-
[:`has_operator_greater_equal<int, double, bool>` inherits from `__true_type`.]
+[:`has_operator_greater_equal<const int>` inherits from `__true_type`.]
+[:`has_operator_greater_equal<int*, int>` inherits from `__false_type`.]
+[:`has_operator_greater_equal<int*, double*>` inherits from `__false_type`.]
[:`has_operator_greater_equal<int, int, std::string>` inherits from `__false_type`.]
[endsect]
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_left_shift.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_left_shift.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_left_shift.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of binary `operator<<`.
+Be careful that it does not mean that `operator<<` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -25,12 +26,12 @@
f(lhs<<rhs); // is valid if has_operator_left_shift<LHS, RHS, RET>::value==true
``
-This trait can not detect whether binary `operator<<` is public or not:
+This trait cannot detect whether binary `operator<<` is public or not:
if `operator<<` is defined as a private member of `LHS` then
instantiating `has_operator_left_shift<LHS>` will produce a compiler error.
-For this reason `has_operator_left_shift` can not be used to determine whether a type has a public `operator<<` or not.
+For this reason `has_operator_left_shift` cannot be used to determine whether a type has a public `operator<<` or not.
-__header `#include <boost/type_traits/has_operator_left_shift.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_left_shift.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
@@ -41,9 +42,12 @@
[:`has_operator_left_shift<long>` inherits from `__true_type`.]
[:`has_operator_left_shift<int, int, int>` inherits from `__true_type`.]
+[:`has_operator_left_shift<const int, int>` inherits from `__true_type`.]
+[:`has_operator_left_shift<std::ostream, int>` inherits from `__true_type`.]
+[:`has_operator_left_shift<std::ostream, char*, std::ostream>` inherits from `__true_type`.]
+[:`has_operator_left_shift<std::ostream, std::string>` inherits from `__true_type`.]
[:`has_operator_left_shift<int, double, bool>` inherits from `__false_type`.]
-
[:`has_operator_left_shift<int, int, std::string>` inherits from `__false_type`.]
[endsect]
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_left_shift_equal.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_left_shift_equal.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_left_shift_equal.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of binary `operator<<=`.
+Be careful that it does not mean that `operator<<=` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -25,12 +26,12 @@
f(lhs<<=rhs); // is valid if has_operator_left_shift_equal<LHS, RHS, RET>::value==true
``
-This trait can not detect whether binary `operator<<=` is public or not:
+This trait cannot detect whether binary `operator<<=` is public or not:
if `operator<<=` is defined as a private member of `LHS` then
instantiating `has_operator_left_shift_equal<LHS>` will produce a compiler error.
-For this reason `has_operator_left_shift_equal` can not be used to determine whether a type has a public `operator<<=` or not.
+For this reason `has_operator_left_shift_equal` cannot be used to determine whether a type has a public `operator<<=` or not.
-__header `#include <boost/type_traits/has_operator_left_shift_equal.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_left_shift_equal.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
@@ -42,8 +43,8 @@
[:`has_operator_left_shift_equal<int, int, int>` inherits from `__true_type`.]
+[:`has_operator_left_shift_equal<const int, int>` inherits from `__false_type`.]
[:`has_operator_left_shift_equal<int, double, bool>` inherits from `__false_type`.]
-
[:`has_operator_left_shift_equal<int, int, std::string>` inherits from `__false_type`.]
[endsect]
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_less.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_less.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_less.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of binary `operator<`.
+Be careful that it does not mean that `operator<` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -25,12 +26,12 @@
f(lhs<rhs); // is valid if has_operator_less<LHS, RHS, RET>::value==true
``
-This trait can not detect whether binary `operator<` is public or not:
+This trait cannot detect whether binary `operator<` is public or not:
if `operator<` is defined as a private member of `LHS` then
instantiating `has_operator_less<LHS>` will produce a compiler error.
-For this reason `has_operator_less` can not be used to determine whether a type has a public `operator<` or not.
+For this reason `has_operator_less` cannot be used to determine whether a type has a public `operator<` or not.
-__header `#include <boost/type_traits/has_operator_less.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_less.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
@@ -41,9 +42,11 @@
[:`has_operator_less<long>` inherits from `__true_type`.]
[:`has_operator_less<int, int, bool>` inherits from `__true_type`.]
-
[:`has_operator_less<int, double, bool>` inherits from `__true_type`.]
+[:`has_operator_less<const int>` inherits from `__true_type`.]
+[:`has_operator_less<int*, int>` inherits from `__false_type`.]
+[:`has_operator_less<int*, double*>` inherits from `__false_type`.]
[:`has_operator_less<int, int, std::string>` inherits from `__false_type`.]
[endsect]
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_less_equal.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_less_equal.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_less_equal.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of binary `operator<=`.
+Be careful that it does not mean that `operator<=` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -25,12 +26,12 @@
f(lhs<=rhs); // is valid if has_operator_less_equal<LHS, RHS, RET>::value==true
``
-This trait can not detect whether binary `operator<=` is public or not:
+This trait cannot detect whether binary `operator<=` is public or not:
if `operator<=` is defined as a private member of `LHS` then
instantiating `has_operator_less_equal<LHS>` will produce a compiler error.
-For this reason `has_operator_less_equal` can not be used to determine whether a type has a public `operator<=` or not.
+For this reason `has_operator_less_equal` cannot be used to determine whether a type has a public `operator<=` or not.
-__header `#include <boost/type_traits/has_operator_less_equal.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_less_equal.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
@@ -41,9 +42,11 @@
[:`has_operator_less_equal<long>` inherits from `__true_type`.]
[:`has_operator_less_equal<int, int, bool>` inherits from `__true_type`.]
-
[:`has_operator_less_equal<int, double, bool>` inherits from `__true_type`.]
+[:`has_operator_less_equal<const int>` inherits from `__true_type`.]
+[:`has_operator_less_equal<int*, int>` inherits from `__false_type`.]
+[:`has_operator_less_equal<int*, double*>` inherits from `__false_type`.]
[:`has_operator_less_equal<int, int, std::string>` inherits from `__false_type`.]
[endsect]
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_logical_and.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_logical_and.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_logical_and.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of binary `operator&&`.
+Be careful that it does not mean that `operator&&` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -25,12 +26,12 @@
f(lhs&&rhs); // is valid if has_operator_logical_and<LHS, RHS, RET>::value==true
``
-This trait can not detect whether binary `operator&&` is public or not:
+This trait cannot detect whether binary `operator&&` is public or not:
if `operator&&` is defined as a private member of `LHS` then
instantiating `has_operator_logical_and<LHS>` will produce a compiler error.
-For this reason `has_operator_logical_and` can not be used to determine whether a type has a public `operator&&` or not.
+For this reason `has_operator_logical_and` cannot be used to determine whether a type has a public `operator&&` or not.
-__header `#include <boost/type_traits/has_operator_logical_and.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_logical_and.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
@@ -41,8 +42,9 @@
[:`has_operator_logical_and<bool>` inherits from `__true_type`.]
[:`has_operator_logical_and<int, int, bool>` inherits from `__true_type`.]
-
+[:`has_operator_logical_and<int, int, long>` inherits from `__true_type`.]
[:`has_operator_logical_and<int, double, bool>` inherits from `__true_type`.]
+[:`has_operator_logical_and<const int, int>::value` inherits from `__true_type`.]
[:`has_operator_logical_and<int, int, std::string>` inherits from `__false_type`.]
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_logical_not.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_logical_not.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_logical_not.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of prefix `operator!`.
+Be careful that it does not mean that `operator!` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -24,12 +25,12 @@
f(!rhs); // is valid if has_operator_logical_not<RHS, RET>::value==true
``
-This trait can not detect whether prefix `operator!` is public or not:
+This trait cannot detect whether prefix `operator!` is public or not:
if `operator!` is defined as a private member of `RHS` then
instantiating `has_operator_logical_not<RHS>` will produce a compiler error.
-For this reason `has_operator_logical_not` can not be used to determine whether a type has a public `operator!` or not.
+For this reason `has_operator_logical_not` cannot be used to determine whether a type has a public `operator!` or not.
-__header `#include <boost/type_traits/has_operator_logical_not.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_logical_not.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
@@ -40,8 +41,10 @@
[:`has_operator_logical_not<bool>` inherits from `__true_type`.]
[:`has_operator_logical_not<int, bool>` inherits from `__true_type`.]
-
+[:`has_operator_logical_not<int, long>` inherits from `__true_type`.]
+[:`has_operator_logical_not<double, double>` inherits from `__true_type`.]
[:`has_operator_logical_not<double, bool>` inherits from `__true_type`.]
+[:`has_operator_logical_not<const bool>` inherits from `__true_type`.]
[:`has_operator_logical_not<int, std::string>` inherits from `__false_type`.]
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_logical_or.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_logical_or.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_logical_or.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of binary `operator||`.
+Be careful that it does not mean that `operator||` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -25,12 +26,12 @@
f(lhs||rhs); // is valid if has_operator_logical_or<LHS, RHS, RET>::value==true
``
-This trait can not detect whether binary `operator||` is public or not:
+This trait cannot detect whether binary `operator||` is public or not:
if `operator||` is defined as a private member of `LHS` then
instantiating `has_operator_logical_or<LHS>` will produce a compiler error.
-For this reason `has_operator_logical_or` can not be used to determine whether a type has a public `operator||` or not.
+For this reason `has_operator_logical_or` cannot be used to determine whether a type has a public `operator||` or not.
-__header `#include <boost/type_traits/has_operator_logical_or.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_logical_or.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
@@ -41,8 +42,9 @@
[:`has_operator_logical_or<bool>` inherits from `__true_type`.]
[:`has_operator_logical_or<int, int, bool>` inherits from `__true_type`.]
-
+[:`has_operator_logical_or<int, int, long>` inherits from `__true_type`.]
[:`has_operator_logical_or<int, double, bool>` inherits from `__true_type`.]
+[:`has_operator_logical_or<const int, int>::value` inherits from `__true_type`.]
[:`has_operator_logical_or<int, int, std::string>` inherits from `__false_type`.]
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_minus.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_minus.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_minus.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of binary `operator-`.
+Be careful that it does not mean that `operator-` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -25,12 +26,12 @@
f(lhs-rhs); // is valid if has_operator_minus<LHS, RHS, RET>::value==true
``
-This trait can not detect whether binary `operator-` is public or not:
+This trait cannot detect whether binary `operator-` is public or not:
if `operator-` is defined as a private member of `LHS` then
instantiating `has_operator_minus<LHS>` will produce a compiler error.
-For this reason `has_operator_minus` can not be used to determine whether a type has a public `operator-` or not.
+For this reason `has_operator_minus` cannot be used to determine whether a type has a public `operator-` or not.
-__header `#include <boost/type_traits/has_operator_minus.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_minus.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_minus_equal.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_minus_equal.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_minus_equal.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of binary `operator-=`.
+Be careful that it does not mean that `operator-=` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -25,12 +26,12 @@
f(lhs-=rhs); // is valid if has_operator_minus_equal<LHS, RHS, RET>::value==true
``
-This trait can not detect whether binary `operator-=` is public or not:
+This trait cannot detect whether binary `operator-=` is public or not:
if `operator-=` is defined as a private member of `LHS` then
instantiating `has_operator_minus_equal<LHS>` will produce a compiler error.
-For this reason `has_operator_minus_equal` can not be used to determine whether a type has a public `operator-=` or not.
+For this reason `has_operator_minus_equal` cannot be used to determine whether a type has a public `operator-=` or not.
-__header `#include <boost/type_traits/has_operator_minus_equal.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_minus_equal.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_modulus.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_modulus.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_modulus.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of binary `operator%`.
+Be careful that it does not mean that `operator%` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -25,12 +26,12 @@
f(lhs%rhs); // is valid if has_operator_modulus<LHS, RHS, RET>::value==true
``
-This trait can not detect whether binary `operator%` is public or not:
+This trait cannot detect whether binary `operator%` is public or not:
if `operator%` is defined as a private member of `LHS` then
instantiating `has_operator_modulus<LHS>` will produce a compiler error.
-For this reason `has_operator_modulus` can not be used to determine whether a type has a public `operator%` or not.
+For this reason `has_operator_modulus` cannot be used to determine whether a type has a public `operator%` or not.
-__header `#include <boost/type_traits/has_operator_modulus.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_modulus.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_modulus_equal.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_modulus_equal.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_modulus_equal.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of binary `operator%=`.
+Be careful that it does not mean that `operator%=` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -25,12 +26,12 @@
f(lhs%=rhs); // is valid if has_operator_modulus_equal<LHS, RHS, RET>::value==true
``
-This trait can not detect whether binary `operator%=` is public or not:
+This trait cannot detect whether binary `operator%=` is public or not:
if `operator%=` is defined as a private member of `LHS` then
instantiating `has_operator_modulus_equal<LHS>` will produce a compiler error.
-For this reason `has_operator_modulus_equal` can not be used to determine whether a type has a public `operator%=` or not.
+For this reason `has_operator_modulus_equal` cannot be used to determine whether a type has a public `operator%=` or not.
-__header `#include <boost/type_traits/has_operator_modulus_equal.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_modulus_equal.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_multiplies.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_multiplies.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_multiplies.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of binary `operator*`.
+Be careful that it does not mean that `operator*` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -25,12 +26,12 @@
f(lhs*rhs); // is valid if has_operator_multiplies<LHS, RHS, RET>::value==true
``
-This trait can not detect whether binary `operator*` is public or not:
+This trait cannot detect whether binary `operator*` is public or not:
if `operator*` is defined as a private member of `LHS` then
instantiating `has_operator_multiplies<LHS>` will produce a compiler error.
-For this reason `has_operator_multiplies` can not be used to determine whether a type has a public `operator*` or not.
+For this reason `has_operator_multiplies` cannot be used to determine whether a type has a public `operator*` or not.
-__header `#include <boost/type_traits/has_operator_multiplies.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_multiplies.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_multiplies_equal.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_multiplies_equal.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_multiplies_equal.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of binary `operator*=`.
+Be careful that it does not mean that `operator*=` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -25,12 +26,12 @@
f(lhs*=rhs); // is valid if has_operator_multiplies_equal<LHS, RHS, RET>::value==true
``
-This trait can not detect whether binary `operator*=` is public or not:
+This trait cannot detect whether binary `operator*=` is public or not:
if `operator*=` is defined as a private member of `LHS` then
instantiating `has_operator_multiplies_equal<LHS>` will produce a compiler error.
-For this reason `has_operator_multiplies_equal` can not be used to determine whether a type has a public `operator*=` or not.
+For this reason `has_operator_multiplies_equal` cannot be used to determine whether a type has a public `operator*=` or not.
-__header `#include <boost/type_traits/has_operator_multiplies_equal.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_multiplies_equal.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_not_equal_to.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_not_equal_to.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_not_equal_to.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of binary `operator!=`.
+Be careful that it does not mean that `operator!=` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -25,12 +26,12 @@
f(lhs!=rhs); // is valid if has_operator_not_equal_to<LHS, RHS, RET>::value==true
``
-This trait can not detect whether binary `operator!=` is public or not:
+This trait cannot detect whether binary `operator!=` is public or not:
if `operator!=` is defined as a private member of `LHS` then
instantiating `has_operator_not_equal_to<LHS>` will produce a compiler error.
-For this reason `has_operator_not_equal_to` can not be used to determine whether a type has a public `operator!=` or not.
+For this reason `has_operator_not_equal_to` cannot be used to determine whether a type has a public `operator!=` or not.
-__header `#include <boost/type_traits/has_operator_not_equal_to.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_not_equal_to.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
@@ -41,9 +42,11 @@
[:`has_operator_not_equal_to<long>` inherits from `__true_type`.]
[:`has_operator_not_equal_to<int, int, bool>` inherits from `__true_type`.]
-
[:`has_operator_not_equal_to<int, double, bool>` inherits from `__true_type`.]
+[:`has_operator_not_equal_to<const int>` inherits from `__true_type`.]
+[:`has_operator_not_equal_to<int*, int>` inherits from `__false_type`.]
+[:`has_operator_not_equal_to<int*, double*>` inherits from `__false_type`.]
[:`has_operator_not_equal_to<int, int, std::string>` inherits from `__false_type`.]
[endsect]
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_plus.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_plus.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_plus.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of binary `operator+`.
+Be careful that it does not mean that `operator+` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -25,12 +26,12 @@
f(lhs+rhs); // is valid if has_operator_plus<LHS, RHS, RET>::value==true
``
-This trait can not detect whether binary `operator+` is public or not:
+This trait cannot detect whether binary `operator+` is public or not:
if `operator+` is defined as a private member of `LHS` then
instantiating `has_operator_plus<LHS>` will produce a compiler error.
-For this reason `has_operator_plus` can not be used to determine whether a type has a public `operator+` or not.
+For this reason `has_operator_plus` cannot be used to determine whether a type has a public `operator+` or not.
-__header `#include <boost/type_traits/has_operator_plus.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_plus.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_plus_equal.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_plus_equal.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_plus_equal.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of binary `operator+=`.
+Be careful that it does not mean that `operator+=` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -25,12 +26,12 @@
f(lhs+=rhs); // is valid if has_operator_plus_equal<LHS, RHS, RET>::value==true
``
-This trait can not detect whether binary `operator+=` is public or not:
+This trait cannot detect whether binary `operator+=` is public or not:
if `operator+=` is defined as a private member of `LHS` then
instantiating `has_operator_plus_equal<LHS>` will produce a compiler error.
-For this reason `has_operator_plus_equal` can not be used to determine whether a type has a public `operator+=` or not.
+For this reason `has_operator_plus_equal` cannot be used to determine whether a type has a public `operator+=` or not.
-__header `#include <boost/type_traits/has_operator_plus_equal.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_plus_equal.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_postfix_decrement.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_postfix_decrement.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_postfix_decrement.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of postfix `operator--`.
+Be careful that it does not mean that `operator--` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -24,12 +25,12 @@
f(lhs--); // is valid if has_operator_postfix_decrement<LHS, RET>::value==true
``
-This trait can not detect whether postfix `operator--` is public or not:
+This trait cannot detect whether postfix `operator--` is public or not:
if `operator--` is defined as a private member of `LHS` then
instantiating `has_operator_postfix_decrement<LHS>` will produce a compiler error.
-For this reason `has_operator_postfix_decrement` can not be used to determine whether a type has a public `operator--` or not.
+For this reason `has_operator_postfix_decrement` cannot be used to determine whether a type has a public `operator--` or not.
-__header `#include <boost/type_traits/has_operator_postfix_decrement.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_postfix_decrement.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
@@ -40,13 +41,13 @@
[:`has_operator_postfix_decrement<long>` inherits from `__true_type`.]
[:`has_operator_postfix_decrement<int, int>` inherits from `__true_type`.]
-
[:`has_operator_postfix_decrement<int, long>` inherits from `__true_type`.]
-
[:`has_operator_postfix_decrement<double, double>` inherits from `__true_type`.]
-
[:`has_operator_postfix_decrement<double, int>` inherits from `__true_type`.]
+[:`has_operator_postfix_decrement<bool>` inherits from `__false_type`.]
+[:`has_operator_postfix_decrement<const int>` inherits from `__false_type`.]
+[:`has_operator_postfix_decrement<void*>` inherits from `__false_type`.]
[:`has_operator_postfix_decrement<int, std::string>` inherits from `__false_type`.]
[endsect]
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_postfix_increment.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_postfix_increment.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_postfix_increment.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of postfix `operator++`.
+Be careful that it does not mean that `operator++` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -24,12 +25,12 @@
f(lhs++); // is valid if has_operator_postfix_increment<LHS, RET>::value==true
``
-This trait can not detect whether postfix `operator++` is public or not:
+This trait cannot detect whether postfix `operator++` is public or not:
if `operator++` is defined as a private member of `LHS` then
instantiating `has_operator_postfix_increment<LHS>` will produce a compiler error.
-For this reason `has_operator_postfix_increment` can not be used to determine whether a type has a public `operator++` or not.
+For this reason `has_operator_postfix_increment` cannot be used to determine whether a type has a public `operator++` or not.
-__header `#include <boost/type_traits/has_operator_postfix_increment.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_postfix_increment.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
@@ -40,13 +41,13 @@
[:`has_operator_postfix_increment<long>` inherits from `__true_type`.]
[:`has_operator_postfix_increment<int, int>` inherits from `__true_type`.]
-
[:`has_operator_postfix_increment<int, long>` inherits from `__true_type`.]
-
[:`has_operator_postfix_increment<double, double>` inherits from `__true_type`.]
-
[:`has_operator_postfix_increment<double, int>` inherits from `__true_type`.]
+[:`has_operator_postfix_increment<bool>` inherits from `__true_type`.]
+[:`has_operator_postfix_increment<const int>` inherits from `__false_type`.]
+[:`has_operator_postfix_increment<void*>` inherits from `__false_type`.]
[:`has_operator_postfix_increment<int, std::string>` inherits from `__false_type`.]
[endsect]
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_prefix_decrement.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_prefix_decrement.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_prefix_decrement.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of prefix `operator--`.
+Be careful that it does not mean that `operator--` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -24,12 +25,12 @@
f(--rhs); // is valid if has_operator_prefix_decrement<RHS, RET>::value==true
``
-This trait can not detect whether prefix `operator--` is public or not:
+This trait cannot detect whether prefix `operator--` is public or not:
if `operator--` is defined as a private member of `RHS` then
instantiating `has_operator_prefix_decrement<RHS>` will produce a compiler error.
-For this reason `has_operator_prefix_decrement` can not be used to determine whether a type has a public `operator--` or not.
+For this reason `has_operator_prefix_decrement` cannot be used to determine whether a type has a public `operator--` or not.
-__header `#include <boost/type_traits/has_operator_prefix_decrement.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_prefix_decrement.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
@@ -40,13 +41,13 @@
[:`has_operator_prefix_decrement<long>` inherits from `__true_type`.]
[:`has_operator_prefix_decrement<int, int>` inherits from `__true_type`.]
-
[:`has_operator_prefix_decrement<int, long>` inherits from `__true_type`.]
-
[:`has_operator_prefix_decrement<double, double>` inherits from `__true_type`.]
-
[:`has_operator_prefix_decrement<double, int>` inherits from `__true_type`.]
+[:`has_operator_prefix_decrement<bool>` inherits from `__false_type`.]
+[:`has_operator_prefix_decrement<const int>` inherits from `__false_type`.]
+[:`has_operator_prefix_decrement<void*>` inherits from `__false_type`.]
[:`has_operator_prefix_decrement<int, std::string>` inherits from `__false_type`.]
[endsect]
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_prefix_increment.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_prefix_increment.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_prefix_increment.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of prefix `operator++`.
+Be careful that it does not mean that `operator++` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -24,12 +25,12 @@
f(++rhs); // is valid if has_operator_prefix_increment<RHS, RET>::value==true
``
-This trait can not detect whether prefix `operator++` is public or not:
+This trait cannot detect whether prefix `operator++` is public or not:
if `operator++` is defined as a private member of `RHS` then
instantiating `has_operator_prefix_increment<RHS>` will produce a compiler error.
-For this reason `has_operator_prefix_increment` can not be used to determine whether a type has a public `operator++` or not.
+For this reason `has_operator_prefix_increment` cannot be used to determine whether a type has a public `operator++` or not.
-__header `#include <boost/type_traits/has_operator_prefix_increment.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_prefix_increment.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
@@ -40,13 +41,13 @@
[:`has_operator_prefix_increment<long>` inherits from `__true_type`.]
[:`has_operator_prefix_increment<int, int>` inherits from `__true_type`.]
-
[:`has_operator_prefix_increment<int, long>` inherits from `__true_type`.]
-
[:`has_operator_prefix_increment<double, double>` inherits from `__true_type`.]
-
[:`has_operator_prefix_increment<double, int>` inherits from `__true_type`.]
+[:`has_operator_prefix_increment<bool>` inherits from `__true_type`.]
+[:`has_operator_prefix_increment<const int>` inherits from `__false_type`.]
+[:`has_operator_prefix_increment<void*>` inherits from `__false_type`.]
[:`has_operator_prefix_increment<int, std::string>` inherits from `__false_type`.]
[endsect]
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_right_shift.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_right_shift.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_right_shift.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of binary `operator>>`.
+Be careful that it does not mean that `operator>>` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -25,12 +26,12 @@
f(lhs>>rhs); // is valid if has_operator_right_shift<LHS, RHS, RET>::value==true
``
-This trait can not detect whether binary `operator>>` is public or not:
+This trait cannot detect whether binary `operator>>` is public or not:
if `operator>>` is defined as a private member of `LHS` then
instantiating `has_operator_right_shift<LHS>` will produce a compiler error.
-For this reason `has_operator_right_shift` can not be used to determine whether a type has a public `operator>>` or not.
+For this reason `has_operator_right_shift` cannot be used to determine whether a type has a public `operator>>` or not.
-__header `#include <boost/type_traits/has_operator_right_shift.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_right_shift.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
@@ -41,9 +42,12 @@
[:`has_operator_right_shift<long>` inherits from `__true_type`.]
[:`has_operator_right_shift<int, int, int>` inherits from `__true_type`.]
+[:`has_operator_right_shift<const int, int>` inherits from `__true_type`.]
+[:`has_operator_right_shift<std::istream, int&>` inherits from `__true_type`.]
+[:`has_operator_right_shift<std::istream, char*, std::ostream>` inherits from `__true_type`.]
+[:`has_operator_right_shift<std::istream, std::string&>` inherits from `__true_type`.]
[:`has_operator_right_shift<int, double, bool>` inherits from `__false_type`.]
-
[:`has_operator_right_shift<int, int, std::string>` inherits from `__false_type`.]
[endsect]
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_right_shift_equal.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_right_shift_equal.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_right_shift_equal.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of binary `operator>>=`.
+Be careful that it does not mean that `operator>>=` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -25,12 +26,12 @@
f(lhs>>=rhs); // is valid if has_operator_right_shift_equal<LHS, RHS, RET>::value==true
``
-This trait can not detect whether binary `operator>>=` is public or not:
+This trait cannot detect whether binary `operator>>=` is public or not:
if `operator>>=` is defined as a private member of `LHS` then
instantiating `has_operator_right_shift_equal<LHS>` will produce a compiler error.
-For this reason `has_operator_right_shift_equal` can not be used to determine whether a type has a public `operator>>=` or not.
+For this reason `has_operator_right_shift_equal` cannot be used to determine whether a type has a public `operator>>=` or not.
-__header `#include <boost/type_traits/has_operator_right_shift_equal.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_right_shift_equal.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
@@ -42,8 +43,8 @@
[:`has_operator_right_shift_equal<int, int, int>` inherits from `__true_type`.]
+[:`has_operator_right_shift_equal<const int, int>` inherits from `__false_type`.]
[:`has_operator_right_shift_equal<int, double, bool>` inherits from `__false_type`.]
-
[:`has_operator_right_shift_equal<int, int, std::string>` inherits from `__false_type`.]
[endsect]
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_unary_minus.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_unary_minus.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_unary_minus.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of prefix `operator-`.
+Be careful that it does not mean that `operator-` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -24,12 +25,12 @@
f(-rhs); // is valid if has_operator_unary_minus<RHS, RET>::value==true
``
-This trait can not detect whether prefix `operator-` is public or not:
+This trait cannot detect whether prefix `operator-` is public or not:
if `operator-` is defined as a private member of `RHS` then
instantiating `has_operator_unary_minus<RHS>` will produce a compiler error.
-For this reason `has_operator_unary_minus` can not be used to determine whether a type has a public `operator-` or not.
+For this reason `has_operator_unary_minus` cannot be used to determine whether a type has a public `operator-` or not.
-__header `#include <boost/type_traits/has_operator_unary_minus.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_unary_minus.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
@@ -40,12 +41,10 @@
[:`has_operator_unary_minus<long>` inherits from `__true_type`.]
[:`has_operator_unary_minus<int, int>` inherits from `__true_type`.]
-
[:`has_operator_unary_minus<int, long>` inherits from `__true_type`.]
-
[:`has_operator_unary_minus<double, double>` inherits from `__true_type`.]
-
[:`has_operator_unary_minus<double, int>` inherits from `__true_type`.]
+[:`has_operator_unary_minus<const int>` inherits from `__true_type`.]
[:`has_operator_unary_minus<int, std::string>` inherits from `__false_type`.]
Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_unary_plus.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_unary_plus.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_unary_plus.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -16,6 +16,7 @@
otherwise inherits from __false_type.
The default behaviour (`RET=void`) is to not check for the return value of prefix `operator+`.
+Be careful that it does not mean that `operator+` must return `void` to have the trait derive from __true_type.
If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
``
@@ -24,12 +25,12 @@
f(+rhs); // is valid if has_operator_unary_plus<RHS, RET>::value==true
``
-This trait can not detect whether prefix `operator+` is public or not:
+This trait cannot detect whether prefix `operator+` is public or not:
if `operator+` is defined as a private member of `RHS` then
instantiating `has_operator_unary_plus<RHS>` will produce a compiler error.
-For this reason `has_operator_unary_plus` can not be used to determine whether a type has a public `operator+` or not.
+For this reason `has_operator_unary_plus` cannot be used to determine whether a type has a public `operator+` or not.
-__header `#include <boost/type_traits/has_operator_unary_plus.hpp>` or `#include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_unary_plus.hpp>` or `#include <boost/type_traits/operators.hpp>`
__examples
@@ -40,12 +41,10 @@
[:`has_operator_unary_plus<long>` inherits from `__true_type`.]
[:`has_operator_unary_plus<int, int>` inherits from `__true_type`.]
-
[:`has_operator_unary_plus<int, long>` inherits from `__true_type`.]
-
[:`has_operator_unary_plus<double, double>` inherits from `__true_type`.]
-
[:`has_operator_unary_plus<double, int>` inherits from `__true_type`.]
+[:`has_operator_unary_plus<const int>` inherits from `__true_type`.]
[:`has_operator_unary_plus<int, std::string>` inherits from `__false_type`.]
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/background.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/background.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/background.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -49,7 +49,7 @@
method available to them.
</p>
<a name="boost_typetraits.background.type_traits"></a><h5>
-<a name="id3296925"></a>
+<a name="id3241970"></a>
<a class="link" href="background.html#boost_typetraits.background.type_traits">Type Traits</a>
</h5>
<p>
@@ -77,7 +77,7 @@
given.
</p>
<a name="boost_typetraits.background.implementation"></a><h5>
-<a name="id3295968"></a>
+<a name="id3241014"></a>
<a class="link" href="background.html#boost_typetraits.background.implementation">Implementation</a>
</h5>
<p>
@@ -167,7 +167,7 @@
in the default template.
</p>
<a name="boost_typetraits.background.optimized_copy"></a><h5>
-<a name="id3347453"></a>
+<a name="id3292498"></a>
<a class="link" href="background.html#boost_typetraits.background.optimized_copy">Optimized copy</a>
</h5>
<p>
@@ -240,7 +240,7 @@
otherwise it will call the "slow but safe version".
</p>
<a name="boost_typetraits.background.was_it_worth_it_"></a><h5>
-<a name="id3347916"></a>
+<a name="id3292961"></a>
<a class="link" href="background.html#boost_typetraits.background.was_it_worth_it_">Was it worth it?</a>
</h5>
<p>
@@ -273,7 +273,7 @@
</li>
</ul></div>
<div class="table">
-<a name="id3347984"></a><p class="title"><b>Table 1.1. Time taken to copy 1000 elements using `copy<const T*, T*>` (times
+<a name="id3293029"></a><p class="title"><b>Table 1.1. Time taken to copy 1000 elements using `copy<const T*, T*>` (times
in micro-seconds)</b></p>
<div class="table-contents"><table class="table" summary="Time taken to copy 1000 elements using `copy<const T*, T*>` (times
in micro-seconds)">
@@ -372,7 +372,7 @@
</table></div>
</div>
<br class="table-break"><a name="boost_typetraits.background.pair_of_references"></a><h5>
-<a name="id3348136"></a>
+<a name="id3293181"></a>
<a class="link" href="background.html#boost_typetraits.background.pair_of_references">Pair of References</a>
</h5>
<p>
@@ -409,7 +409,7 @@
to hold non-reference types, references, and constant references:
</p>
<div class="table">
-<a name="id3348443"></a><p class="title"><b>Table 1.2. Required Constructor Argument Types</b></p>
+<a name="id3293488"></a><p class="title"><b>Table 1.2. Required Constructor Argument Types</b></p>
<div class="table-contents"><table class="table" summary="Required Constructor Argument Types">
<colgroup>
<col>
@@ -474,7 +474,7 @@
adds a reference to its type, unless it is already a reference.
</p>
<div class="table">
-<a name="id3348559"></a><p class="title"><b>Table 1.3. Using add_reference to synthesize the correct constructor type</b></p>
+<a name="id3293605"></a><p class="title"><b>Table 1.3. Using add_reference to synthesize the correct constructor type</b></p>
<div class="table-contents"><table class="table" summary="Using add_reference to synthesize the correct constructor type">
<colgroup>
<col>
@@ -590,7 +590,7 @@
easier to maintain and easier to understand.
</p>
<a name="boost_typetraits.background.conclusion"></a><h5>
-<a name="id3349091"></a>
+<a name="id3294136"></a>
<a class="link" href="background.html#boost_typetraits.background.conclusion">Conclusion</a>
</h5>
<p>
@@ -603,7 +603,7 @@
can be optimal as well as generic.
</p>
<a name="boost_typetraits.background.acknowledgements"></a><h5>
-<a name="id3349122"></a>
+<a name="id3294168"></a>
<a class="link" href="background.html#boost_typetraits.background.acknowledgements">Acknowledgements</a>
</h5>
<p>
@@ -611,7 +611,7 @@
comments when preparing this article.
</p>
<a name="background.references"></a><a name="boost_typetraits.background.references"></a><h5>
-<a name="id3349149"></a>
+<a name="id3294195"></a>
<a class="link" href="background.html#boost_typetraits.background.references">References</a>
</h5>
<div class="orderedlist"><ol class="orderedlist" type="1">
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/transform.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/transform.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/transform.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -90,7 +90,7 @@
<span class="keyword">struct</span> <a class="link" href="../reference/remove_volatile.html" title="remove_volatile">remove_volatile</a><span class="special">;</span>
</pre>
<a name="boost_typetraits.category.transform.broken_compiler_workarounds_"></a><h5>
-<a name="id3360025"></a>
+<a name="id3308747"></a>
<a class="link" href="transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">Broken
Compiler Workarounds:</a>
</h5>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/value_traits/operators.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/value_traits/operators.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/value_traits/operators.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -21,7 +21,7 @@
Operator Type Traits</a>
</h4></div></div></div>
<a name="boost_typetraits.category.value_traits.operators.introduction"></a><h6>
-<a name="id3351763"></a>
+<a name="id3296808"></a>
<a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.introduction">Introduction</a>
</h6>
<p>
@@ -78,9 +78,12 @@
</ul></div>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of the operator. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>,
- the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of the operator. Be careful that it does
+ not mean that the operator must return <code class="computeroutput"><span class="keyword">void</span></code>
+ to have the trait value to be <code class="computeroutput"><span class="keyword">true</span></code>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code>, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value can be used as argument to a function expecting
<code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -106,7 +109,7 @@
operators.
</p>
<div class="table">
-<a name="id3352579"></a><p class="title"><b>Table 1.4. Supported binary operators</b></p>
+<a name="id3297644"></a><p class="title"><b>Table 1.4. Supported binary operators</b></p>
<div class="table-contents"><table class="table" summary="Supported binary operators">
<colgroup>
<col>
@@ -552,7 +555,7 @@
</table></div>
</div>
<br class="table-break"><div class="table">
-<a name="id3355654"></a><p class="title"><b>Table 1.5. Supported prefix operators</b></p>
+<a name="id3300719"></a><p class="title"><b>Table 1.5. Supported prefix operators</b></p>
<div class="table-contents"><table class="table" summary="Supported prefix operators">
<colgroup>
<col>
@@ -680,7 +683,7 @@
</table></div>
</div>
<br class="table-break"><div class="table">
-<a name="id3356292"></a><p class="title"><b>Table 1.6. Supported postfix operators</b></p>
+<a name="id3301357"></a><p class="title"><b>Table 1.6. Supported postfix operators</b></p>
<div class="table-contents"><table class="table" summary="Supported postfix operators">
<colgroup>
<col>
@@ -739,7 +742,7 @@
for each operator and the corresponding trait name.
</p>
<div class="table">
-<a name="id3356512"></a><p class="title"><b>Table 1.7. Operator names in the standard</b></p>
+<a name="id3301577"></a><p class="title"><b>Table 1.7. Operator names in the standard</b></p>
<div class="table-contents"><table class="table" summary="Operator names in the standard">
<colgroup>
<col>
@@ -1642,9 +1645,216 @@
</table></div>
</div>
<br class="table-break"><a name="boost_typetraits.category.value_traits.operators.implementation"></a><h6>
-<a name="id3359038"></a>
+<a name="id3304106"></a>
<a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.implementation">Implementation</a>
</h6>
+<p>
+ The implementation consists in only header files. The following headers
+ should included first:
+</p>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></pre>
+<p>
+ or
+</p>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_name</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></pre>
+<p>
+ where <code class="literal">name</code> is the textual name chosen for the wanted
+ operator. The first method includes all operator traits.
+ </p>
+<p>
+ All traits are implemented the same way using preprocessor macros to avoid
+ code duplication. The main files are in <code class="literal">boost/type_traits/detail</code>:
+ <code class="literal">has_binary_operator.hpp</code>, <code class="literal">has_prefix_operator.hpp</code>
+ and <code class="literal">has_postfix_operator.hpp</code>. The example of prefix
+ <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code>
+ is presented below:
+ </p>
+<p>
+
+</p>
+<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
+<span class="keyword">namespace</span> <span class="identifier">detail</span> <span class="special">{</span>
+<span class="keyword">namespace</span> <span class="identifier">has_operator_unary_minus_impl</span> <span class="special">{</span>
+
+<span class="comment">// 1. a function to have an instance of type T without requiring T to be default
+</span><span class="comment">// constructible
+</span><span class="keyword">namespace</span> <span class="special">{</span>
+ <span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">></span> <span class="identifier">T</span> <span class="special">&</span><span class="identifier">make</span><span class="special">();</span>
+<span class="special">}</span>
+
+<span class="comment">// 2. we provide operator- for types that do not have one already
+</span>
+<span class="comment">// a type returned from operator- when no such operator is found in the type's
+</span><span class="comment">// own namespace so that we have a means to know that our operator was used
+</span><span class="keyword">struct</span> <span class="identifier">tag</span> <span class="special">{</span> <span class="special">};</span>
+
+<span class="comment">// this class allows implicit conversions and makes the following operator
+</span><span class="comment">// definition less-preferred than any other such operators that might be found
+</span><span class="comment">// via argument-dependent name lookup
+</span><span class="keyword">struct</span> <span class="identifier">any</span> <span class="special">{</span> <span class="keyword">template</span> <span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> <span class="identifier">any</span><span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&);</span> <span class="special">};</span>
+
+<span class="comment">// when operator- is not available, this one is used
+</span><span class="identifier">tag</span> <span class="keyword">operator</span><span class="special">-(</span><span class="keyword">const</span> <span class="identifier">any</span><span class="special">&);</span>
+
+<span class="comment">// 3. if the return type has to be checked, we need to determine if operator-
+</span><span class="comment">// returns void or not
+</span>
+<span class="comment">// we first redefine "operator," so that we have no compilation error if
+</span><span class="comment">// operator- returns void and we can use the return type of
+</span><span class="comment">// (-rhs, returns_void_t()) to deduce if operator- returns void or not:
+</span><span class="comment">// - operator- returns void -> (-rhs, returns_void_t()) returns returns_void_t
+</span><span class="comment">// - operator- returns !=void -> (-rhs, returns_void_t()) returns int
+</span><span class="keyword">struct</span> <span class="identifier">returns_void_t</span> <span class="special">{};</span>
+<span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">></span>
+<span class="keyword">int</span> <span class="keyword">operator</span><span class="special">,(</span><span class="identifier">T</span> <span class="keyword">const</span> <span class="special">&,</span> <span class="identifier">returns_void_t</span><span class="special">);</span>
+
+<span class="comment">// this intermediate trait has member value of type bool:
+</span><span class="comment">// - value==true -> operator- returns void
+</span><span class="comment">// - value==false -> operator- does not return void
+</span><span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">RHS</span> <span class="special">></span>
+<span class="keyword">struct</span> <span class="identifier">operator_unary_minus_returns_void</span> <span class="special">{</span>
+ <span class="comment">// overloads of function returns_void make the difference
+</span> <span class="comment">// yes_type and no_type have different size by construction
+</span> <span class="keyword">static</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">type_traits</span><span class="special">::</span><span class="identifier">yes_type</span> <span class="identifier">returns_void</span><span class="special">(</span><span class="identifier">returns_void_t</span><span class="special">);</span>
+ <span class="keyword">static</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">type_traits</span><span class="special">::</span><span class="identifier">no_type</span> <span class="identifier">returns_void</span><span class="special">(</span><span class="keyword">int</span><span class="special">);</span>
+ <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span><span class="special">=(</span><span class="keyword">sizeof</span><span class="special">(::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">type_traits</span><span class="special">::</span><span class="identifier">yes_type</span><span class="special">)==</span><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">returns_void</span><span class="special">((-</span><span class="identifier">make</span><span class="special"><</span><span class="identifier">RHS</span><span class="special">>(),</span><span class="identifier">returns_void_t</span><span class="special">()))));</span>
+<span class="special">};</span>
+
+<span class="comment">// 4. check for return type when RET is non void
+</span>
+<span class="comment">// this class is used only when RET is non void, therefore it is specialized to
+</span><span class="comment">// have its value==false when the operator returns void
+</span><span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">RET</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">RETURNS_VOID</span> <span class="special">></span>
+<span class="keyword">struct</span> <span class="identifier">has_operator_unary_minus_impl2</span><span class="special">;</span>
+
+<span class="comment">// operator- does not return void, checks if it is convertible to RET using the
+</span><span class="comment">// sizeof trick based on overload resolution
+</span><span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">RET</span> <span class="special">></span>
+<span class="keyword">struct</span> <span class="identifier">has_operator_unary_minus_impl2</span><span class="special"><</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</span><span class="special">,</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">false_type</span> <span class="special">></span> <span class="special">{</span>
+ <span class="keyword">static</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">type_traits</span><span class="special">::</span><span class="identifier">yes_type</span> <span class="identifier">is_convertible_to_RET</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+ <span class="keyword">static</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">type_traits</span><span class="special">::</span><span class="identifier">no_type</span> <span class="identifier">is_convertible_to_RET</span><span class="special">(...);</span>
+ <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span><span class="special">=(</span><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">is_convertible_to_RET</span><span class="special">(-</span> <span class="identifier">make</span><span class="special"><</span><span class="identifier">RHS</span><span class="special">>()))==</span><span class="keyword">sizeof</span><span class="special">(::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">type_traits</span><span class="special">::</span><span class="identifier">yes_type</span><span class="special">));</span>
+<span class="special">};</span>
+
+<span class="comment">// operator- returns void!=RET -> specialization to return value==false
+</span><span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">RET</span> <span class="special">></span>
+<span class="keyword">struct</span> <span class="identifier">has_operator_unary_minus_impl2</span><span class="special"><</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</span><span class="special">,</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">true_type</span> <span class="special">></span> <span class="special">{</span>
+ <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span><span class="special">=</span><span class="keyword">false</span><span class="special">;</span>
+<span class="special">};</span>
+
+<span class="comment">// 5. main struct: to avoid any compilation error, this struct behaves
+</span><span class="comment">// differently when:
+</span><span class="comment">// - RET is void or non void
+</span><span class="comment">// - operator-(RHS) is forbidden by the standard
+</span><span class="comment">// forbidden_if is a bool that is:
+</span><span class="comment">// - true when the operator-(RHS) is forbidden by the standard (would yield
+</span><span class="comment">// compilation error if used)
+</span><span class="comment">// - false otherwise
+</span><span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">RET</span><span class="special">,</span> <span class="keyword">bool</span> <span class="identifier">forbidden_if</span> <span class="special">></span>
+<span class="keyword">struct</span> <span class="identifier">has_operator_unary_minus_impl1</span><span class="special">;</span>
+
+<span class="comment">// specialization to avoid compilation error when forbidden by the standard
+</span><span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">RET</span> <span class="special">></span>
+<span class="keyword">struct</span> <span class="identifier">has_operator_unary_minus_impl1</span> <span class="special"><</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</span><span class="special">,</span> <span class="keyword">true</span> <span class="special">></span> <span class="special">{</span>
+ <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span><span class="special">=</span><span class="keyword">false</span><span class="special">;</span>
+<span class="special">};</span>
+
+<span class="comment">// checks for return type if template parameter RET is non void: use previously
+</span><span class="comment">// defined struct
+</span><span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">RET</span> <span class="special">></span>
+<span class="keyword">struct</span> <span class="identifier">has_operator_unary_minus_impl1</span> <span class="special"><</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</span><span class="special">,</span> <span class="keyword">false</span> <span class="special">></span> <span class="special">{</span>
+ <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span><span class="special">=(</span><span class="identifier">has_operator_unary_minus_impl2</span><span class="special"><</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</span><span class="special">,</span> <span class="keyword">typename</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">integral_constant</span><span class="special"><</span> <span class="keyword">bool</span><span class="special">,</span> <span class="identifier">operator_unary_minus_returns_void</span><span class="special"><</span> <span class="identifier">RHS</span> <span class="special">>::</span><span class="identifier">value</span> <span class="special">></span> <span class="special">>::</span><span class="identifier">value</span><span class="special
">);</span>
+<span class="special">};</span>
+
+<span class="comment">// in case we do not want to check for return type, we still need to know if our
+</span><span class="comment">// definition of operator BOOST_TT_TRAIT_OP is used or an other existing one;
+</span><span class="comment">// this is done with redefinition of "operator," that returns tag or int
+</span><span class="identifier">tag</span> <span class="keyword">operator</span><span class="special">,(</span><span class="identifier">tag</span><span class="special">,</span> <span class="keyword">int</span><span class="special">);</span>
+
+<span class="comment">// do not check for return type if 2nd template parameter RET is void
+</span><span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">RHS</span> <span class="special">></span>
+<span class="keyword">struct</span> <span class="identifier">has_operator_unary_minus_impl1</span><span class="special"><</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="keyword">void</span><span class="special">,</span> <span class="keyword">false</span> <span class="special">></span> <span class="special">{</span>
+ <span class="keyword">static</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">type_traits</span><span class="special">::</span><span class="identifier">yes_type</span> <span class="identifier">check</span><span class="special">(</span><span class="keyword">int</span><span class="special">);</span>
+ <span class="keyword">static</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">type_traits</span><span class="special">::</span><span class="identifier">no_type</span> <span class="identifier">check</span><span class="special">(</span><span class="identifier">tag</span><span class="special">);</span>
+
+ <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span><span class="special">=(</span><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">check</span><span class="special">(((-</span> <span class="identifier">make</span><span class="special"><</span><span class="identifier">RHS</span><span class="special">>()),</span><span class="number">0</span><span class="special">)))==</span><span class="keyword">sizeof</span><span class="special">(::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">type_traits</span><span class="special">::</span><span class="identifier">yes_type</span><span class="special">));</span>
+<span class="special">};</span>
+
+<span class="comment">// some specializations needs to be declared for the special void case
+</span><span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">RET</span> <span class="special">></span>
+<span class="keyword">struct</span> <span class="identifier">has_operator_unary_minus_impl1</span><span class="special"><</span> <span class="keyword">void</span><span class="special">,</span> <span class="identifier">RET</span><span class="special">,</span> <span class="keyword">false</span> <span class="special">></span> <span class="special">{</span>
+ <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span><span class="special">=</span><span class="keyword">false</span><span class="special">;</span>
+<span class="special">};</span>
+
+<span class="keyword">template</span> <span class="special"><></span>
+<span class="keyword">struct</span> <span class="identifier">has_operator_unary_minus_impl1</span><span class="special"><</span> <span class="keyword">void</span><span class="special">,</span> <span class="keyword">void</span><span class="special">,</span> <span class="keyword">false</span> <span class="special">></span> <span class="special">{</span>
+ <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span><span class="special">=</span><span class="keyword">false</span><span class="special">;</span>
+<span class="special">};</span>
+
+<span class="comment">// defines some typedef for convenience
+</span><span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">RET</span> <span class="special">></span>
+<span class="keyword">struct</span> <span class="identifier">has_operator_unary_minus_impl</span> <span class="special">{</span>
+ <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">remove_reference</span><span class="special"><</span><span class="identifier">RHS</span><span class="special">>::</span><span class="identifier">type</span> <span class="identifier">rhs_noref</span><span class="special">;</span>
+ <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">remove_cv</span><span class="special"><</span><span class="identifier">rhs_noref</span><span class="special">>::</span><span class="identifier">type</span> <span class="identifier">rhs_nocv</span><span class="special">;</span>
+ <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span><span class="special">=(</span><span class="identifier">has_operator_unary_minus_impl1</span> <span class="special"><</span> <span class="identifier">rhs_noref</span><span class="special">,</span> <span class="identifier">RET</span><span class="special">,</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_pointer</span><span class="special"><</span> <span class="identifier">rhs_noref</span> <span class="special">>::</span><span class="identifier">value</span> <span class="special">>::</span><span class="identifier">value</span><span class="special">);</span>
+<span class="special">};</span>
+<span class="special">}</span> <span class="comment">// namespace has_operator_unary_minus_impl
+</span><span class="special">}</span> <span class="comment">// namespace detail
+</span>
+<span class="comment">// this is the accessible definition of the trait to end user
+</span><span class="keyword">template</span> <span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span> <span class="special">></span>
+<span class="keyword">struct</span> <span class="identifier">has_operator_unary_minus</span> <span class="special">:</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">integral_constant</span><span class="special"><</span> <span class="keyword">bool</span><span class="special">,</span> <span class="special">(::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">detail</span><span class="special">::</span><span class="identifier">has_operator_unary_minus_impl</span><span class="special">::</span><span class="identifier">has_operator_unary_minus_impl</span><span class="special"><</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</span> <span class="special">>::</span><span class="identifier">value</span><span class="special">)></span> <span class="special">{</span>
+<span class="special">};</span>
+<span class="special">}</span> <span class="comment">// namespace boost
+</span></pre>
+<p>
+ </p>
+<a name="boost_typetraits.category.value_traits.operators.known_issues"></a><h6>
+<a name="id3307261"></a>
+ <a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.known_issues">Known
+ issues</a>
+ </h6>
+<p>
+ These traits cannot detect whether the operators are public or not: if
+ an operator is defined as a private member of type <code class="computeroutput"><span class="identifier">T</span></code>
+ then the instantiation of the corresponding trait will produce a compiler
+ error. For this reason these traits cannot be used to determine whether
+ a type has a public operator or not.
+ </p>
+<p>
+ There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">U</span></code>
+ and <code class="computeroutput"><span class="identifier">T</span></code> is convertible to
+ <code class="computeroutput"><span class="identifier">U</span></code>. In this case, the compiler
+ will report an ambigous overload because both the existing operator and
+ the one we provide (with argument of type <code class="computeroutput"><span class="identifier">any</span></code>)
+ need type conversion, so that none is preferred.
+ </p>
+<p>
+ Example 1:
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">-(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_unary_minus</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_unary_minus</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload between
+</span> <span class="comment">// operator-(const any&) and
+</span> <span class="comment">// operator-(const A&)
+</span> <span class="comment">// both need type conversion
+</span></pre>
+<p>
+ Example 2:
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="identifier">A</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">B</span><span class="special">&)</span> <span class="special">{</span> <span class="special">}</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">-(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&);</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_unary_minus</span><span class="special"><</span><span class="identifier">A</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_unary_minus</span><span class="special"><</span><span class="identifier">B</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload between
+</span> <span class="comment">// operator-(const any&) and
+</span> <span class="comment">// operator-(const A&)
+</span> <span class="comment">// both need type conversion
+</span></pre>
+<p>
+ </p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/intrinsics.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/intrinsics.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/intrinsics.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -92,7 +92,7 @@
of the following macros:
</p>
<div class="table">
-<a name="id3362105"></a><p class="title"><b>Table 1.8. Macros for Compiler Intrinsics</b></p>
+<a name="id3310833"></a><p class="title"><b>Table 1.8. Macros for Compiler Intrinsics</b></p>
<div class="table-contents"><table class="table" summary="Macros for Compiler Intrinsics">
<colgroup>
<col>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_const.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_const.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_const.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -46,7 +46,7 @@
or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<div class="table">
-<a name="id3366905"></a><p class="title"><b>Table 1.9. Examples</b></p>
+<a name="id3315632"></a><p class="title"><b>Table 1.9. Examples</b></p>
<div class="table-contents"><table class="table" summary="Examples">
<colgroup>
<col>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_cv.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_cv.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_cv.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -47,7 +47,7 @@
or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<div class="table">
-<a name="id3367488"></a><p class="title"><b>Table 1.10. Examples</b></p>
+<a name="id3316215"></a><p class="title"><b>Table 1.10. Examples</b></p>
<div class="table-contents"><table class="table" summary="Examples">
<colgroup>
<col>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_pointer.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_pointer.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_pointer.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -49,7 +49,7 @@
or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<div class="table">
-<a name="id3368141"></a><p class="title"><b>Table 1.11. Examples</b></p>
+<a name="id3316868"></a><p class="title"><b>Table 1.11. Examples</b></p>
<div class="table-contents"><table class="table" summary="Examples">
<colgroup>
<col>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_reference.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_reference.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_reference.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -46,7 +46,7 @@
or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<div class="table">
-<a name="id3368727"></a><p class="title"><b>Table 1.12. Examples</b></p>
+<a name="id3317454"></a><p class="title"><b>Table 1.12. Examples</b></p>
<div class="table-contents"><table class="table" summary="Examples">
<colgroup>
<col>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_volatile.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_volatile.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_volatile.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -46,7 +46,7 @@
or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<div class="table">
-<a name="id3369304"></a><p class="title"><b>Table 1.13. Examples</b></p>
+<a name="id3318031"></a><p class="title"><b>Table 1.13. Examples</b></p>
<div class="table-contents"><table class="table" summary="Examples">
<colgroup>
<col>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/decay.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/decay.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/decay.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -41,7 +41,7 @@
or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<div class="table">
-<a name="id3370802"></a><p class="title"><b>Table 1.14. Examples</b></p>
+<a name="id3319529"></a><p class="title"><b>Table 1.14. Examples</b></p>
<div class="table-contents"><table class="table" summary="Examples">
<colgroup>
<col>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/floating_point_promotion.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/floating_point_promotion.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/floating_point_promotion.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -42,7 +42,7 @@
or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<div class="table">
-<a name="id3372411"></a><p class="title"><b>Table 1.15. Examples</b></p>
+<a name="id3321138"></a><p class="title"><b>Table 1.15. Examples</b></p>
<div class="table-contents"><table class="table" summary="Examples">
<colgroup>
<col>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/function_traits.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/function_traits.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/function_traits.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -52,7 +52,7 @@
</p></td></tr>
</table></div>
<div class="table">
-<a name="id3372856"></a><p class="title"><b>Table 1.16. Function Traits Members</b></p>
+<a name="id3321583"></a><p class="title"><b>Table 1.16. Function Traits Members</b></p>
<div class="table-contents"><table class="table" summary="Function Traits Members">
<colgroup>
<col>
@@ -115,7 +115,7 @@
</table></div>
</div>
<br class="table-break"><div class="table">
-<a name="id3373114"></a><p class="title"><b>Table 1.17. Examples</b></p>
+<a name="id3321840"></a><p class="title"><b>Table 1.17. Examples</b></p>
<div class="table-contents"><table class="table" summary="Examples">
<colgroup>
<col>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_and.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_and.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_and.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -32,9 +32,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&</span></code>. Be careful that it does not mean that
+ <code class="computeroutput"><span class="keyword">operator</span><span class="special">&</span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -47,14 +51,14 @@
<p>
</p>
<p>
- This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_bit_and</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_bit_and</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_bit_and</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">&</span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">&</span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_bit_and</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
@@ -79,6 +83,10 @@
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
</p></blockquote></div>
<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_bit_and</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
<code class="computeroutput"><span class="identifier">has_operator_bit_and</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code>
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
</p></blockquote></div>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_and_equal.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_and_equal.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_and_equal.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -33,9 +33,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&=</span></code>. Be careful that it does not mean that
+ <code class="computeroutput"><span class="keyword">operator</span><span class="special">&=</span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -48,16 +52,16 @@
<p>
</p>
<p>
- This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&=</span></code>
+ This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&=</span></code>
is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code>
then instantiating <code class="computeroutput"><span class="identifier">has_operator_bit_and_equal</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_bit_and_equal</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">&=</span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">&=</span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_bit_and_equal</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
@@ -85,6 +89,9 @@
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
</p></blockquote></div>
<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_bit_and_equal</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
<code class="computeroutput"><span class="identifier">has_operator_bit_and_equal</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code>
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
</p></blockquote></div>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_or.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_or.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_or.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -33,9 +33,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">|</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">|</span></code>. Be careful that it does not mean that
+ <code class="computeroutput"><span class="keyword">operator</span><span class="special">|</span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -48,14 +52,14 @@
<p>
</p>
<p>
- This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">|</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">|</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_bit_or</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">|</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">|</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_bit_or</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_bit_or</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">|</span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">|</span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_bit_or</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
@@ -80,6 +84,10 @@
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
</p></blockquote></div>
<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_bit_or</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
<code class="computeroutput"><span class="identifier">has_operator_bit_or</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code>
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
</p></blockquote></div>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_or_equal.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_or_equal.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_or_equal.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -34,9 +34,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">|=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">|=</span></code>. Be careful that it does not mean that
+ <code class="computeroutput"><span class="keyword">operator</span><span class="special">|=</span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -49,14 +53,14 @@
<p>
</p>
<p>
- This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">|=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">|=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_bit_or_equal</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">|=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">|=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_bit_or_equal</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_bit_or_equal</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">|=</span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">|=</span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_bit_or_equal</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
@@ -84,6 +88,9 @@
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
</p></blockquote></div>
<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_bit_or_equal</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
<code class="computeroutput"><span class="identifier">has_operator_bit_or_equal</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code>
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
</p></blockquote></div>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_xor.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_xor.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_xor.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -33,9 +33,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">^</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">^</span></code>. Be careful that it does not mean that
+ <code class="computeroutput"><span class="keyword">operator</span><span class="special">^</span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -48,14 +52,14 @@
<p>
</p>
<p>
- This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">^</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">^</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_bit_xor</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">^</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">^</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_bit_xor</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_bit_xor</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">^</span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">^</span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_bit_xor</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
@@ -80,6 +84,10 @@
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
</p></blockquote></div>
<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_bit_xor</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
<code class="computeroutput"><span class="identifier">has_operator_bit_xor</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code>
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
</p></blockquote></div>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_xor_equal.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_xor_equal.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_xor_equal.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -34,9 +34,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">^=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">^=</span></code>. Be careful that it does not mean that
+ <code class="computeroutput"><span class="keyword">operator</span><span class="special">^=</span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -49,14 +53,14 @@
<p>
</p>
<p>
- This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">^=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">^=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_bit_xor_equal</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">^=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">^=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_bit_xor_equal</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_bit_xor_equal</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">^=</span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">^=</span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_bit_xor_equal</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
@@ -84,6 +88,9 @@
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
</p></blockquote></div>
<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_bit_xor_equal</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
<code class="computeroutput"><span class="identifier">has_operator_bit_xor_equal</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code>
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
</p></blockquote></div>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_complement.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_complement.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_complement.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -34,9 +34,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">~</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">~</span></code>. Be careful that it does not mean that
+ <code class="computeroutput"><span class="keyword">operator</span><span class="special">~</span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -48,14 +52,14 @@
<p>
</p>
<p>
- This trait can not detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">~</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">~</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_complement</span><span class="special"><</span><span class="identifier">RHS</span><span class="special">></span></code> will produce a compiler error. For this
+ This trait cannot detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">~</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">~</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_complement</span><span class="special"><</span><span class="identifier">RHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_complement</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">~</span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">~</span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_complement</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
@@ -86,6 +90,13 @@
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
</p></blockquote></div>
<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_complement</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">></span></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_complement</span><span class="special"><</span><span class="keyword">int</span><span class="special">*></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
<code class="computeroutput"><span class="identifier">has_operator_complement</span><span class="special"><</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
</p></blockquote></div>
<div class="blockquote"><blockquote class="blockquote"><p>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_dereference.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_dereference.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_dereference.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -34,9 +34,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code>. Be careful that it does not mean that
+ <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -48,14 +52,14 @@
<p>
</p>
<p>
- This trait can not detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_dereference</span><span class="special"><</span><span class="identifier">RHS</span><span class="special">></span></code> will produce a compiler error. For this
+ This trait cannot detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_dereference</span><span class="special"><</span><span class="identifier">RHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_dereference</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_dereference</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
@@ -78,13 +82,34 @@
<code class="computeroutput"><span class="identifier">has_operator_dereference</span><span class="special"><</span><span class="keyword">long</span><span class="special">*></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
</p></blockquote></div>
<div class="blockquote"><blockquote class="blockquote"><p>
- <code class="computeroutput"><span class="identifier">has_operator_dereference</span><span class="special"><</span><span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ <code class="computeroutput"><span class="identifier">has_operator_dereference</span><span class="special"><</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">int</span><span class="special">></span></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
</p></blockquote></div>
<div class="blockquote"><blockquote class="blockquote"><p>
<code class="computeroutput"><span class="identifier">has_operator_dereference</span><span class="special"><</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">const</span> <span class="keyword">int</span><span class="special">></span></code>
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
</p></blockquote></div>
<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_dereference</span><span class="special"><</span><span class="keyword">int</span> <span class="keyword">const</span> <span class="special">*></span></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_dereference</span><span class="special"><</span><span class="keyword">int</span> <span class="special">*</span> <span class="keyword">const</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_dereference</span><span class="special"><</span><span class="keyword">int</span> <span class="keyword">const</span> <span class="special">*</span> <span class="keyword">const</span><span class="special">></span></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_dereference</span><span class="special"><</span><span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_dereference</span><span class="special"><</span><span class="keyword">double</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_dereference</span><span class="special"><</span><span class="keyword">void</span><span class="special">*></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
<code class="computeroutput"><span class="identifier">has_operator_dereference</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">*,</span> <span class="keyword">int</span><span class="special">&></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
</p></blockquote></div>
</div>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_divides.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_divides.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_divides.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -33,9 +33,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">/</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">/</span></code>. Be careful that it does not mean that
+ <code class="computeroutput"><span class="keyword">operator</span><span class="special">/</span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -48,14 +52,14 @@
<p>
</p>
<p>
- This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">/</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">/</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_divides</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">/</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">/</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_divides</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_divides</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">/</span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">/</span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_divides</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_divides_equal.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_divides_equal.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_divides_equal.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -34,9 +34,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">/=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">/=</span></code>. Be careful that it does not mean that
+ <code class="computeroutput"><span class="keyword">operator</span><span class="special">/=</span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -49,14 +53,14 @@
<p>
</p>
<p>
- This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">/=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">/=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_divides_equal</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">/=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">/=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_divides_equal</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_divides_equal</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">/=</span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">/=</span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_divides_equal</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_equal_to.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_equal_to.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_equal_to.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -33,9 +33,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code>. Be careful that it does not mean that
+ <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -48,14 +52,14 @@
<p>
</p>
<p>
- This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_equal_to</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_equal_to</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_equal_to</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_equal_to</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
@@ -84,6 +88,15 @@
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
</p></blockquote></div>
<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_equal_to</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_equal_to</span><span class="special"><</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_equal_to</span><span class="special"><</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">double</span><span class="special">*></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
<code class="computeroutput"><span class="identifier">has_operator_equal_to</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
</p></blockquote></div>
</div>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_greater.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_greater.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_greater.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -32,9 +32,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">></span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">></span></code>. Be careful that it does not mean that
+ <code class="computeroutput"><span class="keyword">operator</span><span class="special">></span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -47,14 +51,14 @@
<p>
</p>
<p>
- This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">></span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">></span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_greater</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">></span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">></span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_greater</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_greater</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">></span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">></span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_greater</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
@@ -83,6 +87,15 @@
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
</p></blockquote></div>
<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_greater</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_greater</span><span class="special"><</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_greater</span><span class="special"><</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">double</span><span class="special">*></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
<code class="computeroutput"><span class="identifier">has_operator_greater</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
</p></blockquote></div>
</div>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_greater_equal.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_greater_equal.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_greater_equal.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -33,9 +33,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">>=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">>=</span></code>. Be careful that it does not mean that
+ <code class="computeroutput"><span class="keyword">operator</span><span class="special">>=</span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -48,14 +52,14 @@
<p>
</p>
<p>
- This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">>=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">>=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_greater_equal</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">>=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">>=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_greater_equal</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_greater_equal</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">>=</span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">>=</span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_greater_equal</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
@@ -87,6 +91,17 @@
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
</p></blockquote></div>
<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_greater_equal</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">></span></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_greater_equal</span><span class="special"><</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">int</span><span class="special">></span></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_greater_equal</span><span class="special"><</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">double</span><span class="special">*></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
<code class="computeroutput"><span class="identifier">has_operator_greater_equal</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code>
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_left_shift.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_left_shift.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_left_shift.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -33,9 +33,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special"><<</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special"><<</span></code>. Be careful that it does not mean
+ that <code class="computeroutput"><span class="keyword">operator</span><span class="special"><<</span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -48,16 +52,16 @@
<p>
</p>
<p>
- This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special"><<</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special"><<</span></code>
+ This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special"><<</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special"><<</span></code>
is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code>
then instantiating <code class="computeroutput"><span class="identifier">has_operator_left_shift</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_left_shift</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special"><<</span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special"><<</span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_left_shift</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
@@ -85,6 +89,21 @@
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
</p></blockquote></div>
<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_left_shift</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_left_shift</span><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_left_shift</span><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">,</span> <span class="keyword">char</span><span class="special">*,</span>
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">></span></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_left_shift</span><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
<code class="computeroutput"><span class="identifier">has_operator_left_shift</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code>
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
</p></blockquote></div>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_left_shift_equal.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_left_shift_equal.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_left_shift_equal.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -33,9 +33,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special"><<=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special"><<=</span></code>. Be careful that it does not mean
+ that <code class="computeroutput"><span class="keyword">operator</span><span class="special"><<=</span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -48,16 +52,16 @@
<p>
</p>
<p>
- This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special"><<=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special"><<=</span></code>
+ This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special"><<=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special"><<=</span></code>
is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code>
then instantiating <code class="computeroutput"><span class="identifier">has_operator_left_shift_equal</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_left_shift_equal</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special"><<=</span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special"><<=</span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_left_shift_equal</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
@@ -85,6 +89,9 @@
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
</p></blockquote></div>
<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_left_shift_equal</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
<code class="computeroutput"><span class="identifier">has_operator_left_shift_equal</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code>
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
</p></blockquote></div>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_less.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_less.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_less.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -32,9 +32,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special"><</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special"><</span></code>. Be careful that it does not mean that
+ <code class="computeroutput"><span class="keyword">operator</span><span class="special"><</span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -47,14 +51,14 @@
<p>
</p>
<p>
- This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special"><</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special"><</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_less</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special"><</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special"><</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_less</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_less</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special"><</span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special"><</span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_less</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
@@ -83,6 +87,15 @@
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
</p></blockquote></div>
<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_less</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_less</span><span class="special"><</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_less</span><span class="special"><</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">double</span><span class="special">*></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
<code class="computeroutput"><span class="identifier">has_operator_less</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
</p></blockquote></div>
</div>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_less_equal.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_less_equal.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_less_equal.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -33,9 +33,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special"><=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special"><=</span></code>. Be careful that it does not mean that
+ <code class="computeroutput"><span class="keyword">operator</span><span class="special"><=</span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -48,14 +52,14 @@
<p>
</p>
<p>
- This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special"><=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special"><=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_less_equal</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special"><=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special"><=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_less_equal</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_less_equal</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special"><=</span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special"><=</span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_less_equal</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
@@ -87,6 +91,17 @@
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
</p></blockquote></div>
<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_less_equal</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">></span></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_less_equal</span><span class="special"><</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">int</span><span class="special">></span></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_less_equal</span><span class="special"><</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">double</span><span class="special">*></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
<code class="computeroutput"><span class="identifier">has_operator_less_equal</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code>
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_logical_and.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_logical_and.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_logical_and.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -33,9 +33,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&&</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&&</span></code>. Be careful that it does not mean
+ that <code class="computeroutput"><span class="keyword">operator</span><span class="special">&&</span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -48,16 +52,16 @@
<p>
</p>
<p>
- This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&&</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&&</span></code>
+ This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&&</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&&</span></code>
is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code>
then instantiating <code class="computeroutput"><span class="identifier">has_operator_logical_and</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_logical_and</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">&&</span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">&&</span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_logical_and</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
@@ -85,10 +89,19 @@
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
</p></blockquote></div>
<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_logical_and</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
+ <span class="keyword">long</span><span class="special">></span></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
<code class="computeroutput"><span class="identifier">has_operator_logical_and</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code>
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
</p></blockquote></div>
<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_logical_and</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
<code class="computeroutput"><span class="identifier">has_operator_logical_and</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code>
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_logical_not.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_logical_not.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_logical_not.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -34,9 +34,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">!</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">!</span></code>. Be careful that it does not mean that
+ <code class="computeroutput"><span class="keyword">operator</span><span class="special">!</span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -48,14 +52,14 @@
<p>
</p>
<p>
- This trait can not detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">!</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">!</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_logical_not</span><span class="special"><</span><span class="identifier">RHS</span><span class="special">></span></code> will produce a compiler error. For this
+ This trait cannot detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">!</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">!</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_logical_not</span><span class="special"><</span><span class="identifier">RHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_logical_not</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">!</span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">!</span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_logical_not</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
@@ -82,10 +86,21 @@
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
</p></blockquote></div>
<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_logical_not</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">></span></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_logical_not</span><span class="special"><</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
<code class="computeroutput"><span class="identifier">has_operator_logical_not</span><span class="special"><</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code>
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
</p></blockquote></div>
<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_logical_not</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">bool</span><span class="special">></span></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
<code class="computeroutput"><span class="identifier">has_operator_logical_not</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
</p></blockquote></div>
</div>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_logical_or.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_logical_or.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_logical_or.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -34,9 +34,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">||</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">||</span></code>. Be careful that it does not mean that
+ <code class="computeroutput"><span class="keyword">operator</span><span class="special">||</span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -49,14 +53,14 @@
<p>
</p>
<p>
- This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">||</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">||</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_logical_or</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">||</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">||</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_logical_or</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_logical_or</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">||</span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">||</span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_logical_or</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
@@ -84,10 +88,19 @@
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
</p></blockquote></div>
<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_logical_or</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
+ <span class="keyword">long</span><span class="special">></span></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
<code class="computeroutput"><span class="identifier">has_operator_logical_or</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code>
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
</p></blockquote></div>
<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_logical_or</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">>::</span><span class="identifier">value</span></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
<code class="computeroutput"><span class="identifier">has_operator_logical_or</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code>
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_minus.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_minus.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_minus.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -33,9 +33,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code>. Be careful that it does not mean that
+ <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -48,14 +52,14 @@
<p>
</p>
<p>
- This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_minus</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_minus</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_minus</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_minus</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_minus_equal.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_minus_equal.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_minus_equal.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -34,9 +34,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">-=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">-=</span></code>. Be careful that it does not mean that
+ <code class="computeroutput"><span class="keyword">operator</span><span class="special">-=</span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -49,14 +53,14 @@
<p>
</p>
<p>
- This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">-=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">-=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_minus_equal</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">-=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">-=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_minus_equal</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_minus_equal</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">-=</span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">-=</span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_minus_equal</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_modulus.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_modulus.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_modulus.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -33,9 +33,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">%</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">%</span></code>. Be careful that it does not mean that
+ <code class="computeroutput"><span class="keyword">operator</span><span class="special">%</span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -48,14 +52,14 @@
<p>
</p>
<p>
- This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">%</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">%</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_modulus</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">%</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">%</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_modulus</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_modulus</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">%</span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">%</span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_modulus</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_modulus_equal.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_modulus_equal.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_modulus_equal.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -34,9 +34,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">%=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">%=</span></code>. Be careful that it does not mean that
+ <code class="computeroutput"><span class="keyword">operator</span><span class="special">%=</span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -49,14 +53,14 @@
<p>
</p>
<p>
- This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">%=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">%=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_modulus_equal</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">%=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">%=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_modulus_equal</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_modulus_equal</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">%=</span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">%=</span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_modulus_equal</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_multiplies.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_multiplies.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_multiplies.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -34,9 +34,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code>. Be careful that it does not mean that
+ <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -49,14 +53,14 @@
<p>
</p>
<p>
- This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_multiplies</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_multiplies</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_multiplies</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_multiplies</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_multiplies_equal.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_multiplies_equal.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_multiplies_equal.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -34,9 +34,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">*=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">*=</span></code>. Be careful that it does not mean that
+ <code class="computeroutput"><span class="keyword">operator</span><span class="special">*=</span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -49,14 +53,14 @@
<p>
</p>
<p>
- This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">*=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">*=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_multiplies_equal</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">*=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">*=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_multiplies_equal</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_multiplies_equal</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">*=</span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">*=</span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_multiplies_equal</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_not_equal_to.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_not_equal_to.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_not_equal_to.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -34,9 +34,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">!=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">!=</span></code>. Be careful that it does not mean that
+ <code class="computeroutput"><span class="keyword">operator</span><span class="special">!=</span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -49,14 +53,14 @@
<p>
</p>
<p>
- This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">!=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">!=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_not_equal_to</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">!=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">!=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_not_equal_to</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_not_equal_to</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">!=</span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">!=</span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_not_equal_to</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
@@ -88,6 +92,17 @@
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
</p></blockquote></div>
<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_not_equal_to</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">></span></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_not_equal_to</span><span class="special"><</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">int</span><span class="special">></span></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_not_equal_to</span><span class="special"><</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">double</span><span class="special">*></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
<code class="computeroutput"><span class="identifier">has_operator_not_equal_to</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code>
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_plus.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_plus.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_plus.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -33,9 +33,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code>. Be careful that it does not mean that
+ <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -48,14 +52,14 @@
<p>
</p>
<p>
- This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_plus</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_plus</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_plus</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_plus</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_plus_equal.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_plus_equal.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_plus_equal.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -34,9 +34,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">+=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">+=</span></code>. Be careful that it does not mean that
+ <code class="computeroutput"><span class="keyword">operator</span><span class="special">+=</span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -49,14 +53,14 @@
<p>
</p>
<p>
- This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">+=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">+=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_plus_equal</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">+=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">+=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_plus_equal</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_plus_equal</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">+=</span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">+=</span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_plus_equal</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_postfix_decrement.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_postfix_decrement.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_postfix_decrement.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -34,9 +34,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of postfix <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of postfix <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code>. Be careful that it does not mean that
+ <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -48,14 +52,14 @@
<p>
</p>
<p>
- This trait can not detect whether postfix <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_postfix_decrement</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
+ This trait cannot detect whether postfix <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_postfix_decrement</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_postfix_decrement</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_postfix_decrement</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
@@ -93,6 +97,16 @@
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
</p></blockquote></div>
<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_postfix_decrement</span><span class="special"><</span><span class="keyword">bool</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_postfix_decrement</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">></span></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_postfix_decrement</span><span class="special"><</span><span class="keyword">void</span><span class="special">*></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
<code class="computeroutput"><span class="identifier">has_operator_postfix_decrement</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
</p></blockquote></div>
</div>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_postfix_increment.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_postfix_increment.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_postfix_increment.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -34,9 +34,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of postfix <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of postfix <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code>. Be careful that it does not mean that
+ <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -48,14 +52,14 @@
<p>
</p>
<p>
- This trait can not detect whether postfix <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_postfix_increment</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
+ This trait cannot detect whether postfix <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_postfix_increment</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_postfix_increment</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_postfix_increment</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
@@ -93,6 +97,16 @@
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
</p></blockquote></div>
<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_postfix_increment</span><span class="special"><</span><span class="keyword">bool</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_postfix_increment</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">></span></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_postfix_increment</span><span class="special"><</span><span class="keyword">void</span><span class="special">*></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
<code class="computeroutput"><span class="identifier">has_operator_postfix_increment</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
</p></blockquote></div>
</div>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_prefix_decrement.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_prefix_decrement.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_prefix_decrement.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -34,9 +34,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code>. Be careful that it does not mean that
+ <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -48,14 +52,14 @@
<p>
</p>
<p>
- This trait can not detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_prefix_decrement</span><span class="special"><</span><span class="identifier">RHS</span><span class="special">></span></code> will produce a compiler error. For this
+ This trait cannot detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_prefix_decrement</span><span class="special"><</span><span class="identifier">RHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_prefix_decrement</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_prefix_decrement</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
@@ -93,6 +97,16 @@
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
</p></blockquote></div>
<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_prefix_decrement</span><span class="special"><</span><span class="keyword">bool</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_prefix_decrement</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">></span></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_prefix_decrement</span><span class="special"><</span><span class="keyword">void</span><span class="special">*></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
<code class="computeroutput"><span class="identifier">has_operator_prefix_decrement</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
</p></blockquote></div>
</div>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_prefix_increment.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_prefix_increment.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_prefix_increment.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -34,9 +34,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code>. Be careful that it does not mean that
+ <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -48,14 +52,14 @@
<p>
</p>
<p>
- This trait can not detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_prefix_increment</span><span class="special"><</span><span class="identifier">RHS</span><span class="special">></span></code> will produce a compiler error. For this
+ This trait cannot detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_prefix_increment</span><span class="special"><</span><span class="identifier">RHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_prefix_increment</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_prefix_increment</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
@@ -93,6 +97,16 @@
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
</p></blockquote></div>
<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_prefix_increment</span><span class="special"><</span><span class="keyword">bool</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_prefix_increment</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">></span></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_prefix_increment</span><span class="special"><</span><span class="keyword">void</span><span class="special">*></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
<code class="computeroutput"><span class="identifier">has_operator_prefix_increment</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
</p></blockquote></div>
</div>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_right_shift.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_right_shift.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_right_shift.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -33,9 +33,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">>></span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">>></span></code>. Be careful that it does not mean
+ that <code class="computeroutput"><span class="keyword">operator</span><span class="special">>></span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -48,16 +52,16 @@
<p>
</p>
<p>
- This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">>></span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">>></span></code>
+ This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">>></span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">>></span></code>
is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code>
then instantiating <code class="computeroutput"><span class="identifier">has_operator_right_shift</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_right_shift</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">>></span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">>></span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_right_shift</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
@@ -85,6 +89,21 @@
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
</p></blockquote></div>
<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_right_shift</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_right_shift</span><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">istream</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&></span></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_right_shift</span><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">istream</span><span class="special">,</span> <span class="keyword">char</span><span class="special">*,</span>
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">></span></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_right_shift</span><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">istream</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
<code class="computeroutput"><span class="identifier">has_operator_right_shift</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code>
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
</p></blockquote></div>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_right_shift_equal.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_right_shift_equal.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_right_shift_equal.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -33,9 +33,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">>>=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">>>=</span></code>. Be careful that it does not mean
+ that <code class="computeroutput"><span class="keyword">operator</span><span class="special">>>=</span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -48,16 +52,16 @@
<p>
</p>
<p>
- This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">>>=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">>>=</span></code>
+ This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">>>=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">>>=</span></code>
is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code>
then instantiating <code class="computeroutput"><span class="identifier">has_operator_right_shift_equal</span><span class="special"><</span><span class="identifier">LHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_right_shift_equal</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">>>=</span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">>>=</span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_right_shift_equal</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
@@ -85,6 +89,9 @@
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
</p></blockquote></div>
<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_right_shift_equal</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
<code class="computeroutput"><span class="identifier">has_operator_right_shift_equal</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">></span></code>
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
</p></blockquote></div>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_unary_minus.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_unary_minus.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_unary_minus.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -34,9 +34,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code>. Be careful that it does not mean that
+ <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -48,14 +52,14 @@
<p>
</p>
<p>
- This trait can not detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_unary_minus</span><span class="special"><</span><span class="identifier">RHS</span><span class="special">></span></code> will produce a compiler error. For this
+ This trait cannot detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_unary_minus</span><span class="special"><</span><span class="identifier">RHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_unary_minus</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_unary_minus</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
@@ -93,6 +97,10 @@
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
</p></blockquote></div>
<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_unary_minus</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">></span></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
<code class="computeroutput"><span class="identifier">has_operator_unary_minus</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
</p></blockquote></div>
</div>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_unary_plus.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_unary_plus.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_unary_plus.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -34,9 +34,13 @@
</p>
<p>
The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
- to not check for the return value of prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
- is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
- type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+ to not check for the return value of prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code>. Be careful that it does not mean that
+ <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code>
+ must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
+ the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
+ value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
that the return value of the operator can be used as argument to a function
expecting <code class="computeroutput"><span class="identifier">RET</span></code>:
@@ -48,14 +52,14 @@
<p>
</p>
<p>
- This trait can not detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_unary_plus</span><span class="special"><</span><span class="identifier">RHS</span><span class="special">></span></code> will produce a compiler error. For this
+ This trait cannot detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_unary_plus</span><span class="special"><</span><span class="identifier">RHS</span><span class="special">></span></code> will produce a compiler error. For this
reason <code class="computeroutput"><span class="identifier">has_operator_unary_plus</span></code>
- can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> or not.
</p>
<p>
<span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
<span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_unary_plus</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
- or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
+ or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<p>
<span class="bold"><strong>Examples:</strong></span>
@@ -93,6 +97,10 @@
inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
</p></blockquote></div>
<div class="blockquote"><blockquote class="blockquote"><p>
+ <code class="computeroutput"><span class="identifier">has_operator_unary_plus</span><span class="special"><</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">></span></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
<code class="computeroutput"><span class="identifier">has_operator_unary_plus</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">></span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
</p></blockquote></div>
</div>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/integral_promotion.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/integral_promotion.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/integral_promotion.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -42,7 +42,7 @@
or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<div class="table">
-<a name="id3420990"></a><p class="title"><b>Table 1.18. Examples</b></p>
+<a name="id3374862"></a><p class="title"><b>Table 1.18. Examples</b></p>
<div class="table-contents"><table class="table" summary="Examples">
<colgroup>
<col>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/make_signed.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/make_signed.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/make_signed.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -47,7 +47,7 @@
or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<div class="table">
-<a name="id3438909"></a><p class="title"><b>Table 1.19. Examples</b></p>
+<a name="id3392784"></a><p class="title"><b>Table 1.19. Examples</b></p>
<div class="table-contents"><table class="table" summary="Examples">
<colgroup>
<col>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/make_unsigned.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/make_unsigned.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/make_unsigned.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -47,7 +47,7 @@
or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<div class="table">
-<a name="id3439489"></a><p class="title"><b>Table 1.20. Examples</b></p>
+<a name="id3393365"></a><p class="title"><b>Table 1.20. Examples</b></p>
<div class="table-contents"><table class="table" summary="Examples">
<colgroup>
<col>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/member_object.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/member_object.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/member_object.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -44,7 +44,7 @@
or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<div class="table">
-<a name="id3440094"></a><p class="title"><b>Table 1.21. Examples</b></p>
+<a name="id3393969"></a><p class="title"><b>Table 1.21. Examples</b></p>
<div class="table-contents"><table class="table" summary="Examples">
<colgroup>
<col>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/promote.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/promote.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/promote.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -44,7 +44,7 @@
or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<div class="table">
-<a name="id3440853"></a><p class="title"><b>Table 1.22. Examples</b></p>
+<a name="id3394729"></a><p class="title"><b>Table 1.22. Examples</b></p>
<div class="table-contents"><table class="table" summary="Examples">
<colgroup>
<col>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_all_extents.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_all_extents.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_all_extents.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -47,7 +47,7 @@
or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<div class="table">
-<a name="id3442140"></a><p class="title"><b>Table 1.23. Examples</b></p>
+<a name="id3396014"></a><p class="title"><b>Table 1.23. Examples</b></p>
<div class="table-contents"><table class="table" summary="Examples">
<colgroup>
<col>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_const.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_const.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_const.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -46,7 +46,7 @@
or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<div class="table">
-<a name="id3442802"></a><p class="title"><b>Table 1.24. Examples</b></p>
+<a name="id3396677"></a><p class="title"><b>Table 1.24. Examples</b></p>
<div class="table-contents"><table class="table" summary="Examples">
<colgroup>
<col>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_cv.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_cv.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_cv.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -46,7 +46,7 @@
or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<div class="table">
-<a name="id3443447"></a><p class="title"><b>Table 1.25. Examples</b></p>
+<a name="id3397322"></a><p class="title"><b>Table 1.25. Examples</b></p>
<div class="table-contents"><table class="table" summary="Examples">
<colgroup>
<col>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_extent.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_extent.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_extent.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -47,7 +47,7 @@
or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<div class="table">
-<a name="id3444094"></a><p class="title"><b>Table 1.26. Examples</b></p>
+<a name="id3397969"></a><p class="title"><b>Table 1.26. Examples</b></p>
<div class="table-contents"><table class="table" summary="Examples">
<colgroup>
<col>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_member_pointer.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_member_pointer.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_member_pointer.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -42,7 +42,7 @@
or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<div class="table">
-<a name="id3445362"></a><p class="title"><b>Table 1.28. Examples</b></p>
+<a name="id3399237"></a><p class="title"><b>Table 1.28. Examples</b></p>
<div class="table-contents"><table class="table" summary="Examples">
<colgroup>
<col>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_pointer.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_pointer.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_pointer.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -46,7 +46,7 @@
or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<div class="table">
-<a name="id3444770"></a><p class="title"><b>Table 1.27. Examples</b></p>
+<a name="id3398645"></a><p class="title"><b>Table 1.27. Examples</b></p>
<div class="table-contents"><table class="table" summary="Examples">
<colgroup>
<col>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_reference.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_reference.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_reference.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -46,7 +46,7 @@
or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<div class="table">
-<a name="id3446151"></a><p class="title"><b>Table 1.29. Examples</b></p>
+<a name="id3400027"></a><p class="title"><b>Table 1.29. Examples</b></p>
<div class="table-contents"><table class="table" summary="Examples">
<colgroup>
<col>
Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_volatile.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_volatile.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_volatile.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -46,7 +46,7 @@
or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
<div class="table">
-<a name="id3446707"></a><p class="title"><b>Table 1.30. Examples</b></p>
+<a name="id3400582"></a><p class="title"><b>Table 1.30. Examples</b></p>
<div class="table-contents"><table class="table" summary="Examples">
<colgroup>
<col>
Modified: sandbox/type_traits/libs/type_traits/doc/html/index.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/index.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/index.html 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -24,7 +24,7 @@
Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven
Watanabe</p></div>
<div><div class="legalnotice">
-<a name="id3337342"></a><p>
+<a name="id3282387"></a><p>
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)
</p>
Modified: sandbox/type_traits/libs/type_traits/doc/operators.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/operators.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/operators.qbk 2011-03-02 07:51:22 EST (Wed, 02 Mar 2011)
@@ -18,13 +18,15 @@
that given types can or not be used with given operators.
For example, `has_operator_plus<int, double>::value` is a `bool`
-which value is `true` because it is possible to add a `double` to an `int` like in the following code:
+which value is `true` because it is possible to add a `double` to an `int` like
+in the following code:
``
int i;
double d;
d+i;
``
-It is also possible to know if the result of the operator is convertible or not to a given type:
+It is also possible to know if the result of the operator is convertible or not
+to a given type:
``
has_operator_plus<int, double, double>::value; // true: int+double is convertible to double
has_operator_plus<int, double, char*>::value; // false: int+double is not convertible to char*
@@ -39,11 +41,15 @@
* `LHS` is the type used at the left hand side of `operator op`,
* `RHS` is the type used at the right hand side of `operator op`,
-* `RET` is the type for which we want to know if the result of `operator op` can be converted to.
+* `RET` is the type for which we want to know if the result of `operator op` can
+ be converted to.
-The default behaviour (`RET=void`) is to not check for the return value of the operator.
-If `RET` is different from the default `void`, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value can be used as argument to a function expecting `RET`:
+The default behaviour (`RET=void`) is to not check for the return value of the
+operator. Be careful that it does not mean that the operator must return `void`
+to have the trait value to be `true`.
+If `RET` is different from the default `void`, the return value is checked to be
+convertible to `RET`. Convertible to `RET` means that the return value can be
+used as argument to a function expecting `RET`:
``
void f(RET);
LHS lhs;
@@ -57,7 +63,8 @@
template __postfix_temp has_operator_postfixop;
``
-The following tables give the list of supported binary, prefix and postfix operators.
+The following tables give the list of supported binary, prefix and postfix
+operators.
[table Supported binary operators
[[operator] [trait name]]
@@ -165,4 +172,190 @@
[heading Implementation]
+The implementation consists in only header files. The following headers should
+included first:
+``#include <boost/type_traits/operators.hpp>``
+or
+``#include <boost/type_traits/has_operator_name.hpp>``
+where [^name] is the textual name chosen for the wanted operator. The first
+method includes all operator traits.
+
+All traits are implemented the same way using preprocessor macros to avoid code
+duplication.
+The main files are in [^boost/type_traits/detail]: [^has_binary_operator.hpp],
+[^has_prefix_operator.hpp] and [^has_postfix_operator.hpp].
+The example of prefix `operator-` is presented below:
+
+``
+namespace boost {
+namespace detail {
+namespace has_operator_unary_minus_impl {
+
+// 1. a function to have an instance of type T without requiring T to be default
+// constructible
+namespace {
+ template <typename T> T &make();
+}
+
+// 2. we provide operator- for types that do not have one already
+
+// a type returned from operator- when no such operator is found in the type's
+// own namespace so that we have a means to know that our operator was used
+struct tag { };
+
+// this class allows implicit conversions and makes the following operator
+// definition less-preferred than any other such operators that might be found
+// via argument-dependent name lookup
+struct any { template <class T> any(T const&); };
+
+// when operator- is not available, this one is used
+tag operator-(const any&);
+
+// 3. if the return type has to be checked, we need to determine if operator-
+// returns void or not
+
+// we first redefine "operator," so that we have no compilation error if
+// operator- returns void and we can use the return type of
+// (-rhs, returns_void_t()) to deduce if operator- returns void or not:
+// - operator- returns void -> (-rhs, returns_void_t()) returns returns_void_t
+// - operator- returns !=void -> (-rhs, returns_void_t()) returns int
+struct returns_void_t {};
+template <typename T>
+int operator,(T const &, returns_void_t);
+
+// this intermediate trait has member value of type bool:
+// - value==true -> operator- returns void
+// - value==false -> operator- does not return void
+template < typename RHS >
+struct operator_unary_minus_returns_void {
+ // overloads of function returns_void make the difference
+ // yes_type and no_type have different size by construction
+ static ::boost::type_traits::yes_type returns_void(returns_void_t);
+ static ::boost::type_traits::no_type returns_void(int);
+ static const bool value=(sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((-make<RHS>(),returns_void_t()))));
+};
+
+// 4. check for return type when RET is non void
+
+// this class is used only when RET is non void, therefore it is specialized to
+// have its value==false when the operator returns void
+template < typename RHS, typename RET, typename RETURNS_VOID >
+struct has_operator_unary_minus_impl2;
+
+// operator- does not return void, checks if it is convertible to RET using the
+// sizeof trick based on overload resolution
+template < typename RHS, typename RET >
+struct has_operator_unary_minus_impl2< RHS, RET, ::boost::false_type > {
+ static ::boost::type_traits::yes_type is_convertible_to_RET(RET);
+ static ::boost::type_traits::no_type is_convertible_to_RET(...);
+ static const bool value=(sizeof(is_convertible_to_RET(- make<RHS>()))==sizeof(::boost::type_traits::yes_type));
+};
+
+// operator- returns void!=RET -> specialization to return value==false
+template < typename RHS, typename RET >
+struct has_operator_unary_minus_impl2< RHS, RET, ::boost::true_type > {
+ static const bool value=false;
+};
+
+// 5. main struct: to avoid any compilation error, this struct behaves
+// differently when:
+// - RET is void or non void
+// - operator-(RHS) is forbidden by the standard
+// forbidden_if is a bool that is:
+// - true when the operator-(RHS) is forbidden by the standard (would yield
+// compilation error if used)
+// - false otherwise
+template < typename RHS, typename RET, bool forbidden_if >
+struct has_operator_unary_minus_impl1;
+
+// specialization to avoid compilation error when forbidden by the standard
+template < typename RHS, typename RET >
+struct has_operator_unary_minus_impl1 < RHS, RET, true > {
+ static const bool value=false;
+};
+
+// checks for return type if template parameter RET is non void: use previously
+// defined struct
+template < typename RHS, typename RET >
+struct has_operator_unary_minus_impl1 < RHS, RET, false > {
+ static const bool value=(has_operator_unary_minus_impl2< RHS, RET, typename ::boost::integral_constant< bool, operator_unary_minus_returns_void< RHS >::value > >::value);
+};
+
+// in case we do not want to check for return type, we still need to know if our
+// definition of operator BOOST_TT_TRAIT_OP is used or an other existing one;
+// this is done with redefinition of "operator," that returns tag or int
+tag operator,(tag, int);
+
+// do not check for return type if 2nd template parameter RET is void
+template < typename RHS >
+struct has_operator_unary_minus_impl1< RHS, void, false > {
+ static ::boost::type_traits::yes_type check(int);
+ static ::boost::type_traits::no_type check(tag);
+
+ static const bool value=(sizeof(check(((- make<RHS>()),0)))==sizeof(::boost::type_traits::yes_type));
+};
+
+// some specializations needs to be declared for the special void case
+template < typename RET >
+struct has_operator_unary_minus_impl1< void, RET, false > {
+ static const bool value=false;
+};
+
+template <>
+struct has_operator_unary_minus_impl1< void, void, false > {
+ static const bool value=false;
+};
+
+// defines some typedef for convenience
+template < typename RHS, typename RET >
+struct has_operator_unary_minus_impl {
+ typedef typename ::boost::remove_reference<RHS>::type rhs_noref;
+ typedef typename ::boost::remove_cv<rhs_noref>::type rhs_nocv;
+ static const bool value=(has_operator_unary_minus_impl1 < rhs_noref, RET, ::boost::is_pointer< rhs_noref >::value >::value);
+};
+} // namespace has_operator_unary_minus_impl
+} // namespace detail
+
+// this is the accessible definition of the trait to end user
+template < typename RHS, typename RET=void >
+struct has_operator_unary_minus : ::boost::integral_constant< bool, (::boost::detail::has_operator_unary_minus_impl::has_operator_unary_minus_impl< RHS, RET >::value)> {
+};
+} // namespace boost
+``
+
+[heading Known issues]
+
+These traits cannot detect whether the operators are public or not:
+if an operator is defined as a private member of type `T` then
+the instantiation of the corresponding trait will produce a compiler error.
+For this reason these traits cannot be used to determine whether a type has a
+public operator or not.
+
+There is an issue if the operator exists only for type `U` and `T` is
+convertible to `U`. In this case, the compiler will report an ambigous overload
+because both the existing operator and the one we provide (with argument of type
+`any`) need type conversion, so that none is preferred.
+
+Example 1:
+``
+struct A { };
+void operator-(const A&);
+struct B { operator A(); };
+boost::has_operator_unary_minus<A>::value; // this is fine
+boost::has_operator_unary_minus<B>::value; // error: ambigous overload between
+ // operator-(const any&) and
+ // operator-(const A&)
+ // both need type conversion
+``
+Example 2:
+``
+struct B { };
+struct A { A(const B&) { } };
+void operator-(const A&);
+boost::has_operator_unary_minus<A>::value; // this is fine
+boost::has_operator_unary_minus<B>::value; // error: ambigous overload between
+ // operator-(const any&) and
+ // operator-(const A&)
+ // both need type conversion
+``
[endsect]
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk