Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r69593 - in sandbox/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 libs/type_traits/test
From: frederic.bron_at_[hidden]
Date: 2011-03-05 19:20:30

Next message: lorcaminiti_at_[hidden]: "[Boost-commit] svn:boost r69594 - in sandbox/local: . boost/local/aux_/function_macros/code_ libs/local/example"
Previous message: atompkins_at_[hidden]: "[Boost-commit] svn:boost r69592 - trunk/libs/uuid/test"

Author: bronf
Date: 2011-03-05 19:20:12 EST (Sat, 05 Mar 2011)
New Revision: 69593
URL: http://svn.boost.org/trac/boost/changeset/69593

Log:
operator traits: fixed issue with overload of operator,(RET,int), more testing, improved documentation, added acknowledgments
Text files modified:
   sandbox/type_traits/boost/type_traits/detail/bool_trait_undef.hpp | 1
   sandbox/type_traits/boost/type_traits/detail/has_binary_operator.hpp | 7 ++--
   sandbox/type_traits/boost/type_traits/detail/has_postfix_operator.hpp | 7 ++--
   sandbox/type_traits/boost/type_traits/detail/has_prefix_operator.hpp | 7 ++--
   sandbox/type_traits/libs/type_traits/doc/has_operator_bit_and.qbk | 29 +++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/has_operator_bit_and_equal.qbk | 29 +++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/has_operator_bit_or.qbk | 29 +++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/has_operator_bit_or_equal.qbk | 29 +++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/has_operator_bit_xor.qbk | 29 +++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/has_operator_bit_xor_equal.qbk | 29 +++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/has_operator_complement.qbk | 29 +++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/has_operator_dereference.qbk | 29 +++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/has_operator_divides.qbk | 29 +++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/has_operator_divides_equal.qbk | 29 +++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/has_operator_equal_to.qbk | 29 +++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/has_operator_greater.qbk | 29 +++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/has_operator_greater_equal.qbk | 29 +++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/has_operator_left_shift.qbk | 29 +++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/has_operator_left_shift_equal.qbk | 29 +++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/has_operator_less.qbk | 29 +++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/has_operator_less_equal.qbk | 29 +++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/has_operator_logical_and.qbk | 29 +++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/has_operator_logical_not.qbk | 29 +++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/has_operator_logical_or.qbk | 29 +++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/has_operator_minus.qbk | 29 +++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/has_operator_minus_equal.qbk | 29 +++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/has_operator_modulus.qbk | 29 +++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/has_operator_modulus_equal.qbk | 29 +++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/has_operator_multiplies.qbk | 29 +++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/has_operator_multiplies_equal.qbk | 29 +++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/has_operator_not_equal_to.qbk | 29 +++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/has_operator_plus.qbk | 29 +++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/has_operator_plus_equal.qbk | 29 +++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/has_operator_postfix_decrement.qbk | 29 +++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/has_operator_postfix_increment.qbk | 29 +++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/has_operator_prefix_decrement.qbk | 29 +++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/has_operator_prefix_increment.qbk | 29 +++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/has_operator_right_shift.qbk | 29 +++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/has_operator_right_shift_equal.qbk | 29 +++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/has_operator_unary_minus.qbk | 29 +++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/has_operator_unary_plus.qbk | 29 +++++++++++++++----
   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 | 60 ++++++++++++++++++++++++++--------------
   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 | 32 ++++++++++++++++++---
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_and_equal.html | 36 +++++++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_or.html | 32 ++++++++++++++++++---
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_or_equal.html | 32 ++++++++++++++++++---
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_xor.html | 32 ++++++++++++++++++---
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_xor_equal.html | 32 ++++++++++++++++++---
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_complement.html | 32 ++++++++++++++++++---
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_dereference.html | 32 ++++++++++++++++++---
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_divides.html | 32 ++++++++++++++++++---
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_divides_equal.html | 32 ++++++++++++++++++---
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_equal_to.html | 32 ++++++++++++++++++---
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_greater.html | 32 ++++++++++++++++++---
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_greater_equal.html | 32 ++++++++++++++++++---
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_left_shift.html | 36 +++++++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_left_shift_equal.html | 36 +++++++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_less.html | 32 ++++++++++++++++++---
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_less_equal.html | 32 ++++++++++++++++++---
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_logical_and.html | 36 +++++++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_logical_not.html | 32 ++++++++++++++++++---
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_logical_or.html | 32 ++++++++++++++++++---
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_minus.html | 32 ++++++++++++++++++---
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_minus_equal.html | 32 ++++++++++++++++++---
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_modulus.html | 32 ++++++++++++++++++---
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_modulus_equal.html | 32 ++++++++++++++++++---
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_multiplies.html | 32 ++++++++++++++++++---
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_multiplies_equal.html | 32 ++++++++++++++++++---
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_not_equal_to.html | 32 ++++++++++++++++++---
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_plus.html | 32 ++++++++++++++++++---
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_plus_equal.html | 32 ++++++++++++++++++---
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_postfix_decrement.html | 32 ++++++++++++++++++---
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_postfix_increment.html | 32 ++++++++++++++++++---
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_prefix_decrement.html | 32 ++++++++++++++++++---
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_prefix_increment.html | 32 ++++++++++++++++++---
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_right_shift.html | 36 +++++++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_right_shift_equal.html | 36 +++++++++++++++++++----
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_unary_minus.html | 32 ++++++++++++++++++---
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_unary_plus.html | 32 ++++++++++++++++++---
   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 | 19 +++++++++---
   sandbox/type_traits/libs/type_traits/test/has_binary_operator_test.hpp | 27 ++++++++++++++++-
   sandbox/type_traits/libs/type_traits/test/has_postfix_operator_test.hpp | 27 ++++++++++++++++-
   sandbox/type_traits/libs/type_traits/test/has_prefix_operator_test.hpp | 29 ++++++++++++++++--
   108 files changed, 2039 insertions(+), 498 deletions(-)

Modified: sandbox/type_traits/boost/type_traits/detail/bool_trait_undef.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/detail/bool_trait_undef.hpp (original)
+++ sandbox/type_traits/boost/type_traits/detail/bool_trait_undef.hpp 2011-03-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -15,6 +15,7 @@
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
+#undef BOOST_TT_AUX_BOOL_TRAIT_DEF3
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1

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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -144,15 +144,16 @@
// 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);
+struct tag2 { };
+tag operator,(tag, tag2);

// 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
+ static ::boost::type_traits::yes_type check(tag2); // this version is preferred when operator exists
static ::boost::type_traits::no_type check(tag); // this version is used otherwise

- BOOST_STATIC_CONSTANT(bool, value = (sizeof(check(((make<LHS>() BOOST_TT_TRAIT_OP make<RHS>()),0)))==sizeof(::boost::type_traits::yes_type)));
+ BOOST_STATIC_CONSTANT(bool, value = (sizeof(check(((make<LHS>() BOOST_TT_TRAIT_OP make<RHS>()),tag2())))==sizeof(::boost::type_traits::yes_type)));
};

// some specializations needs to be declared for the special void case

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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -122,15 +122,16 @@
// 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);
+struct tag2 { };
+tag operator,(tag, tag2);

// 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
+ static ::boost::type_traits::yes_type check(tag2); // this version is preferred when operator exists
static ::boost::type_traits::no_type check(tag); // this version is used otherwise

- BOOST_STATIC_CONSTANT(bool, value = (sizeof(check(((make<LHS>() BOOST_TT_TRAIT_OP),0)))==sizeof(::boost::type_traits::yes_type)));
+ BOOST_STATIC_CONSTANT(bool, value = (sizeof(check(((make<LHS>() BOOST_TT_TRAIT_OP),tag2())))==sizeof(::boost::type_traits::yes_type)));
};

// some specializations needs to be declared for the special void case

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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -139,15 +139,16 @@
// 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);
+struct tag2 { };
+tag operator,(tag, tag2);

// 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
+ static ::boost::type_traits::yes_type check(tag2); // this version is preferred when operator exists
static ::boost::type_traits::no_type check(tag); // this version is used otherwise

- BOOST_STATIC_CONSTANT(bool, value = (sizeof(check(((BOOST_TT_TRAIT_OP make<RHS>()),0)))==sizeof(::boost::type_traits::yes_type)));
+ BOOST_STATIC_CONSTANT(bool, value = (sizeof(check(((BOOST_TT_TRAIT_OP make<RHS>()),tag2())))==sizeof(::boost::type_traits::yes_type)));
};

