Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r66843 - in sandbox/type_traits: boost/type_traits boost/type_traits/detail libs/type_traits/doc libs/type_traits/doc/html libs/type_traits/doc/html/boost_typetraits libs/type_traits/doc/html/boost_typetraits/category libs/type_traits/doc/html/boost_typetraits/reference libs/type_traits/test
From: frederic.bron_at_[hidden]
Date: 2010-11-29 10:29:23

Next message: john_at_[hidden]: "[Boost-commit] svn:boost r66844 - in sandbox/math_constants: boost/math/constants libs/math/test"
Previous message: afojgo_at_[hidden]: "[Boost-commit] svn:boost r66842 - in trunk/boost/icl: . detail"

Author: bronf
Date: 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
New Revision: 66843
URL: http://svn.boost.org/trac/boost/changeset/66843

Log:
added operator traits for +=, *=, -=, /*, %=, &=, |=, ^=, <<, >>, >>= and <<=; added note about private operators yielding compiler error in the doc
Added:
 sandbox/type_traits/boost/type_traits/has_operator_bit_and_equal.hpp (contents, props changed)
 sandbox/type_traits/boost/type_traits/has_operator_bit_or_equal.hpp (contents, props changed)
 sandbox/type_traits/boost/type_traits/has_operator_bit_xor_equal.hpp (contents, props changed)
 sandbox/type_traits/boost/type_traits/has_operator_divides_equal.hpp (contents, props changed)
 sandbox/type_traits/boost/type_traits/has_operator_left_shift.hpp (contents, props changed)
 sandbox/type_traits/boost/type_traits/has_operator_left_shift_equal.hpp (contents, props changed)
 sandbox/type_traits/boost/type_traits/has_operator_minus_equal.hpp (contents, props changed)
 sandbox/type_traits/boost/type_traits/has_operator_modulus_equal.hpp (contents, props changed)
 sandbox/type_traits/boost/type_traits/has_operator_multiplies_equal.hpp (contents, props changed)
 sandbox/type_traits/boost/type_traits/has_operator_plus_equal.hpp (contents, props changed)
 sandbox/type_traits/boost/type_traits/has_operator_right_shift.hpp (contents, props changed)
 sandbox/type_traits/boost/type_traits/has_operator_right_shift_equal.hpp (contents, props changed)
 sandbox/type_traits/libs/type_traits/doc/has_operator_bit_and_equal.qbk (contents, props changed)
 sandbox/type_traits/libs/type_traits/doc/has_operator_bit_or_equal.qbk (contents, props changed)
 sandbox/type_traits/libs/type_traits/doc/has_operator_bit_xor_equal.qbk (contents, props changed)
 sandbox/type_traits/libs/type_traits/doc/has_operator_divides_equal.qbk (contents, props changed)
 sandbox/type_traits/libs/type_traits/doc/has_operator_left_shift.qbk (contents, props changed)
 sandbox/type_traits/libs/type_traits/doc/has_operator_left_shift_equal.qbk (contents, props changed)
 sandbox/type_traits/libs/type_traits/doc/has_operator_minus_equal.qbk (contents, props changed)
 sandbox/type_traits/libs/type_traits/doc/has_operator_modulus_equal.qbk (contents, props changed)
 sandbox/type_traits/libs/type_traits/doc/has_operator_multiplies_equal.qbk (contents, props changed)
 sandbox/type_traits/libs/type_traits/doc/has_operator_plus_equal.qbk (contents, props changed)
 sandbox/type_traits/libs/type_traits/doc/has_operator_right_shift.qbk (contents, props changed)
 sandbox/type_traits/libs/type_traits/doc/has_operator_right_shift_equal.qbk (contents, props changed)
 sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_and_equal.html (contents, props changed)
 sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_or_equal.html (contents, props changed)
 sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_xor_equal.html (contents, props changed)
 sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_divides_equal.html (contents, props changed)
 sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_left_shift.html (contents, props changed)
 sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_left_shift_equal.html (contents, props changed)
 sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_minus_equal.html (contents, props changed)
 sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_modulus_equal.html (contents, props changed)
 sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_multiplies_equal.html (contents, props changed)
 sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_plus_equal.html (contents, props changed)
 sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_right_shift.html (contents, props changed)
 sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_right_shift_equal.html (contents, props changed)
 sandbox/type_traits/libs/type_traits/test/has_operator_bit_and_equal_test.cpp (contents, props changed)
 sandbox/type_traits/libs/type_traits/test/has_operator_bit_or_equal_test.cpp (contents, props changed)
 sandbox/type_traits/libs/type_traits/test/has_operator_bit_xor_equal_test.cpp (contents, props changed)
 sandbox/type_traits/libs/type_traits/test/has_operator_divides_equal_test.cpp (contents, props changed)
 sandbox/type_traits/libs/type_traits/test/has_operator_left_shift_equal_test.cpp (contents, props changed)
 sandbox/type_traits/libs/type_traits/test/has_operator_left_shift_test.cpp (contents, props changed)
 sandbox/type_traits/libs/type_traits/test/has_operator_minus_equal_test.cpp (contents, props changed)
 sandbox/type_traits/libs/type_traits/test/has_operator_modulus_equal_test.cpp (contents, props changed)
 sandbox/type_traits/libs/type_traits/test/has_operator_multiplies_equal_test.cpp (contents, props changed)
 sandbox/type_traits/libs/type_traits/test/has_operator_plus_equal_test.cpp (contents, props changed)
 sandbox/type_traits/libs/type_traits/test/has_operator_right_shift_equal_test.cpp (contents, props changed)
 sandbox/type_traits/libs/type_traits/test/has_operator_right_shift_test.cpp (contents, props changed)
Text files modified:
 sandbox/type_traits/boost/type_traits/detail/has_binary_operator.hpp | 2
 sandbox/type_traits/libs/type_traits/doc/has_operator_bit_and.qbk | 19 +++++---
 sandbox/type_traits/libs/type_traits/doc/has_operator_bit_or.qbk | 19 +++++---
 sandbox/type_traits/libs/type_traits/doc/has_operator_bit_xor.qbk | 19 +++++---
 sandbox/type_traits/libs/type_traits/doc/has_operator_divides.qbk | 19 +++++---
 sandbox/type_traits/libs/type_traits/doc/has_operator_equal_to.qbk | 19 +++++---
 sandbox/type_traits/libs/type_traits/doc/has_operator_greater.qbk | 19 +++++---
 sandbox/type_traits/libs/type_traits/doc/has_operator_greater_equal.qbk | 19 +++++---
 sandbox/type_traits/libs/type_traits/doc/has_operator_less.qbk | 19 +++++---
 sandbox/type_traits/libs/type_traits/doc/has_operator_less_equal.qbk | 19 +++++---
 sandbox/type_traits/libs/type_traits/doc/has_operator_logical_and.qbk | 19 +++++---
 sandbox/type_traits/libs/type_traits/doc/has_operator_logical_not.qbk | 19 +++++---
 sandbox/type_traits/libs/type_traits/doc/has_operator_logical_or.qbk | 19 +++++---
 sandbox/type_traits/libs/type_traits/doc/has_operator_minus.qbk | 19 +++++---
 sandbox/type_traits/libs/type_traits/doc/has_operator_modulus.qbk | 19 +++++---
 sandbox/type_traits/libs/type_traits/doc/has_operator_multiplies.qbk | 19 +++++---
 sandbox/type_traits/libs/type_traits/doc/has_operator_not_equal_to.qbk | 19 +++++---
 sandbox/type_traits/libs/type_traits/doc/has_operator_plus.qbk | 19 +++++---
 sandbox/type_traits/libs/type_traits/doc/has_operator_unary_minus.qbk | 19 +++++---
 sandbox/type_traits/libs/type_traits/doc/has_operator_unary_plus.qbk | 19 +++++---
 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/intrinsics.html | 2
 sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference.html | 24 +++++++++++
 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_no_throw_def_cons.html | 6 +-
 sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_and.html | 23 +++++++---
 sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_or.html | 23 +++++++---
 sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_xor.html | 23 +++++++---
 sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_divides.html | 21 ++++++---
 sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_equal_to.html | 15 +++++-
 sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_greater.html | 21 ++++++---
 sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_greater_equal.html | 15 +++++-
 sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_less.html | 15 +++++-
 sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_less_equal.html | 21 ++++++---
 sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_logical_and.html | 17 ++++++-
 sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_logical_not.html | 15 +++++-
 sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_logical_or.html | 21 ++++++---
 sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_minus.html | 23 +++++++---
 sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_modulus.html | 23 +++++++---
 sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_multiplies.html | 21 ++++++---
 sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_not_equal_to.html | 21 ++++++---
 sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_plus.html | 23 +++++++---
 sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_unary_minus.html | 21 ++++++---
 sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_unary_plus.html | 15 +++++-
 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 | 28 ++++++++++++
 sandbox/type_traits/libs/type_traits/doc/type_traits.qbk | 12 +++++
 sandbox/type_traits/libs/type_traits/test/has_binary_operator_test.hpp | 84 ++++++++++++++++++++-------------------
 sandbox/type_traits/libs/type_traits/test/has_integral_operator_test.hpp | 84 ++++++++++++++++++++-------------------
 sandbox/type_traits/libs/type_traits/test/has_unary_operator_test.hpp | 84 ++++++++++++++++++++-------------------
 70 files changed, 717 insertions(+), 415 deletions(-)

Modified: sandbox/type_traits/boost/type_traits/detail/has_binary_operator.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/detail/has_binary_operator.hpp (original)
+++ sandbox/type_traits/boost/type_traits/detail/has_binary_operator.hpp 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -36,7 +36,7 @@

namespace {
template <typename T>
- typename ::boost::remove_cv<T>::type make();
+ typename ::boost::remove_cv<T>::type &make();
}

template < typename LHS, typename RHS >

Added: sandbox/type_traits/boost/type_traits/has_operator_bit_and_equal.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/has_operator_bit_and_equal.hpp 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,102 @@
+// Copyright 2010 FrÃ©dÃ©ric Bron (frederic.bron_at_[hidden])
+//
+// Use, modification and distribution are subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt).
+//
+// See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_bit_and_equal_HPP_INCLUDED
+#define BOOST_TT_bit_and_equal_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME has_operator_bit_and_equal
+#define BOOST_TT_TRAIT_OP &=
+#define BOOST_TT_DEFAULT_RET void
+
+#include <boost/type_traits/detail/has_binary_operator.hpp>
+
+namespace boost {
+
+template < typename R > struct BOOST_TT_TRAIT_NAME < bool, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < bool, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < bool, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < char, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < char, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < char, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < signed char, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < signed char, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < signed char, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned char, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned char, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned char, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short unsigned int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short unsigned int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short unsigned int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long unsigned int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long unsigned int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long unsigned int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < wchar_t, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < wchar_t, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < wchar_t, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, bool, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, signed char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, short int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, long int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, unsigned char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, short unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, long unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, wchar_t, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, bool, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, signed char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, short int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, long int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, unsigned char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, short unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, long unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, wchar_t, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, bool, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, signed char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, short int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, long int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, unsigned char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, short unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, long unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, wchar_t, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, long double, R > : ::boost::integral_constant<bool,false> { };
+
+}
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_DEFAULT_RET
+
+#endif

Added: sandbox/type_traits/boost/type_traits/has_operator_bit_or_equal.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/has_operator_bit_or_equal.hpp 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,102 @@
+// Copyright 2010 FrÃ©dÃ©ric Bron (frederic.bron_at_[hidden])
+//
+// Use, modification and distribution are subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt).
+//
+// See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_bit_or_equal_HPP_INCLUDED
+#define BOOST_TT_bit_or_equal_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME has_operator_bit_or_equal
+#define BOOST_TT_TRAIT_OP |=
+#define BOOST_TT_DEFAULT_RET void
+
+#include <boost/type_traits/detail/has_binary_operator.hpp>
+
+namespace boost {
+
+template < typename R > struct BOOST_TT_TRAIT_NAME < bool, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < bool, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < bool, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < char, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < char, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < char, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < signed char, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < signed char, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < signed char, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned char, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned char, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned char, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short unsigned int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short unsigned int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short unsigned int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long unsigned int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long unsigned int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long unsigned int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < wchar_t, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < wchar_t, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < wchar_t, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, bool, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, signed char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, short int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, long int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, unsigned char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, short unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, long unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, wchar_t, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, bool, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, signed char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, short int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, long int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, unsigned char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, short unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, long unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, wchar_t, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, bool, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, signed char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, short int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, long int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, unsigned char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, short unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, long unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, wchar_t, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, long double, R > : ::boost::integral_constant<bool,false> { };
+
+}
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_DEFAULT_RET
+
+#endif

Added: sandbox/type_traits/boost/type_traits/has_operator_bit_xor_equal.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/has_operator_bit_xor_equal.hpp 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,102 @@
+// Copyright 2010 FrÃ©dÃ©ric Bron (frederic.bron_at_[hidden])
+//
+// Use, modification and distribution are subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt).
+//
+// See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_bit_xor_equal_HPP_INCLUDED
+#define BOOST_TT_bit_xor_equal_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME has_operator_bit_xor_equal
+#define BOOST_TT_TRAIT_OP ^=
+#define BOOST_TT_DEFAULT_RET void
+
+#include <boost/type_traits/detail/has_binary_operator.hpp>
+
+namespace boost {
+
+template < typename R > struct BOOST_TT_TRAIT_NAME < bool, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < bool, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < bool, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < char, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < char, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < char, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < signed char, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < signed char, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < signed char, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned char, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned char, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned char, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short unsigned int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short unsigned int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short unsigned int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long unsigned int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long unsigned int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long unsigned int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < wchar_t, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < wchar_t, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < wchar_t, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, bool, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, signed char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, short int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, long int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, unsigned char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, short unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, long unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, wchar_t, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, bool, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, signed char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, short int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, long int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, unsigned char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, short unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, long unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, wchar_t, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, bool, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, signed char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, short int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, long int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, unsigned char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, short unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, long unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, wchar_t, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, long double, R > : ::boost::integral_constant<bool,false> { };
+
+}
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_DEFAULT_RET
+
+#endif

Added: sandbox/type_traits/boost/type_traits/has_operator_divides_equal.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/has_operator_divides_equal.hpp 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,22 @@
+// Copyright 2010 FrÃ©dÃ©ric Bron (frederic.bron_at_[hidden])
+//
+// Use, modification and distribution are subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt).
+//
+// See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_divides_equal_HPP_INCLUDED
+#define BOOST_TT_divides_equal_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME has_operator_divides_equal
+#define BOOST_TT_TRAIT_OP /=
+#define BOOST_TT_DEFAULT_RET void
+
+#include <boost/type_traits/detail/has_binary_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_DEFAULT_RET
+
+#endif

Added: sandbox/type_traits/boost/type_traits/has_operator_left_shift.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/has_operator_left_shift.hpp 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,102 @@
+// Copyright 2010 FrÃ©dÃ©ric Bron (frederic.bron_at_[hidden])
+//
+// Use, modification and distribution are subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt).
+//
+// See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_left_shift_HPP_INCLUDED
+#define BOOST_TT_left_shift_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME has_operator_left_shift
+#define BOOST_TT_TRAIT_OP <<
+#define BOOST_TT_DEFAULT_RET void
+
+#include <boost/type_traits/detail/has_binary_operator.hpp>
+
+namespace boost {
+
+template < typename R > struct BOOST_TT_TRAIT_NAME < bool, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < bool, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < bool, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < char, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < char, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < char, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < signed char, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < signed char, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < signed char, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned char, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned char, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned char, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short unsigned int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short unsigned int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short unsigned int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long unsigned int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long unsigned int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long unsigned int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < wchar_t, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < wchar_t, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < wchar_t, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, bool, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, signed char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, short int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, long int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, unsigned char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, short unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, long unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, wchar_t, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, bool, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, signed char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, short int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, long int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, unsigned char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, short unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, long unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, wchar_t, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, bool, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, signed char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, short int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, long int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, unsigned char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, short unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, long unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, wchar_t, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, long double, R > : ::boost::integral_constant<bool,false> { };
+
+}
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_DEFAULT_RET
+
+#endif

Added: sandbox/type_traits/boost/type_traits/has_operator_left_shift_equal.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/has_operator_left_shift_equal.hpp 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,102 @@
+// Copyright 2010 FrÃ©dÃ©ric Bron (frederic.bron_at_[hidden])
+//
+// Use, modification and distribution are subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt).
+//
+// See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_left_shift_equal_HPP_INCLUDED
+#define BOOST_TT_left_shift_equal_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME has_operator_left_shift_equal
+#define BOOST_TT_TRAIT_OP <<=
+#define BOOST_TT_DEFAULT_RET void
+
+#include <boost/type_traits/detail/has_binary_operator.hpp>
+
+namespace boost {
+
+template < typename R > struct BOOST_TT_TRAIT_NAME < bool, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < bool, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < bool, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < char, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < char, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < char, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < signed char, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < signed char, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < signed char, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned char, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned char, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned char, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short unsigned int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short unsigned int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short unsigned int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long unsigned int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long unsigned int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long unsigned int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < wchar_t, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < wchar_t, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < wchar_t, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, bool, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, signed char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, short int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, long int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, unsigned char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, short unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, long unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, wchar_t, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, bool, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, signed char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, short int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, long int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, unsigned char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, short unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, long unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, wchar_t, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, bool, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, signed char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, short int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, long int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, unsigned char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, short unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, long unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, wchar_t, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, long double, R > : ::boost::integral_constant<bool,false> { };
+
+}
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_DEFAULT_RET
+
+#endif

Added: sandbox/type_traits/boost/type_traits/has_operator_minus_equal.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/has_operator_minus_equal.hpp 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,22 @@
+// Copyright 2010 FrÃ©dÃ©ric Bron (frederic.bron_at_[hidden])
+//
+// Use, modification and distribution are subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt).
+//
+// See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_minus_equal_HPP_INCLUDED
+#define BOOST_TT_minus_equal_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME has_operator_minus_equal
+#define BOOST_TT_TRAIT_OP -=
+#define BOOST_TT_DEFAULT_RET void
+
+#include <boost/type_traits/detail/has_binary_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_DEFAULT_RET
+
+#endif

Added: sandbox/type_traits/boost/type_traits/has_operator_modulus_equal.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/has_operator_modulus_equal.hpp 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,102 @@
+// Copyright 2010 FrÃ©dÃ©ric Bron (frederic.bron_at_[hidden])
+//
+// Use, modification and distribution are subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt).
+//
+// See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_modulus_equal_HPP_INCLUDED
+#define BOOST_TT_modulus_equal_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME has_operator_modulus_equal
+#define BOOST_TT_TRAIT_OP %=
+#define BOOST_TT_DEFAULT_RET void
+
+#include <boost/type_traits/detail/has_binary_operator.hpp>
+
+namespace boost {
+
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, bool, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < bool, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < char, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, signed char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < signed char, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, short int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, long int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, unsigned char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned char, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, unsigned short int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned short int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, unsigned long int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned long int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, wchar_t, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < wchar_t, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, bool, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < bool, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < char, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, signed char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < signed char, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, short int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, long int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, unsigned char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned char, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, unsigned short int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned short int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, unsigned long int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned long int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, wchar_t, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < wchar_t, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, bool, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < bool, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < char, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, signed char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < signed char, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, short int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, long int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, unsigned char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned char, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, unsigned short int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned short int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, unsigned long int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned long int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, wchar_t, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < wchar_t, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, long double, R > : ::boost::integral_constant<bool,false> { };
+
+}
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_DEFAULT_RET
+
+#endif

Added: sandbox/type_traits/boost/type_traits/has_operator_multiplies_equal.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/has_operator_multiplies_equal.hpp 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,22 @@
+// Copyright 2010 FrÃ©dÃ©ric Bron (frederic.bron_at_[hidden])
+//
+// Use, modification and distribution are subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt).
+//
+// See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_multiplies_equal_HPP_INCLUDED
+#define BOOST_TT_multiplies_equal_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME has_operator_multiplies_equal
+#define BOOST_TT_TRAIT_OP *=
+#define BOOST_TT_DEFAULT_RET void
+
+#include <boost/type_traits/detail/has_binary_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_DEFAULT_RET
+
+#endif

Added: sandbox/type_traits/boost/type_traits/has_operator_plus_equal.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/has_operator_plus_equal.hpp 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,22 @@
+// Copyright 2010 FrÃ©dÃ©ric Bron (frederic.bron_at_[hidden])
+//
+// Use, modification and distribution are subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt).
+//
+// See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_plus_equal_HPP_INCLUDED
+#define BOOST_TT_plus_equal_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME has_operator_plus_equal
+#define BOOST_TT_TRAIT_OP +=
+#define BOOST_TT_DEFAULT_RET void
+
+#include <boost/type_traits/detail/has_binary_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_DEFAULT_RET
+
+#endif

Added: sandbox/type_traits/boost/type_traits/has_operator_right_shift.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/has_operator_right_shift.hpp 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,102 @@
+// Copyright 2010 FrÃ©dÃ©ric Bron (frederic.bron_at_[hidden])
+//
+// Use, modification and distribution are subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt).
+//
+// See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_right_shift_HPP_INCLUDED
+#define BOOST_TT_right_shift_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME has_operator_right_shift
+#define BOOST_TT_TRAIT_OP >>
+#define BOOST_TT_DEFAULT_RET void
+
+#include <boost/type_traits/detail/has_binary_operator.hpp>
+
+namespace boost {
+
+template < typename R > struct BOOST_TT_TRAIT_NAME < bool, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < bool, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < bool, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < char, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < char, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < char, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < signed char, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < signed char, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < signed char, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned char, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned char, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned char, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short unsigned int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short unsigned int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short unsigned int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long unsigned int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long unsigned int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long unsigned int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < wchar_t, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < wchar_t, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < wchar_t, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, bool, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, signed char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, short int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, long int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, unsigned char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, short unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, long unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, wchar_t, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, bool, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, signed char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, short int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, long int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, unsigned char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, short unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, long unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, wchar_t, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, bool, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, signed char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, short int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, long int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, unsigned char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, short unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, long unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, wchar_t, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, long double, R > : ::boost::integral_constant<bool,false> { };
+
+}
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_DEFAULT_RET
+
+#endif

Added: sandbox/type_traits/boost/type_traits/has_operator_right_shift_equal.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/has_operator_right_shift_equal.hpp 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,102 @@
+// Copyright 2010 FrÃ©dÃ©ric Bron (frederic.bron_at_[hidden])
+//
+// Use, modification and distribution are subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt).
+//
+// See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_right_shift_equal_HPP_INCLUDED
+#define BOOST_TT_right_shift_equal_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME has_operator_right_shift_equal
+#define BOOST_TT_TRAIT_OP >>=
+#define BOOST_TT_DEFAULT_RET void
+
+#include <boost/type_traits/detail/has_binary_operator.hpp>
+
+namespace boost {
+
+template < typename R > struct BOOST_TT_TRAIT_NAME < bool, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < bool, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < bool, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < char, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < char, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < char, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < signed char, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < signed char, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < signed char, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned char, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned char, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned char, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short unsigned int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short unsigned int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < short unsigned int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < unsigned int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long unsigned int, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long unsigned int, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long unsigned int, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < wchar_t, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < wchar_t, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < wchar_t, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, bool, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, signed char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, short int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, long int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, unsigned char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, short unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, long unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, wchar_t, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < float, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, bool, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, signed char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, short int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, long int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, unsigned char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, short unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, long unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, wchar_t, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < double, long double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, bool, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, signed char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, short int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, long int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, unsigned char, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, short unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, long unsigned int, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, wchar_t, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, float, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, double, R > : ::boost::integral_constant<bool,false> { };
+template < typename R > struct BOOST_TT_TRAIT_NAME < long double, long double, R > : ::boost::integral_constant<bool,false> { };
+
+}
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_DEFAULT_RET
+
+#endif

Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_bit_and.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_bit_and.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_bit_and.qbk 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -10,14 +10,19 @@
struct has_operator_bit_and : public __tof {};

__inherit
- If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs&rhs`,
- and (ii) `RET=void` or the result of expression `lhs&rhs` is convertible to `RET`
- then inherits from __true_type,
- otherwise inherits from __false_type.
- Thus the default behaviour is to not check for the return value of the operator (`RET=void`).
- If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs&rhs`,
+and (ii) `RET=void` or the result of expression `lhs&rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=void`) is to not check for the return value of `operator&`.
+If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+
+This trait can not detect whether `operator&` is public or not: if `operator&` is defined as a private member of `LHS` then
+instantiating `has_operator_bit_and<LHS>` will produce a compiler error.
+For this reason `has_operator_bit_and` can not be used to determine whether a type has a public `operator&` or not.

-__header ` #include <boost/type_traits/has_operator_bit_and.hpp>` or ` #include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_bit_and.hpp>` or `#include <boost/type_traits.hpp>`

__examples

Added: sandbox/type_traits/libs/type_traits/doc/has_operator_bit_and_equal.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_bit_and_equal.qbk 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,43 @@
+[/
+ Copyright 2010 Frédéric Bron.
+ 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).
+]
+
+[section:has_operator_bit_and_equal has_operator_bit_and_equal]
+ template <class LHS, class RHS=LHS, class RET=void>
+ struct has_operator_bit_and_equal : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs&=rhs`,
+and (ii) `RET=void` or the result of expression `lhs&=rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=void`) is to not check for the return value of `operator&=`.
+If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+
+This trait can not detect whether `operator&=` is public or not: if `operator&=` is defined as a private member of `LHS` then
+instantiating `has_operator_bit_and_equal<LHS>` will produce a compiler error.
+For this reason `has_operator_bit_and_equal` can not be used to determine whether a type has a public `operator&=` or not.
+
+__header `#include <boost/type_traits/has_operator_bit_and_equal.hpp>` or `#include <boost/type_traits.hpp>`
+
+__examples
+
+[:`has_operator_bit_and_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
+
+[:`has_operator_bit_and_equal<int>` inherits from `__true_type`.]
+
+[:`has_operator_bit_and_equal<int, int, int>` inherits from `__true_type`.]
+
+[:`has_operator_bit_and_equal<int, double, bool>` inherits from `__false_type`.]
+
+[:`has_operator_bit_and_equal<int, int, std::string>` inherits from `__false_type`.]
+
+[:`has_operator_bit_and_equal<long>::value` is a `bool` integral constant
+expression that evaluates to /true/.]
+
+[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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -10,14 +10,19 @@
struct has_operator_bit_or : public __tof {};

__inherit
- If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs|rhs`,
- and (ii) `RET=void` or the result of expression `lhs|rhs` is convertible to `RET`
- then inherits from __true_type,
- otherwise inherits from __false_type.
- Thus the default behaviour is to not check for the return value of the operator (`RET=void`).
- If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs|rhs`,
+and (ii) `RET=void` or the result of expression `lhs|rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=void`) is to not check for the return value of `operator|`.
+If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+
+This trait can not detect whether `operator|` is public or not: if `operator|` is defined as a private member of `LHS` then
+instantiating `has_operator_bit_or<LHS>` will produce a compiler error.
+For this reason `has_operator_bit_or` can not be used to determine whether a type has a public `operator|` or not.

-__header ` #include <boost/type_traits/has_operator_bit_or.hpp>` or ` #include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_bit_or.hpp>` or `#include <boost/type_traits.hpp>`

__examples

Added: sandbox/type_traits/libs/type_traits/doc/has_operator_bit_or_equal.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_bit_or_equal.qbk 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,43 @@
+[/
+ Copyright 2010 Frédéric Bron.
+ 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).
+]
+
+[section:has_operator_bit_or_equal has_operator_bit_or_equal]
+ template <class LHS, class RHS=LHS, class RET=void>
+ struct has_operator_bit_or_equal : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs|=rhs`,
+and (ii) `RET=void` or the result of expression `lhs|=rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=void`) is to not check for the return value of `operator|=`.
+If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+
+This trait can not detect whether `operator|=` is public or not: if `operator|=` is defined as a private member of `LHS` then
+instantiating `has_operator_bit_or_equal<LHS>` will produce a compiler error.
+For this reason `has_operator_bit_or_equal` can not be used to determine whether a type has a public `operator|=` or not.
+
+__header `#include <boost/type_traits/has_operator_bit_or_equal.hpp>` or `#include <boost/type_traits.hpp>`
+
+__examples
+
+[:`has_operator_bit_or_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
+
+[:`has_operator_bit_or_equal<int>` inherits from `__true_type`.]
+
+[:`has_operator_bit_or_equal<int, int, int>` inherits from `__true_type`.]
+
+[:`has_operator_bit_or_equal<int, double, bool>` inherits from `__false_type`.]
+
+[:`has_operator_bit_or_equal<int, int, std::string>` inherits from `__false_type`.]
+
+[:`has_operator_bit_or_equal<long>::value` is a `bool` integral constant
+expression that evaluates to /true/.]
+
+[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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -10,14 +10,19 @@
struct has_operator_bit_xor : public __tof {};

__inherit
- If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs^rhs`,
- and (ii) `RET=void` or the result of expression `lhs^rhs` is convertible to `RET`
- then inherits from __true_type,
- otherwise inherits from __false_type.
- Thus the default behaviour is to not check for the return value of the operator (`RET=void`).
- If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs^rhs`,
+and (ii) `RET=void` or the result of expression `lhs^rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=void`) is to not check for the return value of `operator^`.
+If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+
+This trait can not detect whether `operator^` is public or not: if `operator^` is defined as a private member of `LHS` then
+instantiating `has_operator_bit_xor<LHS>` will produce a compiler error.
+For this reason `has_operator_bit_xor` can not be used to determine whether a type has a public `operator^` or not.

-__header ` #include <boost/type_traits/has_operator_bit_xor.hpp>` or ` #include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_bit_xor.hpp>` or `#include <boost/type_traits.hpp>`

__examples

Added: sandbox/type_traits/libs/type_traits/doc/has_operator_bit_xor_equal.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_bit_xor_equal.qbk 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,43 @@
+[/
+ Copyright 2010 Frédéric Bron.
+ 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).
+]
+
+[section:has_operator_bit_xor_equal has_operator_bit_xor_equal]
+ template <class LHS, class RHS=LHS, class RET=void>
+ struct has_operator_bit_xor_equal : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs^=rhs`,
+and (ii) `RET=void` or the result of expression `lhs^=rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=void`) is to not check for the return value of `operator^=`.
+If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+
+This trait can not detect whether `operator^=` is public or not: if `operator^=` is defined as a private member of `LHS` then
+instantiating `has_operator_bit_xor_equal<LHS>` will produce a compiler error.
+For this reason `has_operator_bit_xor_equal` can not be used to determine whether a type has a public `operator^=` or not.
+
+__header `#include <boost/type_traits/has_operator_bit_xor_equal.hpp>` or `#include <boost/type_traits.hpp>`
+
+__examples
+
+[:`has_operator_bit_xor_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
+
+[:`has_operator_bit_xor_equal<int>` inherits from `__true_type`.]
+
+[:`has_operator_bit_xor_equal<int, int, int>` inherits from `__true_type`.]
+
+[:`has_operator_bit_xor_equal<int, double, bool>` inherits from `__false_type`.]
+
+[:`has_operator_bit_xor_equal<int, int, std::string>` inherits from `__false_type`.]
+
+[:`has_operator_bit_xor_equal<long>::value` is a `bool` integral constant
+expression that evaluates to /true/.]
+
+[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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -10,14 +10,19 @@
struct has_operator_divides : public __tof {};

__inherit
- If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs/rhs`,
- and (ii) `RET=void` or the result of expression `lhs/rhs` is convertible to `RET`
- then inherits from __true_type,
- otherwise inherits from __false_type.
- Thus the default behaviour is to not check for the return value of the operator (`RET=void`).
- If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs/rhs`,
+and (ii) `RET=void` or the result of expression `lhs/rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=void`) is to not check for the return value of `operator/`.
+If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+
+This trait can not detect whether `operator/` is public or not: if `operator/` is defined as a private member of `LHS` then
+instantiating `has_operator_divides<LHS>` will produce a compiler error.
+For this reason `has_operator_divides` can not be used to determine whether a type has a public `operator/` or not.

-__header ` #include <boost/type_traits/has_operator_divides.hpp>` or ` #include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_divides.hpp>` or `#include <boost/type_traits.hpp>`

__examples

Added: sandbox/type_traits/libs/type_traits/doc/has_operator_divides_equal.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_divides_equal.qbk 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,47 @@
+[/
+ Copyright 2010 Frédéric Bron.
+ 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).
+]
+
+[section:has_operator_divides_equal has_operator_divides_equal]
+ template <class LHS, class RHS=LHS, class RET=void>
+ struct has_operator_divides_equal : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs/=rhs`,
+and (ii) `RET=void` or the result of expression `lhs/=rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=void`) is to not check for the return value of `operator/=`.
+If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+
+This trait can not detect whether `operator/=` is public or not: if `operator/=` is defined as a private member of `LHS` then
+instantiating `has_operator_divides_equal<LHS>` will produce a compiler error.
+For this reason `has_operator_divides_equal` can not be used to determine whether a type has a public `operator/=` or not.
+
+__header `#include <boost/type_traits/has_operator_divides_equal.hpp>` or `#include <boost/type_traits.hpp>`
+
+__examples
+
+[:`has_operator_divides_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
+
+[:`has_operator_divides_equal<int>` inherits from `__true_type`.]
+
+[:`has_operator_divides_equal<int, int, int>` inherits from `__true_type`.]
+
+[:`has_operator_divides_equal<int, int, long>` inherits from `__true_type`.]
+
+[:`has_operator_divides_equal<int, double, double>` inherits from `__true_type`.]
+
+[:`has_operator_divides_equal<int, double, int>` inherits from `__true_type`.]
+
+[:`has_operator_divides_equal<int, int, std::string>` inherits from `__false_type`.]
+
+[:`has_operator_divides_equal<long>::value` is a `bool` integral constant
+expression that evaluates to /true/.]
+
+[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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -10,14 +10,19 @@
struct has_operator_equal_to : public __tof {};

__inherit
- If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs==rhs`,
- and (ii) `RET=void` or the result of expression `lhs==rhs` is convertible to `RET`
- then inherits from __true_type,
- otherwise inherits from __false_type.
- Thus the default behaviour is to not check for the return value of the operator (`RET=void`).
- If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs==rhs`,
+and (ii) `RET=void` or the result of expression `lhs==rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=void`) is to not check for the return value of `operator==`.
+If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+
+This trait can not detect whether `operator==` is public or not: if `operator==` is defined as a private member of `LHS` then
+instantiating `has_operator_equal_to<LHS>` will produce a compiler error.
+For this reason `has_operator_equal_to` can not be used to determine whether a type has a public `operator==` or not.

-__header ` #include <boost/type_traits/has_operator_equal_to.hpp>` or ` #include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_equal_to.hpp>` or `#include <boost/type_traits.hpp>`

__examples

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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -10,14 +10,19 @@
struct has_operator_greater : public __tof {};

__inherit
- If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs>rhs`,
- and (ii) `RET=void` or the result of expression `lhs>rhs` is convertible to `RET`
- then inherits from __true_type,
- otherwise inherits from __false_type.
- Thus the default behaviour is to not check for the return value of the operator (`RET=void`).
- If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs>rhs`,
+and (ii) `RET=void` or the result of expression `lhs>rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=void`) is to not check for the return value of `operator>`.
+If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+
+This trait can not detect whether `operator>` is public or not: if `operator>` is defined as a private member of `LHS` then
+instantiating `has_operator_greater<LHS>` will produce a compiler error.
+For this reason `has_operator_greater` can not be used to determine whether a type has a public `operator>` or not.

-__header ` #include <boost/type_traits/has_operator_greater.hpp>` or ` #include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_greater.hpp>` or `#include <boost/type_traits.hpp>`

__examples

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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -10,14 +10,19 @@
struct has_operator_greater_equal : public __tof {};

__inherit
- If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs>=rhs`,
- and (ii) `RET=void` or the result of expression `lhs>=rhs` is convertible to `RET`
- then inherits from __true_type,
- otherwise inherits from __false_type.
- Thus the default behaviour is to not check for the return value of the operator (`RET=void`).
- If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs>=rhs`,
+and (ii) `RET=void` or the result of expression `lhs>=rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=void`) is to not check for the return value of `operator>=`.
+If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+
+This trait can not detect whether `operator>=` is public or not: if `operator>=` is defined as a private member of `LHS` then
+instantiating `has_operator_greater_equal<LHS>` will produce a compiler error.
+For this reason `has_operator_greater_equal` can not be used to determine whether a type has a public `operator>=` or not.

-__header ` #include <boost/type_traits/has_operator_greater_equal.hpp>` or ` #include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_greater_equal.hpp>` or `#include <boost/type_traits.hpp>`

__examples

Added: sandbox/type_traits/libs/type_traits/doc/has_operator_left_shift.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_left_shift.qbk 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,43 @@
+[/
+ Copyright 2010 Frédéric Bron.
+ 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).
+]
+
+[section:has_operator_left_shift has_operator_left_shift]
+ template <class LHS, class RHS=LHS, class RET=void>
+ struct has_operator_left_shift : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs<<rhs`,
+and (ii) `RET=void` or the result of expression `lhs<<rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=void`) is to not check for the return value of `operator<<`.
+If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+
+This trait can not detect whether `operator<<` is public or not: if `operator<<` is defined as a private member of `LHS` then
+instantiating `has_operator_left_shift<LHS>` will produce a compiler error.
+For this reason `has_operator_left_shift` can not be used to determine whether a type has a public `operator<<` or not.
+
+__header `#include <boost/type_traits/has_operator_left_shift.hpp>` or `#include <boost/type_traits.hpp>`
+
+__examples
+
+[:`has_operator_left_shift<LHS, RHS, RET>::value_type` is the type `bool`.]
+
+[:`has_operator_left_shift<int>` inherits from `__true_type`.]
+
+[:`has_operator_left_shift<int, int, int>` inherits from `__true_type`.]
+
+[:`has_operator_left_shift<int, double, bool>` inherits from `__false_type`.]
+
+[:`has_operator_left_shift<int, int, std::string>` inherits from `__false_type`.]
+
+[:`has_operator_left_shift<long>::value` is a `bool` integral constant
+expression that evaluates to /true/.]
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/has_operator_left_shift_equal.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_left_shift_equal.qbk 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,43 @@
+[/
+ Copyright 2010 Frédéric Bron.
+ 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).
+]
+
+[section:has_operator_left_shift_equal has_operator_left_shift_equal]
+ template <class LHS, class RHS=LHS, class RET=void>
+ struct has_operator_left_shift_equal : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs<<=rhs`,
+and (ii) `RET=void` or the result of expression `lhs<<=rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=void`) is to not check for the return value of `operator<<=`.
+If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+
+This trait can not detect whether `operator<<=` is public or not: if `operator<<=` is defined as a private member of `LHS` then
+instantiating `has_operator_left_shift_equal<LHS>` will produce a compiler error.
+For this reason `has_operator_left_shift_equal` can not be used to determine whether a type has a public `operator<<=` or not.
+
+__header `#include <boost/type_traits/has_operator_left_shift_equal.hpp>` or `#include <boost/type_traits.hpp>`
+
+__examples
+
+[:`has_operator_left_shift_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
+
+[:`has_operator_left_shift_equal<int>` inherits from `__true_type`.]
+
+[:`has_operator_left_shift_equal<int, int, int>` inherits from `__true_type`.]
+
+[:`has_operator_left_shift_equal<int, double, bool>` inherits from `__false_type`.]
+
+[:`has_operator_left_shift_equal<int, int, std::string>` inherits from `__false_type`.]
+
+[:`has_operator_left_shift_equal<long>::value` is a `bool` integral constant
+expression that evaluates to /true/.]
+
+[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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -10,14 +10,19 @@
struct has_operator_less : public __tof {};

__inherit
- If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs<rhs`,
- and (ii) `RET=void` or the result of expression `lhs<rhs` is convertible to `RET`
- then inherits from __true_type,
- otherwise inherits from __false_type.
- Thus the default behaviour is to not check for the return value of the operator (`RET=void`).
- If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs<rhs`,
+and (ii) `RET=void` or the result of expression `lhs<rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=void`) is to not check for the return value of `operator<`.
+If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+
+This trait can not detect whether `operator<` is public or not: if `operator<` is defined as a private member of `LHS` then
+instantiating `has_operator_less<LHS>` will produce a compiler error.
+For this reason `has_operator_less` can not be used to determine whether a type has a public `operator<` or not.

-__header ` #include <boost/type_traits/has_operator_less.hpp>` or ` #include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_less.hpp>` or `#include <boost/type_traits.hpp>`

__examples

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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -10,14 +10,19 @@
struct has_operator_less_equal : public __tof {};

__inherit
- If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs<=rhs`,
- and (ii) `RET=void` or the result of expression `lhs<=rhs` is convertible to `RET`
- then inherits from __true_type,
- otherwise inherits from __false_type.
- Thus the default behaviour is to not check for the return value of the operator (`RET=void`).
- If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs<=rhs`,
+and (ii) `RET=void` or the result of expression `lhs<=rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=void`) is to not check for the return value of `operator<=`.
+If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+
+This trait can not detect whether `operator<=` is public or not: if `operator<=` is defined as a private member of `LHS` then
+instantiating `has_operator_less_equal<LHS>` will produce a compiler error.
+For this reason `has_operator_less_equal` can not be used to determine whether a type has a public `operator<=` or not.

-__header ` #include <boost/type_traits/has_operator_less_equal.hpp>` or ` #include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_less_equal.hpp>` or `#include <boost/type_traits.hpp>`

__examples

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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -10,14 +10,19 @@
struct has_operator_logical_and : public __tof {};

__inherit
- If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs&&rhs`,
- and (ii) `RET=void` or the result of expression `lhs&&rhs` is convertible to `RET`
- then inherits from __true_type,
- otherwise inherits from __false_type.
- Thus the default behaviour is to not check for the return value of the operator (`RET=void`).
- If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs&&rhs`,
+and (ii) `RET=void` or the result of expression `lhs&&rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=void`) is to not check for the return value of `operator&&`.
+If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+
+This trait can not detect whether `operator&&` is public or not: if `operator&&` is defined as a private member of `LHS` then
+instantiating `has_operator_logical_and<LHS>` will produce a compiler error.
+For this reason `has_operator_logical_and` can not be used to determine whether a type has a public `operator&&` or not.

-__header ` #include <boost/type_traits/has_operator_logical_and.hpp>` or ` #include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_logical_and.hpp>` or `#include <boost/type_traits.hpp>`

__examples

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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -10,14 +10,19 @@
struct has_operator_logical_not : public __tof {};

__inherit
- If (i) `rhs` of type `RHS` can be used in expression `!rhs`,
- and (ii) `RET=void` or the result of expression `!rhs` is convertible to `RET`
- then inherits from __true_type,
- otherwise inherits from __false_type.
- Thus the default behaviour is to not check for the return value of the operator (`RET=void`).
- If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+If (i) `rhs` of type `RHS` can be used in expression `!rhs`,
+and (ii) `RET=void` or the result of expression `!rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=void`) is to not check for the return value of `operator!`.
+If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+
+This trait can not detect whether `operator!` is public or not: if `operator!` is defined as a private member of `RHS` then
+instantiating `has_operator_logical_not<RHS>` will produce a compiler error.
+For this reason `has_operator_logical_not` can not be used to determine whether a type has a public `operator!` or not.

-__header ` #include <boost/type_traits/has_operator_logical_not.hpp>` or ` #include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_logical_not.hpp>` or `#include <boost/type_traits.hpp>`

__examples

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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -10,14 +10,19 @@
struct has_operator_logical_or : public __tof {};

__inherit
- If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs||rhs`,
- and (ii) `RET=void` or the result of expression `lhs||rhs` is convertible to `RET`
- then inherits from __true_type,
- otherwise inherits from __false_type.
- Thus the default behaviour is to not check for the return value of the operator (`RET=void`).
- If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs||rhs`,
+and (ii) `RET=void` or the result of expression `lhs||rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=void`) is to not check for the return value of `operator||`.
+If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+
+This trait can not detect whether `operator||` is public or not: if `operator||` is defined as a private member of `LHS` then
+instantiating `has_operator_logical_or<LHS>` will produce a compiler error.
+For this reason `has_operator_logical_or` can not be used to determine whether a type has a public `operator||` or not.

-__header ` #include <boost/type_traits/has_operator_logical_or.hpp>` or ` #include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_logical_or.hpp>` or `#include <boost/type_traits.hpp>`

__examples

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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -10,14 +10,19 @@
struct has_operator_minus : public __tof {};

__inherit
- If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs-rhs`,
- and (ii) `RET=void` or the result of expression `lhs-rhs` is convertible to `RET`
- then inherits from __true_type,
- otherwise inherits from __false_type.
- Thus the default behaviour is to not check for the return value of the operator (`RET=void`).
- If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs-rhs`,
+and (ii) `RET=void` or the result of expression `lhs-rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=void`) is to not check for the return value of `operator-`.
+If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+
+This trait can not detect whether `operator-` is public or not: if `operator-` is defined as a private member of `LHS` then
+instantiating `has_operator_minus<LHS>` will produce a compiler error.
+For this reason `has_operator_minus` can not be used to determine whether a type has a public `operator-` or not.

-__header ` #include <boost/type_traits/has_operator_minus.hpp>` or ` #include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_minus.hpp>` or `#include <boost/type_traits.hpp>`

__examples

Added: sandbox/type_traits/libs/type_traits/doc/has_operator_minus_equal.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_minus_equal.qbk 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,47 @@
+[/
+ Copyright 2010 Frédéric Bron.
+ 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).
+]
+
+[section:has_operator_minus_equal has_operator_minus_equal]
+ template <class LHS, class RHS=LHS, class RET=void>
+ struct has_operator_minus_equal : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs-=rhs`,
+and (ii) `RET=void` or the result of expression `lhs-=rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=void`) is to not check for the return value of `operator-=`.
+If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+
+This trait can not detect whether `operator-=` is public or not: if `operator-=` is defined as a private member of `LHS` then
+instantiating `has_operator_minus_equal<LHS>` will produce a compiler error.
+For this reason `has_operator_minus_equal` can not be used to determine whether a type has a public `operator-=` or not.
+
+__header `#include <boost/type_traits/has_operator_minus_equal.hpp>` or `#include <boost/type_traits.hpp>`
+
+__examples
+
+[:`has_operator_minus_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
+
+[:`has_operator_minus_equal<int>` inherits from `__true_type`.]
+
+[:`has_operator_minus_equal<int, int, int>` inherits from `__true_type`.]
+
+[:`has_operator_minus_equal<int, int, long>` inherits from `__true_type`.]
+
+[:`has_operator_minus_equal<int, double, double>` inherits from `__true_type`.]
+
+[:`has_operator_minus_equal<int, double, int>` inherits from `__true_type`.]
+
+[:`has_operator_minus_equal<int, int, std::string>` inherits from `__false_type`.]
+
+[:`has_operator_minus_equal<long>::value` is a `bool` integral constant
+expression that evaluates to /true/.]
+
+[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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -10,14 +10,19 @@
struct has_operator_modulus : public __tof {};

__inherit
- If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs%rhs`,
- and (ii) `RET=void` or the result of expression `lhs%rhs` is convertible to `RET`
- then inherits from __true_type,
- otherwise inherits from __false_type.
- Thus the default behaviour is to not check for the return value of the operator (`RET=void`).
- If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs%rhs`,
+and (ii) `RET=void` or the result of expression `lhs%rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=void`) is to not check for the return value of `operator%`.
+If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+
+This trait can not detect whether `operator%` is public or not: if `operator%` is defined as a private member of `LHS` then
+instantiating `has_operator_modulus<LHS>` will produce a compiler error.
+For this reason `has_operator_modulus` can not be used to determine whether a type has a public `operator%` or not.

-__header ` #include <boost/type_traits/has_operator_modulus.hpp>` or ` #include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_modulus.hpp>` or `#include <boost/type_traits.hpp>`

__examples

Added: sandbox/type_traits/libs/type_traits/doc/has_operator_modulus_equal.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_modulus_equal.qbk 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,43 @@
+[/
+ Copyright 2010 Frédéric Bron.
+ 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).
+]
+
+[section:has_operator_modulus_equal has_operator_modulus_equal]
+ template <class LHS, class RHS=LHS, class RET=void>
+ struct has_operator_modulus_equal : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs%=rhs`,
+and (ii) `RET=void` or the result of expression `lhs%=rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=void`) is to not check for the return value of `operator%=`.
+If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+
+This trait can not detect whether `operator%=` is public or not: if `operator%=` is defined as a private member of `LHS` then
+instantiating `has_operator_modulus_equal<LHS>` will produce a compiler error.
+For this reason `has_operator_modulus_equal` can not be used to determine whether a type has a public `operator%=` or not.
+
+__header `#include <boost/type_traits/has_operator_modulus_equal.hpp>` or `#include <boost/type_traits.hpp>`
+
+__examples
+
+[:`has_operator_modulus_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
+
+[:`has_operator_modulus_equal<int>` inherits from `__true_type`.]
+
+[:`has_operator_modulus_equal<int, int, int>` inherits from `__true_type`.]
+
+[:`has_operator_modulus_equal<int, int, std::string>` inherits from `__false_type`.]
+
+[:`has_operator_modulus_equal<int, double>` inherits from `__false_type`.]
+
+[:`has_operator_modulus_equal<long>::value` is a `bool` integral constant
+expression that evaluates to /true/.]
+
+[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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -10,14 +10,19 @@
struct has_operator_multiplies : public __tof {};

__inherit
- If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs*rhs`,
- and (ii) `RET=void` or the result of expression `lhs*rhs` is convertible to `RET`
- then inherits from __true_type,
- otherwise inherits from __false_type.
- Thus the default behaviour is to not check for the return value of the operator (`RET=void`).
- If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs*rhs`,
+and (ii) `RET=void` or the result of expression `lhs*rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=void`) is to not check for the return value of `operator*`.
+If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+
+This trait can not detect whether `operator*` is public or not: if `operator*` is defined as a private member of `LHS` then
+instantiating `has_operator_multiplies<LHS>` will produce a compiler error.
+For this reason `has_operator_multiplies` can not be used to determine whether a type has a public `operator*` or not.

-__header ` #include <boost/type_traits/has_operator_multiplies.hpp>` or ` #include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_multiplies.hpp>` or `#include <boost/type_traits.hpp>`

__examples

Added: sandbox/type_traits/libs/type_traits/doc/has_operator_multiplies_equal.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_multiplies_equal.qbk 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,47 @@
+[/
+ Copyright 2010 Frédéric Bron.
+ 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).
+]
+
+[section:has_operator_multiplies_equal has_operator_multiplies_equal]
+ template <class LHS, class RHS=LHS, class RET=void>
+ struct has_operator_multiplies_equal : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs*=rhs`,
+and (ii) `RET=void` or the result of expression `lhs*=rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=void`) is to not check for the return value of `operator*=`.
+If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+
+This trait can not detect whether `operator*=` is public or not: if `operator*=` is defined as a private member of `LHS` then
+instantiating `has_operator_multiplies_equal<LHS>` will produce a compiler error.
+For this reason `has_operator_multiplies_equal` can not be used to determine whether a type has a public `operator*=` or not.
+
+__header `#include <boost/type_traits/has_operator_multiplies_equal.hpp>` or `#include <boost/type_traits.hpp>`
+
+__examples
+
+[:`has_operator_multiplies_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
+
+[:`has_operator_multiplies_equal<int>` inherits from `__true_type`.]
+
+[:`has_operator_multiplies_equal<int, int, int>` inherits from `__true_type`.]
+
+[:`has_operator_multiplies_equal<int, int, long>` inherits from `__true_type`.]
+
+[:`has_operator_multiplies_equal<int, double, double>` inherits from `__true_type`.]
+
+[:`has_operator_multiplies_equal<int, double, int>` inherits from `__true_type`.]
+
+[:`has_operator_multiplies_equal<int, int, std::string>` inherits from `__false_type`.]
+
+[:`has_operator_multiplies_equal<long>::value` is a `bool` integral constant
+expression that evaluates to /true/.]
+
+[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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -10,14 +10,19 @@
struct has_operator_not_equal_to : public __tof {};

__inherit
- If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs!=rhs`,
- and (ii) `RET=void` or the result of expression `lhs!=rhs` is convertible to `RET`
- then inherits from __true_type,
- otherwise inherits from __false_type.
- Thus the default behaviour is to not check for the return value of the operator (`RET=void`).
- If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs!=rhs`,
+and (ii) `RET=void` or the result of expression `lhs!=rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=void`) is to not check for the return value of `operator!=`.
+If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+
+This trait can not detect whether `operator!=` is public or not: if `operator!=` is defined as a private member of `LHS` then
+instantiating `has_operator_not_equal_to<LHS>` will produce a compiler error.
+For this reason `has_operator_not_equal_to` can not be used to determine whether a type has a public `operator!=` or not.

-__header ` #include <boost/type_traits/has_operator_not_equal_to.hpp>` or ` #include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_not_equal_to.hpp>` or `#include <boost/type_traits.hpp>`

__examples

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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -10,14 +10,19 @@
struct has_operator_plus : public __tof {};

__inherit
- If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs+rhs`,
- and (ii) `RET=void` or the result of expression `lhs+rhs` is convertible to `RET`
- then inherits from __true_type,
- otherwise inherits from __false_type.
- Thus the default behaviour is to not check for the return value of the operator (`RET=void`).
- If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs+rhs`,
+and (ii) `RET=void` or the result of expression `lhs+rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=void`) is to not check for the return value of `operator+`.
+If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+
+This trait can not detect whether `operator+` is public or not: if `operator+` is defined as a private member of `LHS` then
+instantiating `has_operator_plus<LHS>` will produce a compiler error.
+For this reason `has_operator_plus` can not be used to determine whether a type has a public `operator+` or not.

-__header ` #include <boost/type_traits/has_operator_plus.hpp>` or ` #include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_plus.hpp>` or `#include <boost/type_traits.hpp>`

__examples

Added: sandbox/type_traits/libs/type_traits/doc/has_operator_plus_equal.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_plus_equal.qbk 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,47 @@
+[/
+ Copyright 2010 Frédéric Bron.
+ 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).
+]
+
+[section:has_operator_plus_equal has_operator_plus_equal]
+ template <class LHS, class RHS=LHS, class RET=void>
+ struct has_operator_plus_equal : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs+=rhs`,
+and (ii) `RET=void` or the result of expression `lhs+=rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=void`) is to not check for the return value of `operator+=`.
+If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+
+This trait can not detect whether `operator+=` is public or not: if `operator+=` is defined as a private member of `LHS` then
+instantiating `has_operator_plus_equal<LHS>` will produce a compiler error.
+For this reason `has_operator_plus_equal` can not be used to determine whether a type has a public `operator+=` or not.
+
+__header `#include <boost/type_traits/has_operator_plus_equal.hpp>` or `#include <boost/type_traits.hpp>`
+
+__examples
+
+[:`has_operator_plus_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
+
+[:`has_operator_plus_equal<int>` inherits from `__true_type`.]
+
+[:`has_operator_plus_equal<int, int, int>` inherits from `__true_type`.]
+
+[:`has_operator_plus_equal<int, int, long>` inherits from `__true_type`.]
+
+[:`has_operator_plus_equal<int, double, double>` inherits from `__true_type`.]
+
+[:`has_operator_plus_equal<int, double, int>` inherits from `__true_type`.]
+
+[:`has_operator_plus_equal<int, int, std::string>` inherits from `__false_type`.]
+
+[:`has_operator_plus_equal<long>::value` is a `bool` integral constant
+expression that evaluates to /true/.]
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/has_operator_right_shift.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_right_shift.qbk 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,43 @@
+[/
+ Copyright 2010 Frédéric Bron.
+ 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).
+]
+
+[section:has_operator_right_shift has_operator_right_shift]
+ template <class LHS, class RHS=LHS, class RET=void>
+ struct has_operator_right_shift : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs>>rhs`,
+and (ii) `RET=void` or the result of expression `lhs>>rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=void`) is to not check for the return value of `operator>>`.
+If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+
+This trait can not detect whether `operator>>` is public or not: if `operator>>` is defined as a private member of `LHS` then
+instantiating `has_operator_right_shift<LHS>` will produce a compiler error.
+For this reason `has_operator_right_shift` can not be used to determine whether a type has a public `operator>>` or not.
+
+__header `#include <boost/type_traits/has_operator_right_shift.hpp>` or `#include <boost/type_traits.hpp>`
+
+__examples
+
+[:`has_operator_right_shift<LHS, RHS, RET>::value_type` is the type `bool`.]
+
+[:`has_operator_right_shift<int>` inherits from `__true_type`.]
+
+[:`has_operator_right_shift<int, int, int>` inherits from `__true_type`.]
+
+[:`has_operator_right_shift<int, double, bool>` inherits from `__false_type`.]
+
+[:`has_operator_right_shift<int, int, std::string>` inherits from `__false_type`.]
+
+[:`has_operator_right_shift<long>::value` is a `bool` integral constant
+expression that evaluates to /true/.]
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/has_operator_right_shift_equal.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_right_shift_equal.qbk 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,43 @@
+[/
+ Copyright 2010 Frédéric Bron.
+ 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).
+]
+
+[section:has_operator_right_shift_equal has_operator_right_shift_equal]
+ template <class LHS, class RHS=LHS, class RET=void>
+ struct has_operator_right_shift_equal : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs>>=rhs`,
+and (ii) `RET=void` or the result of expression `lhs>>=rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=void`) is to not check for the return value of `operator>>=`.
+If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+
+This trait can not detect whether `operator>>=` is public or not: if `operator>>=` is defined as a private member of `LHS` then
+instantiating `has_operator_right_shift_equal<LHS>` will produce a compiler error.
+For this reason `has_operator_right_shift_equal` can not be used to determine whether a type has a public `operator>>=` or not.
+
+__header `#include <boost/type_traits/has_operator_right_shift_equal.hpp>` or `#include <boost/type_traits.hpp>`
+
+__examples
+
+[:`has_operator_right_shift_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
+
+[:`has_operator_right_shift_equal<int>` inherits from `__true_type`.]
+
+[:`has_operator_right_shift_equal<int, int, int>` inherits from `__true_type`.]
+
+[:`has_operator_right_shift_equal<int, double, bool>` inherits from `__false_type`.]
+
+[:`has_operator_right_shift_equal<int, int, std::string>` inherits from `__false_type`.]
+
+[:`has_operator_right_shift_equal<long>::value` is a `bool` integral constant
+expression that evaluates to /true/.]
+
+[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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -10,14 +10,19 @@
struct has_operator_unary_minus : public __tof {};

__inherit
- If (i) `rhs` of type `RHS` can be used in expression `-rhs`,
- and (ii) `RET=void` or the result of expression `-rhs` is convertible to `RET`
- then inherits from __true_type,
- otherwise inherits from __false_type.
- Thus the default behaviour is to not check for the return value of the operator (`RET=void`).
- If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+If (i) `rhs` of type `RHS` can be used in expression `-rhs`,
+and (ii) `RET=void` or the result of expression `-rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=void`) is to not check for the return value of `operator-`.
+If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+
+This trait can not detect whether `operator-` is public or not: if `operator-` is defined as a private member of `RHS` then
+instantiating `has_operator_unary_minus<RHS>` will produce a compiler error.
+For this reason `has_operator_unary_minus` can not be used to determine whether a type has a public `operator-` or not.

-__header ` #include <boost/type_traits/has_operator_unary_minus.hpp>` or ` #include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_unary_minus.hpp>` or `#include <boost/type_traits.hpp>`

__examples

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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -10,14 +10,19 @@
struct has_operator_unary_plus : public __tof {};

__inherit
- If (i) `rhs` of type `RHS` can be used in expression `+rhs`,
- and (ii) `RET=void` or the result of expression `+rhs` is convertible to `RET`
- then inherits from __true_type,
- otherwise inherits from __false_type.
- Thus the default behaviour is to not check for the return value of the operator (`RET=void`).
- If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+If (i) `rhs` of type `RHS` can be used in expression `+rhs`,
+and (ii) `RET=void` or the result of expression `+rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=void`) is to not check for the return value of `operator+`.
+If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+
+This trait can not detect whether `operator+` is public or not: if `operator+` is defined as a private member of `RHS` then
+instantiating `has_operator_unary_plus<RHS>` will produce a compiler error.
+For this reason `has_operator_unary_plus` can not be used to determine whether a type has a public `operator+` or not.

-__header ` #include <boost/type_traits/has_operator_unary_plus.hpp>` or ` #include <boost/type_traits.hpp>`
+__header `#include <boost/type_traits/has_operator_unary_plus.hpp>` or `#include <boost/type_traits.hpp>`

__examples

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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -49,7 +49,7 @@
 method available to them.
 
<a name="boost_typetraits.background.type_traits"></a><h5>
-<a name="id2863431"></a>
+<a name="id3295764"></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="id2862475"></a>
+<a name="id3294808"></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="id2913960"></a>
+<a name="id3346293"></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="id2914422"></a>
+<a name="id3346755"></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="id2914491"></a>Table 1.1. Time taken to copy 1000 elements using `copy<const T*, T*>` (times
+<a name="id3346824"></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="id2914643"></a>
+<a name="id3346975"></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="id2914949"></a>Table 1.2. Required Constructor Argument Types
+<a name="id3347282"></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="id2915066"></a>Table 1.3. Using add_reference to synthesize the correct constructor type
+<a name="id3347399"></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="id2915598"></a>
+<a name="id3347930"></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="id2915629"></a>
+<a name="id3347962"></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="id2915656"></a>
+<a name="id3347989"></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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -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="id2919109"></a>
+<a name="id3351442"></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/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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -92,7 +92,7 @@
of the following macros:

<div class="table">
-<a name="id2920990"></a>Table 1.4. Macros for Compiler Intrinsics
+<a name="id3353323"></a>Table 1.4. 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.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference.html 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -38,14 +38,26 @@
<dt> has_nothrow_copy</dt>
<dt> has_nothrow_copy_constructor</dt>
<dt> has_nothrow_default_constructor</dt>
+<dt><a href="reference/has_operator_bit_and_equal.html">
+ has_operator_bit_and_equal</a></dt>
<dt> has_operator_bit_and</dt>
+<dt><a href="reference/has_operator_bit_or_equal.html">
+ has_operator_bit_or_equal</a></dt>
<dt> has_operator_bit_or</dt>
+<dt><a href="reference/has_operator_bit_xor_equal.html">
+ has_operator_bit_xor_equal</a></dt>
<dt> has_operator_bit_xor</dt>
+<dt><a href="reference/has_operator_divides_equal.html">
+ has_operator_divides_equal</a></dt>
<dt> has_operator_divides</dt>
<dt> has_operator_equal_to</dt>
<dt><a href="reference/has_operator_greater_equal.html">
 has_operator_greater_equal</a></dt>
<dt> has_operator_greater</dt>
+<dt><a href="reference/has_operator_left_shift_equal.html">
+ has_operator_left_shift_equal</a></dt>
+<dt><a href="reference/has_operator_left_shift.html">
+ has_operator_left_shift</a></dt>
<dt><a href="reference/has_operator_less_equal.html">
 has_operator_less_equal</a></dt>
<dt> has_operator_less</dt>
@@ -55,13 +67,25 @@
 has_operator_logical_not</a></dt>
<dt><a href="reference/has_operator_logical_or.html">
 has_operator_logical_or</a></dt>
+<dt><a href="reference/has_operator_minus_equal.html">
+ has_operator_minus_equal</a></dt>
<dt> has_operator_minus</dt>
+<dt><a href="reference/has_operator_modulus_equal.html">
+ has_operator_modulus_equal</a></dt>
<dt> has_operator_modulus</dt>
+<dt><a href="reference/has_operator_multiplies_equal.html">
+ has_operator_multiplies_equal</a></dt>
<dt><a href="reference/has_operator_multiplies.html">
 has_operator_multiplies</a></dt>
<dt><a href="reference/has_operator_not_equal_to.html">
 has_operator_not_equal_to</a></dt>
+<dt><a href="reference/has_operator_plus_equal.html">
+ has_operator_plus_equal</a></dt>
<dt> has_operator_plus</dt>
+<dt><a href="reference/has_operator_right_shift_equal.html">
+ has_operator_right_shift_equal</a></dt>
+<dt><a href="reference/has_operator_right_shift.html">
+ has_operator_right_shift</a></dt>
<dt><a href="reference/has_operator_unary_minus.html">
 has_operator_unary_minus</a></dt>
<dt><a href="reference/has_operator_unary_plus.html">

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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -46,7 +46,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id2925545"></a>Table 1.5. Examples
+<a name="id3357878"></a>Table 1.5. 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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -47,7 +47,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id2926130"></a>Table 1.6. Examples
+<a name="id3358463"></a>Table 1.6. 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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -49,7 +49,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id2926783"></a>Table 1.7. Examples
+<a name="id3359115"></a>Table 1.7. 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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -46,7 +46,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id2927368"></a>Table 1.8. Examples
+<a name="id3359700"></a>Table 1.8. 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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -46,7 +46,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id2927946"></a>Table 1.9. Examples
+<a name="id3360278"></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/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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -41,7 +41,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id2929443"></a>Table 1.10. Examples
+<a name="id3361776"></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/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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -42,7 +42,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id2931053"></a>Table 1.11. Examples
+<a name="id3363386"></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/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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -52,7 +52,7 @@
</td></tr>
</table></div>
<div class="table">
-<a name="id2931498"></a>Table 1.12. Function Traits Members
+<a name="id3363831"></a>Table 1.12. 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="id2931755"></a>Table 1.13. Examples
+<a name="id3364088"></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/has_no_throw_def_cons.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_no_throw_def_cons.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_no_throw_def_cons.html 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -7,13 +7,13 @@
<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
<link rel="up" href="../reference.html" title="Alphabetical Reference">
<link rel="prev" href="has_nothrow_cp_cons.html" title="has_nothrow_copy_constructor">
-<link rel="next" href="has_operator_bit_and.html" title="has_operator_bit_and">
+<link rel="next" href="has_operator_bit_and_equal.html" title="has_operator_bit_and_equal">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="has_nothrow_cp_cons.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_bit_and.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="has_nothrow_cp_cons.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_bit_and_equal.html"><img src="../../images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
@@ -37,7 +37,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="has_nothrow_cp_cons.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_bit_and.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="has_nothrow_cp_cons.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_bit_and_equal.html"><img src="../../images/next.png" alt="Next"></a>
</div>
</body>
</html>

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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -6,14 +6,14 @@
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
<link rel="up" href="../reference.html" title="Alphabetical Reference">
-<link rel="prev" href="has_no_throw_def_cons.html" title="has_nothrow_default_constructor">
-<link rel="next" href="has_operator_bit_or.html" title="has_operator_bit_or">
+<link rel="prev" href="has_operator_bit_and_equal.html" title="has_operator_bit_and_equal">
+<link rel="next" href="has_operator_bit_or_equal.html" title="has_operator_bit_or_equal">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="has_no_throw_def_cons.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_bit_or.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="has_operator_bit_and_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_bit_or_equal.html"><img src="../../images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
@@ -29,15 +29,22 @@
 and (ii) <code class="computeroutput">RET=void</code> or the result of expression <code class="computeroutput">lhs&rhs</code> is convertible to <code class="computeroutput">RET</code>
 then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>,
 otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>.
- Thus the default behaviour is to not check for the return value of the operator
- (<code class="computeroutput">RET=void</code>). If <code class="computeroutput">RET</code>
+ 
+
+ The default behaviour (<code class="computeroutput">RET=void</code>) is
+ to not check for the return value of <code class="computeroutput">operator&</code>. If <code class="computeroutput">RET</code>
 is different from the default <code class="computeroutput">void</code>
 type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
 

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

 Examples:
@@ -79,7 +86,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="has_no_throw_def_cons.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_bit_or.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="has_operator_bit_and_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_bit_or_equal.html"><img src="../../images/next.png" alt="Next"></a>
</div>
</body>
</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_and_equal.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_and_equal.html 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,99 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>has_operator_bit_and_equal</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="has_no_throw_def_cons.html" title="has_nothrow_default_constructor">
+<link rel="next" href="has_operator_bit_and.html" title="has_operator_bit_and">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="has_no_throw_def_cons.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_bit_and.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.reference.has_operator_bit_and_equal"></a><a class="link" href="has_operator_bit_and_equal.html" title="has_operator_bit_and_equal">
+ has_operator_bit_and_equal</a>
+</h3></div></div></div>
+<pre class="programlisting">template <class LHS, class RHS=LHS, class RET=void>
+struct has_operator_bit_and_equal : public <code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code> {};
+</pre>
+
+ Inherits: If (i) <code class="computeroutput">lhs</code>
+ of type <code class="computeroutput">LHS</code> and <code class="computeroutput">rhs</code> of type <code class="computeroutput">RHS</code>
+ can be used in expression <code class="computeroutput">lhs&=rhs</code>,
+ and (ii) <code class="computeroutput">RET=void</code> or the result of expression <code class="computeroutput">lhs&=rhs</code> is convertible to <code class="computeroutput">RET</code>
+ then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>,
+ otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>.
+ 
+
+ The default behaviour (<code class="computeroutput">RET=void</code>) is
+ to not check for the return value of <code class="computeroutput">operator&=</code>. If <code class="computeroutput">RET</code>
+ is different from the default <code class="computeroutput">void</code>
+ type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ 
+
+ This trait can not detect whether <code class="computeroutput">operator&=</code> is public or not: if <code class="computeroutput">operator&=</code>
+ is defined as a private member of <code class="computeroutput">LHS</code>
+ then instantiating <code class="computeroutput">has_operator_bit_and_equal<LHS></code> will produce a compiler error. For this
+ reason <code class="computeroutput">has_operator_bit_and_equal</code>
+ can not be used to determine whether a type has a public <code class="computeroutput">operator&=</code> or not.
+ 
+
+ Header: <code class="computeroutput">#include
+ <boost/type_traits/has_operator_bit_and_equal.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ 
+
+ Examples:
+ 
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_bit_and_equal<LHS, RHS, RET>::value_type</code>
+ is the type <code class="computeroutput">bool</code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_bit_and_equal<int></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_bit_and_equal<int, int,
+ int></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_bit_and_equal<int, double, bool></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_bit_and_equal<int, int,
+ std::string></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_bit_and_equal<long>::value</code>
+ is a <code class="computeroutput">bool</code> integral constant
+ expression that evaluates to true.
+ </blockquote></div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2000, 2010 Adobe Systems Inc, David Abrahams,
+ Frédéric Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant,
+ Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten
+ Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven
+ Watanabe
+ 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)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="has_no_throw_def_cons.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_bit_and.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -6,14 +6,14 @@
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
<link rel="up" href="../reference.html" title="Alphabetical Reference">
-<link rel="prev" href="has_operator_bit_and.html" title="has_operator_bit_and">
-<link rel="next" href="has_operator_bit_xor.html" title="has_operator_bit_xor">
+<link rel="prev" href="has_operator_bit_or_equal.html" title="has_operator_bit_or_equal">
+<link rel="next" href="has_operator_bit_xor_equal.html" title="has_operator_bit_xor_equal">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="has_operator_bit_and.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_bit_xor.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="has_operator_bit_or_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_bit_xor_equal.html"><img src="../../images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
@@ -30,15 +30,22 @@
 is convertible to <code class="computeroutput">RET</code> then
 inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>,
 otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>.
- Thus the default behaviour is to not check for the return value of the operator
- (<code class="computeroutput">RET=void</code>). If <code class="computeroutput">RET</code>
+ 
+
+ The default behaviour (<code class="computeroutput">RET=void</code>) is
+ to not check for the return value of <code class="computeroutput">operator|</code>. If <code class="computeroutput">RET</code>
 is different from the default <code class="computeroutput">void</code>
 type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
 

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

 Examples:
@@ -80,7 +87,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="has_operator_bit_and.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_bit_xor.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="has_operator_bit_or_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_bit_xor_equal.html"><img src="../../images/next.png" alt="Next"></a>
</div>
</body>
</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_or_equal.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_or_equal.html 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,98 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>has_operator_bit_or_equal</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="has_operator_bit_and.html" title="has_operator_bit_and">
+<link rel="next" href="has_operator_bit_or.html" title="has_operator_bit_or">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="has_operator_bit_and.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_bit_or.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.reference.has_operator_bit_or_equal"></a><a class="link" href="has_operator_bit_or_equal.html" title="has_operator_bit_or_equal">
+ has_operator_bit_or_equal</a>
+</h3></div></div></div>
+<pre class="programlisting">template <class LHS, class RHS=LHS, class RET=void>
+struct has_operator_bit_or_equal : public <code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code> {};
+</pre>
+
+ Inherits: If (i) <code class="computeroutput">lhs</code>
+ of type <code class="computeroutput">LHS</code> and <code class="computeroutput">rhs</code> of type <code class="computeroutput">RHS</code>
+ can be used in expression <code class="computeroutput">lhs|=rhs</code>,
+ and (ii) <code class="computeroutput">RET=void</code> or the result of expression <code class="computeroutput">lhs|=rhs</code>
+ is convertible to <code class="computeroutput">RET</code> then
+ inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>,
+ otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>.
+ 
+
+ The default behaviour (<code class="computeroutput">RET=void</code>) is
+ to not check for the return value of <code class="computeroutput">operator|=</code>. If <code class="computeroutput">RET</code>
+ is different from the default <code class="computeroutput">void</code>
+ type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ 
+
+ This trait can not detect whether <code class="computeroutput">operator|=</code> is public or not: if <code class="computeroutput">operator|=</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_bit_or_equal<LHS></code> will produce a compiler error. For this
+ reason <code class="computeroutput">has_operator_bit_or_equal</code>
+ can not be used to determine whether a type has a public <code class="computeroutput">operator|=</code> or not.
+ 
+
+ Header: <code class="computeroutput">#include
+ <boost/type_traits/has_operator_bit_or_equal.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ 
+
+ Examples:
+ 
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_bit_or_equal<LHS, RHS, RET>::value_type</code>
+ is the type <code class="computeroutput">bool</code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_bit_or_equal<int></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_bit_or_equal<int, int,
+ int></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_bit_or_equal<int, double, bool></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_bit_or_equal<int, int,
+ std::string></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_bit_or_equal<long>::value</code>
+ is a <code class="computeroutput">bool</code> integral constant
+ expression that evaluates to true.
+ </blockquote></div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2000, 2010 Adobe Systems Inc, David Abrahams,
+ Frédéric Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant,
+ Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten
+ Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven
+ Watanabe
+ 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)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="has_operator_bit_and.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_bit_or.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -6,14 +6,14 @@
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
<link rel="up" href="../reference.html" title="Alphabetical Reference">
-<link rel="prev" href="has_operator_bit_or.html" title="has_operator_bit_or">
-<link rel="next" href="has_operator_divides.html" title="has_operator_divides">
+<link rel="prev" href="has_operator_bit_xor_equal.html" title="has_operator_bit_xor_equal">
+<link rel="next" href="has_operator_divides_equal.html" title="has_operator_divides_equal">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="has_operator_bit_or.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_divides.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="has_operator_bit_xor_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_divides_equal.html"><img src="../../images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
@@ -30,15 +30,22 @@
 is convertible to <code class="computeroutput">RET</code> then
 inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>,
 otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>.
- Thus the default behaviour is to not check for the return value of the operator
- (<code class="computeroutput">RET=void</code>). If <code class="computeroutput">RET</code>
+ 
+
+ The default behaviour (<code class="computeroutput">RET=void</code>) is
+ to not check for the return value of <code class="computeroutput">operator^</code>. If <code class="computeroutput">RET</code>
 is different from the default <code class="computeroutput">void</code>
 type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
 

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

 Examples:
@@ -80,7 +87,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="has_operator_bit_or.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_divides.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="has_operator_bit_xor_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_divides_equal.html"><img src="../../images/next.png" alt="Next"></a>
</div>
</body>
</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_xor_equal.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_xor_equal.html 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,98 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>has_operator_bit_xor_equal</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="has_operator_bit_or.html" title="has_operator_bit_or">
+<link rel="next" href="has_operator_bit_xor.html" title="has_operator_bit_xor">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="has_operator_bit_or.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_bit_xor.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.reference.has_operator_bit_xor_equal"></a><a class="link" href="has_operator_bit_xor_equal.html" title="has_operator_bit_xor_equal">
+ has_operator_bit_xor_equal</a>
+</h3></div></div></div>
+<pre class="programlisting">template <class LHS, class RHS=LHS, class RET=void>
+struct has_operator_bit_xor_equal : public <code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code> {};
+</pre>
+
+ Inherits: If (i) <code class="computeroutput">lhs</code>
+ of type <code class="computeroutput">LHS</code> and <code class="computeroutput">rhs</code> of type <code class="computeroutput">RHS</code>
+ can be used in expression <code class="computeroutput">lhs^=rhs</code>,
+ and (ii) <code class="computeroutput">RET=void</code> or the result of expression <code class="computeroutput">lhs^=rhs</code>
+ is convertible to <code class="computeroutput">RET</code> then
+ inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>,
+ otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>.
+ 
+
+ The default behaviour (<code class="computeroutput">RET=void</code>) is
+ to not check for the return value of <code class="computeroutput">operator^=</code>. If <code class="computeroutput">RET</code>
+ is different from the default <code class="computeroutput">void</code>
+ type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ 
+
+ This trait can not detect whether <code class="computeroutput">operator^=</code> is public or not: if <code class="computeroutput">operator^=</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_bit_xor_equal<LHS></code> will produce a compiler error. For this
+ reason <code class="computeroutput">has_operator_bit_xor_equal</code>
+ can not be used to determine whether a type has a public <code class="computeroutput">operator^=</code> or not.
+ 
+
+ Header: <code class="computeroutput">#include
+ <boost/type_traits/has_operator_bit_xor_equal.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ 
+
+ Examples:
+ 
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_bit_xor_equal<LHS, RHS, RET>::value_type</code>
+ is the type <code class="computeroutput">bool</code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_bit_xor_equal<int></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_bit_xor_equal<int, int,
+ int></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_bit_xor_equal<int, double, bool></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_bit_xor_equal<int, int,
+ std::string></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_bit_xor_equal<long>::value</code>
+ is a <code class="computeroutput">bool</code> integral constant
+ expression that evaluates to true.
+ </blockquote></div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2000, 2010 Adobe Systems Inc, David Abrahams,
+ Frédéric Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant,
+ Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten
+ Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven
+ Watanabe
+ 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)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="has_operator_bit_or.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_bit_xor.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -6,14 +6,14 @@
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
<link rel="up" href="../reference.html" title="Alphabetical Reference">
-<link rel="prev" href="has_operator_bit_xor.html" title="has_operator_bit_xor">
+<link rel="prev" href="has_operator_divides_equal.html" title="has_operator_divides_equal">
<link rel="next" href="has_operator_equal_to.html" title="has_operator_equal_to">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="has_operator_bit_xor.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_equal_to.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="has_operator_divides_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_equal_to.html"><img src="../../images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
@@ -30,15 +30,22 @@
 is convertible to <code class="computeroutput">RET</code> then
 inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>,
 otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>.
- Thus the default behaviour is to not check for the return value of the operator
- (<code class="computeroutput">RET=void</code>). If <code class="computeroutput">RET</code>
+ 
+
+ The default behaviour (<code class="computeroutput">RET=void</code>) is
+ to not check for the return value of <code class="computeroutput">operator/</code>. If <code class="computeroutput">RET</code>
 is different from the default <code class="computeroutput">void</code>
 type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
 

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

 Examples:
@@ -87,7 +94,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="has_operator_bit_xor.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_equal_to.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="has_operator_divides_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_equal_to.html"><img src="../../images/next.png" alt="Next"></a>
</div>
</body>
</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_divides_equal.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_divides_equal.html 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,106 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>has_operator_divides_equal</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="has_operator_bit_xor.html" title="has_operator_bit_xor">
+<link rel="next" href="has_operator_divides.html" title="has_operator_divides">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="has_operator_bit_xor.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_divides.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.reference.has_operator_divides_equal"></a><a class="link" href="has_operator_divides_equal.html" title="has_operator_divides_equal">
+ has_operator_divides_equal</a>
+</h3></div></div></div>
+<pre class="programlisting">template <class LHS, class RHS=LHS, class RET=void>
+struct has_operator_divides_equal : public <code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code> {};
+</pre>
+
+ Inherits: If (i) <code class="computeroutput">lhs</code>
+ of type <code class="computeroutput">LHS</code> and <code class="computeroutput">rhs</code> of type <code class="computeroutput">RHS</code>
+ can be used in expression <code class="computeroutput">lhs/=rhs</code>,
+ and (ii) <code class="computeroutput">RET=void</code> or the result of expression <code class="computeroutput">lhs/=rhs</code>
+ is convertible to <code class="computeroutput">RET</code> then
+ inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>,
+ otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>.
+ 
+
+ The default behaviour (<code class="computeroutput">RET=void</code>) is
+ to not check for the return value of <code class="computeroutput">operator/=</code>. If <code class="computeroutput">RET</code>
+ is different from the default <code class="computeroutput">void</code>
+ type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ 
+
+ This trait can not detect whether <code class="computeroutput">operator/=</code> is public or not: if <code class="computeroutput">operator/=</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_divides_equal<LHS></code> will produce a compiler error. For this
+ reason <code class="computeroutput">has_operator_divides_equal</code>
+ can not be used to determine whether a type has a public <code class="computeroutput">operator/=</code> or not.
+ 
+
+ Header: <code class="computeroutput">#include
+ <boost/type_traits/has_operator_divides_equal.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ 
+
+ Examples:
+ 
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_divides_equal<LHS, RHS, RET>::value_type</code>
+ is the type <code class="computeroutput">bool</code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_divides_equal<int></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_divides_equal<int, int,
+ int></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_divides_equal<int, int,
+ long></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_divides_equal<int, double, double></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_divides_equal<int, double, int></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_divides_equal<int, int,
+ std::string></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_divides_equal<long>::value</code>
+ is a <code class="computeroutput">bool</code> integral constant
+ expression that evaluates to true.
+ </blockquote></div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2000, 2010 Adobe Systems Inc, David Abrahams,
+ Frédéric Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant,
+ Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten
+ Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven
+ Watanabe
+ 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)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="has_operator_bit_xor.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_divides.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -30,15 +30,22 @@
 is convertible to <code class="computeroutput">RET</code> then
 inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>,
 otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>.
- Thus the default behaviour is to not check for the return value of the operator
- (<code class="computeroutput">RET=void</code>). If <code class="computeroutput">RET</code>
+ 
+
+ The default behaviour (<code class="computeroutput">RET=void</code>) is
+ to not check for the return value of <code class="computeroutput">operator==</code>. If <code class="computeroutput">RET</code>
 is different from the default <code class="computeroutput">void</code>
 type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
 

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

 Examples:

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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -7,13 +7,13 @@
<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
<link rel="up" href="../reference.html" title="Alphabetical Reference">
<link rel="prev" href="has_operator_greater_equal.html" title="has_operator_greater_equal">
-<link rel="next" href="has_operator_less_equal.html" title="has_operator_less_equal">
+<link rel="next" href="has_operator_left_shift_equal.html" title="has_operator_left_shift_equal">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="has_operator_greater_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_less_equal.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="has_operator_greater_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_left_shift_equal.html"><img src="../../images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
@@ -29,15 +29,22 @@
 and (ii) <code class="computeroutput">RET=void</code> or the result of expression <code class="computeroutput">lhs>rhs</code> is convertible to <code class="computeroutput">RET</code>
 then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>,
 otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>.
- Thus the default behaviour is to not check for the return value of the operator
- (<code class="computeroutput">RET=void</code>). If <code class="computeroutput">RET</code>
+ 
+
+ The default behaviour (<code class="computeroutput">RET=void</code>) is
+ to not check for the return value of <code class="computeroutput">operator></code>. If <code class="computeroutput">RET</code>
 is different from the default <code class="computeroutput">void</code>
 type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
 

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

 Examples:
@@ -79,7 +86,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="has_operator_greater_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_less_equal.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="has_operator_greater_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_left_shift_equal.html"><img src="../../images/next.png" alt="Next"></a>
</div>
</body>
</html>

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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -30,15 +30,22 @@
 and (ii) <code class="computeroutput">RET=void</code> or the result of expression <code class="computeroutput">lhs>=rhs</code> is convertible to <code class="computeroutput">RET</code>
 then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>,
 otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>.
- Thus the default behaviour is to not check for the return value of the operator
- (<code class="computeroutput">RET=void</code>). If <code class="computeroutput">RET</code>
+ 
+
+ The default behaviour (<code class="computeroutput">RET=void</code>) is
+ to not check for the return value of <code class="computeroutput">operator>=</code>. If <code class="computeroutput">RET</code>
 is different from the default <code class="computeroutput">void</code>
 type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
 

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

 Examples:

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_left_shift.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_left_shift.html 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,99 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>has_operator_left_shift</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="has_operator_left_shift_equal.html" title="has_operator_left_shift_equal">
+<link rel="next" href="has_operator_less_equal.html" title="has_operator_less_equal">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="has_operator_left_shift_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_less_equal.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.reference.has_operator_left_shift"></a><a class="link" href="has_operator_left_shift.html" title="has_operator_left_shift">
+ has_operator_left_shift</a>
+</h3></div></div></div>
+<pre class="programlisting">template <class LHS, class RHS=LHS, class RET=void>
+struct has_operator_left_shift : public <code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code> {};
+</pre>
+
+ Inherits: If (i) <code class="computeroutput">lhs</code>
+ of type <code class="computeroutput">LHS</code> and <code class="computeroutput">rhs</code> of type <code class="computeroutput">RHS</code>
+ can be used in expression <code class="computeroutput">lhs<<rhs</code>,
+ and (ii) <code class="computeroutput">RET=void</code> or the result of expression <code class="computeroutput">lhs<<rhs</code> is convertible to <code class="computeroutput">RET</code>
+ then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>,
+ otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>.
+ 
+
+ The default behaviour (<code class="computeroutput">RET=void</code>) is
+ to not check for the return value of <code class="computeroutput">operator<<</code>. If <code class="computeroutput">RET</code>
+ is different from the default <code class="computeroutput">void</code>
+ type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ 
+
+ This trait can not detect whether <code class="computeroutput">operator<<</code> is public or not: if <code class="computeroutput">operator<<</code>
+ is defined as a private member of <code class="computeroutput">LHS</code>
+ then instantiating <code class="computeroutput">has_operator_left_shift<LHS></code> will produce a compiler error. For this
+ reason <code class="computeroutput">has_operator_left_shift</code>
+ can not be used to determine whether a type has a public <code class="computeroutput">operator<<</code> or not.
+ 
+
+ Header: <code class="computeroutput">#include
+ <boost/type_traits/has_operator_left_shift.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ 
+
+ Examples:
+ 
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_left_shift<LHS, RHS, RET>::value_type</code>
+ is the type <code class="computeroutput">bool</code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_left_shift<int></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_left_shift<int, int,
+ int></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_left_shift<int, double, bool></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_left_shift<int, int,
+ std::string></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_left_shift<long>::value</code>
+ is a <code class="computeroutput">bool</code> integral constant
+ expression that evaluates to true.
+ </blockquote></div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2000, 2010 Adobe Systems Inc, David Abrahams,
+ Frédéric Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant,
+ Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten
+ Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven
+ Watanabe
+ 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)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="has_operator_left_shift_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_less_equal.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_left_shift_equal.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_left_shift_equal.html 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,99 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>has_operator_left_shift_equal</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="has_operator_greater.html" title="has_operator_greater">
+<link rel="next" href="has_operator_left_shift.html" title="has_operator_left_shift">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="has_operator_greater.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_left_shift.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.reference.has_operator_left_shift_equal"></a><a class="link" href="has_operator_left_shift_equal.html" title="has_operator_left_shift_equal">
+ has_operator_left_shift_equal</a>
+</h3></div></div></div>
+<pre class="programlisting">template <class LHS, class RHS=LHS, class RET=void>
+struct has_operator_left_shift_equal : public <code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code> {};
+</pre>
+
+ Inherits: If (i) <code class="computeroutput">lhs</code>
+ of type <code class="computeroutput">LHS</code> and <code class="computeroutput">rhs</code> of type <code class="computeroutput">RHS</code>
+ can be used in expression <code class="computeroutput">lhs<<=rhs</code>,
+ and (ii) <code class="computeroutput">RET=void</code> or the result of expression <code class="computeroutput">lhs<<=rhs</code> is convertible to <code class="computeroutput">RET</code>
+ then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>,
+ otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>.
+ 
+
+ The default behaviour (<code class="computeroutput">RET=void</code>) is
+ to not check for the return value of <code class="computeroutput">operator<<=</code>. If <code class="computeroutput">RET</code>
+ is different from the default <code class="computeroutput">void</code>
+ type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ 
+
+ This trait can not detect whether <code class="computeroutput">operator<<=</code> is public or not: if <code class="computeroutput">operator<<=</code>
+ is defined as a private member of <code class="computeroutput">LHS</code>
+ then instantiating <code class="computeroutput">has_operator_left_shift_equal<LHS></code> will produce a compiler error. For this
+ reason <code class="computeroutput">has_operator_left_shift_equal</code>
+ can not be used to determine whether a type has a public <code class="computeroutput">operator<<=</code> or not.
+ 
+
+ Header: <code class="computeroutput">#include
+ <boost/type_traits/has_operator_left_shift_equal.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ 
+
+ Examples:
+ 
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_left_shift_equal<LHS, RHS, RET>::value_type</code>
+ is the type <code class="computeroutput">bool</code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_left_shift_equal<int></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_left_shift_equal<int, int,
+ int></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_left_shift_equal<int, double, bool></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_left_shift_equal<int, int,
+ std::string></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_left_shift_equal<long>::value</code>
+ is a <code class="computeroutput">bool</code> integral constant
+ expression that evaluates to true.
+ </blockquote></div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2000, 2010 Adobe Systems Inc, David Abrahams,
+ Frédéric Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant,
+ Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten
+ Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven
+ Watanabe
+ 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)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="has_operator_greater.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_left_shift.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -29,15 +29,22 @@
 and (ii) <code class="computeroutput">RET=void</code> or the result of expression <code class="computeroutput">lhs<rhs</code> is convertible to <code class="computeroutput">RET</code>
 then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>,
 otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>.
- Thus the default behaviour is to not check for the return value of the operator
- (<code class="computeroutput">RET=void</code>). If <code class="computeroutput">RET</code>
+ 
+
+ The default behaviour (<code class="computeroutput">RET=void</code>) is
+ to not check for the return value of <code class="computeroutput">operator<</code>. If <code class="computeroutput">RET</code>
 is different from the default <code class="computeroutput">void</code>
 type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
 

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

 Examples:

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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -6,14 +6,14 @@
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
<link rel="up" href="../reference.html" title="Alphabetical Reference">
-<link rel="prev" href="has_operator_greater.html" title="has_operator_greater">
+<link rel="prev" href="has_operator_left_shift.html" title="has_operator_left_shift">
<link rel="next" href="has_operator_less.html" title="has_operator_less">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="has_operator_greater.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_less.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="has_operator_left_shift.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_less.html"><img src="../../images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
@@ -30,15 +30,22 @@
 and (ii) <code class="computeroutput">RET=void</code> or the result of expression <code class="computeroutput">lhs<=rhs</code> is convertible to <code class="computeroutput">RET</code>
 then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>,
 otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>.
- Thus the default behaviour is to not check for the return value of the operator
- (<code class="computeroutput">RET=void</code>). If <code class="computeroutput">RET</code>
+ 
+
+ The default behaviour (<code class="computeroutput">RET=void</code>) is
+ to not check for the return value of <code class="computeroutput">operator<=</code>. If <code class="computeroutput">RET</code>
 is different from the default <code class="computeroutput">void</code>
 type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
 

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

 Examples:
@@ -84,7 +91,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="has_operator_greater.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_less.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="has_operator_left_shift.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_less.html"><img src="../../images/next.png" alt="Next"></a>
</div>
</body>
</html>

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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -30,15 +30,24 @@
 and (ii) <code class="computeroutput">RET=void</code> or the result of expression <code class="computeroutput">lhs&&rhs</code> is convertible to <code class="computeroutput">RET</code>
 then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>,
 otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>.
- Thus the default behaviour is to not check for the return value of the operator
- (<code class="computeroutput">RET=void</code>). If <code class="computeroutput">RET</code>
+ 
+
+ The default behaviour (<code class="computeroutput">RET=void</code>) is
+ to not check for the return value of <code class="computeroutput">operator&&</code>. If <code class="computeroutput">RET</code>
 is different from the default <code class="computeroutput">void</code>
 type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
 

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

 Examples:

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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -31,15 +31,22 @@
 convertible to <code class="computeroutput">RET</code> then inherits
 from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>,
 otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>.
- Thus the default behaviour is to not check for the return value of the operator
- (<code class="computeroutput">RET=void</code>). If <code class="computeroutput">RET</code>
+ 
+
+ The default behaviour (<code class="computeroutput">RET=void</code>) is
+ to not check for the return value of <code class="computeroutput">operator!</code>. If <code class="computeroutput">RET</code>
 is different from the default <code class="computeroutput">void</code>
 type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
 

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

 Examples:

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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -7,13 +7,13 @@
<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
<link rel="up" href="../reference.html" title="Alphabetical Reference">
<link rel="prev" href="has_operator_logical_not.html" title="has_operator_logical_not">
-<link rel="next" href="has_operator_minus.html" title="has_operator_minus">
+<link rel="next" href="has_operator_minus_equal.html" title="has_operator_minus_equal">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="has_operator_logical_not.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_minus.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="has_operator_logical_not.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_minus_equal.html"><img src="../../images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
@@ -31,15 +31,22 @@
 is convertible to <code class="computeroutput">RET</code> then
 inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>,
 otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>.
- Thus the default behaviour is to not check for the return value of the operator
- (<code class="computeroutput">RET=void</code>). If <code class="computeroutput">RET</code>
+ 
+
+ The default behaviour (<code class="computeroutput">RET=void</code>) is
+ to not check for the return value of <code class="computeroutput">operator||</code>. If <code class="computeroutput">RET</code>
 is different from the default <code class="computeroutput">void</code>
 type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
 

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

 Examples:
@@ -85,7 +92,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="has_operator_logical_not.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_minus.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="has_operator_logical_not.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_minus_equal.html"><img src="../../images/next.png" alt="Next"></a>
</div>
</body>
</html>

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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -6,14 +6,14 @@
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
<link rel="up" href="../reference.html" title="Alphabetical Reference">
-<link rel="prev" href="has_operator_logical_or.html" title="has_operator_logical_or">
-<link rel="next" href="has_operator_modulus.html" title="has_operator_modulus">
+<link rel="prev" href="has_operator_minus_equal.html" title="has_operator_minus_equal">
+<link rel="next" href="has_operator_modulus_equal.html" title="has_operator_modulus_equal">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="has_operator_logical_or.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_modulus.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="has_operator_minus_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_modulus_equal.html"><img src="../../images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
@@ -30,15 +30,22 @@
 is convertible to <code class="computeroutput">RET</code> then
 inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>,
 otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>.
- Thus the default behaviour is to not check for the return value of the operator
- (<code class="computeroutput">RET=void</code>). If <code class="computeroutput">RET</code>
+ 
+
+ The default behaviour (<code class="computeroutput">RET=void</code>) is
+ to not check for the return value of <code class="computeroutput">operator-</code>. If <code class="computeroutput">RET</code>
 is different from the default <code class="computeroutput">void</code>
 type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
 

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

 Examples:
@@ -87,7 +94,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="has_operator_logical_or.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_modulus.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="has_operator_minus_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_modulus_equal.html"><img src="../../images/next.png" alt="Next"></a>
</div>
</body>
</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_minus_equal.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_minus_equal.html 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,106 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>has_operator_minus_equal</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="has_operator_logical_or.html" title="has_operator_logical_or">
+<link rel="next" href="has_operator_minus.html" title="has_operator_minus">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="has_operator_logical_or.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_minus.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.reference.has_operator_minus_equal"></a><a class="link" href="has_operator_minus_equal.html" title="has_operator_minus_equal">
+ has_operator_minus_equal</a>
+</h3></div></div></div>
+<pre class="programlisting">template <class LHS, class RHS=LHS, class RET=void>
+struct has_operator_minus_equal : public <code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code> {};
+</pre>
+
+ Inherits: If (i) <code class="computeroutput">lhs</code>
+ of type <code class="computeroutput">LHS</code> and <code class="computeroutput">rhs</code> of type <code class="computeroutput">RHS</code>
+ can be used in expression <code class="computeroutput">lhs-=rhs</code>,
+ and (ii) <code class="computeroutput">RET=void</code> or the result of expression <code class="computeroutput">lhs-=rhs</code>
+ is convertible to <code class="computeroutput">RET</code> then
+ inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>,
+ otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>.
+ 
+
+ The default behaviour (<code class="computeroutput">RET=void</code>) is
+ to not check for the return value of <code class="computeroutput">operator-=</code>. If <code class="computeroutput">RET</code>
+ is different from the default <code class="computeroutput">void</code>
+ type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ 
+
+ This trait can not detect whether <code class="computeroutput">operator-=</code> is public or not: if <code class="computeroutput">operator-=</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_minus_equal<LHS></code> will produce a compiler error. For this
+ reason <code class="computeroutput">has_operator_minus_equal</code>
+ can not be used to determine whether a type has a public <code class="computeroutput">operator-=</code> or not.
+ 
+
+ Header: <code class="computeroutput">#include
+ <boost/type_traits/has_operator_minus_equal.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ 
+
+ Examples:
+ 
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_minus_equal<LHS, RHS, RET>::value_type</code>
+ is the type <code class="computeroutput">bool</code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_minus_equal<int></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_minus_equal<int, int,
+ int></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_minus_equal<int, int,
+ long></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_minus_equal<int, double, double></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_minus_equal<int, double, int></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_minus_equal<int, int,
+ std::string></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_minus_equal<long>::value</code>
+ is a <code class="computeroutput">bool</code> integral constant
+ expression that evaluates to true.
+ </blockquote></div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2000, 2010 Adobe Systems Inc, David Abrahams,
+ Frédéric Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant,
+ Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten
+ Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven
+ Watanabe
+ 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)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="has_operator_logical_or.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_minus.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -6,14 +6,14 @@
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
<link rel="up" href="../reference.html" title="Alphabetical Reference">
-<link rel="prev" href="has_operator_minus.html" title="has_operator_minus">
-<link rel="next" href="has_operator_multiplies.html" title="has_operator_multiplies">
+<link rel="prev" href="has_operator_modulus_equal.html" title="has_operator_modulus_equal">
+<link rel="next" href="has_operator_multiplies_equal.html" title="has_operator_multiplies_equal">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="has_operator_minus.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_multiplies.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="has_operator_modulus_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_multiplies_equal.html"><img src="../../images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
@@ -30,15 +30,22 @@
 is convertible to <code class="computeroutput">RET</code> then
 inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>,
 otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>.
- Thus the default behaviour is to not check for the return value of the operator
- (<code class="computeroutput">RET=void</code>). If <code class="computeroutput">RET</code>
+ 
+
+ The default behaviour (<code class="computeroutput">RET=void</code>) is
+ to not check for the return value of <code class="computeroutput">operator%</code>. If <code class="computeroutput">RET</code>
 is different from the default <code class="computeroutput">void</code>
 type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
 

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

 Examples:
@@ -79,7 +86,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="has_operator_minus.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_multiplies.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="has_operator_modulus_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_multiplies_equal.html"><img src="../../images/next.png" alt="Next"></a>
</div>
</body>
</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_modulus_equal.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_modulus_equal.html 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,97 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>has_operator_modulus_equal</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="has_operator_minus.html" title="has_operator_minus">
+<link rel="next" href="has_operator_modulus.html" title="has_operator_modulus">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="has_operator_minus.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_modulus.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.reference.has_operator_modulus_equal"></a><a class="link" href="has_operator_modulus_equal.html" title="has_operator_modulus_equal">
+ has_operator_modulus_equal</a>
+</h3></div></div></div>
+<pre class="programlisting">template <class LHS, class RHS=LHS, class RET=void>
+struct has_operator_modulus_equal : public <code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code> {};
+</pre>
+
+ Inherits: If (i) <code class="computeroutput">lhs</code>
+ of type <code class="computeroutput">LHS</code> and <code class="computeroutput">rhs</code> of type <code class="computeroutput">RHS</code>
+ can be used in expression <code class="computeroutput">lhs%=rhs</code>,
+ and (ii) <code class="computeroutput">RET=void</code> or the result of expression <code class="computeroutput">lhs%=rhs</code>
+ is convertible to <code class="computeroutput">RET</code> then
+ inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>,
+ otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>.
+ 
+
+ The default behaviour (<code class="computeroutput">RET=void</code>) is
+ to not check for the return value of <code class="computeroutput">operator%=</code>. If <code class="computeroutput">RET</code>
+ is different from the default <code class="computeroutput">void</code>
+ type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ 
+
+ This trait can not detect whether <code class="computeroutput">operator%=</code> is public or not: if <code class="computeroutput">operator%=</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_modulus_equal<LHS></code> will produce a compiler error. For this
+ reason <code class="computeroutput">has_operator_modulus_equal</code>
+ can not be used to determine whether a type has a public <code class="computeroutput">operator%=</code> or not.
+ 
+
+ Header: <code class="computeroutput">#include
+ <boost/type_traits/has_operator_modulus_equal.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ 
+
+ Examples:
+ 
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_modulus_equal<LHS, RHS, RET>::value_type</code>
+ is the type <code class="computeroutput">bool</code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_modulus_equal<int></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_modulus_equal<int, int,
+ int></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_modulus_equal<int, int,
+ std::string></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<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>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_modulus_equal<long>::value</code>
+ is a <code class="computeroutput">bool</code> integral constant
+ expression that evaluates to true.
+ </blockquote></div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2000, 2010 Adobe Systems Inc, David Abrahams,
+ Frédéric Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant,
+ Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten
+ Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven
+ Watanabe
+ 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)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="has_operator_minus.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_modulus.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -6,14 +6,14 @@
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
<link rel="up" href="../reference.html" title="Alphabetical Reference">
-<link rel="prev" href="has_operator_modulus.html" title="has_operator_modulus">
+<link rel="prev" href="has_operator_multiplies_equal.html" title="has_operator_multiplies_equal">
<link rel="next" href="has_operator_not_equal_to.html" title="has_operator_not_equal_to">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="has_operator_modulus.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_not_equal_to.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="has_operator_multiplies_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_not_equal_to.html"><img src="../../images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
@@ -31,15 +31,22 @@
 is convertible to <code class="computeroutput">RET</code> then
 inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>,
 otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>.
- Thus the default behaviour is to not check for the return value of the operator
- (<code class="computeroutput">RET=void</code>). If <code class="computeroutput">RET</code>
+ 
+
+ The default behaviour (<code class="computeroutput">RET=void</code>) is
+ to not check for the return value of <code class="computeroutput">operator*</code>. If <code class="computeroutput">RET</code>
 is different from the default <code class="computeroutput">void</code>
 type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
 

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

 Examples:
@@ -93,7 +100,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="has_operator_modulus.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_not_equal_to.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="has_operator_multiplies_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_not_equal_to.html"><img src="../../images/next.png" alt="Next"></a>
</div>
</body>
</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_multiplies_equal.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_multiplies_equal.html 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,106 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>has_operator_multiplies_equal</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="has_operator_modulus.html" title="has_operator_modulus">
+<link rel="next" href="has_operator_multiplies.html" title="has_operator_multiplies">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="has_operator_modulus.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_multiplies.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.reference.has_operator_multiplies_equal"></a><a class="link" href="has_operator_multiplies_equal.html" title="has_operator_multiplies_equal">
+ has_operator_multiplies_equal</a>
+</h3></div></div></div>
+<pre class="programlisting">template <class LHS, class RHS=LHS, class RET=void>
+struct has_operator_multiplies_equal : public <code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code> {};
+</pre>
+
+ Inherits: If (i) <code class="computeroutput">lhs</code>
+ of type <code class="computeroutput">LHS</code> and <code class="computeroutput">rhs</code> of type <code class="computeroutput">RHS</code>
+ can be used in expression <code class="computeroutput">lhs*=rhs</code>,
+ and (ii) <code class="computeroutput">RET=void</code> or the result of expression <code class="computeroutput">lhs*=rhs</code>
+ is convertible to <code class="computeroutput">RET</code> then
+ inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>,
+ otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>.
+ 
+
+ The default behaviour (<code class="computeroutput">RET=void</code>) is
+ to not check for the return value of <code class="computeroutput">operator*=</code>. If <code class="computeroutput">RET</code>
+ is different from the default <code class="computeroutput">void</code>
+ type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ 
+
+ This trait can not detect whether <code class="computeroutput">operator*=</code> is public or not: if <code class="computeroutput">operator*=</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_multiplies_equal<LHS></code> will produce a compiler error. For this
+ reason <code class="computeroutput">has_operator_multiplies_equal</code>
+ can not be used to determine whether a type has a public <code class="computeroutput">operator*=</code> or not.
+ 
+
+ Header: <code class="computeroutput">#include
+ <boost/type_traits/has_operator_multiplies_equal.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ 
+
+ Examples:
+ 
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_multiplies_equal<LHS, RHS, RET>::value_type</code>
+ is the type <code class="computeroutput">bool</code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_multiplies_equal<int></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_multiplies_equal<int, int,
+ int></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_multiplies_equal<int, int,
+ long></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_multiplies_equal<int, double, double></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_multiplies_equal<int, double, int></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_multiplies_equal<int, int,
+ std::string></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_multiplies_equal<long>::value</code>
+ is a <code class="computeroutput">bool</code> integral constant
+ expression that evaluates to true.
+ </blockquote></div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2000, 2010 Adobe Systems Inc, David Abrahams,
+ Frédéric Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant,
+ Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten
+ Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven
+ Watanabe
+ 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)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="has_operator_modulus.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_multiplies.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -7,13 +7,13 @@
<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
<link rel="up" href="../reference.html" title="Alphabetical Reference">
<link rel="prev" href="has_operator_multiplies.html" title="has_operator_multiplies">
-<link rel="next" href="has_operator_plus.html" title="has_operator_plus">
+<link rel="next" href="has_operator_plus_equal.html" title="has_operator_plus_equal">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="has_operator_multiplies.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_plus.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="has_operator_multiplies.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_plus_equal.html"><img src="../../images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
@@ -31,15 +31,22 @@
 is convertible to <code class="computeroutput">RET</code> then
 inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>,
 otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>.
- Thus the default behaviour is to not check for the return value of the operator
- (<code class="computeroutput">RET=void</code>). If <code class="computeroutput">RET</code>
+ 
+
+ The default behaviour (<code class="computeroutput">RET=void</code>) is
+ to not check for the return value of <code class="computeroutput">operator!=</code>. If <code class="computeroutput">RET</code>
 is different from the default <code class="computeroutput">void</code>
 type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
 

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

 Examples:
@@ -85,7 +92,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="has_operator_multiplies.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_plus.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="has_operator_multiplies.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_plus_equal.html"><img src="../../images/next.png" alt="Next"></a>
</div>
</body>
</html>

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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -6,14 +6,14 @@
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
<link rel="up" href="../reference.html" title="Alphabetical Reference">
-<link rel="prev" href="has_operator_not_equal_to.html" title="has_operator_not_equal_to">
-<link rel="next" href="has_operator_unary_minus.html" title="has_operator_unary_minus">
+<link rel="prev" href="has_operator_plus_equal.html" title="has_operator_plus_equal">
+<link rel="next" href="has_operator_right_shift_equal.html" title="has_operator_right_shift_equal">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="has_operator_not_equal_to.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_unary_minus.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="has_operator_plus_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_right_shift_equal.html"><img src="../../images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
@@ -30,15 +30,22 @@
 is convertible to <code class="computeroutput">RET</code> then
 inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>,
 otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>.
- Thus the default behaviour is to not check for the return value of the operator
- (<code class="computeroutput">RET=void</code>). If <code class="computeroutput">RET</code>
+ 
+
+ The default behaviour (<code class="computeroutput">RET=void</code>) is
+ to not check for the return value of <code class="computeroutput">operator+</code>. If <code class="computeroutput">RET</code>
 is different from the default <code class="computeroutput">void</code>
 type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
 

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

 Examples:
@@ -87,7 +94,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="has_operator_not_equal_to.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_unary_minus.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="has_operator_plus_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_right_shift_equal.html"><img src="../../images/next.png" alt="Next"></a>
</div>
</body>
</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_plus_equal.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_plus_equal.html 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,106 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>has_operator_plus_equal</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="has_operator_not_equal_to.html" title="has_operator_not_equal_to">
+<link rel="next" href="has_operator_plus.html" title="has_operator_plus">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="has_operator_not_equal_to.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_plus.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.reference.has_operator_plus_equal"></a><a class="link" href="has_operator_plus_equal.html" title="has_operator_plus_equal">
+ has_operator_plus_equal</a>
+</h3></div></div></div>
+<pre class="programlisting">template <class LHS, class RHS=LHS, class RET=void>
+struct has_operator_plus_equal : public <code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code> {};
+</pre>
+
+ Inherits: If (i) <code class="computeroutput">lhs</code>
+ of type <code class="computeroutput">LHS</code> and <code class="computeroutput">rhs</code> of type <code class="computeroutput">RHS</code>
+ can be used in expression <code class="computeroutput">lhs+=rhs</code>,
+ and (ii) <code class="computeroutput">RET=void</code> or the result of expression <code class="computeroutput">lhs+=rhs</code>
+ is convertible to <code class="computeroutput">RET</code> then
+ inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>,
+ otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>.
+ 
+
+ The default behaviour (<code class="computeroutput">RET=void</code>) is
+ to not check for the return value of <code class="computeroutput">operator+=</code>. If <code class="computeroutput">RET</code>
+ is different from the default <code class="computeroutput">void</code>
+ type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ 
+
+ This trait can not detect whether <code class="computeroutput">operator+=</code> is public or not: if <code class="computeroutput">operator+=</code> is defined as a private member of <code class="computeroutput">LHS</code> then instantiating <code class="computeroutput">has_operator_plus_equal<LHS></code> will produce a compiler error. For this
+ reason <code class="computeroutput">has_operator_plus_equal</code>
+ can not be used to determine whether a type has a public <code class="computeroutput">operator+=</code> or not.
+ 
+
+ Header: <code class="computeroutput">#include
+ <boost/type_traits/has_operator_plus_equal.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ 
+
+ Examples:
+ 
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_plus_equal<LHS, RHS, RET>::value_type</code>
+ is the type <code class="computeroutput">bool</code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_plus_equal<int></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_plus_equal<int, int,
+ int></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_plus_equal<int, int,
+ long></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_plus_equal<int, double, double></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_plus_equal<int, double, int></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_plus_equal<int, int,
+ std::string></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_plus_equal<long>::value</code>
+ is a <code class="computeroutput">bool</code> integral constant
+ expression that evaluates to true.
+ </blockquote></div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2000, 2010 Adobe Systems Inc, David Abrahams,
+ Frédéric Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant,
+ Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten
+ Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven
+ Watanabe
+ 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)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="has_operator_not_equal_to.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_plus.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_right_shift.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_right_shift.html 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,99 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>has_operator_right_shift</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="has_operator_right_shift_equal.html" title="has_operator_right_shift_equal">
+<link rel="next" href="has_operator_unary_minus.html" title="has_operator_unary_minus">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="has_operator_right_shift_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_unary_minus.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.reference.has_operator_right_shift"></a><a class="link" href="has_operator_right_shift.html" title="has_operator_right_shift">
+ has_operator_right_shift</a>
+</h3></div></div></div>
+<pre class="programlisting">template <class LHS, class RHS=LHS, class RET=void>
+struct has_operator_right_shift : public <code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code> {};
+</pre>
+
+ Inherits: If (i) <code class="computeroutput">lhs</code>
+ of type <code class="computeroutput">LHS</code> and <code class="computeroutput">rhs</code> of type <code class="computeroutput">RHS</code>
+ can be used in expression <code class="computeroutput">lhs>>rhs</code>,
+ and (ii) <code class="computeroutput">RET=void</code> or the result of expression <code class="computeroutput">lhs>>rhs</code> is convertible to <code class="computeroutput">RET</code>
+ then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>,
+ otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>.
+ 
+
+ The default behaviour (<code class="computeroutput">RET=void</code>) is
+ to not check for the return value of <code class="computeroutput">operator>></code>. If <code class="computeroutput">RET</code>
+ is different from the default <code class="computeroutput">void</code>
+ type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ 
+
+ This trait can not detect whether <code class="computeroutput">operator>></code> is public or not: if <code class="computeroutput">operator>></code>
+ is defined as a private member of <code class="computeroutput">LHS</code>
+ then instantiating <code class="computeroutput">has_operator_right_shift<LHS></code> will produce a compiler error. For this
+ reason <code class="computeroutput">has_operator_right_shift</code>
+ can not be used to determine whether a type has a public <code class="computeroutput">operator>></code> or not.
+ 
+
+ Header: <code class="computeroutput">#include
+ <boost/type_traits/has_operator_right_shift.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ 
+
+ Examples:
+ 
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_right_shift<LHS, RHS, RET>::value_type</code>
+ is the type <code class="computeroutput">bool</code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_right_shift<int></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_right_shift<int, int,
+ int></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_right_shift<int, double, bool></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_right_shift<int, int,
+ std::string></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_right_shift<long>::value</code>
+ is a <code class="computeroutput">bool</code> integral constant
+ expression that evaluates to true.
+ </blockquote></div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2000, 2010 Adobe Systems Inc, David Abrahams,
+ Frédéric Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant,
+ Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten
+ Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven
+ Watanabe
+ 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)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="has_operator_right_shift_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_unary_minus.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_right_shift_equal.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_right_shift_equal.html 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,99 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>has_operator_right_shift_equal</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="has_operator_plus.html" title="has_operator_plus">
+<link rel="next" href="has_operator_right_shift.html" title="has_operator_right_shift">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="has_operator_plus.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_right_shift.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.reference.has_operator_right_shift_equal"></a><a class="link" href="has_operator_right_shift_equal.html" title="has_operator_right_shift_equal">
+ has_operator_right_shift_equal</a>
+</h3></div></div></div>
+<pre class="programlisting">template <class LHS, class RHS=LHS, class RET=void>
+struct has_operator_right_shift_equal : public <code><a class="link" href="integral_constant.html" title="integral_constant">true_type</a>-or-<a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code> {};
+</pre>
+
+ Inherits: If (i) <code class="computeroutput">lhs</code>
+ of type <code class="computeroutput">LHS</code> and <code class="computeroutput">rhs</code> of type <code class="computeroutput">RHS</code>
+ can be used in expression <code class="computeroutput">lhs>>=rhs</code>,
+ and (ii) <code class="computeroutput">RET=void</code> or the result of expression <code class="computeroutput">lhs>>=rhs</code> is convertible to <code class="computeroutput">RET</code>
+ then inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>,
+ otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>.
+ 
+
+ The default behaviour (<code class="computeroutput">RET=void</code>) is
+ to not check for the return value of <code class="computeroutput">operator>>=</code>. If <code class="computeroutput">RET</code>
+ is different from the default <code class="computeroutput">void</code>
+ type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
+ 
+
+ This trait can not detect whether <code class="computeroutput">operator>>=</code> is public or not: if <code class="computeroutput">operator>>=</code>
+ is defined as a private member of <code class="computeroutput">LHS</code>
+ then instantiating <code class="computeroutput">has_operator_right_shift_equal<LHS></code> will produce a compiler error. For this
+ reason <code class="computeroutput">has_operator_right_shift_equal</code>
+ can not be used to determine whether a type has a public <code class="computeroutput">operator>>=</code> or not.
+ 
+
+ Header: <code class="computeroutput">#include
+ <boost/type_traits/has_operator_right_shift_equal.hpp></code>
+ or <code class="computeroutput">#include <boost/type_traits.hpp></code>
+ 
+
+ Examples:
+ 
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_right_shift_equal<LHS, RHS, RET>::value_type</code>
+ is the type <code class="computeroutput">bool</code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_right_shift_equal<int></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_right_shift_equal<int, int,
+ int></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_right_shift_equal<int, double, bool></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_right_shift_equal<int, int,
+ std::string></code>
+ inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+ </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+ <code class="computeroutput">has_operator_right_shift_equal<long>::value</code>
+ is a <code class="computeroutput">bool</code> integral constant
+ expression that evaluates to true.
+ </blockquote></div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2000, 2010 Adobe Systems Inc, David Abrahams,
+ Frédéric Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant,
+ Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten
+ Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven
+ Watanabe
+ 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)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="has_operator_plus.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_right_shift.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -6,14 +6,14 @@
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../index.html" title="Chapter 1. Boost.TypeTraits">
<link rel="up" href="../reference.html" title="Alphabetical Reference">
-<link rel="prev" href="has_operator_plus.html" title="has_operator_plus">
+<link rel="prev" href="has_operator_right_shift.html" title="has_operator_right_shift">
<link rel="next" href="has_operator_unary_plus.html" title="has_operator_unary_plus">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="has_operator_plus.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_unary_plus.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="has_operator_right_shift.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_unary_plus.html"><img src="../../images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
@@ -31,15 +31,22 @@
 convertible to <code class="computeroutput">RET</code> then inherits
 from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>,
 otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>.
- Thus the default behaviour is to not check for the return value of the operator
- (<code class="computeroutput">RET=void</code>). If <code class="computeroutput">RET</code>
+ 
+
+ The default behaviour (<code class="computeroutput">RET=void</code>) is
+ to not check for the return value of <code class="computeroutput">operator-</code>. If <code class="computeroutput">RET</code>
 is different from the default <code class="computeroutput">void</code>
 type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
 

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

 Examples:
@@ -89,7 +96,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="has_operator_plus.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_unary_plus.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="has_operator_right_shift.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_unary_plus.html"><img src="../../images/next.png" alt="Next"></a>
</div>
</body>
</html>

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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -31,15 +31,22 @@
 convertible to <code class="computeroutput">RET</code> then inherits
 from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>,
 otherwise inherits from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>.
- Thus the default behaviour is to not check for the return value of the operator
- (<code class="computeroutput">RET=void</code>). If <code class="computeroutput">RET</code>
+ 
+
+ The default behaviour (<code class="computeroutput">RET=void</code>) is
+ to not check for the return value of <code class="computeroutput">operator+</code>. If <code class="computeroutput">RET</code>
 is different from the default <code class="computeroutput">void</code>
 type, the return value is checked to be convertible to <code class="computeroutput">RET</code>.
 

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

 Examples:

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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -42,7 +42,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id2952714"></a>Table 1.14. Examples
+<a name="id3398987"></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/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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -47,7 +47,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id2970631"></a>Table 1.15. Examples
+<a name="id3416905"></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/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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -47,7 +47,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id2971212"></a>Table 1.16. Examples
+<a name="id3417486"></a>Table 1.16. 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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -44,7 +44,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id2971816"></a>Table 1.17. Examples
+<a name="id3418090"></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/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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -44,7 +44,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id2972576"></a>Table 1.18. Examples
+<a name="id3418850"></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/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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -47,7 +47,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id2973862"></a>Table 1.19. Examples
+<a name="id3420136"></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/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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -46,7 +46,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id2974525"></a>Table 1.20. Examples
+<a name="id3420799"></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/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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -46,7 +46,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id2975170"></a>Table 1.21. Examples
+<a name="id3421444"></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/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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -47,7 +47,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id2975816"></a>Table 1.22. Examples
+<a name="id3422090"></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_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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -42,7 +42,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id2977084"></a>Table 1.24. Examples
+<a name="id3423358"></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_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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -46,7 +46,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id2976492"></a>Table 1.23. Examples
+<a name="id3422765"></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_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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -46,7 +46,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id2977874"></a>Table 1.25. Examples
+<a name="id3424148"></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_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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -46,7 +46,7 @@
or <code class="computeroutput"> #include <boost/type_traits.hpp></code>

<div class="table">
-<a name="id2978429"></a>Table 1.26. Examples
+<a name="id3424703"></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/index.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/index.html (original)
+++ sandbox/type_traits/libs/type_traits/doc/html/index.html 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -24,7 +24,7 @@
 Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven
 Watanabe</div>
<div><div class="legalnotice">
-<a name="id2903848"></a>
+<a name="id3336181"></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)
 
@@ -90,14 +90,26 @@
<dt> has_nothrow_copy</dt>
<dt> has_nothrow_copy_constructor</dt>
<dt> has_nothrow_default_constructor</dt>
+<dt><a href="boost_typetraits/reference/has_operator_bit_and_equal.html">
+ has_operator_bit_and_equal</a></dt>
<dt> has_operator_bit_and</dt>
+<dt><a href="boost_typetraits/reference/has_operator_bit_or_equal.html">
+ has_operator_bit_or_equal</a></dt>
<dt> has_operator_bit_or</dt>
+<dt><a href="boost_typetraits/reference/has_operator_bit_xor_equal.html">
+ has_operator_bit_xor_equal</a></dt>
<dt> has_operator_bit_xor</dt>
+<dt><a href="boost_typetraits/reference/has_operator_divides_equal.html">
+ has_operator_divides_equal</a></dt>
<dt> has_operator_divides</dt>
<dt> has_operator_equal_to</dt>
<dt><a href="boost_typetraits/reference/has_operator_greater_equal.html">
 has_operator_greater_equal</a></dt>
<dt> has_operator_greater</dt>
+<dt><a href="boost_typetraits/reference/has_operator_left_shift_equal.html">
+ has_operator_left_shift_equal</a></dt>
+<dt><a href="boost_typetraits/reference/has_operator_left_shift.html">
+ has_operator_left_shift</a></dt>
<dt><a href="boost_typetraits/reference/has_operator_less_equal.html">
 has_operator_less_equal</a></dt>
<dt> has_operator_less</dt>
@@ -107,13 +119,25 @@
 has_operator_logical_not</a></dt>
<dt><a href="boost_typetraits/reference/has_operator_logical_or.html">
 has_operator_logical_or</a></dt>
+<dt><a href="boost_typetraits/reference/has_operator_minus_equal.html">
+ has_operator_minus_equal</a></dt>
<dt> has_operator_minus</dt>
+<dt><a href="boost_typetraits/reference/has_operator_modulus_equal.html">
+ has_operator_modulus_equal</a></dt>
<dt> has_operator_modulus</dt>
+<dt><a href="boost_typetraits/reference/has_operator_multiplies_equal.html">
+ has_operator_multiplies_equal</a></dt>
<dt><a href="boost_typetraits/reference/has_operator_multiplies.html">
 has_operator_multiplies</a></dt>
<dt><a href="boost_typetraits/reference/has_operator_not_equal_to.html">
 has_operator_not_equal_to</a></dt>
+<dt><a href="boost_typetraits/reference/has_operator_plus_equal.html">
+ has_operator_plus_equal</a></dt>
<dt> has_operator_plus</dt>
+<dt><a href="boost_typetraits/reference/has_operator_right_shift_equal.html">
+ has_operator_right_shift_equal</a></dt>
+<dt><a href="boost_typetraits/reference/has_operator_right_shift.html">
+ has_operator_right_shift</a></dt>
<dt><a href="boost_typetraits/reference/has_operator_unary_minus.html">
 has_operator_unary_minus</a></dt>
<dt><a href="boost_typetraits/reference/has_operator_unary_plus.html">
@@ -185,7 +209,7 @@
 
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left">Last revised: September 04, 2009 at 13:41:05 +0200</td>
+<td align="left">Last revised: November 17, 2010 at 00:28:29 +0100</td>
<td align="right"><div class="copyright-footer"></div></td>
</tr></table>
<hr>

Modified: sandbox/type_traits/libs/type_traits/doc/type_traits.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/type_traits.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/type_traits.qbk 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -179,23 +179,35 @@
[section:has_no_throw_def_cons has_nothrow_default_constructor]
See __has_nothrow_constructor.
[endsect]
+[include has_operator_bit_and_equal.qbk]
[include has_operator_bit_and.qbk]
+[include has_operator_bit_or_equal.qbk]
[include has_operator_bit_or.qbk]
+[include has_operator_bit_xor_equal.qbk]
[include has_operator_bit_xor.qbk]
+[include has_operator_divides_equal.qbk]
[include has_operator_divides.qbk]
[include has_operator_equal_to.qbk]
[include has_operator_greater_equal.qbk]
[include has_operator_greater.qbk]
+[include has_operator_left_shift_equal.qbk]
+[include has_operator_left_shift.qbk]
[include has_operator_less_equal.qbk]
[include has_operator_less.qbk]
[include has_operator_logical_and.qbk]
[include has_operator_logical_not.qbk]
[include has_operator_logical_or.qbk]
+[include has_operator_minus_equal.qbk]
[include has_operator_minus.qbk]
+[include has_operator_modulus_equal.qbk]
[include has_operator_modulus.qbk]
+[include has_operator_multiplies_equal.qbk]
[include has_operator_multiplies.qbk]
[include has_operator_not_equal_to.qbk]
+[include has_operator_plus_equal.qbk]
[include has_operator_plus.qbk]
+[include has_operator_right_shift_equal.qbk]
+[include has_operator_right_shift.qbk]
[include has_operator_unary_minus.qbk]
[include has_operator_unary_plus.qbk]
[include has_trivial_assign.qbk]

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 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -28,6 +28,8 @@
struct external { };
ret operator BOOST_TT_TRAIT_OP (const external&, const external&);

+class internal_private { ret operator BOOST_TT_TRAIT_OP (const internal_private&) const; };
+
struct returns_int { int operator BOOST_TT_TRAIT_OP (const returns_int&); };

struct returns_void { void operator BOOST_TT_TRAIT_OP (const returns_void&); };
@@ -38,18 +40,18 @@

struct returns_string { std::string operator BOOST_TT_TRAIT_OP (const returns_string&); };

-//struct convertible_to_bool { operator bool () const ; } ;
-//struct returns_convertible_to_bool { convertible_to_bool operator BOOST_TT_TRAIT_OP (const returns_convertible_to_bool&) ; } ;
+//struct convertible_to_bool { operator bool () const; };
+//struct returns_convertible_to_bool { convertible_to_bool operator BOOST_TT_TRAIT_OP (const returns_convertible_to_bool&); };

-class Base1 { } ;
-class Derived1 : public Base1 { } ;
+class Base1 { };
+class Derived1 : public Base1 { };

bool operator BOOST_TT_TRAIT_OP (const Base1&, const Base1&) { return true; }

-class Base2 { } ;
+class Base2 { };
struct Derived2 : public Base2 {
- Derived2(int) ; // to check if it works with a class that is not default constructible
-} ;
+ Derived2(int); // to check if it works with a class that is not default constructible
+};

bool operator BOOST_TT_TRAIT_OP (const Derived2&, const Derived2&) { return true; }

@@ -692,39 +694,41 @@
TEST_TTR(long double, double, tag, false);
TEST_TTR(long double, long double, tag, false);

- TEST_T(without, false) ;
- TEST_T(internal, true) ;
- TEST_T(external, true) ;
- TEST_T(returns_int, true) ;
- TEST_T(returns_void, true) ;
- TEST_T(returns_void_star, true) ;
- TEST_T(returns_double, true) ;
- TEST_T(returns_string, true) ;
-// TEST_T(convertible_to_bool, true) ;
- TEST_T(Base1, true) ;
- TEST_T(Derived1, true) ;
- TEST_T(Base2, false) ;
- TEST_T(Derived2, true) ;
-
- TEST_TR(without, bool, false) ;
- TEST_TR(internal, bool, false) ;
- TEST_TR(internal, ret, true) ;
- TEST_TR(external, bool, false) ;
- TEST_TR(external, ret, true) ;
- TEST_TR(returns_int, bool, true) ;
- TEST_TR(returns_int, int, true) ;
- TEST_TR(returns_void, void, true) ;
- TEST_TR(returns_void, bool, false) ;
- TEST_TR(returns_void_star, bool, true) ;
- TEST_TR(returns_double, bool, true) ;
- TEST_TR(returns_double, double, true) ;
- TEST_TR(returns_string, bool, false) ;
- TEST_TR(returns_string, std::string, true) ;
-// TEST_TR(convertible_to_bool, bool, true) ;
- TEST_TR(Base1, bool, true) ;
- TEST_TR(Derived1, bool, true) ;
- TEST_TR(Base2, bool, false) ;
- TEST_TR(Derived2, bool, true) ;
+ TEST_T(without, false);
+ TEST_T(internal, true);
+ TEST_T(external, true);
+// compile time error
+// TEST_T(internal_private, false);
+ TEST_T(returns_int, true);
+ TEST_T(returns_void, true);
+ TEST_T(returns_void_star, true);
+ TEST_T(returns_double, true);
+ TEST_T(returns_string, true);
+// TEST_T(convertible_to_bool, true);
+ TEST_T(Base1, true);
+ TEST_T(Derived1, true);
+ TEST_T(Base2, false);
+ TEST_T(Derived2, true);
+
+ TEST_TR(without, bool, false);
+ TEST_TR(internal, bool, false);
+ TEST_TR(internal, ret, true);
+ TEST_TR(external, bool, false);
+ TEST_TR(external, ret, true);
+ TEST_TR(returns_int, bool, true);
+ TEST_TR(returns_int, int, true);
+ TEST_TR(returns_void, void, true);
+ TEST_TR(returns_void, bool, false);
+ TEST_TR(returns_void_star, bool, true);
+ TEST_TR(returns_double, bool, true);
+ TEST_TR(returns_double, double, true);
+ TEST_TR(returns_string, bool, false);
+ TEST_TR(returns_string, std::string, true);
+// TEST_TR(convertible_to_bool, bool, true);
+ TEST_TR(Base1, bool, true);
+ TEST_TR(Derived1, bool, true);
+ TEST_TR(Base2, bool, false);
+ TEST_TR(Derived2, bool, true);
}
}

Modified: sandbox/type_traits/libs/type_traits/test/has_integral_operator_test.hpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_integral_operator_test.hpp (original)
+++ sandbox/type_traits/libs/type_traits/test/has_integral_operator_test.hpp 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -28,6 +28,8 @@
struct external { };
ret operator BOOST_TT_TRAIT_OP (const external&, const external&);

+class internal_private { ret operator BOOST_TT_TRAIT_OP (const internal_private&) const; };
+
struct returns_int { int operator BOOST_TT_TRAIT_OP (const returns_int&); };

struct returns_void { void operator BOOST_TT_TRAIT_OP (const returns_void&); };
@@ -38,18 +40,18 @@

struct returns_string { std::string operator BOOST_TT_TRAIT_OP (const returns_string&); };

-//struct convertible_to_bool { operator bool () const ; } ;
-//struct returns_convertible_to_bool { convertible_to_bool operator BOOST_TT_TRAIT_OP (const returns_convertible_to_bool&) ; } ;
+//struct convertible_to_bool { operator bool () const; };
+//struct returns_convertible_to_bool { convertible_to_bool operator BOOST_TT_TRAIT_OP (const returns_convertible_to_bool&); };

-class Base1 { } ;
-class Derived1 : public Base1 { } ;
+class Base1 { };
+class Derived1 : public Base1 { };

bool operator BOOST_TT_TRAIT_OP (const Base1&, const Base1&) { return true; }

-class Base2 { } ;
+class Base2 { };
struct Derived2 : public Base2 {
- Derived2(int) ; // to check if it works with a class that is not default constructible
-} ;
+ Derived2(int); // to check if it works with a class that is not default constructible
+};

bool operator BOOST_TT_TRAIT_OP (const Derived2&, const Derived2&) { return true; }

@@ -692,39 +694,41 @@
TEST_TTR(long double, double, tag, false);
TEST_TTR(long double, long double, tag, false);

- TEST_T(without, false) ;
- TEST_T(internal, true) ;
- TEST_T(external, true) ;
- TEST_T(returns_int, true) ;
- TEST_T(returns_void, true) ;
- TEST_T(returns_void_star, true) ;
- TEST_T(returns_double, true) ;
- TEST_T(returns_string, true) ;
-// TEST_T(convertible_to_bool, true) ;
- TEST_T(Base1, true) ;
- TEST_T(Derived1, true) ;
- TEST_T(Base2, false) ;
- TEST_T(Derived2, true) ;
-
- TEST_TR(without, bool, false) ;
- TEST_TR(internal, bool, false) ;
- TEST_TR(internal, ret, true) ;
- TEST_TR(external, bool, false) ;
- TEST_TR(external, ret, true) ;
- TEST_TR(returns_int, bool, true) ;
- TEST_TR(returns_int, int, true) ;
- TEST_TR(returns_void, void, true) ;
- TEST_TR(returns_void, bool, false) ;
- TEST_TR(returns_void_star, bool, true) ;
- TEST_TR(returns_double, bool, true) ;
- TEST_TR(returns_double, double, true) ;
- TEST_TR(returns_string, bool, false) ;
- TEST_TR(returns_string, std::string, true) ;
-// TEST_TR(convertible_to_bool, bool, true) ;
- TEST_TR(Base1, bool, true) ;
- TEST_TR(Derived1, bool, true) ;
- TEST_TR(Base2, bool, false) ;
- TEST_TR(Derived2, bool, true) ;
+ TEST_T(without, false);
+ TEST_T(internal, true);
+ TEST_T(external, true);
+// compile time error
+// TEST_T(internal_private, false);
+ TEST_T(returns_int, true);
+ TEST_T(returns_void, true);
+ TEST_T(returns_void_star, true);
+ TEST_T(returns_double, true);
+ TEST_T(returns_string, true);
+// TEST_T(convertible_to_bool, true);
+ TEST_T(Base1, true);
+ TEST_T(Derived1, true);
+ TEST_T(Base2, false);
+ TEST_T(Derived2, true);
+
+ TEST_TR(without, bool, false);
+ TEST_TR(internal, bool, false);
+ TEST_TR(internal, ret, true);
+ TEST_TR(external, bool, false);
+ TEST_TR(external, ret, true);
+ TEST_TR(returns_int, bool, true);
+ TEST_TR(returns_int, int, true);
+ TEST_TR(returns_void, void, true);
+ TEST_TR(returns_void, bool, false);
+ TEST_TR(returns_void_star, bool, true);
+ TEST_TR(returns_double, bool, true);
+ TEST_TR(returns_double, double, true);
+ TEST_TR(returns_string, bool, false);
+ TEST_TR(returns_string, std::string, true);
+// TEST_TR(convertible_to_bool, bool, true);
+ TEST_TR(Base1, bool, true);
+ TEST_TR(Derived1, bool, true);
+ TEST_TR(Base2, bool, false);
+ TEST_TR(Derived2, bool, true);
}
}

Added: sandbox/type_traits/libs/type_traits/test/has_operator_bit_and_equal_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/has_operator_bit_and_equal_test.cpp 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,18 @@
+// (C) Copyright Frederic Bron 2010.
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "test.hpp"
+#include "check_integral_constant.hpp"
+
+#ifdef TEST_STD
+# include <type_traits>
+#else
+# include <boost/type_traits/has_operator_bit_and_equal.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME has_operator_bit_and_equal
+#define BOOST_TT_TRAIT_OP &=
+
+#include "has_integral_operator_test.hpp"

Added: sandbox/type_traits/libs/type_traits/test/has_operator_bit_or_equal_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/has_operator_bit_or_equal_test.cpp 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,18 @@
+// (C) Copyright Frederic Bron 2010.
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "test.hpp"
+#include "check_integral_constant.hpp"
+
+#ifdef TEST_STD
+# include <type_traits>
+#else
+# include <boost/type_traits/has_operator_bit_or_equal.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME has_operator_bit_or_equal
+#define BOOST_TT_TRAIT_OP |=
+
+#include "has_integral_operator_test.hpp"

Added: sandbox/type_traits/libs/type_traits/test/has_operator_bit_xor_equal_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/has_operator_bit_xor_equal_test.cpp 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,18 @@
+// (C) Copyright Frederic Bron 2010.
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "test.hpp"
+#include "check_integral_constant.hpp"
+
+#ifdef TEST_STD
+# include <type_traits>
+#else
+# include <boost/type_traits/has_operator_bit_xor_equal.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME has_operator_bit_xor_equal
+#define BOOST_TT_TRAIT_OP ^=
+
+#include "has_integral_operator_test.hpp"

Added: sandbox/type_traits/libs/type_traits/test/has_operator_divides_equal_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/has_operator_divides_equal_test.cpp 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,18 @@
+// (C) Copyright Frederic Bron 2010.
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "test.hpp"
+#include "check_integral_constant.hpp"
+
+#ifdef TEST_STD
+# include <type_traits>
+#else
+# include <boost/type_traits/has_operator_divides_equal.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME has_operator_divides_equal
+#define BOOST_TT_TRAIT_OP /=
+
+#include "has_binary_operator_test.hpp"

Added: sandbox/type_traits/libs/type_traits/test/has_operator_left_shift_equal_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/has_operator_left_shift_equal_test.cpp 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,18 @@
+// (C) Copyright Frederic Bron 2010.
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "test.hpp"
+#include "check_integral_constant.hpp"
+
+#ifdef TEST_STD
+# include <type_traits>
+#else
+# include <boost/type_traits/has_operator_left_shift_equal.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME has_operator_left_shift_equal
+#define BOOST_TT_TRAIT_OP <<=
+
+#include "has_integral_operator_test.hpp"

Added: sandbox/type_traits/libs/type_traits/test/has_operator_left_shift_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/has_operator_left_shift_test.cpp 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,18 @@
+// (C) Copyright Frederic Bron 2010.
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "test.hpp"
+#include "check_integral_constant.hpp"
+
+#ifdef TEST_STD
+# include <type_traits>
+#else
+# include <boost/type_traits/has_operator_left_shift.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME has_operator_left_shift
+#define BOOST_TT_TRAIT_OP <<
+
+#include "has_integral_operator_test.hpp"

Added: sandbox/type_traits/libs/type_traits/test/has_operator_minus_equal_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/has_operator_minus_equal_test.cpp 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,18 @@
+// (C) Copyright Frederic Bron 2010.
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "test.hpp"
+#include "check_integral_constant.hpp"
+
+#ifdef TEST_STD
+# include <type_traits>
+#else
+# include <boost/type_traits/has_operator_minus_equal.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME has_operator_minus_equal
+#define BOOST_TT_TRAIT_OP -=
+
+#include "has_binary_operator_test.hpp"

Added: sandbox/type_traits/libs/type_traits/test/has_operator_modulus_equal_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/has_operator_modulus_equal_test.cpp 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,18 @@
+// (C) Copyright Frederic Bron 2010.
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "test.hpp"
+#include "check_integral_constant.hpp"
+
+#ifdef TEST_STD
+# include <type_traits>
+#else
+# include <boost/type_traits/has_operator_modulus_equal.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME has_operator_modulus_equal
+#define BOOST_TT_TRAIT_OP %=
+
+#include "has_integral_operator_test.hpp"

Added: sandbox/type_traits/libs/type_traits/test/has_operator_multiplies_equal_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/has_operator_multiplies_equal_test.cpp 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,18 @@
+// (C) Copyright Frederic Bron 2010.
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "test.hpp"
+#include "check_integral_constant.hpp"
+
+#ifdef TEST_STD
+# include <type_traits>
+#else
+# include <boost/type_traits/has_operator_multiplies_equal.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME has_operator_multiplies_equal
+#define BOOST_TT_TRAIT_OP *=
+
+#include "has_binary_operator_test.hpp"

Added: sandbox/type_traits/libs/type_traits/test/has_operator_plus_equal_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/has_operator_plus_equal_test.cpp 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,18 @@
+// (C) Copyright Frederic Bron 2010.
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "test.hpp"
+#include "check_integral_constant.hpp"
+
+#ifdef TEST_STD
+# include <type_traits>
+#else
+# include <boost/type_traits/has_operator_plus_equal.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME has_operator_plus_equal
+#define BOOST_TT_TRAIT_OP +=
+
+#include "has_binary_operator_test.hpp"

Added: sandbox/type_traits/libs/type_traits/test/has_operator_right_shift_equal_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/has_operator_right_shift_equal_test.cpp 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,18 @@
+// (C) Copyright Frederic Bron 2010.
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "test.hpp"
+#include "check_integral_constant.hpp"
+
+#ifdef TEST_STD
+# include <type_traits>
+#else
+# include <boost/type_traits/has_operator_right_shift_equal.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME has_operator_right_shift_equal
+#define BOOST_TT_TRAIT_OP >>=
+
+#include "has_integral_operator_test.hpp"

Added: sandbox/type_traits/libs/type_traits/test/has_operator_right_shift_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/has_operator_right_shift_test.cpp 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -0,0 +1,18 @@
+// (C) Copyright Frederic Bron 2010.
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "test.hpp"
+#include "check_integral_constant.hpp"
+
+#ifdef TEST_STD
+# include <type_traits>
+#else
+# include <boost/type_traits/has_operator_right_shift.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME has_operator_right_shift
+#define BOOST_TT_TRAIT_OP >>
+
+#include "has_integral_operator_test.hpp"

Modified: sandbox/type_traits/libs/type_traits/test/has_unary_operator_test.hpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_unary_operator_test.hpp (original)
+++ sandbox/type_traits/libs/type_traits/test/has_unary_operator_test.hpp 2010-11-29 10:29:09 EST (Mon, 29 Nov 2010)
@@ -24,6 +24,8 @@
struct external { };
ret operator BOOST_TT_TRAIT_OP (const external&);

+class internal_private { ret operator BOOST_TT_TRAIT_OP () const; };
+
struct returns_int { int operator BOOST_TT_TRAIT_OP (); };

struct returns_void { void operator BOOST_TT_TRAIT_OP (); };
@@ -34,18 +36,18 @@

struct returns_string { std::string operator BOOST_TT_TRAIT_OP (); };

-//struct convertible_to_bool { operator bool () const ; } ;
-//struct returns_convertible_to_bool { convertible_to_bool operator BOOST_TT_TRAIT_OP () ; } ;
+//struct convertible_to_bool { operator bool () const; };
+//struct returns_convertible_to_bool { convertible_to_bool operator BOOST_TT_TRAIT_OP (); };

-class Base1 { } ;
-class Derived1 : public Base1 { } ;
+class Base1 { };
+class Derived1 : public Base1 { };

bool operator BOOST_TT_TRAIT_OP (const Base1&) { return true; }

-class Base2 { } ;
+class Base2 { };
struct Derived2 : public Base2 {
- Derived2(int) ; // to check if it works with a class that is not default constructible
-} ;
+ Derived2(int); // to check if it works with a class that is not default constructible
+};

bool operator BOOST_TT_TRAIT_OP (const Derived2&) { return true; }

@@ -99,39 +101,41 @@
TEST_TR(double, tag, false);
TEST_TR(long double, tag, false);

- TEST_T(without, false) ;
- TEST_T(internal, true) ;
- TEST_T(external, true) ;
- TEST_T(returns_int, true) ;
- TEST_T(returns_void, true) ;
- TEST_T(returns_void_star, true) ;
- TEST_T(returns_double, true) ;
- TEST_T(returns_string, true) ;
-// TEST_T(convertible_to_bool, true) ;
- TEST_T(Base1, true) ;
- TEST_T(Derived1, true) ;
- TEST_T(Base2, false) ;
- TEST_T(Derived2, true) ;
-
- TEST_TR(without, bool, false) ;
- TEST_TR(internal, bool, false) ;
- TEST_TR(internal, ret, true) ;
- TEST_TR(external, bool, false) ;
- TEST_TR(external, ret, true) ;
- TEST_TR(returns_int, bool, true) ;
- TEST_TR(returns_int, int, true) ;
- TEST_TR(returns_void, void, true) ;
- TEST_TR(returns_void, bool, false) ;
- TEST_TR(returns_void_star, bool, true) ;
- TEST_TR(returns_double, bool, true) ;
- TEST_TR(returns_double, double, true) ;
- TEST_TR(returns_string, bool, false) ;
- TEST_TR(returns_string, std::string, true) ;
-// TEST_TR(convertible_to_bool, bool, true) ;
- TEST_TR(Base1, bool, true) ;
- TEST_TR(Derived1, bool, true) ;
- TEST_TR(Base2, bool, false) ;
- TEST_TR(Derived2, bool, true) ;
+ TEST_T(without, false);
+ TEST_T(internal, true);
+ TEST_T(external, true);
+// compile time error
+// TEST_T(internal_private, false);
+ TEST_T(returns_int, true);
+ TEST_T(returns_void, true);
+ TEST_T(returns_void_star, true);
+ TEST_T(returns_double, true);
+ TEST_T(returns_string, true);
+// TEST_T(convertible_to_bool, true);
+ TEST_T(Base1, true);
+ TEST_T(Derived1, true);
+ TEST_T(Base2, false);
+ TEST_T(Derived2, true);
+
+ TEST_TR(without, bool, false);
+ TEST_TR(internal, bool, false);
+ TEST_TR(internal, ret, true);
+ TEST_TR(external, bool, false);
+ TEST_TR(external, ret, true);
+ TEST_TR(returns_int, bool, true);
+ TEST_TR(returns_int, int, true);
+ TEST_TR(returns_void, void, true);
+ TEST_TR(returns_void, bool, false);
+ TEST_TR(returns_void_star, bool, true);
+ TEST_TR(returns_double, bool, true);
+ TEST_TR(returns_double, double, true);
+ TEST_TR(returns_string, bool, false);
+ TEST_TR(returns_string, std::string, true);
+// TEST_TR(convertible_to_bool, bool, true);
+ TEST_TR(Base1, bool, true);
+ TEST_TR(Derived1, bool, true);
+ TEST_TR(Base2, bool, false);
+ TEST_TR(Derived2, bool, true);
}
}

Next message: john_at_[hidden]: "[Boost-commit] svn:boost r66844 - in sandbox/math_constants: boost/math/constants libs/math/test"
Previous message: afojgo_at_[hidden]: "[Boost-commit] svn:boost r66842 - in trunk/boost/icl: . detail"

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