Boost-Commit :

Date view	Thread view	Subject view	Author view

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

Next message: fmhess_at_[hidden]: "[Boost-commit] svn:boost r69479 - in branches/release/boost/signals2: . detail"
Previous message: garcia_at_[hidden]: "[Boost-commit] svn:boost r69477 - website/public_html/live/community"

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.
 
<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>

@@ -77,7 +77,7 @@
 given.
 
<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>

@@ -167,7 +167,7 @@
 in the default template.
 
<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>

@@ -240,7 +240,7 @@
 otherwise it will call the "slow but safe version".
 
<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>

@@ -273,7 +273,7 @@
 </li>
</ul></div>
<div class="table">
-<a name="id3347984"></a>Table 1.1. Time taken to copy 1000 elements using `copy<const T*, T*>` (times
+<a name="id3293029"></a>Table 1.1. Time taken to copy 1000 elements using `copy<const T*, T*>` (times
 in micro-seconds)
<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>
 <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>

@@ -409,7 +409,7 @@
 to hold non-reference types, references, and constant references:
 
<div class="table">
-<a name="id3348443"></a>Table 1.2. Required Constructor Argument Types
+<a name="id3293488"></a>Table 1.2. Required Constructor Argument Types
<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.
 
<div class="table">
-<a name="id3348559"></a>Table 1.3. Using add_reference to synthesize the correct constructor type
+<a name="id3293605"></a>Table 1.3. Using add_reference to synthesize the correct constructor type
<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.
 
<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>

@@ -603,7 +603,7 @@
 can be optimal as well as generic.
 
<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>

@@ -611,7 +611,7 @@
 comments when preparing this article.
 
<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 @@
struct <a class="link" href="../reference/remove_volatile.html" title="remove_volatile">remove_volatile</a>;
</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>

@@ -78,9 +78,12 @@
</ul></div>

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of the operator. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>,
- the return value is checked to be convertible to <code class="computeroutput">RET</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">void</code>
+ to have the trait value to be <code class="computeroutput">true</code>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code>, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value can be used as argument to a function expecting
 <code class="computeroutput">RET</code>:
@@ -106,7 +109,7 @@
 operators.
 
<div class="table">
-<a name="id3352579"></a>Table 1.4. Supported binary operators
+<a name="id3297644"></a>Table 1.4. Supported binary operators
<div class="table-contents"><table class="table" summary="Supported binary operators">
<colgroup>
<col>
@@ -552,7 +555,7 @@
</table></div>
</div>
 <div class="table">
-<a name="id3355654"></a>Table 1.5. Supported prefix operators
+<a name="id3300719"></a>Table 1.5. Supported prefix operators
<div class="table-contents"><table class="table" summary="Supported prefix operators">
<colgroup>
<col>
@@ -680,7 +683,7 @@
</table></div>
</div>
 <div class="table">
-<a name="id3356292"></a>Table 1.6. Supported postfix operators
+<a name="id3301357"></a>Table 1.6. Supported postfix operators
<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.
 
<div class="table">
-<a name="id3356512"></a>Table 1.7. Operator names in the standard
+<a name="id3301577"></a>Table 1.7. Operator names in the standard
<div class="table-contents"><table class="table" summary="Operator names in the standard">
<colgroup>
<col>
@@ -1642,9 +1645,216 @@
</table></div>
</div>
 <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>
+
+ The implementation consists in only header files. The following headers
+ should included first:
+
+<pre class="programlisting">#include <boost/type_traits/operators.hpp></pre>
+
+ or
+
+<pre class="programlisting">#include <boost/type_traits/has_operator_name.hpp></pre>
+
+ where <code class="literal">name</code> 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 <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">operator-</code>
+ is presented below:
+ 
+
+
+
+<pre class="programlisting">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
+</pre>
+
+ 
+<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>
+
+ 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">T</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.
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">U</code>
+ and <code class="computeroutput">T</code> is convertible to
+ <code class="computeroutput">U</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">any</code>)
+ need type conversion, so that none is preferred.
+ 
+
+ Example 1:
+
+<pre class="programlisting">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
+</pre>
+
+ Example 2:
+
+<pre class="programlisting">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
+</pre>
+
+ 
</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:

<div class="table">
-<a name="id3362105"></a>Table 1.8. Macros for Compiler Intrinsics
+<a name="id3310833"></a>Table 1.8. Macros for Compiler Intrinsics
<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"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3366905"></a>Table 1.9. Examples
+<a name="id3315632"></a>Table 1.9. Examples
<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"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3367488"></a>Table 1.10. Examples
+<a name="id3316215"></a>Table 1.10. Examples
<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"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3368141"></a>Table 1.11. Examples
+<a name="id3316868"></a>Table 1.11. Examples
<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"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3368727"></a>Table 1.12. Examples
+<a name="id3317454"></a>Table 1.12. Examples
<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"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3369304"></a>Table 1.13. Examples
+<a name="id3318031"></a>Table 1.13. Examples
<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"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3370802"></a>Table 1.14. Examples
+<a name="id3319529"></a>Table 1.14. Examples
<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"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3372411"></a>Table 1.15. Examples
+<a name="id3321138"></a>Table 1.15. Examples
<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 @@
</td></tr>
</table></div>
<div class="table">
-<a name="id3372856"></a>Table 1.16. Function Traits Members
+<a name="id3321583"></a>Table 1.16. Function Traits Members
<div class="table-contents"><table class="table" summary="Function Traits Members">
<colgroup>
<col>
@@ -115,7 +115,7 @@
</table></div>
</div>
 <div class="table">
-<a name="id3373114"></a>Table 1.17. Examples
+<a name="id3321840"></a>Table 1.17. Examples
<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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of binary <code class="computeroutput">operator&</code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of binary <code class="computeroutput">operator&</code>. Be careful that it does not mean that
+ <code class="computeroutput">operator&</code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -47,14 +51,14 @@

 

- This trait can not detect whether binary <code class="computeroutput">operator&</code> is public or not: if <code class="computeroutput">operator&</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_bit_and<LHS></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput">operator&</code> is public or not: if <code class="computeroutput">operator&</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_bit_and<LHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_bit_and</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator&</code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator&</code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_bit_and.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:
@@ -79,6 +83,10 @@
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
 </blockquote></div>
<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_bit_and<const int, int></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_bit_and<int, double, bool></code>
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of binary <code class="computeroutput">operator&=</code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of binary <code class="computeroutput">operator&=</code>. Be careful that it does not mean that
+ <code class="computeroutput">operator&=</code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -48,16 +52,16 @@

 

- This trait can not detect whether binary <code class="computeroutput">operator&=</code> is public or not: if <code class="computeroutput">operator&=</code>
+ This trait cannot detect whether binary <code class="computeroutput">operator&=</code> is public or not: if <code class="computeroutput">operator&=</code>
 is defined as a private member of <code class="computeroutput">LHS</code>
 then instantiating <code class="computeroutput">has_operator_bit_and_equal<LHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_bit_and_equal</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator&=</code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator&=</code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_bit_and_equal.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:
@@ -85,6 +89,9 @@
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
 </blockquote></div>
<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_bit_and_equal<const int, int></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_bit_and_equal<int, double, bool></code>
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of binary <code class="computeroutput">operator|</code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of binary <code class="computeroutput">operator|</code>. Be careful that it does not mean that
+ <code class="computeroutput">operator|</code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -48,14 +52,14 @@

 

- This trait can not detect whether binary <code class="computeroutput">operator|</code> is public or not: if <code class="computeroutput">operator|</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_bit_or<LHS></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput">operator|</code> is public or not: if <code class="computeroutput">operator|</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_bit_or<LHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_bit_or</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator|</code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator|</code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_bit_or.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:
@@ -80,6 +84,10 @@
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
 </blockquote></div>
<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_bit_or<const int, int></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_bit_or<int, double, bool></code>
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of binary <code class="computeroutput">operator|=</code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of binary <code class="computeroutput">operator|=</code>. Be careful that it does not mean that
+ <code class="computeroutput">operator|=</code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -49,14 +53,14 @@

 

- This trait can not detect whether binary <code class="computeroutput">operator|=</code> is public or not: if <code class="computeroutput">operator|=</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_bit_or_equal<LHS></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput">operator|=</code> is public or not: if <code class="computeroutput">operator|=</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_bit_or_equal<LHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_bit_or_equal</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator|=</code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator|=</code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_bit_or_equal.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:
@@ -84,6 +88,9 @@
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
 </blockquote></div>
<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_bit_or_equal<const int, int></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_bit_or_equal<int, double, bool></code>
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of binary <code class="computeroutput">operator^</code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of binary <code class="computeroutput">operator^</code>. Be careful that it does not mean that
+ <code class="computeroutput">operator^</code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -48,14 +52,14 @@

 

- This trait can not detect whether binary <code class="computeroutput">operator^</code> is public or not: if <code class="computeroutput">operator^</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_bit_xor<LHS></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput">operator^</code> is public or not: if <code class="computeroutput">operator^</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_bit_xor<LHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_bit_xor</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator^</code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator^</code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_bit_xor.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:
@@ -80,6 +84,10 @@
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
 </blockquote></div>
<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_bit_xor<const int, int></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_bit_xor<int, double, bool></code>
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of binary <code class="computeroutput">operator^=</code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of binary <code class="computeroutput">operator^=</code>. Be careful that it does not mean that
+ <code class="computeroutput">operator^=</code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -49,14 +53,14 @@

 

- This trait can not detect whether binary <code class="computeroutput">operator^=</code> is public or not: if <code class="computeroutput">operator^=</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_bit_xor_equal<LHS></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput">operator^=</code> is public or not: if <code class="computeroutput">operator^=</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_bit_xor_equal<LHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_bit_xor_equal</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator^=</code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator^=</code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_bit_xor_equal.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:
@@ -84,6 +88,9 @@
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
 </blockquote></div>
<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_bit_xor_equal<const int, int></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_bit_xor_equal<int, double, bool></code>
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of prefix <code class="computeroutput">operator~</code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of prefix <code class="computeroutput">operator~</code>. Be careful that it does not mean that
+ <code class="computeroutput">operator~</code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -48,14 +52,14 @@

 

- This trait can not detect whether prefix <code class="computeroutput">operator~</code> is public or not: if <code class="computeroutput">operator~</code> is defined as a private member of <code class="computeroutput">RHS</code> then instantiating <code class="computeroutput">has_operator_complement<RHS></code> will produce a compiler error. For this
+ This trait cannot detect whether prefix <code class="computeroutput">operator~</code> is public or not: if <code class="computeroutput">operator~</code> is defined as a private member of <code class="computeroutput">RHS</code> then instantiating <code class="computeroutput">has_operator_complement<RHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_complement</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator~</code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator~</code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_complement.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:
@@ -86,6 +90,13 @@
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
 </blockquote></div>
<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_complement<const int></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_complement<int*></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_complement<double, double></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </blockquote></div>
<div class="blockquote"><blockquote class="blockquote">

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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of prefix <code class="computeroutput">operator*</code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of prefix <code class="computeroutput">operator*</code>. Be careful that it does not mean that
+ <code class="computeroutput">operator*</code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -48,14 +52,14 @@

 

- This trait can not detect whether prefix <code class="computeroutput">operator*</code> is public or not: if <code class="computeroutput">operator*</code> is defined as a private member of <code class="computeroutput">RHS</code> then instantiating <code class="computeroutput">has_operator_dereference<RHS></code> will produce a compiler error. For this
+ This trait cannot detect whether prefix <code class="computeroutput">operator*</code> is public or not: if <code class="computeroutput">operator*</code> is defined as a private member of <code class="computeroutput">RHS</code> then instantiating <code class="computeroutput">has_operator_dereference<RHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_dereference</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator*</code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator*</code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_dereference.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:
@@ -78,13 +82,34 @@
 <code class="computeroutput">has_operator_dereference<long*></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
 </blockquote></div>
<div class="blockquote"><blockquote class="blockquote">
- <code class="computeroutput">has_operator_dereference<int></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ <code class="computeroutput">has_operator_dereference<int*, int></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
 </blockquote></div>
<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_dereference<int*, const int></code>
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
 </blockquote></div>
<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_dereference<int const *></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_dereference<int * const></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_dereference<int const * const></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_dereference<int></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_dereference<double></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_dereference<void*></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_dereference<const int*, int&></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of binary <code class="computeroutput">operator/</code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of binary <code class="computeroutput">operator/</code>. Be careful that it does not mean that
+ <code class="computeroutput">operator/</code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -48,14 +52,14 @@

 

- This trait can not detect whether binary <code class="computeroutput">operator/</code> is public or not: if <code class="computeroutput">operator/</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_divides<LHS></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput">operator/</code> is public or not: if <code class="computeroutput">operator/</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_divides<LHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_divides</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator/</code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator/</code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_divides.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:

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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of binary <code class="computeroutput">operator/=</code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of binary <code class="computeroutput">operator/=</code>. Be careful that it does not mean that
+ <code class="computeroutput">operator/=</code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -49,14 +53,14 @@

 

- This trait can not detect whether binary <code class="computeroutput">operator/=</code> is public or not: if <code class="computeroutput">operator/=</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_divides_equal<LHS></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput">operator/=</code> is public or not: if <code class="computeroutput">operator/=</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_divides_equal<LHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_divides_equal</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator/=</code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator/=</code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_divides_equal.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:

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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of binary <code class="computeroutput">operator==</code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of binary <code class="computeroutput">operator==</code>. Be careful that it does not mean that
+ <code class="computeroutput">operator==</code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -48,14 +52,14 @@

 

- This trait can not detect whether binary <code class="computeroutput">operator==</code> is public or not: if <code class="computeroutput">operator==</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_equal_to<LHS></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput">operator==</code> is public or not: if <code class="computeroutput">operator==</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_equal_to<LHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_equal_to</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator==</code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator==</code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_equal_to.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:
@@ -84,6 +88,15 @@
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
 </blockquote></div>
<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_equal_to<const int></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_equal_to<int*, int></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_equal_to<int*, double*></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_equal_to<int, int, std::string></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of binary <code class="computeroutput">operator></code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of binary <code class="computeroutput">operator></code>. Be careful that it does not mean that
+ <code class="computeroutput">operator></code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -47,14 +51,14 @@

 

- This trait can not detect whether binary <code class="computeroutput">operator></code> is public or not: if <code class="computeroutput">operator></code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_greater<LHS></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput">operator></code> is public or not: if <code class="computeroutput">operator></code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_greater<LHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_greater</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator></code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_greater.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:
@@ -83,6 +87,15 @@
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
 </blockquote></div>
<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_greater<const int></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_greater<int*, int></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_greater<int*, double*></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_greater<int, int, std::string></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of binary <code class="computeroutput">operator>=</code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of binary <code class="computeroutput">operator>=</code>. Be careful that it does not mean that
+ <code class="computeroutput">operator>=</code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -48,14 +52,14 @@

 

- This trait can not detect whether binary <code class="computeroutput">operator>=</code> is public or not: if <code class="computeroutput">operator>=</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_greater_equal<LHS></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput">operator>=</code> is public or not: if <code class="computeroutput">operator>=</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_greater_equal<LHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_greater_equal</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator>=</code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator>=</code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_greater_equal.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:
@@ -87,6 +91,17 @@
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
 </blockquote></div>
<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_greater_equal<const int></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_greater_equal<int*, int></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_greater_equal<int*, double*></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_greater_equal<int, int,
 std::string></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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of binary <code class="computeroutput">operator<<</code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of binary <code class="computeroutput">operator<<</code>. Be careful that it does not mean
+ that <code class="computeroutput">operator<<</code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -48,16 +52,16 @@

 

- This trait can not detect whether binary <code class="computeroutput">operator<<</code> is public or not: if <code class="computeroutput">operator<<</code>
+ This trait cannot detect whether binary <code class="computeroutput">operator<<</code> is public or not: if <code class="computeroutput">operator<<</code>
 is defined as a private member of <code class="computeroutput">LHS</code>
 then instantiating <code class="computeroutput">has_operator_left_shift<LHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_left_shift</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator<<</code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator<<</code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_left_shift.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:
@@ -85,6 +89,21 @@
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
 </blockquote></div>
<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_left_shift<const int, int></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_left_shift<std::ostream, int></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_left_shift<std::ostream, char*,
+ std::ostream></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_left_shift<std::ostream, std::string></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_left_shift<int, double, bool></code>
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of binary <code class="computeroutput">operator<<=</code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of binary <code class="computeroutput">operator<<=</code>. Be careful that it does not mean
+ that <code class="computeroutput">operator<<=</code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -48,16 +52,16 @@

 

- This trait can not detect whether binary <code class="computeroutput">operator<<=</code> is public or not: if <code class="computeroutput">operator<<=</code>
+ This trait cannot detect whether binary <code class="computeroutput">operator<<=</code> is public or not: if <code class="computeroutput">operator<<=</code>
 is defined as a private member of <code class="computeroutput">LHS</code>
 then instantiating <code class="computeroutput">has_operator_left_shift_equal<LHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_left_shift_equal</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator<<=</code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator<<=</code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_left_shift_equal.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:
@@ -85,6 +89,9 @@
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
 </blockquote></div>
<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_left_shift_equal<const int, int></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_left_shift_equal<int, double, bool></code>
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of binary <code class="computeroutput">operator<</code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of binary <code class="computeroutput">operator<</code>. Be careful that it does not mean that
+ <code class="computeroutput">operator<</code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -47,14 +51,14 @@

 

- This trait can not detect whether binary <code class="computeroutput">operator<</code> is public or not: if <code class="computeroutput">operator<</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_less<LHS></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput">operator<</code> is public or not: if <code class="computeroutput">operator<</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_less<LHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_less</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator<</code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator<</code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_less.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:
@@ -83,6 +87,15 @@
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
 </blockquote></div>
<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_less<const int></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_less<int*, int></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_less<int*, double*></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_less<int, int, std::string></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of binary <code class="computeroutput">operator<=</code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of binary <code class="computeroutput">operator<=</code>. Be careful that it does not mean that
+ <code class="computeroutput">operator<=</code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -48,14 +52,14 @@

 

- This trait can not detect whether binary <code class="computeroutput">operator<=</code> is public or not: if <code class="computeroutput">operator<=</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_less_equal<LHS></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput">operator<=</code> is public or not: if <code class="computeroutput">operator<=</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_less_equal<LHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_less_equal</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator<=</code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator<=</code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_less_equal.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:
@@ -87,6 +91,17 @@
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
 </blockquote></div>
<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_less_equal<const int></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_less_equal<int*, int></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_less_equal<int*, double*></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_less_equal<int, int,
 std::string></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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of binary <code class="computeroutput">operator&&</code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of binary <code class="computeroutput">operator&&</code>. Be careful that it does not mean
+ that <code class="computeroutput">operator&&</code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -48,16 +52,16 @@

 

- This trait can not detect whether binary <code class="computeroutput">operator&&</code> is public or not: if <code class="computeroutput">operator&&</code>
+ This trait cannot detect whether binary <code class="computeroutput">operator&&</code> is public or not: if <code class="computeroutput">operator&&</code>
 is defined as a private member of <code class="computeroutput">LHS</code>
 then instantiating <code class="computeroutput">has_operator_logical_and<LHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_logical_and</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator&&</code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator&&</code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_logical_and.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:
@@ -85,10 +89,19 @@
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
 </blockquote></div>
<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_logical_and<int, int,
+ long></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_logical_and<int, double, bool></code>
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
 </blockquote></div>
<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_logical_and<const int, int>::value</code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_logical_and<int, int,
 std::string></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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of prefix <code class="computeroutput">operator!</code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of prefix <code class="computeroutput">operator!</code>. Be careful that it does not mean that
+ <code class="computeroutput">operator!</code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -48,14 +52,14 @@

 

- This trait can not detect whether prefix <code class="computeroutput">operator!</code> is public or not: if <code class="computeroutput">operator!</code> is defined as a private member of <code class="computeroutput">RHS</code> then instantiating <code class="computeroutput">has_operator_logical_not<RHS></code> will produce a compiler error. For this
+ This trait cannot detect whether prefix <code class="computeroutput">operator!</code> is public or not: if <code class="computeroutput">operator!</code> is defined as a private member of <code class="computeroutput">RHS</code> then instantiating <code class="computeroutput">has_operator_logical_not<RHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_logical_not</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator!</code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator!</code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_logical_not.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:
@@ -82,10 +86,21 @@
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
 </blockquote></div>
<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_logical_not<int, long></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_logical_not<double, double></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_logical_not<double, bool></code>
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
 </blockquote></div>
<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_logical_not<const bool></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_logical_not<int, std::string></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of binary <code class="computeroutput">operator||</code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of binary <code class="computeroutput">operator||</code>. Be careful that it does not mean that
+ <code class="computeroutput">operator||</code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -49,14 +53,14 @@

 

- This trait can not detect whether binary <code class="computeroutput">operator||</code> is public or not: if <code class="computeroutput">operator||</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_logical_or<LHS></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput">operator||</code> is public or not: if <code class="computeroutput">operator||</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_logical_or<LHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_logical_or</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator||</code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator||</code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_logical_or.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:
@@ -84,10 +88,19 @@
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
 </blockquote></div>
<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_logical_or<int, int,
+ long></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_logical_or<int, double, bool></code>
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
 </blockquote></div>
<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_logical_or<const int, int>::value</code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_logical_or<int, int,
 std::string></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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of binary <code class="computeroutput">operator-</code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of binary <code class="computeroutput">operator-</code>. Be careful that it does not mean that
+ <code class="computeroutput">operator-</code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -48,14 +52,14 @@

 

- This trait can not detect whether binary <code class="computeroutput">operator-</code> is public or not: if <code class="computeroutput">operator-</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_minus<LHS></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput">operator-</code> is public or not: if <code class="computeroutput">operator-</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_minus<LHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_minus</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator-</code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator-</code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_minus.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:

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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of binary <code class="computeroutput">operator-=</code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of binary <code class="computeroutput">operator-=</code>. Be careful that it does not mean that
+ <code class="computeroutput">operator-=</code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -49,14 +53,14 @@

 

- This trait can not detect whether binary <code class="computeroutput">operator-=</code> is public or not: if <code class="computeroutput">operator-=</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_minus_equal<LHS></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput">operator-=</code> is public or not: if <code class="computeroutput">operator-=</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_minus_equal<LHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_minus_equal</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator-=</code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator-=</code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_minus_equal.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:

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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of binary <code class="computeroutput">operator%</code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of binary <code class="computeroutput">operator%</code>. Be careful that it does not mean that
+ <code class="computeroutput">operator%</code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -48,14 +52,14 @@

 

- This trait can not detect whether binary <code class="computeroutput">operator%</code> is public or not: if <code class="computeroutput">operator%</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_modulus<LHS></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput">operator%</code> is public or not: if <code class="computeroutput">operator%</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_modulus<LHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_modulus</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator%</code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator%</code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_modulus.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:

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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of binary <code class="computeroutput">operator%=</code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of binary <code class="computeroutput">operator%=</code>. Be careful that it does not mean that
+ <code class="computeroutput">operator%=</code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -49,14 +53,14 @@

 

- This trait can not detect whether binary <code class="computeroutput">operator%=</code> is public or not: if <code class="computeroutput">operator%=</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_modulus_equal<LHS></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput">operator%=</code> is public or not: if <code class="computeroutput">operator%=</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_modulus_equal<LHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_modulus_equal</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator%=</code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator%=</code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_modulus_equal.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:

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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of binary <code class="computeroutput">operator*</code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of binary <code class="computeroutput">operator*</code>. Be careful that it does not mean that
+ <code class="computeroutput">operator*</code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -49,14 +53,14 @@

 

- This trait can not detect whether binary <code class="computeroutput">operator*</code> is public or not: if <code class="computeroutput">operator*</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_multiplies<LHS></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput">operator*</code> is public or not: if <code class="computeroutput">operator*</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_multiplies<LHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_multiplies</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator*</code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator*</code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_multiplies.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:

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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of binary <code class="computeroutput">operator*=</code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of binary <code class="computeroutput">operator*=</code>. Be careful that it does not mean that
+ <code class="computeroutput">operator*=</code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -49,14 +53,14 @@

 

- This trait can not detect whether binary <code class="computeroutput">operator*=</code> is public or not: if <code class="computeroutput">operator*=</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_multiplies_equal<LHS></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput">operator*=</code> is public or not: if <code class="computeroutput">operator*=</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_multiplies_equal<LHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_multiplies_equal</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator*=</code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator*=</code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_multiplies_equal.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:

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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of binary <code class="computeroutput">operator!=</code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of binary <code class="computeroutput">operator!=</code>. Be careful that it does not mean that
+ <code class="computeroutput">operator!=</code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -49,14 +53,14 @@

 

- This trait can not detect whether binary <code class="computeroutput">operator!=</code> is public or not: if <code class="computeroutput">operator!=</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_not_equal_to<LHS></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput">operator!=</code> is public or not: if <code class="computeroutput">operator!=</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_not_equal_to<LHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_not_equal_to</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator!=</code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator!=</code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_not_equal_to.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:
@@ -88,6 +92,17 @@
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
 </blockquote></div>
<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_not_equal_to<const int></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_not_equal_to<int*, int></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_not_equal_to<int*, double*></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_not_equal_to<int, int,
 std::string></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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of binary <code class="computeroutput">operator+</code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of binary <code class="computeroutput">operator+</code>. Be careful that it does not mean that
+ <code class="computeroutput">operator+</code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -48,14 +52,14 @@

 

- This trait can not detect whether binary <code class="computeroutput">operator+</code> is public or not: if <code class="computeroutput">operator+</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_plus<LHS></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput">operator+</code> is public or not: if <code class="computeroutput">operator+</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_plus<LHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_plus</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator+</code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator+</code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_plus.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:

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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of binary <code class="computeroutput">operator+=</code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of binary <code class="computeroutput">operator+=</code>. Be careful that it does not mean that
+ <code class="computeroutput">operator+=</code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -49,14 +53,14 @@

 

- This trait can not detect whether binary <code class="computeroutput">operator+=</code> is public or not: if <code class="computeroutput">operator+=</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_plus_equal<LHS></code> will produce a compiler error. For this
+ This trait cannot detect whether binary <code class="computeroutput">operator+=</code> is public or not: if <code class="computeroutput">operator+=</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_plus_equal<LHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_plus_equal</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator+=</code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator+=</code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_plus_equal.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:

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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of postfix <code class="computeroutput">operator--</code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of postfix <code class="computeroutput">operator--</code>. Be careful that it does not mean that
+ <code class="computeroutput">operator--</code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -48,14 +52,14 @@

 

- This trait can not detect whether postfix <code class="computeroutput">operator--</code> is public or not: if <code class="computeroutput">operator--</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_postfix_decrement<LHS></code> will produce a compiler error. For this
+ This trait cannot detect whether postfix <code class="computeroutput">operator--</code> is public or not: if <code class="computeroutput">operator--</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_postfix_decrement<LHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_postfix_decrement</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator--</code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator--</code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_postfix_decrement.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:
@@ -93,6 +97,16 @@
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
 </blockquote></div>
<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_postfix_decrement<bool></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_postfix_decrement<const int></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_postfix_decrement<void*></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_postfix_decrement<int, std::string></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of postfix <code class="computeroutput">operator++</code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of postfix <code class="computeroutput">operator++</code>. Be careful that it does not mean that
+ <code class="computeroutput">operator++</code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -48,14 +52,14 @@

 

- This trait can not detect whether postfix <code class="computeroutput">operator++</code> is public or not: if <code class="computeroutput">operator++</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_postfix_increment<LHS></code> will produce a compiler error. For this
+ This trait cannot detect whether postfix <code class="computeroutput">operator++</code> is public or not: if <code class="computeroutput">operator++</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_postfix_increment<LHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_postfix_increment</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator++</code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator++</code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_postfix_increment.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:
@@ -93,6 +97,16 @@
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
 </blockquote></div>
<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_postfix_increment<bool></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_postfix_increment<const int></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_postfix_increment<void*></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_postfix_increment<int, std::string></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of prefix <code class="computeroutput">operator--</code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of prefix <code class="computeroutput">operator--</code>. Be careful that it does not mean that
+ <code class="computeroutput">operator--</code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -48,14 +52,14 @@

 

- This trait can not detect whether prefix <code class="computeroutput">operator--</code> is public or not: if <code class="computeroutput">operator--</code> is defined as a private member of <code class="computeroutput">RHS</code> then instantiating <code class="computeroutput">has_operator_prefix_decrement<RHS></code> will produce a compiler error. For this
+ This trait cannot detect whether prefix <code class="computeroutput">operator--</code> is public or not: if <code class="computeroutput">operator--</code> is defined as a private member of <code class="computeroutput">RHS</code> then instantiating <code class="computeroutput">has_operator_prefix_decrement<RHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_prefix_decrement</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator--</code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator--</code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_prefix_decrement.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:
@@ -93,6 +97,16 @@
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
 </blockquote></div>
<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_prefix_decrement<bool></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_prefix_decrement<const int></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_prefix_decrement<void*></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_prefix_decrement<int, std::string></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of prefix <code class="computeroutput">operator++</code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of prefix <code class="computeroutput">operator++</code>. Be careful that it does not mean that
+ <code class="computeroutput">operator++</code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -48,14 +52,14 @@

 

- This trait can not detect whether prefix <code class="computeroutput">operator++</code> is public or not: if <code class="computeroutput">operator++</code> is defined as a private member of <code class="computeroutput">RHS</code> then instantiating <code class="computeroutput">has_operator_prefix_increment<RHS></code> will produce a compiler error. For this
+ This trait cannot detect whether prefix <code class="computeroutput">operator++</code> is public or not: if <code class="computeroutput">operator++</code> is defined as a private member of <code class="computeroutput">RHS</code> then instantiating <code class="computeroutput">has_operator_prefix_increment<RHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_prefix_increment</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator++</code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator++</code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_prefix_increment.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:
@@ -93,6 +97,16 @@
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
 </blockquote></div>
<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_prefix_increment<bool></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_prefix_increment<const int></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_prefix_increment<void*></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_prefix_increment<int, std::string></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of binary <code class="computeroutput">operator>></code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of binary <code class="computeroutput">operator>></code>. Be careful that it does not mean
+ that <code class="computeroutput">operator>></code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -48,16 +52,16 @@

 

- This trait can not detect whether binary <code class="computeroutput">operator>></code> is public or not: if <code class="computeroutput">operator>></code>
+ This trait cannot detect whether binary <code class="computeroutput">operator>></code> is public or not: if <code class="computeroutput">operator>></code>
 is defined as a private member of <code class="computeroutput">LHS</code>
 then instantiating <code class="computeroutput">has_operator_right_shift<LHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_right_shift</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator>></code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator>></code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_right_shift.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:
@@ -85,6 +89,21 @@
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
 </blockquote></div>
<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_right_shift<const int, int></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_right_shift<std::istream, int&></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_right_shift<std::istream, char*,
+ std::ostream></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_right_shift<std::istream, std::string&></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_right_shift<int, double, bool></code>
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of binary <code class="computeroutput">operator>>=</code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of binary <code class="computeroutput">operator>>=</code>. Be careful that it does not mean
+ that <code class="computeroutput">operator>>=</code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -48,16 +52,16 @@

 

- This trait can not detect whether binary <code class="computeroutput">operator>>=</code> is public or not: if <code class="computeroutput">operator>>=</code>
+ This trait cannot detect whether binary <code class="computeroutput">operator>>=</code> is public or not: if <code class="computeroutput">operator>>=</code>
 is defined as a private member of <code class="computeroutput">LHS</code>
 then instantiating <code class="computeroutput">has_operator_right_shift_equal<LHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_right_shift_equal</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator>>=</code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator>>=</code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_right_shift_equal.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:
@@ -85,6 +89,9 @@
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
 </blockquote></div>
<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_right_shift_equal<const int, int></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_right_shift_equal<int, double, bool></code>
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of prefix <code class="computeroutput">operator-</code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of prefix <code class="computeroutput">operator-</code>. Be careful that it does not mean that
+ <code class="computeroutput">operator-</code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -48,14 +52,14 @@

 

- This trait can not detect whether prefix <code class="computeroutput">operator-</code> is public or not: if <code class="computeroutput">operator-</code> is defined as a private member of <code class="computeroutput">RHS</code> then instantiating <code class="computeroutput">has_operator_unary_minus<RHS></code> will produce a compiler error. For this
+ This trait cannot detect whether prefix <code class="computeroutput">operator-</code> is public or not: if <code class="computeroutput">operator-</code> is defined as a private member of <code class="computeroutput">RHS</code> then instantiating <code class="computeroutput">has_operator_unary_minus<RHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_unary_minus</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator-</code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator-</code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_unary_minus.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:
@@ -93,6 +97,10 @@
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
 </blockquote></div>
<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_unary_minus<const int></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_unary_minus<int, std::string></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </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 @@
 

 The default behaviour (<code class="computeroutput">RET=void</code>) is
- to not check for the return value of prefix <code class="computeroutput">operator+</code>. If <code class="computeroutput">RET</code>
- is different from the default <code class="computeroutput">void</code>
- type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ to not check for the return value of prefix <code class="computeroutput">operator+</code>. Be careful that it does not mean that
+ <code class="computeroutput">operator+</code>
+ must return <code class="computeroutput">void</code> to have the
+ trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
+ If <code class="computeroutput">RET</code> is different from
+ the default <code class="computeroutput">void</code> type, the return
+ value is checked to be convertible to <code class="computeroutput">RET</code>.
 Convertible to <code class="computeroutput">RET</code> means
 that the return value of the operator can be used as argument to a function
 expecting <code class="computeroutput">RET</code>:
@@ -48,14 +52,14 @@

 

- This trait can not detect whether prefix <code class="computeroutput">operator+</code> is public or not: if <code class="computeroutput">operator+</code> is defined as a private member of <code class="computeroutput">RHS</code> then instantiating <code class="computeroutput">has_operator_unary_plus<RHS></code> will produce a compiler error. For this
+ This trait cannot detect whether prefix <code class="computeroutput">operator+</code> is public or not: if <code class="computeroutput">operator+</code> is defined as a private member of <code class="computeroutput">RHS</code> then instantiating <code class="computeroutput">has_operator_unary_plus<RHS></code> will produce a compiler error. For this
 reason <code class="computeroutput">has_operator_unary_plus</code>
- can not be used to determine whether a type has a public <code class="computeroutput">operator+</code> or not.
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator+</code> or not.
 

 Header: <code class="computeroutput">#include
 <boost/type_traits/has_operator_unary_plus.hpp></code>
- or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits/operators.hpp></code>
 

 Examples:
@@ -93,6 +97,10 @@
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
 </blockquote></div>
<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_unary_plus<const int></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_unary_plus<int, std::string></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </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"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3420990"></a>Table 1.18. Examples
+<a name="id3374862"></a>Table 1.18. Examples
<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"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3438909"></a>Table 1.19. Examples
+<a name="id3392784"></a>Table 1.19. Examples
<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"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3439489"></a>Table 1.20. Examples
+<a name="id3393365"></a>Table 1.20. Examples
<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"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3440094"></a>Table 1.21. Examples
+<a name="id3393969"></a>Table 1.21. Examples
<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"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3440853"></a>Table 1.22. Examples
+<a name="id3394729"></a>Table 1.22. Examples
<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"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3442140"></a>Table 1.23. Examples
+<a name="id3396014"></a>Table 1.23. Examples
<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"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3442802"></a>Table 1.24. Examples
+<a name="id3396677"></a>Table 1.24. Examples
<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"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3443447"></a>Table 1.25. Examples
+<a name="id3397322"></a>Table 1.25. Examples
<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"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3444094"></a>Table 1.26. Examples
+<a name="id3397969"></a>Table 1.26. Examples
<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"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3445362"></a>Table 1.28. Examples
+<a name="id3399237"></a>Table 1.28. Examples
<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"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3444770"></a>Table 1.27. Examples
+<a name="id3398645"></a>Table 1.27. Examples
<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"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3446151"></a>Table 1.29. Examples
+<a name="id3400027"></a>Table 1.29. Examples
<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"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3446707"></a>Table 1.30. Examples
+<a name="id3400582"></a>Table 1.30. Examples
<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</div>
<div><div class="legalnotice">
-<a name="id3337342"></a>
+<a name="id3282387"></a>
 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)

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::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::value; // error: ambigous overload between
+ // operator-(const any&) and
+ // operator-(const A&)
+ // both need type conversion
+``
[endsect]

Next message: fmhess_at_[hidden]: "[Boost-commit] svn:boost r69479 - in branches/release/boost/signals2: . detail"
Previous message: garcia_at_[hidden]: "[Boost-commit] svn:boost r69477 - website/public_html/live/community"

Date view	Thread view	Subject view	Author view

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