// some specializations needs to be declared for the special void case

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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -26,16 +26,10 @@
f(lhs&rhs); // is valid if has_operator_bit_and<LHS, RHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_bit_and<LHS, RHS, RET>::value_type` is the type `bool`.]
[:`has_operator_bit_and<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_bit_and<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -47,4 +41,27 @@
[:`has_operator_bit_and<int, double, bool>` inherits from `__false_type`.]
[:`has_operator_bit_and<int, int, std::string>` inherits from `__false_type`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator&` or not.
+``
+struct A { private: void operator&(const A&); };
+boost::has_operator_bit_and<A>::value; // error: A::operator&(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+struct A { };
+void operator&(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_bit_and<A>::value; // this is fine
+boost::has_operator_bit_and::value; // error: ambigous overload
+``
+
[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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -26,16 +26,10 @@
f(lhs&=rhs); // is valid if has_operator_bit_and_equal<LHS, RHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_bit_and_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
[:`has_operator_bit_and_equal<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_bit_and_equal<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -47,4 +41,27 @@
[:`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`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator&=` or not.
+``
+struct A { private: void operator&=(const A&); };
+boost::has_operator_bit_and_equal<A>::value; // error: A::operator&=(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+struct A { };
+void operator&=(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_bit_and_equal<A>::value; // this is fine
+boost::has_operator_bit_and_equal::value; // error: ambigous overload
+``
+
[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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -26,16 +26,10 @@
f(lhs|rhs); // is valid if has_operator_bit_or<LHS, RHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_bit_or<LHS, RHS, RET>::value_type` is the type `bool`.]
[:`has_operator_bit_or<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_bit_or<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -47,4 +41,27 @@
[:`has_operator_bit_or<int, double, bool>` inherits from `__false_type`.]
[:`has_operator_bit_or<int, int, std::string>` inherits from `__false_type`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator|` or not.
+``
+struct A { private: void operator|(const A&); };
+boost::has_operator_bit_or<A>::value; // error: A::operator|(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+struct A { };
+void operator|(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_bit_or<A>::value; // this is fine
+boost::has_operator_bit_or::value; // error: ambigous overload
+``
+
[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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -26,16 +26,10 @@
f(lhs|=rhs); // is valid if has_operator_bit_or_equal<LHS, RHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_bit_or_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
[:`has_operator_bit_or_equal<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_bit_or_equal<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -47,4 +41,27 @@
[:`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`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator|=` or not.
+``
+struct A { private: void operator|=(const A&); };
+boost::has_operator_bit_or_equal<A>::value; // error: A::operator|=(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+struct A { };
+void operator|=(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_bit_or_equal<A>::value; // this is fine
+boost::has_operator_bit_or_equal::value; // error: ambigous overload
+``
+
[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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -26,16 +26,10 @@
f(lhs^rhs); // is valid if has_operator_bit_xor<LHS, RHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_bit_xor<LHS, RHS, RET>::value_type` is the type `bool`.]
[:`has_operator_bit_xor<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_bit_xor<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -47,4 +41,27 @@
[:`has_operator_bit_xor<int, double, bool>` inherits from `__false_type`.]
[:`has_operator_bit_xor<int, int, std::string>` inherits from `__false_type`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator^` or not.
+``
+struct A { private: void operator^(const A&); };
+boost::has_operator_bit_xor<A>::value; // error: A::operator^(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+struct A { };
+void operator^(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_bit_xor<A>::value; // this is fine
+boost::has_operator_bit_xor::value; // error: ambigous overload
+``
+
[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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -26,16 +26,10 @@
f(lhs^=rhs); // is valid if has_operator_bit_xor_equal<LHS, RHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_bit_xor_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
[:`has_operator_bit_xor_equal<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_bit_xor_equal<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -47,4 +41,27 @@
[:`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`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator^=` or not.
+``
+struct A { private: void operator^=(const A&); };
+boost::has_operator_bit_xor_equal<A>::value; // error: A::operator^=(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+struct A { };
+void operator^=(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_bit_xor_equal<A>::value; // this is fine
+boost::has_operator_bit_xor_equal::value; // error: ambigous overload
+``
+
[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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -25,16 +25,10 @@
f(~rhs); // is valid if has_operator_complement<RHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_complement<RHS, RET>::value_type` is the type `bool`.]
[:`has_operator_complement<RHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_complement<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -49,4 +43,27 @@
[:`has_operator_complement<double, int>` inherits from `__false_type`.]
[:`has_operator_complement<int, std::string>` inherits from `__false_type`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator~` or not.
+``
+struct A { private: void operator~(); };
+boost::has_operator_complement<A>::value; // error: A::operator~() is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+struct A { };
+void operator~(const A&);
+struct B { operator A(); };
+boost::has_operator_complement<A>::value; // this is fine
+boost::has_operator_complement::value; // error: ambigous overload
+``
+
[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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -25,16 +25,10 @@
f(*rhs); // is valid if has_operator_dereference<RHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_dereference<RHS, RET>::value_type` is the type `bool`.]
[:`has_operator_dereference<RHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_dereference<int*>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -52,4 +46,27 @@
[:`has_operator_dereference<void*>` inherits from `__false_type`.]
[:`has_operator_dereference<const int*, int&>` inherits from `__false_type`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator*` or not.
+``
+struct A { private: void operator*(); };
+boost::has_operator_dereference<A>::value; // error: A::operator*() is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+struct A { };
+void operator*(const A&);
+struct B { operator A(); };
+boost::has_operator_dereference<A>::value; // this is fine
+boost::has_operator_dereference::value; // error: ambigous overload
+``
+
[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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -26,16 +26,10 @@
f(lhs/rhs); // is valid if has_operator_divides<LHS, RHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_divides<LHS, RHS, RET>::value_type` is the type `bool`.]
[:`has_operator_divides<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_divides<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -49,4 +43,27 @@

[:`has_operator_divides<int, int, std::string>` inherits from `__false_type`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator/` or not.
+``
+struct A { private: void operator/(const A&); };
+boost::has_operator_divides<A>::value; // error: A::operator/(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+struct A { };
+void operator/(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_divides<A>::value; // this is fine
+boost::has_operator_divides::value; // error: ambigous overload
+``
+
[endsect]
+

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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -26,16 +26,10 @@
f(lhs/=rhs); // is valid if has_operator_divides_equal<LHS, RHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_divides_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
[:`has_operator_divides_equal<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_divides_equal<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -49,4 +43,27 @@
[:`has_operator_divides_equal<const int, int>::value` inherits from `__false_type`.]
[:`has_operator_divides_equal<int, int, std::string>` inherits from `__false_type`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator/=` or not.
+``
+struct A { private: void operator/=(const A&); };
+boost::has_operator_divides_equal<A>::value; // error: A::operator/=(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+struct A { };
+void operator/=(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_divides_equal<A>::value; // this is fine
+boost::has_operator_divides_equal::value; // error: ambigous overload
+``
+
[endsect]
+

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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -26,16 +26,10 @@
f(lhs==rhs); // is valid if has_operator_equal_to<LHS, RHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_equal_to<LHS, RHS, RET>::value_type` is the type `bool`.]
[:`has_operator_equal_to<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_equal_to<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -49,4 +43,27 @@
[:`has_operator_equal_to<int*, double*>` inherits from `__false_type`.]
[:`has_operator_equal_to<int, int, std::string>` inherits from `__false_type`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator==` or not.
+``
+struct A { private: void operator==(const A&); };
+boost::has_operator_equal_to<A>::value; // error: A::operator==(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+struct A { };
+void operator==(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_equal_to<A>::value; // this is fine
+boost::has_operator_equal_to::value; // error: ambigous overload
+``
+
[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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -26,16 +26,10 @@
f(lhs>rhs); // is valid if has_operator_greater<LHS, RHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_greater<LHS, RHS, RET>::value_type` is the type `bool`.]
[:`has_operator_greater<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_greater<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -49,4 +43,27 @@
[:`has_operator_greater<int*, double*>` inherits from `__false_type`.]
[:`has_operator_greater<int, int, std::string>` inherits from `__false_type`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator>` or not.
+``
+struct A { private: void operator>(const A&); };
+boost::has_operator_greater<A>::value; // error: A::operator>(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+struct A { };
+void operator>(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_greater<A>::value; // this is fine
+boost::has_operator_greater::value; // error: ambigous overload
+``
+
[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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -26,16 +26,10 @@
f(lhs>=rhs); // is valid if has_operator_greater_equal<LHS, RHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_greater_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
[:`has_operator_greater_equal<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_greater_equal<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -49,4 +43,27 @@
[:`has_operator_greater_equal<int*, double*>` inherits from `__false_type`.]
[:`has_operator_greater_equal<int, int, std::string>` inherits from `__false_type`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator>=` or not.
+``
+struct A { private: void operator>=(const A&); };
+boost::has_operator_greater_equal<A>::value; // error: A::operator>=(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+struct A { };
+void operator>=(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_greater_equal<A>::value; // this is fine
+boost::has_operator_greater_equal::value; // error: ambigous overload
+``
+
[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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -26,16 +26,10 @@
f(lhs<<rhs); // is valid if has_operator_left_shift<LHS, RHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_left_shift<LHS, RHS, RET>::value_type` is the type `bool`.]
[:`has_operator_left_shift<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_left_shift<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -50,4 +44,27 @@
[:`has_operator_left_shift<int, double, bool>` inherits from `__false_type`.]
[:`has_operator_left_shift<int, int, std::string>` inherits from `__false_type`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator<<` or not.
+``
+struct A { private: void operator<<(const A&); };
+boost::has_operator_left_shift<A>::value; // error: A::operator<<(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+struct A { };
+void operator<<(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_left_shift<A>::value; // this is fine
+boost::has_operator_left_shift::value; // error: ambigous overload
+``
+
[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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -26,16 +26,10 @@
f(lhs<<=rhs); // is valid if has_operator_left_shift_equal<LHS, RHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_left_shift_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
[:`has_operator_left_shift_equal<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_left_shift_equal<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -47,4 +41,27 @@
[:`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`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator<<=` or not.
+``
+struct A { private: void operator<<=(const A&); };
+boost::has_operator_left_shift_equal<A>::value; // error: A::operator<<=(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+struct A { };
+void operator<<=(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_left_shift_equal<A>::value; // this is fine
+boost::has_operator_left_shift_equal::value; // error: ambigous overload
+``
+
[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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -26,16 +26,10 @@
f(lhs<rhs); // is valid if has_operator_less<LHS, RHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_less<LHS, RHS, RET>::value_type` is the type `bool`.]
[:`has_operator_less<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_less<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -49,4 +43,27 @@
[:`has_operator_less<int*, double*>` inherits from `__false_type`.]
[:`has_operator_less<int, int, std::string>` inherits from `__false_type`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator<` or not.
+``
+struct A { private: void operator<(const A&); };
+boost::has_operator_less<A>::value; // error: A::operator<(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+struct A { };
+void operator<(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_less<A>::value; // this is fine
+boost::has_operator_less::value; // error: ambigous overload
+``
+
[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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -26,16 +26,10 @@
f(lhs<=rhs); // is valid if has_operator_less_equal<LHS, RHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_less_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
[:`has_operator_less_equal<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_less_equal<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -49,4 +43,27 @@
[:`has_operator_less_equal<int*, double*>` inherits from `__false_type`.]
[:`has_operator_less_equal<int, int, std::string>` inherits from `__false_type`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator<=` or not.
+``
+struct A { private: void operator<=(const A&); };
+boost::has_operator_less_equal<A>::value; // error: A::operator<=(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+struct A { };
+void operator<=(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_less_equal<A>::value; // this is fine
+boost::has_operator_less_equal::value; // error: ambigous overload
+``
+
[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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -26,16 +26,10 @@
f(lhs&&rhs); // is valid if has_operator_logical_and<LHS, RHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_logical_and<LHS, RHS, RET>::value_type` is the type `bool`.]
[:`has_operator_logical_and<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_logical_and<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -48,4 +42,27 @@

[:`has_operator_logical_and<int, int, std::string>` inherits from `__false_type`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator&&` or not.
+``
+struct A { private: void operator&&(const A&); };
+boost::has_operator_logical_and<A>::value; // error: A::operator&&(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+struct A { };
+void operator&&(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_logical_and<A>::value; // this is fine
+boost::has_operator_logical_and::value; // error: ambigous overload
+``
+
[endsect]
+

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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -25,16 +25,10 @@
f(!rhs); // is valid if has_operator_logical_not<RHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_logical_not<RHS, RET>::value_type` is the type `bool`.]
[:`has_operator_logical_not<RHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_logical_not<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -48,4 +42,27 @@

[:`has_operator_logical_not<int, std::string>` inherits from `__false_type`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator!` or not.
+``
+struct A { private: void operator!(); };
+boost::has_operator_logical_not<A>::value; // error: A::operator!() is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+struct A { };
+void operator!(const A&);
+struct B { operator A(); };
+boost::has_operator_logical_not<A>::value; // this is fine
+boost::has_operator_logical_not::value; // error: ambigous overload
+``
+
[endsect]
+

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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -26,16 +26,10 @@
f(lhs||rhs); // is valid if has_operator_logical_or<LHS, RHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_logical_or<LHS, RHS, RET>::value_type` is the type `bool`.]
[:`has_operator_logical_or<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_logical_or<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -48,4 +42,27 @@

[:`has_operator_logical_or<int, int, std::string>` inherits from `__false_type`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator||` or not.
+``
+struct A { private: void operator||(const A&); };
+boost::has_operator_logical_or<A>::value; // error: A::operator||(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+struct A { };
+void operator||(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_logical_or<A>::value; // this is fine
+boost::has_operator_logical_or::value; // error: ambigous overload
+``
+
[endsect]
+

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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -26,16 +26,10 @@
f(lhs-rhs); // is valid if has_operator_minus<LHS, RHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_minus<LHS, RHS, RET>::value_type` is the type `bool`.]
[:`has_operator_minus<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_minus<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -49,4 +43,27 @@

[:`has_operator_minus<int, int, std::string>` inherits from `__false_type`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator-` or not.
+``
+struct A { private: void operator-(const A&); };
+boost::has_operator_minus<A>::value; // error: A::operator-(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+struct A { };
+void operator-(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_minus<A>::value; // this is fine
+boost::has_operator_minus::value; // error: ambigous overload
+``
+
[endsect]
+

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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -26,16 +26,10 @@
f(lhs-=rhs); // is valid if has_operator_minus_equal<LHS, RHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_minus_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
[:`has_operator_minus_equal<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_minus_equal<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -49,4 +43,27 @@
[:`has_operator_minus_equal<const int, int>::value` inherits from `__false_type`.]
[:`has_operator_minus_equal<int, int, std::string>` inherits from `__false_type`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator-=` or not.
+``
+struct A { private: void operator-=(const A&); };
+boost::has_operator_minus_equal<A>::value; // error: A::operator-=(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+struct A { };
+void operator-=(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_minus_equal<A>::value; // this is fine
+boost::has_operator_minus_equal::value; // error: ambigous overload
+``
+
[endsect]
+

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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -26,16 +26,10 @@
f(lhs%rhs); // is valid if has_operator_modulus<LHS, RHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_modulus<LHS, RHS, RET>::value_type` is the type `bool`.]
[:`has_operator_modulus<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_modulus<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -47,4 +41,27 @@

[:`has_operator_modulus<int, double>` inherits from `__false_type`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator%` or not.
+``
+struct A { private: void operator%(const A&); };
+boost::has_operator_modulus<A>::value; // error: A::operator%(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+struct A { };
+void operator%(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_modulus<A>::value; // this is fine
+boost::has_operator_modulus::value; // error: ambigous overload
+``
+
[endsect]
+

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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -26,16 +26,10 @@
f(lhs%=rhs); // is valid if has_operator_modulus_equal<LHS, RHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_modulus_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
[:`has_operator_modulus_equal<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_modulus_equal<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -47,4 +41,27 @@
[:`has_operator_modulus_equal<const int, int>::value` inherits from `__false_type`.]
[:`has_operator_modulus_equal<int, double>` inherits from `__false_type`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator%=` or not.
+``
+struct A { private: void operator%=(const A&); };
+boost::has_operator_modulus_equal<A>::value; // error: A::operator%=(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+struct A { };
+void operator%=(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_modulus_equal<A>::value; // this is fine
+boost::has_operator_modulus_equal::value; // error: ambigous overload
+``
+
[endsect]
+

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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -26,16 +26,10 @@
f(lhs*rhs); // is valid if has_operator_multiplies<LHS, RHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_multiplies<LHS, RHS, RET>::value_type` is the type `bool`.]
[:`has_operator_multiplies<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_multiplies<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -49,4 +43,27 @@

[:`has_operator_multiplies<int, int, std::string>` inherits from `__false_type`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator*` or not.
+``
+struct A { private: void operator*(const A&); };
+boost::has_operator_multiplies<A>::value; // error: A::operator*(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+struct A { };
+void operator*(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_multiplies<A>::value; // this is fine
+boost::has_operator_multiplies::value; // error: ambigous overload
+``
+
[endsect]
+

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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -26,16 +26,10 @@
f(lhs*=rhs); // is valid if has_operator_multiplies_equal<LHS, RHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_multiplies_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
[:`has_operator_multiplies_equal<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_multiplies_equal<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -49,4 +43,27 @@
[:`has_operator_multiplies_equal<const int, int>::value` inherits from `__false_type`.]
[:`has_operator_multiplies_equal<int, int, std::string>` inherits from `__false_type`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator*=` or not.
+``
+struct A { private: void operator*=(const A&); };
+boost::has_operator_multiplies_equal<A>::value; // error: A::operator*=(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+struct A { };
+void operator*=(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_multiplies_equal<A>::value; // this is fine
+boost::has_operator_multiplies_equal::value; // error: ambigous overload
+``
+
[endsect]
+

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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -26,16 +26,10 @@
f(lhs!=rhs); // is valid if has_operator_not_equal_to<LHS, RHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_not_equal_to<LHS, RHS, RET>::value_type` is the type `bool`.]
[:`has_operator_not_equal_to<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_not_equal_to<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -49,4 +43,27 @@
[:`has_operator_not_equal_to<int*, double*>` inherits from `__false_type`.]
[:`has_operator_not_equal_to<int, int, std::string>` inherits from `__false_type`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator!=` or not.
+``
+struct A { private: void operator!=(const A&); };
+boost::has_operator_not_equal_to<A>::value; // error: A::operator!=(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+struct A { };
+void operator!=(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_not_equal_to<A>::value; // this is fine
+boost::has_operator_not_equal_to::value; // error: ambigous overload
+``
+
[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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -26,16 +26,10 @@
f(lhs+rhs); // is valid if has_operator_plus<LHS, RHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_plus<LHS, RHS, RET>::value_type` is the type `bool`.]
[:`has_operator_plus<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_plus<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -49,4 +43,27 @@

[:`has_operator_plus<int, int, std::string>` inherits from `__false_type`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator+` or not.
+``
+struct A { private: void operator+(const A&); };
+boost::has_operator_plus<A>::value; // error: A::operator+(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+struct A { };
+void operator+(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_plus<A>::value; // this is fine
+boost::has_operator_plus::value; // error: ambigous overload
+``
+
[endsect]
+

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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -26,16 +26,10 @@
f(lhs+=rhs); // is valid if has_operator_plus_equal<LHS, RHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_plus_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
[:`has_operator_plus_equal<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_plus_equal<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -49,4 +43,27 @@
[:`has_operator_plus_equal<const int, int>::value` inherits from `__false_type`.]
[:`has_operator_plus_equal<int, int, std::string>` inherits from `__false_type`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator+=` or not.
+``
+struct A { private: void operator+=(const A&); };
+boost::has_operator_plus_equal<A>::value; // error: A::operator+=(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+struct A { };
+void operator+=(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_plus_equal<A>::value; // this is fine
+boost::has_operator_plus_equal::value; // error: ambigous overload
+``
+
[endsect]
+

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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -25,16 +25,10 @@
f(lhs--); // is valid if has_operator_postfix_decrement<LHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_postfix_decrement<LHS, RET>::value_type` is the type `bool`.]
[:`has_operator_postfix_decrement<LHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_postfix_decrement<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -50,4 +44,27 @@
[:`has_operator_postfix_decrement<void*>` inherits from `__false_type`.]
[:`has_operator_postfix_decrement<int, std::string>` inherits from `__false_type`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator--` or not.
+``
+struct A { private: void operator--(int); };
+boost::has_operator_postfix_decrement<A>::value; // error: A::operator--(int) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+struct A { };
+void operator--(const A&, int);
+struct B { operator A(); };
+boost::has_operator_postfix_decrement<A>::value; // this is fine
+boost::has_operator_postfix_decrement::value; // error: ambigous overload
+``
+
[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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -25,16 +25,10 @@
f(lhs++); // is valid if has_operator_postfix_increment<LHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_postfix_increment<LHS, RET>::value_type` is the type `bool`.]
[:`has_operator_postfix_increment<LHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_postfix_increment<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -50,4 +44,27 @@
[:`has_operator_postfix_increment<void*>` inherits from `__false_type`.]
[:`has_operator_postfix_increment<int, std::string>` inherits from `__false_type`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator++` or not.
+``
+struct A { private: void operator++(int); };
+boost::has_operator_postfix_increment<A>::value; // error: A::operator++(int) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+struct A { };
+void operator++(const A&, int);
+struct B { operator A(); };
+boost::has_operator_postfix_increment<A>::value; // this is fine
+boost::has_operator_postfix_increment::value; // error: ambigous overload
+``
+
[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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -25,16 +25,10 @@
f(--rhs); // is valid if has_operator_prefix_decrement<RHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_prefix_decrement<RHS, RET>::value_type` is the type `bool`.]
[:`has_operator_prefix_decrement<RHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_prefix_decrement<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -50,4 +44,27 @@
[:`has_operator_prefix_decrement<void*>` inherits from `__false_type`.]
[:`has_operator_prefix_decrement<int, std::string>` inherits from `__false_type`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator--` or not.
+``
+struct A { private: void operator--(); };
+boost::has_operator_prefix_decrement<A>::value; // error: A::operator--() is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+struct A { };
+void operator--(const A&);
+struct B { operator A(); };
+boost::has_operator_prefix_decrement<A>::value; // this is fine
+boost::has_operator_prefix_decrement::value; // error: ambigous overload
+``
+
[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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -25,16 +25,10 @@
f(++rhs); // is valid if has_operator_prefix_increment<RHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_prefix_increment<RHS, RET>::value_type` is the type `bool`.]
[:`has_operator_prefix_increment<RHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_prefix_increment<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -50,4 +44,27 @@
[:`has_operator_prefix_increment<void*>` inherits from `__false_type`.]
[:`has_operator_prefix_increment<int, std::string>` inherits from `__false_type`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator++` or not.
+``
+struct A { private: void operator++(); };
+boost::has_operator_prefix_increment<A>::value; // error: A::operator++() is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+struct A { };
+void operator++(const A&);
+struct B { operator A(); };
+boost::has_operator_prefix_increment<A>::value; // this is fine
+boost::has_operator_prefix_increment::value; // error: ambigous overload
+``
+
[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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -26,16 +26,10 @@
f(lhs>>rhs); // is valid if has_operator_right_shift<LHS, RHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_right_shift<LHS, RHS, RET>::value_type` is the type `bool`.]
[:`has_operator_right_shift<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_right_shift<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -50,4 +44,27 @@
[:`has_operator_right_shift<int, double, bool>` inherits from `__false_type`.]
[:`has_operator_right_shift<int, int, std::string>` inherits from `__false_type`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator>>` or not.
+``
+struct A { private: void operator>>(const A&); };
+boost::has_operator_right_shift<A>::value; // error: A::operator>>(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+struct A { };
+void operator>>(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_right_shift<A>::value; // this is fine
+boost::has_operator_right_shift::value; // error: ambigous overload
+``
+
[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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -26,16 +26,10 @@
f(lhs>>=rhs); // is valid if has_operator_right_shift_equal<LHS, RHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_right_shift_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
[:`has_operator_right_shift_equal<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_right_shift_equal<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -47,4 +41,27 @@
[:`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`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator>>=` or not.
+``
+struct A { private: void operator>>=(const A&); };
+boost::has_operator_right_shift_equal<A>::value; // error: A::operator>>=(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+struct A { };
+void operator>>=(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_right_shift_equal<A>::value; // this is fine
+boost::has_operator_right_shift_equal::value; // error: ambigous overload
+``
+
[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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -25,16 +25,10 @@
f(-rhs); // is valid if has_operator_unary_minus<RHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_unary_minus<RHS, RET>::value_type` is the type `bool`.]
[:`has_operator_unary_minus<RHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_unary_minus<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -48,4 +42,27 @@

[:`has_operator_unary_minus<int, std::string>` inherits from `__false_type`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator-` or not.
+``
+struct A { private: void operator-(); };
+boost::has_operator_unary_minus<A>::value; // error: A::operator-() is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+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
+``
+
[endsect]
+

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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -25,16 +25,10 @@
f(+rhs); // is valid if has_operator_unary_plus<RHS, RET>::value==true
``

-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` 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/operators.hpp>`

__examples

-
[:`has_operator_unary_plus<RHS, RET>::value_type` is the type `bool`.]
[:`has_operator_unary_plus<RHS, RET>::value` is a `bool` integral constant expression.]
[:`has_operator_unary_plus<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
@@ -48,4 +42,27 @@

[:`has_operator_unary_plus<int, std::string>` inherits from `__false_type`.]

+
+[*Known issues:]
+
+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` cannot be used to determine whether a type has a public `operator+` or not.
+``
+struct A { private: void operator+(); };
+boost::has_operator_unary_plus<A>::value; // error: A::operator+() is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambigous overload.
+``
+struct A { };
+void operator+(const A&);
+struct B { operator A(); };
+boost::has_operator_unary_plus<A>::value; // this is fine
+boost::has_operator_unary_plus::value; // error: ambigous overload
+``
+
[endsect]
+

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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -49,7 +49,7 @@
 method available to them.
 
<a name="boost_typetraits.background.type_traits"></a><h5>
-<a name="id3241970"></a>
+<a name="id2959551"></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="id3241014"></a>
+<a name="id2958594"></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="id3292498"></a>
+<a name="id3010079"></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="id3292961"></a>
+<a name="id3010542"></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="id3293029"></a>Table 1.1. Time taken to copy 1000 elements using `copy<const T*, T*>` (times
+<a name="id3010610"></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="id3293181"></a>
+<a name="id3010762"></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="id3293488"></a>Table 1.2. Required Constructor Argument Types
+<a name="id3011069"></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="id3293605"></a>Table 1.3. Using add_reference to synthesize the correct constructor type
+<a name="id3011186"></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="id3294136"></a>
+<a name="id3011717"></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="id3294168"></a>
+<a name="id3011749"></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="id3294195"></a>
+<a name="id3011775"></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-05 19:20:12 EST (Sat, 05 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="id3308747"></a>
+<a name="id3026476"></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-05 19:20:12 EST (Sat, 05 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="id3296808"></a>
+<a name="id3014389"></a>
 <a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.introduction">Introduction</a>
 </h6>

@@ -109,7 +109,7 @@
 operators.
 
<div class="table">
-<a name="id3297644"></a>Table 1.4. Supported binary operators
+<a name="id3015225"></a>Table 1.4. Supported binary operators
<div class="table-contents"><table class="table" summary="Supported binary operators">
<colgroup>
<col>
@@ -555,7 +555,7 @@
</table></div>
</div>
 <div class="table">
-<a name="id3300719"></a>Table 1.5. Supported prefix operators
+<a name="id3018300"></a>Table 1.5. Supported prefix operators
<div class="table-contents"><table class="table" summary="Supported prefix operators">
<colgroup>
<col>
@@ -683,7 +683,7 @@
</table></div>
</div>
 <div class="table">
-<a name="id3301357"></a>Table 1.6. Supported postfix operators
+<a name="id3018938"></a>Table 1.6. Supported postfix operators
<div class="table-contents"><table class="table" summary="Supported postfix operators">
<colgroup>
<col>
@@ -742,7 +742,7 @@
 for each operator and the corresponding trait name.
 
<div class="table">
-<a name="id3301577"></a>Table 1.7. Operator names in the standard
+<a name="id3019157"></a>Table 1.7. Operator names in the standard
<div class="table-contents"><table class="table" summary="Operator names in the standard">
<colgroup>
<col>
@@ -1645,7 +1645,7 @@
</table></div>
</div>
 <a name="boost_typetraits.category.value_traits.operators.implementation"></a><h6>
-<a name="id3304106"></a>
+<a name="id3021687"></a>
 <a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.implementation">Implementation</a>
 </h6>

@@ -1810,27 +1810,34 @@

 
<a name="boost_typetraits.category.value_traits.operators.known_issues"></a><h6>
-<a name="id3307261"></a>
+<a name="id3024842"></a>
 <a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.known_issues">Known
 issues</a>
 </h6>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
+ 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.
+ </li></ul></div>

- 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.
- 
+
+
+<pre class="programlisting">struct A { private: A operator-(); };
+boost::has_operator_unary_minus<A>::value; // error: A::operator-() is private
+</pre>

- 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.
 
+<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code> and <code class="computeroutput">B</code>
+ is convertible to <code class="computeroutput">A</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.
+ </li></ul></div>

- Example 1:
+

<pre class="programlisting">struct A { };
void operator-(const A&);
@@ -1842,7 +1849,7 @@
 // both need type conversion
</pre>

- Example 2:
+

<pre class="programlisting">struct B { };
struct A { A(const B&) { } };
@@ -1855,6 +1862,17 @@
</pre>

 
+<a name="boost_typetraits.category.value_traits.operators.acknowledgments"></a><h6>
+<a name="id3025474"></a>
+ <a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.acknowledgments">Acknowledgments</a>
+ </h6>
+
+ Frédéric Bron is very thankful to numerous people from the boost mailing
+ list for their kind help and patience. In particular, the following persons
+ have been very helpful for the implementation: Edward Diener, Eric Niebler,
+ Jeffrey Lee Hellrung (Jr.), Robert Stewart, Roman Perepelitsa, Steven Watanabe,
+ Vicente Botet.
+ 
</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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -92,7 +92,7 @@
of the following macros:

<div class="table">
-<a name="id3310833"></a>Table 1.8. Macros for Compiler Intrinsics
+<a name="id3028556"></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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -46,7 +46,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3315632"></a>Table 1.9. Examples
+<a name="id3033355"></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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -47,7 +47,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3316215"></a>Table 1.10. Examples
+<a name="id3033938"></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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -49,7 +49,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3316868"></a>Table 1.11. Examples
+<a name="id3034591"></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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -46,7 +46,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3317454"></a>Table 1.12. Examples
+<a name="id3035177"></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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -46,7 +46,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3318031"></a>Table 1.13. Examples
+<a name="id3035754"></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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -41,7 +41,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3319529"></a>Table 1.14. Examples
+<a name="id3037252"></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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -42,7 +42,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3321138"></a>Table 1.15. Examples
+<a name="id3038861"></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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -52,7 +52,7 @@
</td></tr>
</table></div>
<div class="table">
-<a name="id3321583"></a>Table 1.16. Function Traits Members
+<a name="id3039306"></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="id3321840"></a>Table 1.17. Examples
+<a name="id3039563"></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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -51,11 +51,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -93,6 +88,33 @@
<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_bit_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>.
 </blockquote></div>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator&</code> or not.
+
+<pre class="programlisting">struct A { private: void operator&(const A&); };
+boost::has_operator_bit_and<A>::value; // error: A::operator&(const A&) is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<pre class="programlisting">struct A { };
+void operator&(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_bit_and<A>::value; // this is fine
+boost::has_operator_bit_and<B>::value; // error: ambigous overload
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -52,13 +52,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -100,6 +93,35 @@
 std::string></code>
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </blockquote></div>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator&=</code> or not.
+
+<pre class="programlisting">struct A { private: void operator&=(const A&); };
+boost::has_operator_bit_and_equal<A>::value; // error: A::operator&=(const A&) is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<pre class="programlisting">struct A { };
+void operator&=(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_bit_and_equal<A>::value; // this is fine
+boost::has_operator_bit_and_equal<B>::value; // error: ambigous overload
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -52,11 +52,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -94,6 +89,33 @@
<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_bit_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>.
 </blockquote></div>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator|</code> or not.
+
+<pre class="programlisting">struct A { private: void operator|(const A&); };
+boost::has_operator_bit_or<A>::value; // error: A::operator|(const A&) is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<pre class="programlisting">struct A { };
+void operator|(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_bit_or<A>::value; // this is fine
+boost::has_operator_bit_or<B>::value; // error: ambigous overload
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -53,11 +53,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -99,6 +94,33 @@
 std::string></code>
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </blockquote></div>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator|=</code> or not.
+
+<pre class="programlisting">struct A { private: void operator|=(const A&); };
+boost::has_operator_bit_or_equal<A>::value; // error: A::operator|=(const A&) is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<pre class="programlisting">struct A { };
+void operator|=(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_bit_or_equal<A>::value; // this is fine
+boost::has_operator_bit_or_equal<B>::value; // error: ambigous overload
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -52,11 +52,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -94,6 +89,33 @@
<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_bit_xor<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>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator^</code> or not.
+
+<pre class="programlisting">struct A { private: void operator^(const A&); };
+boost::has_operator_bit_xor<A>::value; // error: A::operator^(const A&) is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<pre class="programlisting">struct A { };
+void operator^(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_bit_xor<A>::value; // this is fine
+boost::has_operator_bit_xor<B>::value; // error: ambigous overload
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -53,11 +53,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -99,6 +94,33 @@
 std::string></code>
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </blockquote></div>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator^=</code> or not.
+
+<pre class="programlisting">struct A { private: void operator^=(const A&); };
+boost::has_operator_bit_xor_equal<A>::value; // error: A::operator^=(const A&) is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<pre class="programlisting">struct A { };
+void operator^=(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_bit_xor_equal<A>::value; // this is fine
+boost::has_operator_bit_xor_equal<B>::value; // error: ambigous overload
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -52,11 +52,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -106,6 +101,33 @@
<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_complement<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>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator~</code> or not.
+
+<pre class="programlisting">struct A { private: void operator~(); };
+boost::has_operator_complement<A>::value; // error: A::operator~() is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<pre class="programlisting">struct A { };
+void operator~(const A&);
+struct B { operator A(); };
+boost::has_operator_complement<A>::value; // this is fine
+boost::has_operator_complement<B>::value; // error: ambigous overload
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -52,11 +52,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -112,6 +107,33 @@
<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>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator*</code> or not.
+
+<pre class="programlisting">struct A { private: void operator*(); };
+boost::has_operator_dereference<A>::value; // error: A::operator*() is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<pre class="programlisting">struct A { };
+void operator*(const A&);
+struct B { operator A(); };
+boost::has_operator_dereference<A>::value; // this is fine
+boost::has_operator_dereference<B>::value; // error: ambigous overload
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -52,11 +52,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -100,6 +95,33 @@
<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_divides<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>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator/</code> or not.
+
+<pre class="programlisting">struct A { private: void operator/(const A&); };
+boost::has_operator_divides<A>::value; // error: A::operator/(const A&) is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<pre class="programlisting">struct A { };
+void operator/(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_divides<A>::value; // this is fine
+boost::has_operator_divides<B>::value; // error: ambigous overload
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -53,11 +53,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -108,6 +103,33 @@
 std::string></code>
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </blockquote></div>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator/=</code> or not.
+
+<pre class="programlisting">struct A { private: void operator/=(const A&); };
+boost::has_operator_divides_equal<A>::value; // error: A::operator/=(const A&) is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<pre class="programlisting">struct A { };
+void operator/=(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_divides_equal<A>::value; // this is fine
+boost::has_operator_divides_equal<B>::value; // error: ambigous overload
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -52,11 +52,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -99,6 +94,33 @@
<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>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator==</code> or not.
+
+<pre class="programlisting">struct A { private: void operator==(const A&); };
+boost::has_operator_equal_to<A>::value; // error: A::operator==(const A&) is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<pre class="programlisting">struct A { };
+void operator==(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_equal_to<A>::value; // this is fine
+boost::has_operator_equal_to<B>::value; // error: ambigous overload
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -51,11 +51,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -98,6 +93,33 @@
<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>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator></code> or not.
+
+<pre class="programlisting">struct A { private: void operator>(const A&); };
+boost::has_operator_greater<A>::value; // error: A::operator>(const A&) is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<pre class="programlisting">struct A { };
+void operator>(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_greater<A>::value; // this is fine
+boost::has_operator_greater<B>::value; // error: ambigous overload
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -52,11 +52,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -106,6 +101,33 @@
 std::string></code>
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </blockquote></div>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator>=</code> or not.
+
+<pre class="programlisting">struct A { private: void operator>=(const A&); };
+boost::has_operator_greater_equal<A>::value; // error: A::operator>=(const A&) is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<pre class="programlisting">struct A { };
+void operator>=(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_greater_equal<A>::value; // this is fine
+boost::has_operator_greater_equal<B>::value; // error: ambigous overload
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -52,13 +52,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -112,6 +105,35 @@
 std::string></code>
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </blockquote></div>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator<<</code> or not.
+
+<pre class="programlisting">struct A { private: void operator<<(const A&); };
+boost::has_operator_left_shift<A>::value; // error: A::operator<<(const A&) is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<pre class="programlisting">struct A { };
+void operator<<(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_left_shift<A>::value; // this is fine
+boost::has_operator_left_shift<B>::value; // error: ambigous overload
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -52,13 +52,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -100,6 +93,35 @@
 std::string></code>
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </blockquote></div>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator<<=</code> or not.
+
+<pre class="programlisting">struct A { private: void operator<<=(const A&); };
+boost::has_operator_left_shift_equal<A>::value; // error: A::operator<<=(const A&) is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<pre class="programlisting">struct A { };
+void operator<<=(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_left_shift_equal<A>::value; // this is fine
+boost::has_operator_left_shift_equal<B>::value; // error: ambigous overload
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -51,11 +51,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -98,6 +93,33 @@
<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>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator<</code> or not.
+
+<pre class="programlisting">struct A { private: void operator<(const A&); };
+boost::has_operator_less<A>::value; // error: A::operator<(const A&) is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<pre class="programlisting">struct A { };
+void operator<(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_less<A>::value; // this is fine
+boost::has_operator_less<B>::value; // error: ambigous overload
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -52,11 +52,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -106,6 +101,33 @@
 std::string></code>
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </blockquote></div>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator<=</code> or not.
+
+<pre class="programlisting">struct A { private: void operator<=(const A&); };
+boost::has_operator_less_equal<A>::value; // error: A::operator<=(const A&) is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<pre class="programlisting">struct A { };
+void operator<=(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_less_equal<A>::value; // this is fine
+boost::has_operator_less_equal<B>::value; // error: ambigous overload
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -52,13 +52,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -106,6 +99,35 @@
 std::string></code>
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </blockquote></div>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator&&</code> or not.
+
+<pre class="programlisting">struct A { private: void operator&&(const A&); };
+boost::has_operator_logical_and<A>::value; // error: A::operator&&(const A&) is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<pre class="programlisting">struct A { };
+void operator&&(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_logical_and<A>::value; // this is fine
+boost::has_operator_logical_and<B>::value; // error: ambigous overload
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -52,11 +52,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -103,6 +98,33 @@
<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>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator!</code> or not.
+
+<pre class="programlisting">struct A { private: void operator!(); };
+boost::has_operator_logical_not<A>::value; // error: A::operator!() is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<pre class="programlisting">struct A { };
+void operator!(const A&);
+struct B { operator A(); };
+boost::has_operator_logical_not<A>::value; // this is fine
+boost::has_operator_logical_not<B>::value; // error: ambigous overload
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -53,11 +53,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -105,6 +100,33 @@
 std::string></code>
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </blockquote></div>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator||</code> or not.
+
+<pre class="programlisting">struct A { private: void operator||(const A&); };
+boost::has_operator_logical_or<A>::value; // error: A::operator||(const A&) is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<pre class="programlisting">struct A { };
+void operator||(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_logical_or<A>::value; // this is fine
+boost::has_operator_logical_or<B>::value; // error: ambigous overload
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -52,11 +52,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -100,6 +95,33 @@
<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_minus<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>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator-</code> or not.
+
+<pre class="programlisting">struct A { private: void operator-(const A&); };
+boost::has_operator_minus<A>::value; // error: A::operator-(const A&) is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<pre class="programlisting">struct A { };
+void operator-(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_minus<A>::value; // this is fine
+boost::has_operator_minus<B>::value; // error: ambigous overload
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -53,11 +53,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -108,6 +103,33 @@
 std::string></code>
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </blockquote></div>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator-=</code> or not.
+
+<pre class="programlisting">struct A { private: void operator-=(const A&); };
+boost::has_operator_minus_equal<A>::value; // error: A::operator-=(const A&) is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<pre class="programlisting">struct A { };
+void operator-=(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_minus_equal<A>::value; // this is fine
+boost::has_operator_minus_equal<B>::value; // error: ambigous overload
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -52,11 +52,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -93,6 +88,33 @@
<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_modulus<int, double></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </blockquote></div>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator%</code> or not.
+
+<pre class="programlisting">struct A { private: void operator%(const A&); };
+boost::has_operator_modulus<A>::value; // error: A::operator%(const A&) is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<pre class="programlisting">struct A { };
+void operator%(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_modulus<A>::value; // this is fine
+boost::has_operator_modulus<B>::value; // error: ambigous overload
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -53,11 +53,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -99,6 +94,33 @@
<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_modulus_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>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator%=</code> or not.
+
+<pre class="programlisting">struct A { private: void operator%=(const A&); };
+boost::has_operator_modulus_equal<A>::value; // error: A::operator%=(const A&) is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<pre class="programlisting">struct A { };
+void operator%=(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_modulus_equal<A>::value; // this is fine
+boost::has_operator_modulus_equal<B>::value; // error: ambigous overload
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -53,11 +53,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -108,6 +103,33 @@
 std::string></code>
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </blockquote></div>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator*</code> or not.
+
+<pre class="programlisting">struct A { private: void operator*(const A&); };
+boost::has_operator_multiplies<A>::value; // error: A::operator*(const A&) is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<pre class="programlisting">struct A { };
+void operator*(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_multiplies<A>::value; // this is fine
+boost::has_operator_multiplies<B>::value; // error: ambigous overload
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -53,11 +53,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -108,6 +103,33 @@
 std::string></code>
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </blockquote></div>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator*=</code> or not.
+
+<pre class="programlisting">struct A { private: void operator*=(const A&); };
+boost::has_operator_multiplies_equal<A>::value; // error: A::operator*=(const A&) is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<pre class="programlisting">struct A { };
+void operator*=(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_multiplies_equal<A>::value; // this is fine
+boost::has_operator_multiplies_equal<B>::value; // error: ambigous overload
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -53,11 +53,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -107,6 +102,33 @@
 std::string></code>
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </blockquote></div>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator!=</code> or not.
+
+<pre class="programlisting">struct A { private: void operator!=(const A&); };
+boost::has_operator_not_equal_to<A>::value; // error: A::operator!=(const A&) is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<pre class="programlisting">struct A { };
+void operator!=(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_not_equal_to<A>::value; // this is fine
+boost::has_operator_not_equal_to<B>::value; // error: ambigous overload
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -52,11 +52,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -100,6 +95,33 @@
<div class="blockquote"><blockquote class="blockquote">
 <code class="computeroutput">has_operator_plus<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>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator+</code> or not.
+
+<pre class="programlisting">struct A { private: void operator+(const A&); };
+boost::has_operator_plus<A>::value; // error: A::operator+(const A&) is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<pre class="programlisting">struct A { };
+void operator+(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_plus<A>::value; // this is fine
+boost::has_operator_plus<B>::value; // error: ambigous overload
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -53,11 +53,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -108,6 +103,33 @@
 std::string></code>
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </blockquote></div>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator+=</code> or not.
+
+<pre class="programlisting">struct A { private: void operator+=(const A&); };
+boost::has_operator_plus_equal<A>::value; // error: A::operator+=(const A&) is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<pre class="programlisting">struct A { };
+void operator+=(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_plus_equal<A>::value; // this is fine
+boost::has_operator_plus_equal<B>::value; // error: ambigous overload
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -52,11 +52,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -109,6 +104,33 @@
<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>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator--</code> or not.
+
+<pre class="programlisting">struct A { private: void operator--(int); };
+boost::has_operator_postfix_decrement<A>::value; // error: A::operator--(int) is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<pre class="programlisting">struct A { };
+void operator--(const A&, int);
+struct B { operator A(); };
+boost::has_operator_postfix_decrement<A>::value; // this is fine
+boost::has_operator_postfix_decrement<B>::value; // error: ambigous overload
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -52,11 +52,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -109,6 +104,33 @@
<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>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator++</code> or not.
+
+<pre class="programlisting">struct A { private: void operator++(int); };
+boost::has_operator_postfix_increment<A>::value; // error: A::operator++(int) is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<pre class="programlisting">struct A { };
+void operator++(const A&, int);
+struct B { operator A(); };
+boost::has_operator_postfix_increment<A>::value; // this is fine
+boost::has_operator_postfix_increment<B>::value; // error: ambigous overload
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -52,11 +52,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -109,6 +104,33 @@
<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>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator--</code> or not.
+
+<pre class="programlisting">struct A { private: void operator--(); };
+boost::has_operator_prefix_decrement<A>::value; // error: A::operator--() is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<pre class="programlisting">struct A { };
+void operator--(const A&);
+struct B { operator A(); };
+boost::has_operator_prefix_decrement<A>::value; // this is fine
+boost::has_operator_prefix_decrement<B>::value; // error: ambigous overload
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -52,11 +52,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -109,6 +104,33 @@
<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>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator++</code> or not.
+
+<pre class="programlisting">struct A { private: void operator++(); };
+boost::has_operator_prefix_increment<A>::value; // error: A::operator++() is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<pre class="programlisting">struct A { };
+void operator++(const A&);
+struct B { operator A(); };
+boost::has_operator_prefix_increment<A>::value; // this is fine
+boost::has_operator_prefix_increment<B>::value; // error: ambigous overload
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -52,13 +52,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -112,6 +105,35 @@
 std::string></code>
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </blockquote></div>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator>></code> or not.
+
+<pre class="programlisting">struct A { private: void operator>>(const A&); };
+boost::has_operator_right_shift<A>::value; // error: A::operator>>(const A&) is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<pre class="programlisting">struct A { };
+void operator>>(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_right_shift<A>::value; // this is fine
+boost::has_operator_right_shift<B>::value; // error: ambigous overload
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -52,13 +52,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -100,6 +93,35 @@
 std::string></code>
 inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
 </blockquote></div>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator>>=</code> or not.
+
+<pre class="programlisting">struct A { private: void operator>>=(const A&); };
+boost::has_operator_right_shift_equal<A>::value; // error: A::operator>>=(const A&) is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<pre class="programlisting">struct A { };
+void operator>>=(const A&, const A&);
+struct B { operator A(); };
+boost::has_operator_right_shift_equal<A>::value; // this is fine
+boost::has_operator_right_shift_equal<B>::value; // error: ambigous overload
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -52,11 +52,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -103,6 +98,33 @@
<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>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator-</code> or not.
+
+<pre class="programlisting">struct A { private: void operator-(); };
+boost::has_operator_unary_minus<A>::value; // error: A::operator-() is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<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
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -52,11 +52,6 @@

 

- 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>
- 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/operators.hpp></code>
@@ -103,6 +98,33 @@
<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>
+
+ Known issues:
+ 
+
+ 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>
+ cannot be used to determine whether a type has a public <code class="computeroutput">operator+</code> or not.
+
+<pre class="programlisting">struct A { private: void operator+(); };
+boost::has_operator_unary_plus<A>::value; // error: A::operator+() is private
+</pre>
+
+ 
+
+ There is an issue if the operator exists only for type <code class="computeroutput">A</code>
+ and <code class="computeroutput">B</code> is convertible to
+ <code class="computeroutput">A</code>. In this case, the compiler
+ will report an ambigous overload.
+
+<pre class="programlisting">struct A { };
+void operator+(const A&);
+struct B { operator A(); };
+boost::has_operator_unary_plus<A>::value; // this is fine
+boost::has_operator_unary_plus<B>::value; // error: ambigous overload
+</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/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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -42,7 +42,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3374862"></a>Table 1.18. Examples
+<a name="id3105558"></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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -47,7 +47,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3392784"></a>Table 1.19. Examples
+<a name="id3123476"></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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -47,7 +47,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3393365"></a>Table 1.20. Examples
+<a name="id3124057"></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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -44,7 +44,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3393969"></a>Table 1.21. Examples
+<a name="id3124661"></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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -44,7 +44,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3394729"></a>Table 1.22. Examples
+<a name="id3125421"></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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -47,7 +47,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3396014"></a>Table 1.23. Examples
+<a name="id3126707"></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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -46,7 +46,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3396677"></a>Table 1.24. Examples
+<a name="id3127369"></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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -46,7 +46,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3397322"></a>Table 1.25. Examples
+<a name="id3128014"></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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -47,7 +47,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3397969"></a>Table 1.26. Examples
+<a name="id3128661"></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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -42,7 +42,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3399237"></a>Table 1.28. Examples
+<a name="id3129929"></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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -46,7 +46,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3398645"></a>Table 1.27. Examples
+<a name="id3129337"></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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -46,7 +46,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3400027"></a>Table 1.29. Examples
+<a name="id3130719"></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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -46,7 +46,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id3400582"></a>Table 1.30. Examples
+<a name="id3131274"></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-05 19:20:12 EST (Sat, 05 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="id3282387"></a>
+<a name="id2999968"></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-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -325,18 +325,22 @@

[heading Known issues]

-These traits cannot detect whether the operators are public or not:
+* 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
+``
+struct A { private: A operator-(); };
+boost::has_operator_unary_minus<A>::value; // error: A::operator-() is private
+``
+
+* There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. 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&);
@@ -347,7 +351,6 @@
 // operator-(const A&)
 // both need type conversion
``
-Example 2:
``
struct B { };
struct A { A(const B&) { } };
@@ -358,4 +361,10 @@
 // operator-(const A&)
 // both need type conversion
``
+
+[heading Acknowledgments]
+
+FrÃ©dÃ©ric Bron is very thankful to numerous people from the boost mailing list for their kind help and patience.
+In particular, the following persons have been very helpful for the implementation: Edward Diener, Eric Niebler, Jeffrey Lee Hellrung (Jr.), Robert Stewart, Roman Perepelitsa, Steven Watanabe, Vicente Botet.
+
[endsect]

Modified: sandbox/type_traits/libs/type_traits/test/has_binary_operator_test.hpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_binary_operator_test.hpp (original)
+++ sandbox/type_traits/libs/type_traits/test/has_binary_operator_test.hpp 2011-03-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -14,15 +14,30 @@

namespace {

-struct ret { };
-
struct without { };

+struct ret { };
+
struct internal { ret operator BOOST_TT_TRAIT_OP (const internal&) const; };

struct external { };
ret operator BOOST_TT_TRAIT_OP (const external&, const external&);

+struct comma1_ret { };
+struct ret_with_comma1 { comma1_ret operator,(int); };
+
+struct internal_comma1 { ret_with_comma1 operator BOOST_TT_TRAIT_OP (const internal_comma1&) const; };
+
+struct external_comma1 { };
+ret_with_comma1 operator BOOST_TT_TRAIT_OP (const external_comma1&, const external_comma1&);
+
+struct ret_with_comma2 { void operator,(int); };
+
+struct internal_comma2 { ret_with_comma2 operator BOOST_TT_TRAIT_OP (const internal_comma2&) const; };
+
+struct external_comma2 { };
+ret_with_comma2 operator BOOST_TT_TRAIT_OP (const external_comma2&, const external_comma2&);
+
struct returns_int { int operator BOOST_TT_TRAIT_OP (const returns_int&); };

struct returns_void { void operator BOOST_TT_TRAIT_OP (const returns_void&); };
@@ -68,6 +83,10 @@
    TEST_T(without, false);
    TEST_T(internal, true);
    TEST_T(external, true);
+ TEST_T(internal_comma1, true);
+ TEST_T(external_comma1, true);
+ TEST_T(internal_comma2, true);
+ TEST_T(external_comma2, true);
    TEST_T(returns_int, true);
    TEST_T(returns_void, true);
    TEST_T(returns_void_star, true);
@@ -82,6 +101,10 @@
    TEST_TR(without, bool, false);
    TEST_TR(internal, bool, false);
    TEST_TR(internal, ret, true);
+ TEST_TR(internal_comma1, bool, false);
+ TEST_TR(internal_comma1, ret_with_comma1, true);
+ TEST_TR(internal_comma2, bool, false);
+ TEST_TR(internal_comma2, ret_with_comma2, true);
    TEST_TR(external, bool, false);
    TEST_TR(external, ret, true);
    TEST_TR(returns_int, bool, true);

Modified: sandbox/type_traits/libs/type_traits/test/has_postfix_operator_test.hpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_postfix_operator_test.hpp (original)
+++ sandbox/type_traits/libs/type_traits/test/has_postfix_operator_test.hpp 2011-03-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -10,15 +10,30 @@

namespace {

-struct ret { };
-
struct without { };

+struct ret { };
+
struct internal { ret operator BOOST_TT_TRAIT_OP (int) const; };

struct external { };
ret operator BOOST_TT_TRAIT_OP (const external&, int);

+struct comma1_ret { };
+struct ret_with_comma1 { comma1_ret operator,(int); };
+
+struct internal_comma1 { ret_with_comma1 operator BOOST_TT_TRAIT_OP (int) const; };
+
+struct external_comma1 { };
+ret_with_comma1 operator BOOST_TT_TRAIT_OP (const external_comma1&, int);
+
+struct ret_with_comma2 { void operator,(int); };
+
+struct internal_comma2 { ret_with_comma2 operator BOOST_TT_TRAIT_OP (int) const; };
+
+struct external_comma2 { };
+ret_with_comma2 operator BOOST_TT_TRAIT_OP (const external_comma2&, int);
+
struct returns_int { int operator BOOST_TT_TRAIT_OP (int); };

struct returns_void { void operator BOOST_TT_TRAIT_OP (int); };
@@ -55,6 +70,10 @@
    TEST_T(without, false);
    TEST_T(internal, true);
    TEST_T(external, true);
+ TEST_T(internal_comma1, true);
+ TEST_T(external_comma1, true);
+ TEST_T(internal_comma2, true);
+ TEST_T(external_comma2, true);
    TEST_T(returns_int, true);
    TEST_T(returns_void, true);
    TEST_T(returns_void_star, true);
@@ -69,6 +88,10 @@
    TEST_TR(without, bool, false);
    TEST_TR(internal, bool, false);
    TEST_TR(internal, ret, true);
+ TEST_TR(internal_comma1, bool, false);
+ TEST_TR(internal_comma1, ret_with_comma1, true);
+ TEST_TR(internal_comma2, bool, false);
+ TEST_TR(internal_comma2, ret_with_comma2, true);
    TEST_TR(external, bool, false);
    TEST_TR(external, ret, true);
    TEST_TR(returns_int, bool, true);

Modified: sandbox/type_traits/libs/type_traits/test/has_prefix_operator_test.hpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_prefix_operator_test.hpp (original)
+++ sandbox/type_traits/libs/type_traits/test/has_prefix_operator_test.hpp 2011-03-05 19:20:12 EST (Sat, 05 Mar 2011)
@@ -10,15 +10,30 @@

namespace {

-struct ret { };
-
struct without { };

+struct ret { };
+
struct internal { ret operator BOOST_TT_TRAIT_OP () const; };

struct external { };
ret operator BOOST_TT_TRAIT_OP (const external&);

+struct comma1_ret { };
+struct ret_with_comma1 { comma1_ret operator,(int); };
+
+struct internal_comma1 { ret_with_comma1 operator BOOST_TT_TRAIT_OP () const; };
+
+struct external_comma1 { };
+ret_with_comma1 operator BOOST_TT_TRAIT_OP (const external_comma1&);
+
+struct ret_with_comma2 { void operator,(int); };
+
+struct internal_comma2 { ret_with_comma2 operator BOOST_TT_TRAIT_OP () const; };
+
+struct external_comma2 { };
+ret_with_comma2 operator BOOST_TT_TRAIT_OP (const external_comma2&);
+
struct returns_int { int operator BOOST_TT_TRAIT_OP (); };

struct returns_void { void operator BOOST_TT_TRAIT_OP (); };
@@ -55,6 +70,10 @@
    TEST_T(without, false);
    TEST_T(internal, true);
    TEST_T(external, true);
+ TEST_T(internal_comma1, true);
+ TEST_T(external_comma1, true);
+ TEST_T(internal_comma2, true);
+ TEST_T(external_comma2, true);
    TEST_T(returns_int, true);
    TEST_T(returns_void, true);
    TEST_T(returns_void_star, true);
@@ -67,8 +86,10 @@
    TEST_T(Derived2, true);

    TEST_TR(without, bool, false);
- TEST_TR(internal, bool, false);
- TEST_TR(internal, ret, true);
+ TEST_TR(internal_comma1, bool, false);
+ TEST_TR(internal_comma1, ret_with_comma1, true);
+ TEST_TR(internal_comma2, bool, false);
+ TEST_TR(internal_comma2, ret_with_comma2, true);
    TEST_TR(external, bool, false);
    TEST_TR(external, ret, true);
    TEST_TR(returns_int, bool, true);

Next message: lorcaminiti_at_[hidden]: "[Boost-commit] svn:boost r69594 - in sandbox/local: . boost/local/aux_/function_macros/code_ libs/local/example"
Previous message: atompkins_at_[hidden]: "[Boost-commit] svn:boost r69592 - trunk/libs/uuid/test"

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