[Boost-commit] svn:boost r69313 - in sandbox/type_traits: boost/type_traits libs/type_traits/doc libs/type_traits/doc/html libs/type_traits/doc/html/boost_typetraits libs/type_traits/doc/html/boost_typetraits/category libs/type_traits/doc/html/boost_typetraits/category/value_traits libs/type_traits/doc/html/boost_typetraits/reference libs/type_traits/test

Subject: [Boost-commit] svn:boost r69313 - in sandbox/type_traits: boost/type_traits libs/type_traits/doc libs/type_traits/doc/html libs/type_traits/doc/html/boost_typetraits libs/type_traits/doc/html/boost_typetraits/category libs/type_traits/doc/html/boost_typetraits/category/value_traits libs/type_traits/doc/html/boost_typetraits/reference libs/type_traits/test
From: frederic.bron_at_[hidden]
Date: 2011-02-26 16:36:39

Author: bronf
Date: 2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
New Revision: 69313
URL: http://svn.boost.org/trac/boost/changeset/69313

Log:
operator traits: added has_operator_dereference, upper case include guards, improved documentation
Added:
   sandbox/type_traits/boost/type_traits/has_operator_dereference.hpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/has_operator_dereference.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_dereference.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/has_dereference_operator_test.hpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/has_operator_dereference_test.cpp   (contents, props changed)
Text files modified: 
   sandbox/type_traits/boost/type_traits/has_operator_bit_and.hpp                                               |     4                                         
   sandbox/type_traits/boost/type_traits/has_operator_bit_and_equal.hpp                                         |     6                                         
   sandbox/type_traits/boost/type_traits/has_operator_bit_or.hpp                                                |     4                                         
   sandbox/type_traits/boost/type_traits/has_operator_bit_or_equal.hpp                                          |     6                                         
   sandbox/type_traits/boost/type_traits/has_operator_bit_xor.hpp                                               |     4                                         
   sandbox/type_traits/boost/type_traits/has_operator_bit_xor_equal.hpp                                         |     6                                         
   sandbox/type_traits/boost/type_traits/has_operator_complement.hpp                                            |     4                                         
   sandbox/type_traits/boost/type_traits/has_operator_divides.hpp                                               |     4                                         
   sandbox/type_traits/boost/type_traits/has_operator_divides_equal.hpp                                         |     4                                         
   sandbox/type_traits/boost/type_traits/has_operator_equal_to.hpp                                              |     4                                         
   sandbox/type_traits/boost/type_traits/has_operator_greater.hpp                                               |     4                                         
   sandbox/type_traits/boost/type_traits/has_operator_greater_equal.hpp                                         |     4                                         
   sandbox/type_traits/boost/type_traits/has_operator_left_shift.hpp                                            |     4                                         
   sandbox/type_traits/boost/type_traits/has_operator_left_shift_equal.hpp                                      |     6                                         
   sandbox/type_traits/boost/type_traits/has_operator_less.hpp                                                  |     4                                         
   sandbox/type_traits/boost/type_traits/has_operator_less_equal.hpp                                            |     4                                         
   sandbox/type_traits/boost/type_traits/has_operator_logical_and.hpp                                           |     4                                         
   sandbox/type_traits/boost/type_traits/has_operator_logical_not.hpp                                           |     4                                         
   sandbox/type_traits/boost/type_traits/has_operator_logical_or.hpp                                            |     4                                         
   sandbox/type_traits/boost/type_traits/has_operator_minus.hpp                                                 |     4                                         
   sandbox/type_traits/boost/type_traits/has_operator_minus_equal.hpp                                           |     4                                         
   sandbox/type_traits/boost/type_traits/has_operator_modulus.hpp                                               |     4                                         
   sandbox/type_traits/boost/type_traits/has_operator_modulus_equal.hpp                                         |     6                                         
   sandbox/type_traits/boost/type_traits/has_operator_multiplies.hpp                                            |     4                                         
   sandbox/type_traits/boost/type_traits/has_operator_multiplies_equal.hpp                                      |     4                                         
   sandbox/type_traits/boost/type_traits/has_operator_not_equal_to.hpp                                          |     4                                         
   sandbox/type_traits/boost/type_traits/has_operator_plus.hpp                                                  |     4                                         
   sandbox/type_traits/boost/type_traits/has_operator_plus_equal.hpp                                            |     4                                         
   sandbox/type_traits/boost/type_traits/has_operator_postfix_decrement.hpp                                     |     4                                         
   sandbox/type_traits/boost/type_traits/has_operator_postfix_increment.hpp                                     |     4                                         
   sandbox/type_traits/boost/type_traits/has_operator_prefix_decrement.hpp                                      |     4                                         
   sandbox/type_traits/boost/type_traits/has_operator_prefix_increment.hpp                                      |     4                                         
   sandbox/type_traits/boost/type_traits/has_operator_right_shift.hpp                                           |     4                                         
   sandbox/type_traits/boost/type_traits/has_operator_right_shift_equal.hpp                                     |     6                                         
   sandbox/type_traits/boost/type_traits/has_operator_unary_minus.hpp                                           |     4                                         
   sandbox/type_traits/boost/type_traits/has_operator_unary_plus.hpp                                            |     4                                         
   sandbox/type_traits/libs/type_traits/doc/has_operator_bit_and.qbk                                            |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/has_operator_bit_and_equal.qbk                                      |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/has_operator_bit_or.qbk                                             |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/has_operator_bit_or_equal.qbk                                       |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/has_operator_bit_xor.qbk                                            |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/has_operator_bit_xor_equal.qbk                                      |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/has_operator_complement.qbk                                         |    15 +                                       
   sandbox/type_traits/libs/type_traits/doc/has_operator_divides.qbk                                            |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/has_operator_divides_equal.qbk                                      |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/has_operator_equal_to.qbk                                           |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/has_operator_greater.qbk                                            |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/has_operator_greater_equal.qbk                                      |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/has_operator_left_shift.qbk                                         |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/has_operator_left_shift_equal.qbk                                   |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/has_operator_less.qbk                                               |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/has_operator_less_equal.qbk                                         |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/has_operator_logical_and.qbk                                        |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/has_operator_logical_not.qbk                                        |    13 +                                       
   sandbox/type_traits/libs/type_traits/doc/has_operator_logical_or.qbk                                         |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/has_operator_minus.qbk                                              |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/has_operator_minus_equal.qbk                                        |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/has_operator_modulus.qbk                                            |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/has_operator_modulus_equal.qbk                                      |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/has_operator_multiplies.qbk                                         |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/has_operator_multiplies_equal.qbk                                   |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/has_operator_not_equal_to.qbk                                       |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/has_operator_plus.qbk                                               |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/has_operator_plus_equal.qbk                                         |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/has_operator_postfix_decrement.qbk                                  |    15 +                                       
   sandbox/type_traits/libs/type_traits/doc/has_operator_postfix_increment.qbk                                  |    15 +                                       
   sandbox/type_traits/libs/type_traits/doc/has_operator_prefix_decrement.qbk                                   |    15 +                                       
   sandbox/type_traits/libs/type_traits/doc/has_operator_prefix_increment.qbk                                   |    15 +                                       
   sandbox/type_traits/libs/type_traits/doc/has_operator_right_shift.qbk                                        |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/has_operator_right_shift_equal.qbk                                  |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/has_operator_unary_minus.qbk                                        |    13 +                                       
   sandbox/type_traits/libs/type_traits/doc/has_operator_unary_plus.qbk                                         |    13 +                                       
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/background.html                               |    22 +-                                      
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/transform.html                       |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/value_traits/operators.html          |   253 ++++++++++++++++++++++++--------------- 
   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                                |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_const.html                      |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_cv.html                         |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_pointer.html                    |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_reference.html                  |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_volatile.html                   |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/decay.html                          |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/floating_point_promotion.html       |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/function_traits.html                |     4                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_and.html           |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_and_equal.html     |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_or.html            |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_or_equal.html      |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_xor.html           |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_xor_equal.html     |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_complement.html        |    15 +                                       
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_divides.html           |    20 ++                                      
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_divides_equal.html     |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_equal_to.html          |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_greater.html           |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_greater_equal.html     |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_left_shift.html        |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_left_shift_equal.html  |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_less.html              |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_less_equal.html        |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_logical_and.html       |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_logical_not.html       |    13 +                                       
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_logical_or.html        |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_minus.html             |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_minus_equal.html       |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_modulus.html           |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_modulus_equal.html     |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_multiplies.html        |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_multiplies_equal.html  |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_not_equal_to.html      |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_plus.html              |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_plus_equal.html        |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_postfix_decrement.html |     9 +                                       
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_postfix_increment.html |     9 +                                       
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_prefix_decrement.html  |     9 +                                       
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_prefix_increment.html  |     9 +                                       
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_right_shift.html       |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_right_shift_equal.html |    14 +                                       
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_unary_minus.html       |    13 +                                       
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_unary_plus.html        |    13 +                                       
   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                                                     |     4                                         
   sandbox/type_traits/libs/type_traits/doc/operators.qbk                                                       |    39 +++--                                   
   sandbox/type_traits/libs/type_traits/doc/type_traits.qbk                                                     |     1                                         
   sandbox/type_traits/libs/type_traits/test/has_binary_logical_operator_test.hpp                               |     4                                         
   sandbox/type_traits/libs/type_traits/test/has_binary_minus_operator_test.hpp                                 |     4                                         
   sandbox/type_traits/libs/type_traits/test/has_binary_plus_operator_test.hpp                                  |     4                                         
   sandbox/type_traits/libs/type_traits/test/has_comparison_operator_test.hpp                                   |     4                                         
   sandbox/type_traits/libs/type_traits/test/has_integral_no_constlhs_operator_test.hpp                         |     4                                         
   sandbox/type_traits/libs/type_traits/test/has_integral_operator_test.hpp                                     |     4                                         
   sandbox/type_traits/libs/type_traits/test/has_minus_equal_operator_test.hpp                                  |     4                                         
   sandbox/type_traits/libs/type_traits/test/has_no_pointer_no_constlhs_operator_test.hpp                       |     4                                         
   sandbox/type_traits/libs/type_traits/test/has_no_pointer_operator_test.hpp                                   |     4                                         
   sandbox/type_traits/libs/type_traits/test/has_plus_equal_operator_test.hpp                                   |     4                                         
   sandbox/type_traits/libs/type_traits/test/has_postfix_decrement_operator_test.hpp                            |     1                                         
   sandbox/type_traits/libs/type_traits/test/has_postfix_increment_operator_test.hpp                            |     1                                         
   sandbox/type_traits/libs/type_traits/test/has_prefix_complement_operator_test.hpp                            |     1                                         
   sandbox/type_traits/libs/type_traits/test/has_prefix_decrement_operator_test.hpp                             |     1                                         
   sandbox/type_traits/libs/type_traits/test/has_prefix_increment_operator_test.hpp                             |     1                                         
   sandbox/type_traits/libs/type_traits/test/has_prefix_minus_operator_test.hpp                                 |     1                                         
   sandbox/type_traits/libs/type_traits/test/has_prefix_plus_not_operator_test.hpp                              |     1                                         
   154 files changed, 1156 insertions(+), 410 deletions(-)

Modified: sandbox/type_traits/boost/type_traits/has_operator_bit_and.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_bit_and.hpp	(original)
+++ sandbox/type_traits/boost/type_traits/has_operator_bit_and.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,8 +6,8 @@
 //
 //  See http://www.boost.org/libs/type_traits for most recent version including documentation.
 
-#ifndef BOOST_TT_bit_and_HPP_INCLUDED
-#define BOOST_TT_bit_and_HPP_INCLUDED
+#ifndef BOOST_TT_HAS_OPERATOR_BIT_AND_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_BIT_AND_HPP_INCLUDED
 
 #define BOOST_TT_TRAIT_NAME has_operator_bit_and
 #define BOOST_TT_TRAIT_OP &

Modified: sandbox/type_traits/boost/type_traits/has_operator_bit_and_equal.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_bit_and_equal.hpp	(original)
+++ sandbox/type_traits/boost/type_traits/has_operator_bit_and_equal.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,8 +6,8 @@
 //
 //  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
+#ifndef BOOST_TT_HAS_OPERATOR_BIT_AND_EQUAL_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_BIT_AND_EQUAL_HPP_INCLUDED
 
 #define BOOST_TT_TRAIT_NAME has_operator_bit_and_equal
 #define BOOST_TT_TRAIT_OP &=
@@ -21,7 +21,7 @@
          ::boost::type_traits::ice_or<\
             ::boost::type_traits::ice_not< ::boost::is_integral< lhs_noref >::value >::value,\
             ::boost::type_traits::ice_not< ::boost::is_integral< rhs_noref >::value >::value,\
-         	::boost::is_const< lhs_noref >::value\
+            ::boost::is_const< lhs_noref >::value\
          >::value\
       >::value,\
       /* one fundamental, one pointer */\

Modified: sandbox/type_traits/boost/type_traits/has_operator_bit_or.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_bit_or.hpp	(original)
+++ sandbox/type_traits/boost/type_traits/has_operator_bit_or.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,8 +6,8 @@
 //
 //  See http://www.boost.org/libs/type_traits for most recent version including documentation.
 
-#ifndef BOOST_TT_bit_or_HPP_INCLUDED
-#define BOOST_TT_bit_or_HPP_INCLUDED
+#ifndef BOOST_TT_HAS_OPERATOR_BIT_OR_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_BIT_OR_HPP_INCLUDED
 
 #define BOOST_TT_TRAIT_NAME has_operator_bit_or
 #define BOOST_TT_TRAIT_OP |

Modified: sandbox/type_traits/boost/type_traits/has_operator_bit_or_equal.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_bit_or_equal.hpp	(original)
+++ sandbox/type_traits/boost/type_traits/has_operator_bit_or_equal.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,8 +6,8 @@
 //
 //  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
+#ifndef BOOST_TT_HAS_OPERATOR_BIT_OR_EQUAL_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_BIT_OR_EQUAL_HPP_INCLUDED
 
 #define BOOST_TT_TRAIT_NAME has_operator_bit_or_equal
 #define BOOST_TT_TRAIT_OP |=
@@ -21,7 +21,7 @@
          ::boost::type_traits::ice_or<\
             ::boost::type_traits::ice_not< ::boost::is_integral< lhs_noref >::value >::value,\
             ::boost::type_traits::ice_not< ::boost::is_integral< rhs_noref >::value >::value,\
-         	::boost::is_const< lhs_noref >::value\
+            ::boost::is_const< lhs_noref >::value\
          >::value\
       >::value,\
       /* one fundamental, one pointer */\

Modified: sandbox/type_traits/boost/type_traits/has_operator_bit_xor.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_bit_xor.hpp	(original)
+++ sandbox/type_traits/boost/type_traits/has_operator_bit_xor.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,8 +6,8 @@
 //
 //  See http://www.boost.org/libs/type_traits for most recent version including documentation.
 
-#ifndef BOOST_TT_bit_xor_HPP_INCLUDED
-#define BOOST_TT_bit_xor_HPP_INCLUDED
+#ifndef BOOST_TT_HAS_OPERATOR_BIT_XOR_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_BIT_XOR_HPP_INCLUDED
 
 #define BOOST_TT_TRAIT_NAME has_operator_bit_xor
 #define BOOST_TT_TRAIT_OP ^

Modified: sandbox/type_traits/boost/type_traits/has_operator_bit_xor_equal.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_bit_xor_equal.hpp	(original)
+++ sandbox/type_traits/boost/type_traits/has_operator_bit_xor_equal.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,8 +6,8 @@
 //
 //  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
+#ifndef BOOST_TT_HAS_OPERATOR_BIT_XOR_EQUAL_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_BIT_XOR_EQUAL_HPP_INCLUDED
 
 #define BOOST_TT_TRAIT_NAME has_operator_bit_xor_equal
 #define BOOST_TT_TRAIT_OP ^=
@@ -21,7 +21,7 @@
          ::boost::type_traits::ice_or<\
             ::boost::type_traits::ice_not< ::boost::is_integral< lhs_noref >::value >::value,\
             ::boost::type_traits::ice_not< ::boost::is_integral< rhs_noref >::value >::value,\
-         	::boost::is_const< lhs_noref >::value\
+            ::boost::is_const< lhs_noref >::value\
          >::value\
       >::value,\
       /* one fundamental, one pointer */\

Modified: sandbox/type_traits/boost/type_traits/has_operator_complement.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_complement.hpp	(original)
+++ sandbox/type_traits/boost/type_traits/has_operator_complement.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,8 +6,8 @@
 //
 //  See http://www.boost.org/libs/type_traits for most recent version including documentation.
 
-#ifndef BOOST_TT_complement_HPP_INCLUDED
-#define BOOST_TT_complement_HPP_INCLUDED
+#ifndef BOOST_TT_HAS_OPERATOR_COMPLEMENT_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_COMPLEMENT_HPP_INCLUDED
 
 #define BOOST_TT_TRAIT_NAME has_operator_complement
 #define BOOST_TT_TRAIT_OP ~

Added: sandbox/type_traits/boost/type_traits/has_operator_dereference.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/has_operator_dereference.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -0,0 +1,33 @@
+//  (C) Copyright 2009-2011 Frédéric Bron (frederic.bron_at_[hidden])
+//
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_HAS_OPERATOR_DEREFERENCE_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_DEREFERENCE_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME has_operator_dereference
+#define BOOST_TT_TRAIT_OP *
+#define BOOST_TT_DEFAULT_RET void
+#define BOOST_TT_FORBIDDEN_IF\
+   /* void* or fundamental */\
+   ::boost::type_traits::ice_or<\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< rhs_noref >::value,\
+         ::boost::is_void< typename ::boost::remove_pointer< rhs_noref >::type >::value\
+      >::value,\
+      ::boost::is_fundamental< rhs_nocv >::value\
+   >::value
+
+
+#include <boost/type_traits/detail/has_prefix_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_DEFAULT_RET
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Modified: sandbox/type_traits/boost/type_traits/has_operator_divides.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_divides.hpp	(original)
+++ sandbox/type_traits/boost/type_traits/has_operator_divides.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,8 +6,8 @@
 //
 //  See http://www.boost.org/libs/type_traits for most recent version including documentation.
 
-#ifndef BOOST_TT_divides_HPP_INCLUDED
-#define BOOST_TT_divides_HPP_INCLUDED
+#ifndef BOOST_TT_HAS_OPERATOR_DIVIDES_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_DIVIDES_HPP_INCLUDED
 
 #define BOOST_TT_TRAIT_NAME has_operator_divides
 #define BOOST_TT_TRAIT_OP /

Modified: sandbox/type_traits/boost/type_traits/has_operator_divides_equal.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_divides_equal.hpp	(original)
+++ sandbox/type_traits/boost/type_traits/has_operator_divides_equal.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,8 +6,8 @@
 //
 //  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
+#ifndef BOOST_TT_HAS_OPERATOR_DIVIDES_EQUAL_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_DIVIDES_EQUAL_HPP_INCLUDED
 
 #define BOOST_TT_TRAIT_NAME has_operator_divides_equal
 #define BOOST_TT_TRAIT_OP /=

Modified: sandbox/type_traits/boost/type_traits/has_operator_equal_to.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_equal_to.hpp	(original)
+++ sandbox/type_traits/boost/type_traits/has_operator_equal_to.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,8 +6,8 @@
 //
 //  See http://www.boost.org/libs/type_traits for most recent version including documentation.
 
-#ifndef BOOST_TT_equal_to_HPP_INCLUDED
-#define BOOST_TT_equal_to_HPP_INCLUDED
+#ifndef BOOST_TT_HAS_OPERATOR_EQUAL_TO_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_EQUAL_TO_HPP_INCLUDED
 
 #define BOOST_TT_TRAIT_NAME has_operator_equal_to
 #define BOOST_TT_TRAIT_OP ==

Modified: sandbox/type_traits/boost/type_traits/has_operator_greater.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_greater.hpp	(original)
+++ sandbox/type_traits/boost/type_traits/has_operator_greater.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,8 +6,8 @@
 //
 //  See http://www.boost.org/libs/type_traits for most recent version including documentation.
 
-#ifndef BOOST_TT_greater_HPP_INCLUDED
-#define BOOST_TT_greater_HPP_INCLUDED
+#ifndef BOOST_TT_HAS_OPERATOR_GREATER_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_GREATER_HPP_INCLUDED
 
 #define BOOST_TT_TRAIT_NAME has_operator_greater
 #define BOOST_TT_TRAIT_OP >

Modified: sandbox/type_traits/boost/type_traits/has_operator_greater_equal.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_greater_equal.hpp	(original)
+++ sandbox/type_traits/boost/type_traits/has_operator_greater_equal.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,8 +6,8 @@
 //
 //  See http://www.boost.org/libs/type_traits for most recent version including documentation.
 
-#ifndef BOOST_TT_greater_equal_HPP_INCLUDED
-#define BOOST_TT_greater_equal_HPP_INCLUDED
+#ifndef BOOST_TT_HAS_OPERATOR_GREATER_EQUAL_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_GREATER_EQUAL_HPP_INCLUDED
 
 #define BOOST_TT_TRAIT_NAME has_operator_greater_equal
 #define BOOST_TT_TRAIT_OP >=

Modified: sandbox/type_traits/boost/type_traits/has_operator_left_shift.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_left_shift.hpp	(original)
+++ sandbox/type_traits/boost/type_traits/has_operator_left_shift.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,8 +6,8 @@
 //
 //  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
+#ifndef BOOST_TT_HAS_OPERATOR_LEFT_SHIFT_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_LEFT_SHIFT_HPP_INCLUDED
 
 #define BOOST_TT_TRAIT_NAME has_operator_left_shift
 #define BOOST_TT_TRAIT_OP <<

Modified: sandbox/type_traits/boost/type_traits/has_operator_left_shift_equal.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_left_shift_equal.hpp	(original)
+++ sandbox/type_traits/boost/type_traits/has_operator_left_shift_equal.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,8 +6,8 @@
 //
 //  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
+#ifndef BOOST_TT_HAS_OPERATOR_LEFT_SHIFT_EQUAL_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_LEFT_SHIFT_EQUAL_HPP_INCLUDED
 
 #define BOOST_TT_TRAIT_NAME has_operator_left_shift_equal
 #define BOOST_TT_TRAIT_OP <<=
@@ -21,7 +21,7 @@
          ::boost::type_traits::ice_or<\
             ::boost::type_traits::ice_not< ::boost::is_integral< lhs_noref >::value >::value,\
             ::boost::type_traits::ice_not< ::boost::is_integral< rhs_noref >::value >::value,\
-         	::boost::is_const< lhs_noref >::value\
+            ::boost::is_const< lhs_noref >::value\
          >::value\
       >::value,\
       /* one fundamental, one pointer */\

Modified: sandbox/type_traits/boost/type_traits/has_operator_less.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_less.hpp	(original)
+++ sandbox/type_traits/boost/type_traits/has_operator_less.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,8 +6,8 @@
 //
 //  See http://www.boost.org/libs/type_traits for most recent version including documentation.
 
-#ifndef BOOST_TT_less_HPP_INCLUDED
-#define BOOST_TT_less_HPP_INCLUDED
+#ifndef BOOST_TT_HAS_OPERATOR_LESS_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_LESS_HPP_INCLUDED
 
 #define BOOST_TT_TRAIT_NAME has_operator_less
 #define BOOST_TT_TRAIT_OP <

Modified: sandbox/type_traits/boost/type_traits/has_operator_less_equal.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_less_equal.hpp	(original)
+++ sandbox/type_traits/boost/type_traits/has_operator_less_equal.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,8 +6,8 @@
 //
 //  See http://www.boost.org/libs/type_traits for most recent version including documentation.
 
-#ifndef BOOST_TT_less_equal_HPP_INCLUDED
-#define BOOST_TT_less_equal_HPP_INCLUDED
+#ifndef BOOST_TT_HAS_OPERATOR_LESS_EQUAL_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_LESS_EQUAL_HPP_INCLUDED
 
 #define BOOST_TT_TRAIT_NAME has_operator_less_equal
 #define BOOST_TT_TRAIT_OP <=

Modified: sandbox/type_traits/boost/type_traits/has_operator_logical_and.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_logical_and.hpp	(original)
+++ sandbox/type_traits/boost/type_traits/has_operator_logical_and.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,8 +6,8 @@
 //
 //  See http://www.boost.org/libs/type_traits for most recent version including documentation.
 
-#ifndef BOOST_TT_logical_and_HPP_INCLUDED
-#define BOOST_TT_logical_and_HPP_INCLUDED
+#ifndef BOOST_TT_HAS_OPERATOR_LOGICAL_AND_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_LOGICAL_AND_HPP_INCLUDED
 
 #define BOOST_TT_TRAIT_NAME has_operator_logical_and
 #define BOOST_TT_TRAIT_OP &&

Modified: sandbox/type_traits/boost/type_traits/has_operator_logical_not.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_logical_not.hpp	(original)
+++ sandbox/type_traits/boost/type_traits/has_operator_logical_not.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,8 +6,8 @@
 //
 //  See http://www.boost.org/libs/type_traits for most recent version including documentation.
 
-#ifndef BOOST_TT_logical_not_HPP_INCLUDED
-#define BOOST_TT_logical_not_HPP_INCLUDED
+#ifndef BOOST_TT_HAS_OPERATOR_LOGICAL_NOT_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_LOGICAL_NOT_HPP_INCLUDED
 
 #define BOOST_TT_TRAIT_NAME has_operator_logical_not
 #define BOOST_TT_TRAIT_OP !

Modified: sandbox/type_traits/boost/type_traits/has_operator_logical_or.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_logical_or.hpp	(original)
+++ sandbox/type_traits/boost/type_traits/has_operator_logical_or.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,8 +6,8 @@
 //
 //  See http://www.boost.org/libs/type_traits for most recent version including documentation.
 
-#ifndef BOOST_TT_logical_or_HPP_INCLUDED
-#define BOOST_TT_logical_or_HPP_INCLUDED
+#ifndef BOOST_TT_HAS_OPERATOR_LOGICAL_OR_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_LOGICAL_OR_HPP_INCLUDED
 
 #define BOOST_TT_TRAIT_NAME has_operator_logical_or
 #define BOOST_TT_TRAIT_OP ||

Modified: sandbox/type_traits/boost/type_traits/has_operator_minus.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_minus.hpp	(original)
+++ sandbox/type_traits/boost/type_traits/has_operator_minus.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,8 +6,8 @@
 //
 //  See http://www.boost.org/libs/type_traits for most recent version including documentation.
 
-#ifndef BOOST_TT_minus_HPP_INCLUDED
-#define BOOST_TT_minus_HPP_INCLUDED
+#ifndef BOOST_TT_HAS_OPERATOR_MINUS_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_MINUS_HPP_INCLUDED
 
 #define BOOST_TT_TRAIT_NAME has_operator_minus
 #define BOOST_TT_TRAIT_OP -

Modified: sandbox/type_traits/boost/type_traits/has_operator_minus_equal.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_minus_equal.hpp	(original)
+++ sandbox/type_traits/boost/type_traits/has_operator_minus_equal.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,8 +6,8 @@
 //
 //  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
+#ifndef BOOST_TT_HAS_OPERATOR_MINUS_EQUAL_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_MINUS_EQUAL_HPP_INCLUDED
 
 #define BOOST_TT_TRAIT_NAME has_operator_minus_equal
 #define BOOST_TT_TRAIT_OP -=

Modified: sandbox/type_traits/boost/type_traits/has_operator_modulus.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_modulus.hpp	(original)
+++ sandbox/type_traits/boost/type_traits/has_operator_modulus.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,8 +6,8 @@
 //
 //  See http://www.boost.org/libs/type_traits for most recent version including documentation.
 
-#ifndef BOOST_TT_modulus_HPP_INCLUDED
-#define BOOST_TT_modulus_HPP_INCLUDED
+#ifndef BOOST_TT_HAS_OPERATOR_MODULUS_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_MODULUS_HPP_INCLUDED
 
 #define BOOST_TT_TRAIT_NAME has_operator_modulus
 #define BOOST_TT_TRAIT_OP %

Modified: sandbox/type_traits/boost/type_traits/has_operator_modulus_equal.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_modulus_equal.hpp	(original)
+++ sandbox/type_traits/boost/type_traits/has_operator_modulus_equal.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,8 +6,8 @@
 //
 //  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
+#ifndef BOOST_TT_HAS_OPERATOR_MODULUS_EQUAL_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_MODULUS_EQUAL_HPP_INCLUDED
 
 #define BOOST_TT_TRAIT_NAME has_operator_modulus_equal
 #define BOOST_TT_TRAIT_OP %=
@@ -21,7 +21,7 @@
          ::boost::type_traits::ice_or<\
             ::boost::type_traits::ice_not< ::boost::is_integral< lhs_noref >::value >::value,\
             ::boost::type_traits::ice_not< ::boost::is_integral< rhs_noref >::value >::value,\
-         	::boost::is_const< lhs_noref >::value\
+            ::boost::is_const< lhs_noref >::value\
          >::value\
       >::value,\
       /* one fundamental, one pointer */\

Modified: sandbox/type_traits/boost/type_traits/has_operator_multiplies.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_multiplies.hpp	(original)
+++ sandbox/type_traits/boost/type_traits/has_operator_multiplies.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,8 +6,8 @@
 //
 //  See http://www.boost.org/libs/type_traits for most recent version including documentation.
 
-#ifndef BOOST_TT_multiplies_HPP_INCLUDED
-#define BOOST_TT_multiplies_HPP_INCLUDED
+#ifndef BOOST_TT_HAS_OPERATOR_MULTIPLIES_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_MULTIPLIES_HPP_INCLUDED
 
 #define BOOST_TT_TRAIT_NAME has_operator_multiplies
 #define BOOST_TT_TRAIT_OP *

Modified: sandbox/type_traits/boost/type_traits/has_operator_multiplies_equal.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_multiplies_equal.hpp	(original)
+++ sandbox/type_traits/boost/type_traits/has_operator_multiplies_equal.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,8 +6,8 @@
 //
 //  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
+#ifndef BOOST_TT_HAS_OPERATOR_MULTIPLIES_EQUAL_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_MULTIPLIES_EQUAL_HPP_INCLUDED
 
 #define BOOST_TT_TRAIT_NAME has_operator_multiplies_equal
 #define BOOST_TT_TRAIT_OP *=

Modified: sandbox/type_traits/boost/type_traits/has_operator_not_equal_to.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_not_equal_to.hpp	(original)
+++ sandbox/type_traits/boost/type_traits/has_operator_not_equal_to.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,8 +6,8 @@
 //
 //  See http://www.boost.org/libs/type_traits for most recent version including documentation.
 
-#ifndef BOOST_TT_not_equal_to_HPP_INCLUDED
-#define BOOST_TT_not_equal_to_HPP_INCLUDED
+#ifndef BOOST_TT_HAS_OPERATOR_NOT_EQUAL_TO_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_NOT_EQUAL_TO_HPP_INCLUDED
 
 #define BOOST_TT_TRAIT_NAME has_operator_not_equal_to
 #define BOOST_TT_TRAIT_OP !=

Modified: sandbox/type_traits/boost/type_traits/has_operator_plus.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_plus.hpp	(original)
+++ sandbox/type_traits/boost/type_traits/has_operator_plus.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,8 +6,8 @@
 //
 //  See http://www.boost.org/libs/type_traits for most recent version including documentation.
 
-#ifndef BOOST_TT_plus_HPP_INCLUDED
-#define BOOST_TT_plus_HPP_INCLUDED
+#ifndef BOOST_TT_HAS_OPERATOR_PLUS_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_PLUS_HPP_INCLUDED
 
 #define BOOST_TT_TRAIT_NAME has_operator_plus
 #define BOOST_TT_TRAIT_OP +

Modified: sandbox/type_traits/boost/type_traits/has_operator_plus_equal.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_plus_equal.hpp	(original)
+++ sandbox/type_traits/boost/type_traits/has_operator_plus_equal.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,8 +6,8 @@
 //
 //  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
+#ifndef BOOST_TT_HAS_OPERATOR_PLUS_EQUAL_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_PLUS_EQUAL_HPP_INCLUDED
 
 #define BOOST_TT_TRAIT_NAME has_operator_plus_equal
 #define BOOST_TT_TRAIT_OP +=

Modified: sandbox/type_traits/boost/type_traits/has_operator_postfix_decrement.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_postfix_decrement.hpp	(original)
+++ sandbox/type_traits/boost/type_traits/has_operator_postfix_decrement.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,8 +6,8 @@
 //
 //  See http://www.boost.org/libs/type_traits for most recent version including documentation.
 
-#ifndef BOOST_TT_postfix_decrement_HPP_INCLUDED
-#define BOOST_TT_postfix_decrement_HPP_INCLUDED
+#ifndef BOOST_TT_HAS_OPERATOR_POSTFIX_DECREMENT_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_POSTFIX_DECREMENT_HPP_INCLUDED
 
 #define BOOST_TT_TRAIT_NAME has_operator_postfix_decrement
 #define BOOST_TT_TRAIT_OP --

Modified: sandbox/type_traits/boost/type_traits/has_operator_postfix_increment.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_postfix_increment.hpp	(original)
+++ sandbox/type_traits/boost/type_traits/has_operator_postfix_increment.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,8 +6,8 @@
 //
 //  See http://www.boost.org/libs/type_traits for most recent version including documentation.
 
-#ifndef BOOST_TT_postfix_increment_HPP_INCLUDED
-#define BOOST_TT_postfix_increment_HPP_INCLUDED
+#ifndef BOOST_TT_HAS_OPERATOR_POSTFIX_INCREMENT_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_POSTFIX_INCREMENT_HPP_INCLUDED
 
 #define BOOST_TT_TRAIT_NAME has_operator_postfix_increment
 #define BOOST_TT_TRAIT_OP ++

Modified: sandbox/type_traits/boost/type_traits/has_operator_prefix_decrement.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_prefix_decrement.hpp	(original)
+++ sandbox/type_traits/boost/type_traits/has_operator_prefix_decrement.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,8 +6,8 @@
 //
 //  See http://www.boost.org/libs/type_traits for most recent version including documentation.
 
-#ifndef BOOST_TT_prefix_decrement_HPP_INCLUDED
-#define BOOST_TT_prefix_decrement_HPP_INCLUDED
+#ifndef BOOST_TT_HAS_OPERATOR_PREFIX_DECREMENT_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_PREFIX_DECREMENT_HPP_INCLUDED
 
 #define BOOST_TT_TRAIT_NAME has_operator_prefix_decrement
 #define BOOST_TT_TRAIT_OP --

Modified: sandbox/type_traits/boost/type_traits/has_operator_prefix_increment.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_prefix_increment.hpp	(original)
+++ sandbox/type_traits/boost/type_traits/has_operator_prefix_increment.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,8 +6,8 @@
 //
 //  See http://www.boost.org/libs/type_traits for most recent version including documentation.
 
-#ifndef BOOST_TT_prefix_increment_HPP_INCLUDED
-#define BOOST_TT_prefix_increment_HPP_INCLUDED
+#ifndef BOOST_TT_HAS_OPERATOR_PREFIX_INCREMENT_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_PREFIX_INCREMENT_HPP_INCLUDED
 
 #define BOOST_TT_TRAIT_NAME has_operator_prefix_increment
 #define BOOST_TT_TRAIT_OP ++

Modified: sandbox/type_traits/boost/type_traits/has_operator_right_shift.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_right_shift.hpp	(original)
+++ sandbox/type_traits/boost/type_traits/has_operator_right_shift.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,8 +6,8 @@
 //
 //  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
+#ifndef BOOST_TT_HAS_OPERATOR_RIGHT_SHIFT_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_RIGHT_SHIFT_HPP_INCLUDED
 
 #define BOOST_TT_TRAIT_NAME has_operator_right_shift
 #define BOOST_TT_TRAIT_OP >>

Modified: sandbox/type_traits/boost/type_traits/has_operator_right_shift_equal.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_right_shift_equal.hpp	(original)
+++ sandbox/type_traits/boost/type_traits/has_operator_right_shift_equal.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,8 +6,8 @@
 //
 //  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
+#ifndef BOOST_TT_HAS_OPERATOR_RIGHT_SHIFT_EQUAL_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_RIGHT_SHIFT_EQUAL_HPP_INCLUDED
 
 #define BOOST_TT_TRAIT_NAME has_operator_right_shift_equal
 #define BOOST_TT_TRAIT_OP >>=
@@ -21,7 +21,7 @@
          ::boost::type_traits::ice_or<\
             ::boost::type_traits::ice_not< ::boost::is_integral< lhs_noref >::value >::value,\
             ::boost::type_traits::ice_not< ::boost::is_integral< rhs_noref >::value >::value,\
-         	::boost::is_const< lhs_noref >::value\
+            ::boost::is_const< lhs_noref >::value\
          >::value\
       >::value,\
       /* one fundamental, one pointer */\

Modified: sandbox/type_traits/boost/type_traits/has_operator_unary_minus.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_unary_minus.hpp	(original)
+++ sandbox/type_traits/boost/type_traits/has_operator_unary_minus.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,8 +6,8 @@
 //
 //  See http://www.boost.org/libs/type_traits for most recent version including documentation.
 
-#ifndef BOOST_TT_unary_minus_HPP_INCLUDED
-#define BOOST_TT_unary_minus_HPP_INCLUDED
+#ifndef BOOST_TT_HAS_OPERATOR_UNARY_MINUS_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_UNARY_MINUS_HPP_INCLUDED
 
 #define BOOST_TT_TRAIT_NAME has_operator_unary_minus
 #define BOOST_TT_TRAIT_OP -

Modified: sandbox/type_traits/boost/type_traits/has_operator_unary_plus.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_unary_plus.hpp	(original)
+++ sandbox/type_traits/boost/type_traits/has_operator_unary_plus.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,8 +6,8 @@
 //
 //  See http://www.boost.org/libs/type_traits for most recent version including documentation.
 
-#ifndef BOOST_TT_unary_plus_HPP_INCLUDED
-#define BOOST_TT_unary_plus_HPP_INCLUDED
+#ifndef BOOST_TT_HAS_OPERATOR_UNARY_PLUS_HPP_INCLUDED
+#define BOOST_TT_HAS_OPERATOR_UNARY_PLUS_HPP_INCLUDED
 
 #define BOOST_TT_TRAIT_NAME has_operator_unary_plus
 #define BOOST_TT_TRAIT_OP +

Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_bit_and.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_bit_and.qbk	(original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_bit_and.qbk	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -15,10 +15,18 @@
 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&`.
+The default behaviour (`RET=void`) is to not check for the return value of binary `operator&`.
 If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+LHS lhs;
+RHS rhs;
+f(lhs&rhs); // is valid if has_operator_bit_and<LHS, RHS, RET>::value==true
+``
 
-This trait can not detect whether `operator&` is public or not: if `operator&` is defined as a private member of `LHS` then
+This trait can not detect whether binary `operator&` is public or not:
+if `operator&` is defined as a private member of `LHS` then
 instantiating `has_operator_bit_and<LHS>` will produce a compiler error.
 For this reason `has_operator_bit_and` can not be used to determine whether a type has a public `operator&` or not.
 
@@ -26,6 +34,7 @@
 
 __examples
 
+
 [:`has_operator_bit_and<LHS, RHS, RET>::value_type` is the type `bool`.]
 
 [:`has_operator_bit_and<int>` inherits from `__true_type`.]
@@ -40,4 +49,3 @@
 expression that evaluates to /true/.]
 
 [endsect]
-

Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_bit_and_equal.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_bit_and_equal.qbk	(original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_bit_and_equal.qbk	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -15,10 +15,18 @@
 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&=`.
+The default behaviour (`RET=void`) is to not check for the return value of binary `operator&=`.
 If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+LHS lhs;
+RHS rhs;
+f(lhs&=rhs); // is valid if has_operator_bit_and_equal<LHS, RHS, RET>::value==true
+``
 
-This trait can not detect whether `operator&=` is public or not: if `operator&=` is defined as a private member of `LHS` then
+This trait can not detect whether binary `operator&=` is public or not:
+if `operator&=` is defined as a private member of `LHS` then
 instantiating `has_operator_bit_and_equal<LHS>` will produce a compiler error.
 For this reason `has_operator_bit_and_equal` can not be used to determine whether a type has a public `operator&=` or not.
 
@@ -26,6 +34,7 @@
 
 __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`.]
@@ -40,4 +49,3 @@
 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	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -15,10 +15,18 @@
 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|`.
+The default behaviour (`RET=void`) is to not check for the return value of binary `operator|`.
 If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+LHS lhs;
+RHS rhs;
+f(lhs|rhs); // is valid if has_operator_bit_or<LHS, RHS, RET>::value==true
+``
 
-This trait can not detect whether `operator|` is public or not: if `operator|` is defined as a private member of `LHS` then
+This trait can not detect whether binary `operator|` is public or not:
+if `operator|` is defined as a private member of `LHS` then
 instantiating `has_operator_bit_or<LHS>` will produce a compiler error.
 For this reason `has_operator_bit_or` can not be used to determine whether a type has a public `operator|` or not.
 
@@ -26,6 +34,7 @@
 
 __examples
 
+
 [:`has_operator_bit_or<LHS, RHS, RET>::value_type` is the type `bool`.]
 
 [:`has_operator_bit_or<int>` inherits from `__true_type`.]
@@ -40,4 +49,3 @@
 expression that evaluates to /true/.]
 
 [endsect]
-

Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_bit_or_equal.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_bit_or_equal.qbk	(original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_bit_or_equal.qbk	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -15,10 +15,18 @@
 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|=`.
+The default behaviour (`RET=void`) is to not check for the return value of binary `operator|=`.
 If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+LHS lhs;
+RHS rhs;
+f(lhs|=rhs); // is valid if has_operator_bit_or_equal<LHS, RHS, RET>::value==true
+``
 
-This trait can not detect whether `operator|=` is public or not: if `operator|=` is defined as a private member of `LHS` then
+This trait can not detect whether binary `operator|=` is public or not:
+if `operator|=` is defined as a private member of `LHS` then
 instantiating `has_operator_bit_or_equal<LHS>` will produce a compiler error.
 For this reason `has_operator_bit_or_equal` can not be used to determine whether a type has a public `operator|=` or not.
 
@@ -26,6 +34,7 @@
 
 __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`.]
@@ -40,4 +49,3 @@
 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	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -15,10 +15,18 @@
 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^`.
+The default behaviour (`RET=void`) is to not check for the return value of binary `operator^`.
 If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+LHS lhs;
+RHS rhs;
+f(lhs^rhs); // is valid if has_operator_bit_xor<LHS, RHS, RET>::value==true
+``
 
-This trait can not detect whether `operator^` is public or not: if `operator^` is defined as a private member of `LHS` then
+This trait can not detect whether binary `operator^` is public or not:
+if `operator^` is defined as a private member of `LHS` then
 instantiating `has_operator_bit_xor<LHS>` will produce a compiler error.
 For this reason `has_operator_bit_xor` can not be used to determine whether a type has a public `operator^` or not.
 
@@ -26,6 +34,7 @@
 
 __examples
 
+
 [:`has_operator_bit_xor<LHS, RHS, RET>::value_type` is the type `bool`.]
 
 [:`has_operator_bit_xor<int>` inherits from `__true_type`.]
@@ -40,4 +49,3 @@
 expression that evaluates to /true/.]
 
 [endsect]
-

Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_bit_xor_equal.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_bit_xor_equal.qbk	(original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_bit_xor_equal.qbk	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -15,10 +15,18 @@
 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^=`.
+The default behaviour (`RET=void`) is to not check for the return value of binary `operator^=`.
 If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+LHS lhs;
+RHS rhs;
+f(lhs^=rhs); // is valid if has_operator_bit_xor_equal<LHS, RHS, RET>::value==true
+``
 
-This trait can not detect whether `operator^=` is public or not: if `operator^=` is defined as a private member of `LHS` then
+This trait can not detect whether binary `operator^=` is public or not:
+if `operator^=` is defined as a private member of `LHS` then
 instantiating `has_operator_bit_xor_equal<LHS>` will produce a compiler error.
 For this reason `has_operator_bit_xor_equal` can not be used to determine whether a type has a public `operator^=` or not.
 
@@ -26,6 +34,7 @@
 
 __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`.]
@@ -40,4 +49,3 @@
 expression that evaluates to /true/.]
 
 [endsect]
-

Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_complement.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_complement.qbk	(original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_complement.qbk	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -17,15 +17,23 @@
 
 The default behaviour (`RET=void`) is to not check for the return value of prefix `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 prefix `operator~` is public or not: if `operator~` is defined
-as a private member of `RHS` then instantiating `has_operator_complement<RHS>` will produce a compiler error.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+RHS rhs;
+f(~rhs); // is valid if has_operator_complement<RHS, RET>::value==true
+``
+
+This trait can not detect whether prefix `operator~` is public or not:
+if `operator~` is defined as a private member of `RHS` then
+instantiating `has_operator_complement<RHS>` will produce a compiler error.
 For this reason `has_operator_complement` can not be used to determine whether a type has a public `operator~` or not.
 
 __header `#include <boost/type_traits/has_operator_complement.hpp>` or `#include <boost/type_traits.hpp>`
 
 __examples
 
+
 [:`has_operator_complement<RHS, RET>::value_type` is the type `bool`.]
 
 [:`has_operator_complement<int>` inherits from `__true_type`.]
@@ -44,4 +52,3 @@
 expression that evaluates to /true/.]
 
 [endsect]
-

Added: sandbox/type_traits/libs/type_traits/doc/has_operator_dereference.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_dereference.qbk	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -0,0 +1,50 @@
+[/
+  Copyright 2009-2011  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_dereference has_operator_dereference]
+   template <class RHS, class RET=void>
+   struct has_operator_dereference : 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.
+
+The default behaviour (`RET=void`) is to not check for the return value of prefix `operator*`.
+If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+RHS rhs;
+f(*rhs); // is valid if has_operator_dereference<RHS, RET>::value==true
+``
+
+This trait can not detect whether prefix `operator*` is public or not:
+if `operator*` is defined as a private member of `RHS` then
+instantiating `has_operator_dereference<RHS>` will produce a compiler error.
+For this reason `has_operator_dereference` can not be used to determine whether a type has a public `operator*` or not.
+
+__header `#include <boost/type_traits/has_operator_dereference.hpp>` or `#include <boost/type_traits.hpp>`
+
+__examples
+
+
+[:`has_operator_dereference<RHS, RET>::value_type` is the type `bool`.]
+
+[:`has_operator_dereference<int*>` inherits from `__true_type`.]
+
+[:`has_operator_dereference<int>` inherits from `__false_type`.]
+
+[:`has_operator_dereference<int*, const int>` inherits from `__true_type`.]
+
+[:`has_operator_dereference<const int*, int&>` inherits from `__false_type`.]
+
+[:`has_operator_dereference<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	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -15,10 +15,18 @@
 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/`.
+The default behaviour (`RET=void`) is to not check for the return value of binary `operator/`.
 If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+LHS lhs;
+RHS rhs;
+f(lhs/rhs); // is valid if has_operator_divides<LHS, RHS, RET>::value==true
+``
 
-This trait can not detect whether `operator/` is public or not: if `operator/` is defined as a private member of `LHS` then
+This trait can not detect whether binary `operator/` is public or not:
+if `operator/` is defined as a private member of `LHS` then
 instantiating `has_operator_divides<LHS>` will produce a compiler error.
 For this reason `has_operator_divides` can not be used to determine whether a type has a public `operator/` or not.
 
@@ -26,6 +34,7 @@
 
 __examples
 
+
 [:`has_operator_divides<LHS, RHS, RET>::value_type` is the type `bool`.]
 
 [:`has_operator_divides<int>` inherits from `__true_type`.]
@@ -44,4 +53,3 @@
 expression that evaluates to /true/.]
 
 [endsect]
-

Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_divides_equal.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_divides_equal.qbk	(original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_divides_equal.qbk	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -15,10 +15,18 @@
 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/=`.
+The default behaviour (`RET=void`) is to not check for the return value of binary `operator/=`.
 If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+LHS lhs;
+RHS rhs;
+f(lhs/=rhs); // is valid if has_operator_divides_equal<LHS, RHS, RET>::value==true
+``
 
-This trait can not detect whether `operator/=` is public or not: if `operator/=` is defined as a private member of `LHS` then
+This trait can not detect whether binary `operator/=` is public or not:
+if `operator/=` is defined as a private member of `LHS` then
 instantiating `has_operator_divides_equal<LHS>` will produce a compiler error.
 For this reason `has_operator_divides_equal` can not be used to determine whether a type has a public `operator/=` or not.
 
@@ -26,6 +34,7 @@
 
 __examples
 
+
 [:`has_operator_divides_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
 
 [:`has_operator_divides_equal<int>` inherits from `__true_type`.]
@@ -44,4 +53,3 @@
 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	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -15,10 +15,18 @@
 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==`.
+The default behaviour (`RET=void`) is to not check for the return value of binary `operator==`.
 If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+LHS lhs;
+RHS rhs;
+f(lhs==rhs); // is valid if has_operator_equal_to<LHS, RHS, RET>::value==true
+``
 
-This trait can not detect whether `operator==` is public or not: if `operator==` is defined as a private member of `LHS` then
+This trait can not detect whether binary `operator==` is public or not:
+if `operator==` is defined as a private member of `LHS` then
 instantiating `has_operator_equal_to<LHS>` will produce a compiler error.
 For this reason `has_operator_equal_to` can not be used to determine whether a type has a public `operator==` or not.
 
@@ -26,6 +34,7 @@
 
 __examples
 
+
 [:`has_operator_equal_to<LHS, RHS, RET>::value_type` is the type `bool`.]
 
 [:`has_operator_equal_to<int>` inherits from `__true_type`.]
@@ -40,4 +49,3 @@
 expression that evaluates to /true/.]
 
 [endsect]
-

Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_greater.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_greater.qbk	(original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_greater.qbk	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -15,10 +15,18 @@
 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>`.
+The default behaviour (`RET=void`) is to not check for the return value of binary `operator>`.
 If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+LHS lhs;
+RHS rhs;
+f(lhs>rhs); // is valid if has_operator_greater<LHS, RHS, RET>::value==true
+``
 
-This trait can not detect whether `operator>` is public or not: if `operator>` is defined as a private member of `LHS` then
+This trait can not detect whether binary `operator>` is public or not:
+if `operator>` is defined as a private member of `LHS` then
 instantiating `has_operator_greater<LHS>` will produce a compiler error.
 For this reason `has_operator_greater` can not be used to determine whether a type has a public `operator>` or not.
 
@@ -26,6 +34,7 @@
 
 __examples
 
+
 [:`has_operator_greater<LHS, RHS, RET>::value_type` is the type `bool`.]
 
 [:`has_operator_greater<int>` inherits from `__true_type`.]
@@ -40,4 +49,3 @@
 expression that evaluates to /true/.]
 
 [endsect]
-

Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_greater_equal.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_greater_equal.qbk	(original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_greater_equal.qbk	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -15,10 +15,18 @@
 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>=`.
+The default behaviour (`RET=void`) is to not check for the return value of binary `operator>=`.
 If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+LHS lhs;
+RHS rhs;
+f(lhs>=rhs); // is valid if has_operator_greater_equal<LHS, RHS, RET>::value==true
+``
 
-This trait can not detect whether `operator>=` is public or not: if `operator>=` is defined as a private member of `LHS` then
+This trait can not detect whether binary `operator>=` is public or not:
+if `operator>=` is defined as a private member of `LHS` then
 instantiating `has_operator_greater_equal<LHS>` will produce a compiler error.
 For this reason `has_operator_greater_equal` can not be used to determine whether a type has a public `operator>=` or not.
 
@@ -26,6 +34,7 @@
 
 __examples
 
+
 [:`has_operator_greater_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
 
 [:`has_operator_greater_equal<int>` inherits from `__true_type`.]
@@ -40,4 +49,3 @@
 expression that evaluates to /true/.]
 
 [endsect]
-

Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_left_shift.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_left_shift.qbk	(original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_left_shift.qbk	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -15,10 +15,18 @@
 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<<`.
+The default behaviour (`RET=void`) is to not check for the return value of binary `operator<<`.
 If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+LHS lhs;
+RHS rhs;
+f(lhs<<rhs); // is valid if has_operator_left_shift<LHS, RHS, RET>::value==true
+``
 
-This trait can not detect whether `operator<<` is public or not: if `operator<<` is defined as a private member of `LHS` then
+This trait can not detect whether binary `operator<<` is public or not:
+if `operator<<` is defined as a private member of `LHS` then
 instantiating `has_operator_left_shift<LHS>` will produce a compiler error.
 For this reason `has_operator_left_shift` can not be used to determine whether a type has a public `operator<<` or not.
 
@@ -26,6 +34,7 @@
 
 __examples
 
+
 [:`has_operator_left_shift<LHS, RHS, RET>::value_type` is the type `bool`.]
 
 [:`has_operator_left_shift<int>` inherits from `__true_type`.]
@@ -40,4 +49,3 @@
 expression that evaluates to /true/.]
 
 [endsect]
-

Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_left_shift_equal.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_left_shift_equal.qbk	(original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_left_shift_equal.qbk	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -15,10 +15,18 @@
 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<<=`.
+The default behaviour (`RET=void`) is to not check for the return value of binary `operator<<=`.
 If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+LHS lhs;
+RHS rhs;
+f(lhs<<=rhs); // is valid if has_operator_left_shift_equal<LHS, RHS, RET>::value==true
+``
 
-This trait can not detect whether `operator<<=` is public or not: if `operator<<=` is defined as a private member of `LHS` then
+This trait can not detect whether binary `operator<<=` is public or not:
+if `operator<<=` is defined as a private member of `LHS` then
 instantiating `has_operator_left_shift_equal<LHS>` will produce a compiler error.
 For this reason `has_operator_left_shift_equal` can not be used to determine whether a type has a public `operator<<=` or not.
 
@@ -26,6 +34,7 @@
 
 __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`.]
@@ -40,4 +49,3 @@
 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	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -15,10 +15,18 @@
 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<`.
+The default behaviour (`RET=void`) is to not check for the return value of binary `operator<`.
 If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+LHS lhs;
+RHS rhs;
+f(lhs<rhs); // is valid if has_operator_less<LHS, RHS, RET>::value==true
+``
 
-This trait can not detect whether `operator<` is public or not: if `operator<` is defined as a private member of `LHS` then
+This trait can not detect whether binary `operator<` is public or not:
+if `operator<` is defined as a private member of `LHS` then
 instantiating `has_operator_less<LHS>` will produce a compiler error.
 For this reason `has_operator_less` can not be used to determine whether a type has a public `operator<` or not.
 
@@ -26,6 +34,7 @@
 
 __examples
 
+
 [:`has_operator_less<LHS, RHS, RET>::value_type` is the type `bool`.]
 
 [:`has_operator_less<int>` inherits from `__true_type`.]
@@ -40,4 +49,3 @@
 expression that evaluates to /true/.]
 
 [endsect]
-

Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_less_equal.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_less_equal.qbk	(original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_less_equal.qbk	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -15,10 +15,18 @@
 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<=`.
+The default behaviour (`RET=void`) is to not check for the return value of binary `operator<=`.
 If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+LHS lhs;
+RHS rhs;
+f(lhs<=rhs); // is valid if has_operator_less_equal<LHS, RHS, RET>::value==true
+``
 
-This trait can not detect whether `operator<=` is public or not: if `operator<=` is defined as a private member of `LHS` then
+This trait can not detect whether binary `operator<=` is public or not:
+if `operator<=` is defined as a private member of `LHS` then
 instantiating `has_operator_less_equal<LHS>` will produce a compiler error.
 For this reason `has_operator_less_equal` can not be used to determine whether a type has a public `operator<=` or not.
 
@@ -26,6 +34,7 @@
 
 __examples
 
+
 [:`has_operator_less_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
 
 [:`has_operator_less_equal<int>` inherits from `__true_type`.]
@@ -40,4 +49,3 @@
 expression that evaluates to /true/.]
 
 [endsect]
-

Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_logical_and.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_logical_and.qbk	(original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_logical_and.qbk	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -15,10 +15,18 @@
 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&&`.
+The default behaviour (`RET=void`) is to not check for the return value of binary `operator&&`.
 If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+LHS lhs;
+RHS rhs;
+f(lhs&&rhs); // is valid if has_operator_logical_and<LHS, RHS, RET>::value==true
+``
 
-This trait can not detect whether `operator&&` is public or not: if `operator&&` is defined as a private member of `LHS` then
+This trait can not detect whether binary `operator&&` is public or not:
+if `operator&&` is defined as a private member of `LHS` then
 instantiating `has_operator_logical_and<LHS>` will produce a compiler error.
 For this reason `has_operator_logical_and` can not be used to determine whether a type has a public `operator&&` or not.
 
@@ -26,6 +34,7 @@
 
 __examples
 
+
 [:`has_operator_logical_and<LHS, RHS, RET>::value_type` is the type `bool`.]
 
 [:`has_operator_logical_and<bool>` inherits from `__true_type`.]
@@ -40,4 +49,3 @@
 expression that evaluates to /true/.]
 
 [endsect]
-

Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_logical_not.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_logical_not.qbk	(original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_logical_not.qbk	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -15,10 +15,17 @@
 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!`.
+The default behaviour (`RET=void`) is to not check for the return value of prefix `operator!`.
 If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+RHS rhs;
+f(!rhs); // is valid if has_operator_logical_not<RHS, RET>::value==true
+``
 
-This trait can not detect whether `operator!` is public or not: if `operator!` is defined as a private member of `RHS` then
+This trait can not detect whether prefix `operator!` is public or not:
+if `operator!` is defined as a private member of `RHS` then
 instantiating `has_operator_logical_not<RHS>` will produce a compiler error.
 For this reason `has_operator_logical_not` can not be used to determine whether a type has a public `operator!` or not.
 
@@ -26,6 +33,7 @@
 
 __examples
 
+
 [:`has_operator_logical_not<RHS, RET>::value_type` is the type `bool`.]
 
 [:`has_operator_logical_not<bool>` inherits from `__true_type`.]
@@ -40,4 +48,3 @@
 expression that evaluates to /true/.]
 
 [endsect]
-

Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_logical_or.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_logical_or.qbk	(original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_logical_or.qbk	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -15,10 +15,18 @@
 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||`.
+The default behaviour (`RET=void`) is to not check for the return value of binary `operator||`.
 If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+LHS lhs;
+RHS rhs;
+f(lhs||rhs); // is valid if has_operator_logical_or<LHS, RHS, RET>::value==true
+``
 
-This trait can not detect whether `operator||` is public or not: if `operator||` is defined as a private member of `LHS` then
+This trait can not detect whether binary `operator||` is public or not:
+if `operator||` is defined as a private member of `LHS` then
 instantiating `has_operator_logical_or<LHS>` will produce a compiler error.
 For this reason `has_operator_logical_or` can not be used to determine whether a type has a public `operator||` or not.
 
@@ -26,6 +34,7 @@
 
 __examples
 
+
 [:`has_operator_logical_or<LHS, RHS, RET>::value_type` is the type `bool`.]
 
 [:`has_operator_logical_or<bool>` inherits from `__true_type`.]
@@ -40,4 +49,3 @@
 expression that evaluates to /true/.]
 
 [endsect]
-

Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_minus.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_minus.qbk	(original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_minus.qbk	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -15,10 +15,18 @@
 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-`.
+The default behaviour (`RET=void`) is to not check for the return value of binary `operator-`.
 If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+LHS lhs;
+RHS rhs;
+f(lhs-rhs); // is valid if has_operator_minus<LHS, RHS, RET>::value==true
+``
 
-This trait can not detect whether `operator-` is public or not: if `operator-` is defined as a private member of `LHS` then
+This trait can not detect whether binary `operator-` is public or not:
+if `operator-` is defined as a private member of `LHS` then
 instantiating `has_operator_minus<LHS>` will produce a compiler error.
 For this reason `has_operator_minus` can not be used to determine whether a type has a public `operator-` or not.
 
@@ -26,6 +34,7 @@
 
 __examples
 
+
 [:`has_operator_minus<LHS, RHS, RET>::value_type` is the type `bool`.]
 
 [:`has_operator_minus<int>` inherits from `__true_type`.]
@@ -44,4 +53,3 @@
 expression that evaluates to /true/.]
 
 [endsect]
-

Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_minus_equal.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_minus_equal.qbk	(original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_minus_equal.qbk	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -15,10 +15,18 @@
 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-=`.
+The default behaviour (`RET=void`) is to not check for the return value of binary `operator-=`.
 If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+LHS lhs;
+RHS rhs;
+f(lhs-=rhs); // is valid if has_operator_minus_equal<LHS, RHS, RET>::value==true
+``
 
-This trait can not detect whether `operator-=` is public or not: if `operator-=` is defined as a private member of `LHS` then
+This trait can not detect whether binary `operator-=` is public or not:
+if `operator-=` is defined as a private member of `LHS` then
 instantiating `has_operator_minus_equal<LHS>` will produce a compiler error.
 For this reason `has_operator_minus_equal` can not be used to determine whether a type has a public `operator-=` or not.
 
@@ -26,6 +34,7 @@
 
 __examples
 
+
 [:`has_operator_minus_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
 
 [:`has_operator_minus_equal<int>` inherits from `__true_type`.]
@@ -44,4 +53,3 @@
 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	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -15,10 +15,18 @@
 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%`.
+The default behaviour (`RET=void`) is to not check for the return value of binary `operator%`.
 If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+LHS lhs;
+RHS rhs;
+f(lhs%rhs); // is valid if has_operator_modulus<LHS, RHS, RET>::value==true
+``
 
-This trait can not detect whether `operator%` is public or not: if `operator%` is defined as a private member of `LHS` then
+This trait can not detect whether binary `operator%` is public or not:
+if `operator%` is defined as a private member of `LHS` then
 instantiating `has_operator_modulus<LHS>` will produce a compiler error.
 For this reason `has_operator_modulus` can not be used to determine whether a type has a public `operator%` or not.
 
@@ -26,6 +34,7 @@
 
 __examples
 
+
 [:`has_operator_modulus<LHS, RHS, RET>::value_type` is the type `bool`.]
 
 [:`has_operator_modulus<int>` inherits from `__true_type`.]
@@ -40,4 +49,3 @@
 expression that evaluates to /true/.]
 
 [endsect]
-

Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_modulus_equal.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_modulus_equal.qbk	(original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_modulus_equal.qbk	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -15,10 +15,18 @@
 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%=`.
+The default behaviour (`RET=void`) is to not check for the return value of binary `operator%=`.
 If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+LHS lhs;
+RHS rhs;
+f(lhs%=rhs); // is valid if has_operator_modulus_equal<LHS, RHS, RET>::value==true
+``
 
-This trait can not detect whether `operator%=` is public or not: if `operator%=` is defined as a private member of `LHS` then
+This trait can not detect whether binary `operator%=` is public or not:
+if `operator%=` is defined as a private member of `LHS` then
 instantiating `has_operator_modulus_equal<LHS>` will produce a compiler error.
 For this reason `has_operator_modulus_equal` can not be used to determine whether a type has a public `operator%=` or not.
 
@@ -26,6 +34,7 @@
 
 __examples
 
+
 [:`has_operator_modulus_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
 
 [:`has_operator_modulus_equal<int>` inherits from `__true_type`.]
@@ -40,4 +49,3 @@
 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	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -15,10 +15,18 @@
 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*`.
+The default behaviour (`RET=void`) is to not check for the return value of binary `operator*`.
 If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+LHS lhs;
+RHS rhs;
+f(lhs*rhs); // is valid if has_operator_multiplies<LHS, RHS, RET>::value==true
+``
 
-This trait can not detect whether `operator*` is public or not: if `operator*` is defined as a private member of `LHS` then
+This trait can not detect whether binary `operator*` is public or not:
+if `operator*` is defined as a private member of `LHS` then
 instantiating `has_operator_multiplies<LHS>` will produce a compiler error.
 For this reason `has_operator_multiplies` can not be used to determine whether a type has a public `operator*` or not.
 
@@ -26,6 +34,7 @@
 
 __examples
 
+
 [:`has_operator_multiplies<LHS, RHS, RET>::value_type` is the type `bool`.]
 
 [:`has_operator_multiplies<int>` inherits from `__true_type`.]
@@ -44,4 +53,3 @@
 expression that evaluates to /true/.]
 
 [endsect]
-

Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_multiplies_equal.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_multiplies_equal.qbk	(original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_multiplies_equal.qbk	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -15,10 +15,18 @@
 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*=`.
+The default behaviour (`RET=void`) is to not check for the return value of binary `operator*=`.
 If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+LHS lhs;
+RHS rhs;
+f(lhs*=rhs); // is valid if has_operator_multiplies_equal<LHS, RHS, RET>::value==true
+``
 
-This trait can not detect whether `operator*=` is public or not: if `operator*=` is defined as a private member of `LHS` then
+This trait can not detect whether binary `operator*=` is public or not:
+if `operator*=` is defined as a private member of `LHS` then
 instantiating `has_operator_multiplies_equal<LHS>` will produce a compiler error.
 For this reason `has_operator_multiplies_equal` can not be used to determine whether a type has a public `operator*=` or not.
 
@@ -26,6 +34,7 @@
 
 __examples
 
+
 [:`has_operator_multiplies_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
 
 [:`has_operator_multiplies_equal<int>` inherits from `__true_type`.]
@@ -44,4 +53,3 @@
 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	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -15,10 +15,18 @@
 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!=`.
+The default behaviour (`RET=void`) is to not check for the return value of binary `operator!=`.
 If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+LHS lhs;
+RHS rhs;
+f(lhs!=rhs); // is valid if has_operator_not_equal_to<LHS, RHS, RET>::value==true
+``
 
-This trait can not detect whether `operator!=` is public or not: if `operator!=` is defined as a private member of `LHS` then
+This trait can not detect whether binary `operator!=` is public or not:
+if `operator!=` is defined as a private member of `LHS` then
 instantiating `has_operator_not_equal_to<LHS>` will produce a compiler error.
 For this reason `has_operator_not_equal_to` can not be used to determine whether a type has a public `operator!=` or not.
 
@@ -26,6 +34,7 @@
 
 __examples
 
+
 [:`has_operator_not_equal_to<LHS, RHS, RET>::value_type` is the type `bool`.]
 
 [:`has_operator_not_equal_to<int>` inherits from `__true_type`.]
@@ -40,4 +49,3 @@
 expression that evaluates to /true/.]
 
 [endsect]
-

Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_plus.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_plus.qbk	(original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_plus.qbk	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -15,10 +15,18 @@
 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+`.
+The default behaviour (`RET=void`) is to not check for the return value of binary `operator+`.
 If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+LHS lhs;
+RHS rhs;
+f(lhs+rhs); // is valid if has_operator_plus<LHS, RHS, RET>::value==true
+``
 
-This trait can not detect whether `operator+` is public or not: if `operator+` is defined as a private member of `LHS` then
+This trait can not detect whether binary `operator+` is public or not:
+if `operator+` is defined as a private member of `LHS` then
 instantiating `has_operator_plus<LHS>` will produce a compiler error.
 For this reason `has_operator_plus` can not be used to determine whether a type has a public `operator+` or not.
 
@@ -26,6 +34,7 @@
 
 __examples
 
+
 [:`has_operator_plus<LHS, RHS, RET>::value_type` is the type `bool`.]
 
 [:`has_operator_plus<int>` inherits from `__true_type`.]
@@ -44,4 +53,3 @@
 expression that evaluates to /true/.]
 
 [endsect]
-

Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_plus_equal.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_plus_equal.qbk	(original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_plus_equal.qbk	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -15,10 +15,18 @@
 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+=`.
+The default behaviour (`RET=void`) is to not check for the return value of binary `operator+=`.
 If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+LHS lhs;
+RHS rhs;
+f(lhs+=rhs); // is valid if has_operator_plus_equal<LHS, RHS, RET>::value==true
+``
 
-This trait can not detect whether `operator+=` is public or not: if `operator+=` is defined as a private member of `LHS` then
+This trait can not detect whether binary `operator+=` is public or not:
+if `operator+=` is defined as a private member of `LHS` then
 instantiating `has_operator_plus_equal<LHS>` will produce a compiler error.
 For this reason `has_operator_plus_equal` can not be used to determine whether a type has a public `operator+=` or not.
 
@@ -26,6 +34,7 @@
 
 __examples
 
+
 [:`has_operator_plus_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
 
 [:`has_operator_plus_equal<int>` inherits from `__true_type`.]
@@ -44,4 +53,3 @@
 expression that evaluates to /true/.]
 
 [endsect]
-

Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_postfix_decrement.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_postfix_decrement.qbk	(original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_postfix_decrement.qbk	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -17,15 +17,23 @@
 
 The default behaviour (`RET=void`) is to not check for the return value of postfix `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 postfix `operator--` is public or not: if `operator--` is defined
-as a private member of `LHS` then instantiating `has_operator_postfix_decrement<LHS>` will produce a compiler error.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+LHS lhs;
+f(lhs--); // is valid if has_operator_postfix_decrement<LHS, RET>::value==true
+``
+
+This trait can not detect whether postfix `operator--` is public or not:
+if `operator--` is defined as a private member of `LHS` then
+instantiating `has_operator_postfix_decrement<LHS>` will produce a compiler error.
 For this reason `has_operator_postfix_decrement` can not be used to determine whether a type has a public `operator--` or not.
 
 __header `#include <boost/type_traits/has_operator_postfix_decrement.hpp>` or `#include <boost/type_traits.hpp>`
 
 __examples
 
+
 [:`has_operator_postfix_decrement<LHS, RET>::value_type` is the type `bool`.]
 
 [:`has_operator_postfix_decrement<int>` inherits from `__true_type`.]
@@ -44,4 +52,3 @@
 expression that evaluates to /true/.]
 
 [endsect]
-

Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_postfix_increment.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_postfix_increment.qbk	(original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_postfix_increment.qbk	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -17,15 +17,23 @@
 
 The default behaviour (`RET=void`) is to not check for the return value of postfix `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 postfix `operator++` is public or not: if `operator++` is defined
-as a private member of `LHS` then instantiating `has_operator_postfix_increment<LHS>` will produce a compiler error.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+LHS lhs;
+f(lhs++); // is valid if has_operator_postfix_increment<LHS, RET>::value==true
+``
+
+This trait can not detect whether postfix `operator++` is public or not:
+if `operator++` is defined as a private member of `LHS` then
+instantiating `has_operator_postfix_increment<LHS>` will produce a compiler error.
 For this reason `has_operator_postfix_increment` can not be used to determine whether a type has a public `operator++` or not.
 
 __header `#include <boost/type_traits/has_operator_postfix_increment.hpp>` or `#include <boost/type_traits.hpp>`
 
 __examples
 
+
 [:`has_operator_postfix_increment<LHS, RET>::value_type` is the type `bool`.]
 
 [:`has_operator_postfix_increment<int>` inherits from `__true_type`.]
@@ -44,4 +52,3 @@
 expression that evaluates to /true/.]
 
 [endsect]
-

Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_prefix_decrement.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_prefix_decrement.qbk	(original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_prefix_decrement.qbk	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -17,15 +17,23 @@
 
 The default behaviour (`RET=void`) is to not check for the return value of prefix `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 prefix `operator--` is public or not: if `operator--` is defined
-as a private member of `RHS` then instantiating `has_operator_prefix_decrement<RHS>` will produce a compiler error.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+RHS rhs;
+f(--rhs); // is valid if has_operator_prefix_decrement<RHS, RET>::value==true
+``
+
+This trait can not detect whether prefix `operator--` is public or not:
+if `operator--` is defined as a private member of `RHS` then
+instantiating `has_operator_prefix_decrement<RHS>` will produce a compiler error.
 For this reason `has_operator_prefix_decrement` can not be used to determine whether a type has a public `operator--` or not.
 
 __header `#include <boost/type_traits/has_operator_prefix_decrement.hpp>` or `#include <boost/type_traits.hpp>`
 
 __examples
 
+
 [:`has_operator_prefix_decrement<RHS, RET>::value_type` is the type `bool`.]
 
 [:`has_operator_prefix_decrement<int>` inherits from `__true_type`.]
@@ -44,4 +52,3 @@
 expression that evaluates to /true/.]
 
 [endsect]
-

Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_prefix_increment.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_prefix_increment.qbk	(original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_prefix_increment.qbk	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -17,15 +17,23 @@
 
 The default behaviour (`RET=void`) is to not check for the return value of prefix `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 prefix `operator++` is public or not: if `operator++` is defined
-as a private member of `RHS` then instantiating `has_operator_prefix_increment<RHS>` will produce a compiler error.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+RHS rhs;
+f(++rhs); // is valid if has_operator_prefix_increment<RHS, RET>::value==true
+``
+
+This trait can not detect whether prefix `operator++` is public or not:
+if `operator++` is defined as a private member of `RHS` then
+instantiating `has_operator_prefix_increment<RHS>` will produce a compiler error.
 For this reason `has_operator_prefix_increment` can not be used to determine whether a type has a public `operator++` or not.
 
 __header `#include <boost/type_traits/has_operator_prefix_increment.hpp>` or `#include <boost/type_traits.hpp>`
 
 __examples
 
+
 [:`has_operator_prefix_increment<RHS, RET>::value_type` is the type `bool`.]
 
 [:`has_operator_prefix_increment<int>` inherits from `__true_type`.]
@@ -44,4 +52,3 @@
 expression that evaluates to /true/.]
 
 [endsect]
-

Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_right_shift.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_right_shift.qbk	(original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_right_shift.qbk	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -15,10 +15,18 @@
 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>>`.
+The default behaviour (`RET=void`) is to not check for the return value of binary `operator>>`.
 If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+LHS lhs;
+RHS rhs;
+f(lhs>>rhs); // is valid if has_operator_right_shift<LHS, RHS, RET>::value==true
+``
 
-This trait can not detect whether `operator>>` is public or not: if `operator>>` is defined as a private member of `LHS` then
+This trait can not detect whether binary `operator>>` is public or not:
+if `operator>>` is defined as a private member of `LHS` then
 instantiating `has_operator_right_shift<LHS>` will produce a compiler error.
 For this reason `has_operator_right_shift` can not be used to determine whether a type has a public `operator>>` or not.
 
@@ -26,6 +34,7 @@
 
 __examples
 
+
 [:`has_operator_right_shift<LHS, RHS, RET>::value_type` is the type `bool`.]
 
 [:`has_operator_right_shift<int>` inherits from `__true_type`.]
@@ -40,4 +49,3 @@
 expression that evaluates to /true/.]
 
 [endsect]
-

Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_right_shift_equal.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_right_shift_equal.qbk	(original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_right_shift_equal.qbk	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -15,10 +15,18 @@
 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>>=`.
+The default behaviour (`RET=void`) is to not check for the return value of binary `operator>>=`.
 If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+LHS lhs;
+RHS rhs;
+f(lhs>>=rhs); // is valid if has_operator_right_shift_equal<LHS, RHS, RET>::value==true
+``
 
-This trait can not detect whether `operator>>=` is public or not: if `operator>>=` is defined as a private member of `LHS` then
+This trait can not detect whether binary `operator>>=` is public or not:
+if `operator>>=` is defined as a private member of `LHS` then
 instantiating `has_operator_right_shift_equal<LHS>` will produce a compiler error.
 For this reason `has_operator_right_shift_equal` can not be used to determine whether a type has a public `operator>>=` or not.
 
@@ -26,6 +34,7 @@
 
 __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`.]
@@ -40,4 +49,3 @@
 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	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -15,10 +15,17 @@
 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-`.
+The default behaviour (`RET=void`) is to not check for the return value of prefix `operator-`.
 If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+RHS rhs;
+f(-rhs); // is valid if has_operator_unary_minus<RHS, RET>::value==true
+``
 
-This trait can not detect whether `operator-` is public or not: if `operator-` is defined as a private member of `RHS` then
+This trait can not detect whether prefix `operator-` is public or not:
+if `operator-` is defined as a private member of `RHS` then
 instantiating `has_operator_unary_minus<RHS>` will produce a compiler error.
 For this reason `has_operator_unary_minus` can not be used to determine whether a type has a public `operator-` or not.
 
@@ -26,6 +33,7 @@
 
 __examples
 
+
 [:`has_operator_unary_minus<RHS, RET>::value_type` is the type `bool`.]
 
 [:`has_operator_unary_minus<int>` inherits from `__true_type`.]
@@ -44,4 +52,3 @@
 expression that evaluates to /true/.]
 
 [endsect]
-

Modified: sandbox/type_traits/libs/type_traits/doc/has_operator_unary_plus.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_unary_plus.qbk	(original)
+++ sandbox/type_traits/libs/type_traits/doc/has_operator_unary_plus.qbk	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -15,10 +15,17 @@
 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+`.
+The default behaviour (`RET=void`) is to not check for the return value of prefix `operator+`.
 If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
+Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+RHS rhs;
+f(+rhs); // is valid if has_operator_unary_plus<RHS, RET>::value==true
+``
 
-This trait can not detect whether `operator+` is public or not: if `operator+` is defined as a private member of `RHS` then
+This trait can not detect whether prefix `operator+` is public or not:
+if `operator+` is defined as a private member of `RHS` then
 instantiating `has_operator_unary_plus<RHS>` will produce a compiler error.
 For this reason `has_operator_unary_plus` can not be used to determine whether a type has a public `operator+` or not.
 
@@ -26,6 +33,7 @@
 
 __examples
 
+
 [:`has_operator_unary_plus<RHS, RET>::value_type` is the type `bool`.]
 
 [:`has_operator_unary_plus<int>` inherits from `__true_type`.]
@@ -44,4 +52,3 @@
 expression that evaluates to /true/.]
 
 [endsect]
-

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/background.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/background.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/background.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -49,7 +49,7 @@
       method available to them.
     </p>
 <a name="boost_typetraits.background.type_traits"></a><h5>
-<a name="id3143597"></a>
+<a name="id3171587"></a>
       <a class="link" href="background.html#boost_typetraits.background.type_traits">Type Traits</a>
     </h5>
 <p>
@@ -77,7 +77,7 @@
       given.
     </p>
 <a name="boost_typetraits.background.implementation"></a><h5>
-<a name="id3142642"></a>
+<a name="id3170631"></a>
       <a class="link" href="background.html#boost_typetraits.background.implementation">Implementation</a>
     </h5>
 <p>
@@ -167,7 +167,7 @@
       in the default template.
     </p>
 <a name="boost_typetraits.background.optimized_copy"></a><h5>
-<a name="id3194126"></a>
+<a name="id3222116"></a>
       <a class="link" href="background.html#boost_typetraits.background.optimized_copy">Optimized copy</a>
     </h5>
 <p>
@@ -240,7 +240,7 @@
       otherwise it will call the "slow but safe version".
     </p>
 <a name="boost_typetraits.background.was_it_worth_it_"></a><h5>
-<a name="id3194589"></a>
+<a name="id3222578"></a>
       <a class="link" href="background.html#boost_typetraits.background.was_it_worth_it_">Was it worth it?</a>
     </h5>
 <p>
@@ -273,7 +273,7 @@
         </li>
 </ul></div>
 <div class="table">
-<a name="id3194657"></a><p class="title"><b>Table&#160;1.1.&#160;Time taken to copy 1000 elements using `copy&lt;const T*, T*&gt;` (times
+<a name="id3222646"></a><p class="title"><b>Table&#160;1.1.&#160;Time taken to copy 1000 elements using `copy&lt;const T*, T*&gt;` (times
       in micro-seconds)</b></p>
 <div class="table-contents"><table class="table" summary="Time taken to copy 1000 elements using `copy&lt;const T*, T*&gt;` (times
       in micro-seconds)">
@@ -372,7 +372,7 @@
 </table></div>
 </div>
 <br class="table-break"><a name="boost_typetraits.background.pair_of_references"></a><h5>
-<a name="id3194809"></a>
+<a name="id3222798"></a>
       <a class="link" href="background.html#boost_typetraits.background.pair_of_references">Pair of References</a>
     </h5>
 <p>
@@ -409,7 +409,7 @@
       to hold non-reference types, references, and constant references:
     </p>
 <div class="table">
-<a name="id3195116"></a><p class="title"><b>Table&#160;1.2.&#160;Required Constructor Argument Types</b></p>
+<a name="id3223105"></a><p class="title"><b>Table&#160;1.2.&#160;Required Constructor Argument Types</b></p>
 <div class="table-contents"><table class="table" summary="Required Constructor Argument Types">
 <colgroup>
 <col>
@@ -474,7 +474,7 @@
       adds a reference to its type, unless it is already a reference.
     </p>
 <div class="table">
-<a name="id3195232"></a><p class="title"><b>Table&#160;1.3.&#160;Using add_reference to synthesize the correct constructor type</b></p>
+<a name="id3223222"></a><p class="title"><b>Table&#160;1.3.&#160;Using add_reference to synthesize the correct constructor type</b></p>
 <div class="table-contents"><table class="table" summary="Using add_reference to synthesize the correct constructor type">
 <colgroup>
 <col>
@@ -590,7 +590,7 @@
       easier to maintain and easier to understand.
     </p>
 <a name="boost_typetraits.background.conclusion"></a><h5>
-<a name="id3195764"></a>
+<a name="id3223753"></a>
       <a class="link" href="background.html#boost_typetraits.background.conclusion">Conclusion</a>
     </h5>
 <p>
@@ -603,7 +603,7 @@
       can be optimal as well as generic.
     </p>
 <a name="boost_typetraits.background.acknowledgements"></a><h5>
-<a name="id3195796"></a>
+<a name="id3223785"></a>
       <a class="link" href="background.html#boost_typetraits.background.acknowledgements">Acknowledgements</a>
     </h5>
 <p>
@@ -611,7 +611,7 @@
       comments when preparing this article.
     </p>
 <a name="background.references"></a><a name="boost_typetraits.background.references"></a><h5>
-<a name="id3195822"></a>
+<a name="id3223812"></a>
       <a class="link" href="background.html#boost_typetraits.background.references">References</a>
     </h5>
 <div class="orderedlist"><ol class="orderedlist" type="1">

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/transform.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/transform.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/transform.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -90,7 +90,7 @@
 <span class="keyword">struct</span> <a class="link" href="../reference/remove_volatile.html" title="remove_volatile">remove_volatile</a><span class="special">;</span>
 </pre>
 <a name="boost_typetraits.category.transform.broken_compiler_workarounds_"></a><h5>
-<a name="id3206392"></a>
+<a name="id3234687"></a>
         <a class="link" href="transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">Broken
         Compiler Workarounds:</a>
       </h5>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/value_traits/operators.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/value_traits/operators.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/value_traits/operators.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -21,7 +21,7 @@
         Operator Type Traits</a>
 </h4></div></div></div>
 <a name="boost_typetraits.category.value_traits.operators.introduction"></a><h6>
-<a name="id3198436"></a>
+<a name="id3226425"></a>
           <a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.introduction">Introduction</a>
         </h6>
 <p>
@@ -73,12 +73,26 @@
 <li class="listitem">
               <code class="computeroutput"><span class="identifier">RET</span></code> is the type for
               which we want to know if the result of <code class="computeroutput"><span class="keyword">operator</span>
-              <span class="identifier">op</span></code> can be converted to. Note
-              that if <code class="computeroutput"><span class="identifier">RET</span></code> is <code class="computeroutput"><span class="keyword">void</span></code> (default), the return type is not
-              checked.
+              <span class="identifier">op</span></code> can be converted to.
             </li>
 </ul></div>
 <p>
+          The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
+          to not check for the return value of the operator. If <code class="computeroutput"><span class="identifier">RET</span></code>
+          is different from the default <code class="computeroutput"><span class="keyword">void</span></code>,
+          the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+          Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+          that the return value can be used as argument to a function expecting
+          <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">LHS</span> <span class="identifier">lhs</span><span class="special">;</span>
+<span class="identifier">RHS</span> <span class="identifier">rhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">+</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_operator_plus&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
+        </p>
+<p>
           Similarly, the syntax for postfix and prefix operators is the following:
           
 </p>
@@ -92,7 +106,7 @@
           operators.
         </p>
 <div class="table">
-<a name="id3199113"></a><p class="title"><b>Table&#160;1.4.&#160;Supported binary operators</b></p>
+<a name="id3227241"></a><p class="title"><b>Table&#160;1.4.&#160;Supported binary operators</b></p>
 <div class="table-contents"><table class="table" summary="Supported binary operators">
 <colgroup>
 <col>
@@ -144,27 +158,28 @@
 <tr>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="special">&gt;</span></code>
+                    <code class="computeroutput"><span class="special">&lt;</span></code>
                   </p>
                 </td>
 <td>
                   <p>
-                    <a class="link" href="../../reference/has_operator_greater.html" title="has_operator_greater"><code class="computeroutput"><span class="identifier">has_operator_greater</span> <code class="computeroutput"><span class="special">&lt;</span> <span class="keyword">class</span>
-                    <span class="identifier">LHS</span><span class="special">,</span>
-                    <span class="keyword">class</span> <span class="identifier">RHS</span><span class="special">=</span><span class="identifier">LHS</span><span class="special">,</span> <span class="keyword">class</span>
-                    <span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span> <span class="special">&gt;</span></code></code></a>
+                    <a class="link" href="../../reference/has_operator_less.html" title="has_operator_less"><code class="computeroutput"><span class="identifier">has_operator_less</span> <code class="computeroutput"><span class="special">&lt;</span>
+                    <span class="keyword">class</span> <span class="identifier">LHS</span><span class="special">,</span> <span class="keyword">class</span>
+                    <span class="identifier">RHS</span><span class="special">=</span><span class="identifier">LHS</span><span class="special">,</span>
+                    <span class="keyword">class</span> <span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span>
+                    <span class="special">&gt;</span></code></code></a>
                   </p>
                 </td>
 </tr>
 <tr>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="special">&gt;=</span></code>
+                    <code class="computeroutput"><span class="special">&lt;=</span></code>
                   </p>
                 </td>
 <td>
                   <p>
-                    <a class="link" href="../../reference/has_operator_greater_equal.html" title="has_operator_greater_equal"><code class="computeroutput"><span class="identifier">has_operator_greater_equal</span> <code class="computeroutput"><span class="special">&lt;</span> <span class="keyword">class</span>
+                    <a class="link" href="../../reference/has_operator_less_equal.html" title="has_operator_less_equal"><code class="computeroutput"><span class="identifier">has_operator_less_equal</span> <code class="computeroutput"><span class="special">&lt;</span> <span class="keyword">class</span>
                     <span class="identifier">LHS</span><span class="special">,</span>
                     <span class="keyword">class</span> <span class="identifier">RHS</span><span class="special">=</span><span class="identifier">LHS</span><span class="special">,</span> <span class="keyword">class</span>
                     <span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span> <span class="special">&gt;</span></code></code></a>
@@ -174,28 +189,27 @@
 <tr>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="special">&lt;</span></code>
+                    <code class="computeroutput"><span class="special">&gt;</span></code>
                   </p>
                 </td>
 <td>
                   <p>
-                    <a class="link" href="../../reference/has_operator_less.html" title="has_operator_less"><code class="computeroutput"><span class="identifier">has_operator_less</span> <code class="computeroutput"><span class="special">&lt;</span>
-                    <span class="keyword">class</span> <span class="identifier">LHS</span><span class="special">,</span> <span class="keyword">class</span>
-                    <span class="identifier">RHS</span><span class="special">=</span><span class="identifier">LHS</span><span class="special">,</span>
-                    <span class="keyword">class</span> <span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span>
-                    <span class="special">&gt;</span></code></code></a>
+                    <a class="link" href="../../reference/has_operator_greater.html" title="has_operator_greater"><code class="computeroutput"><span class="identifier">has_operator_greater</span> <code class="computeroutput"><span class="special">&lt;</span> <span class="keyword">class</span>
+                    <span class="identifier">LHS</span><span class="special">,</span>
+                    <span class="keyword">class</span> <span class="identifier">RHS</span><span class="special">=</span><span class="identifier">LHS</span><span class="special">,</span> <span class="keyword">class</span>
+                    <span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span> <span class="special">&gt;</span></code></code></a>
                   </p>
                 </td>
 </tr>
 <tr>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="special">&lt;=</span></code>
+                    <code class="computeroutput"><span class="special">&gt;=</span></code>
                   </p>
                 </td>
 <td>
                   <p>
-                    <a class="link" href="../../reference/has_operator_less_equal.html" title="has_operator_less_equal"><code class="computeroutput"><span class="identifier">has_operator_less_equal</span> <code class="computeroutput"><span class="special">&lt;</span> <span class="keyword">class</span>
+                    <a class="link" href="../../reference/has_operator_greater_equal.html" title="has_operator_greater_equal"><code class="computeroutput"><span class="identifier">has_operator_greater_equal</span> <code class="computeroutput"><span class="special">&lt;</span> <span class="keyword">class</span>
                     <span class="identifier">LHS</span><span class="special">,</span>
                     <span class="keyword">class</span> <span class="identifier">RHS</span><span class="special">=</span><span class="identifier">LHS</span><span class="special">,</span> <span class="keyword">class</span>
                     <span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span> <span class="special">&gt;</span></code></code></a>
@@ -538,7 +552,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="id3202188"></a><p class="title"><b>Table&#160;1.5.&#160;Supported prefix operators</b></p>
+<a name="id3230316"></a><p class="title"><b>Table&#160;1.5.&#160;Supported prefix operators</b></p>
 <div class="table-contents"><table class="table" summary="Supported prefix operators">
 <colgroup>
 <col>
@@ -560,12 +574,12 @@
 <tr>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="special">+</span></code>
+                    <code class="computeroutput"><span class="special">++</span></code>
                   </p>
                 </td>
 <td>
                   <p>
-                    <a class="link" href="../../reference/has_operator_unary_plus.html" title="has_operator_unary_plus"><code class="computeroutput"><span class="identifier">has_operator_unary_plus</span> <code class="computeroutput"><span class="special">&lt;</span> <span class="keyword">class</span>
+                    <a class="link" href="../../reference/has_operator_prefix_increment.html" title="has_operator_prefix_increment"><code class="computeroutput"><span class="identifier">has_operator_prefix_increment</span> <code class="computeroutput"><span class="special">&lt;</span> <span class="keyword">class</span>
                     <span class="identifier">RHS</span><span class="special">,</span>
                     <span class="keyword">class</span> <span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span>
                     <span class="special">&gt;</span></code></code></a>
@@ -575,12 +589,12 @@
 <tr>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="special">-</span></code>
+                    <code class="computeroutput"><span class="special">--</span></code>
                   </p>
                 </td>
 <td>
                   <p>
-                    <a class="link" href="../../reference/has_operator_unary_minus.html" title="has_operator_unary_minus"><code class="computeroutput"><span class="identifier">has_operator_unary_minus</span> <code class="computeroutput"><span class="special">&lt;</span> <span class="keyword">class</span>
+                    <a class="link" href="../../reference/has_operator_prefix_decrement.html" title="has_operator_prefix_decrement"><code class="computeroutput"><span class="identifier">has_operator_prefix_decrement</span> <code class="computeroutput"><span class="special">&lt;</span> <span class="keyword">class</span>
                     <span class="identifier">RHS</span><span class="special">,</span>
                     <span class="keyword">class</span> <span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span>
                     <span class="special">&gt;</span></code></code></a>
@@ -590,12 +604,12 @@
 <tr>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="special">!</span></code>
+                    <code class="computeroutput"><span class="special">+</span></code>
                   </p>
                 </td>
 <td>
                   <p>
-                    <a class="link" href="../../reference/has_operator_logical_not.html" title="has_operator_logical_not"><code class="computeroutput"><span class="identifier">has_operator_logical_not</span> <code class="computeroutput"><span class="special">&lt;</span> <span class="keyword">class</span>
+                    <a class="link" href="../../reference/has_operator_unary_plus.html" title="has_operator_unary_plus"><code class="computeroutput"><span class="identifier">has_operator_unary_plus</span> <code class="computeroutput"><span class="special">&lt;</span> <span class="keyword">class</span>
                     <span class="identifier">RHS</span><span class="special">,</span>
                     <span class="keyword">class</span> <span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span>
                     <span class="special">&gt;</span></code></code></a>
@@ -605,12 +619,12 @@
 <tr>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="special">~</span></code>
+                    <code class="computeroutput"><span class="special">-</span></code>
                   </p>
                 </td>
 <td>
                   <p>
-                    <a class="link" href="../../reference/has_operator_complement.html" title="has_operator_complement"><code class="computeroutput"><span class="identifier">has_operator_complement</span> <code class="computeroutput"><span class="special">&lt;</span> <span class="keyword">class</span>
+                    <a class="link" href="../../reference/has_operator_unary_minus.html" title="has_operator_unary_minus"><code class="computeroutput"><span class="identifier">has_operator_unary_minus</span> <code class="computeroutput"><span class="special">&lt;</span> <span class="keyword">class</span>
                     <span class="identifier">RHS</span><span class="special">,</span>
                     <span class="keyword">class</span> <span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span>
                     <span class="special">&gt;</span></code></code></a>
@@ -620,12 +634,12 @@
 <tr>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="special">--</span></code>
+                    <code class="computeroutput"><span class="special">!</span></code>
                   </p>
                 </td>
 <td>
                   <p>
-                    <a class="link" href="../../reference/has_operator_prefix_decrement.html" title="has_operator_prefix_decrement"><code class="computeroutput"><span class="identifier">has_operator_prefix_decrement</span> <code class="computeroutput"><span class="special">&lt;</span> <span class="keyword">class</span>
+                    <a class="link" href="../../reference/has_operator_logical_not.html" title="has_operator_logical_not"><code class="computeroutput"><span class="identifier">has_operator_logical_not</span> <code class="computeroutput"><span class="special">&lt;</span> <span class="keyword">class</span>
                     <span class="identifier">RHS</span><span class="special">,</span>
                     <span class="keyword">class</span> <span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span>
                     <span class="special">&gt;</span></code></code></a>
@@ -635,12 +649,27 @@
 <tr>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="special">++</span></code>
+                    <code class="computeroutput"><span class="special">~</span></code>
                   </p>
                 </td>
 <td>
                   <p>
-                    <a class="link" href="../../reference/has_operator_prefix_increment.html" title="has_operator_prefix_increment"><code class="computeroutput"><span class="identifier">has_operator_prefix_increment</span> <code class="computeroutput"><span class="special">&lt;</span> <span class="keyword">class</span>
+                    <a class="link" href="../../reference/has_operator_complement.html" title="has_operator_complement"><code class="computeroutput"><span class="identifier">has_operator_complement</span> <code class="computeroutput"><span class="special">&lt;</span> <span class="keyword">class</span>
+                    <span class="identifier">RHS</span><span class="special">,</span>
+                    <span class="keyword">class</span> <span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span>
+                    <span class="special">&gt;</span></code></code></a>
+                  </p>
+                </td>
+</tr>
+<tr>
+<td>
+                  <p>
+                    <code class="computeroutput"><span class="special">*</span></code>
+                  </p>
+                </td>
+<td>
+                  <p>
+                    <a class="link" href="../../reference/has_operator_dereference.html" title="has_operator_dereference"><code class="computeroutput"><span class="identifier">has_operator_dereference</span> <code class="computeroutput"><span class="special">&lt;</span> <span class="keyword">class</span>
                     <span class="identifier">RHS</span><span class="special">,</span>
                     <span class="keyword">class</span> <span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span>
                     <span class="special">&gt;</span></code></code></a>
@@ -651,7 +680,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="id3202740"></a><p class="title"><b>Table&#160;1.6.&#160;Supported postfix operators</b></p>
+<a name="id3230954"></a><p class="title"><b>Table&#160;1.6.&#160;Supported postfix operators</b></p>
 <div class="table-contents"><table class="table" summary="Supported postfix operators">
 <colgroup>
 <col>
@@ -673,12 +702,12 @@
 <tr>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="special">--</span></code>
+                    <code class="computeroutput"><span class="special">++</span></code>
                   </p>
                 </td>
 <td>
                   <p>
-                    <a class="link" href="../../reference/has_operator_postfix_decrement.html" title="has_operator_postfix_decrement"><code class="computeroutput"><span class="identifier">has_operator_postfix_decrement</span> <code class="computeroutput"><span class="special">&lt;</span> <span class="keyword">class</span>
+                    <a class="link" href="../../reference/has_operator_postfix_increment.html" title="has_operator_postfix_increment"><code class="computeroutput"><span class="identifier">has_operator_postfix_increment</span> <code class="computeroutput"><span class="special">&lt;</span> <span class="keyword">class</span>
                     <span class="identifier">LHS</span><span class="special">,</span>
                     <span class="keyword">class</span> <span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span>
                     <span class="special">&gt;</span></code></code></a>
@@ -688,12 +717,12 @@
 <tr>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="special">++</span></code>
+                    <code class="computeroutput"><span class="special">--</span></code>
                   </p>
                 </td>
 <td>
                   <p>
-                    <a class="link" href="../../reference/has_operator_postfix_increment.html" title="has_operator_postfix_increment"><code class="computeroutput"><span class="identifier">has_operator_postfix_increment</span> <code class="computeroutput"><span class="special">&lt;</span> <span class="keyword">class</span>
+                    <a class="link" href="../../reference/has_operator_postfix_decrement.html" title="has_operator_postfix_decrement"><code class="computeroutput"><span class="identifier">has_operator_postfix_decrement</span> <code class="computeroutput"><span class="special">&lt;</span> <span class="keyword">class</span>
                     <span class="identifier">LHS</span><span class="special">,</span>
                     <span class="keyword">class</span> <span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span>
                     <span class="special">&gt;</span></code></code></a>
@@ -710,7 +739,7 @@
           for each operator and the corresponding trait name.
         </p>
 <div class="table">
-<a name="id3202960"></a><p class="title"><b>Table&#160;1.7.&#160;Operator names in the standard</b></p>
+<a name="id3231174"></a><p class="title"><b>Table&#160;1.7.&#160;Operator names in the standard</b></p>
 <div class="table-contents"><table class="table" summary="Operator names in the standard">
 <colgroup>
 <col>
@@ -1123,6 +1152,57 @@
 <tr>
 <td>
                   <p>
+                    <code class="computeroutput"><span class="special">&amp;&amp;</span></code>
+                  </p>
+                </td>
+<td>
+                  <p>
+                    <code class="computeroutput"><span class="keyword">and</span></code>
+                  </p>
+                </td>
+<td>
+                  <p>
+                    <code class="computeroutput"><span class="identifier">logical_and</span></code>
+                  </p>
+                </td>
+<td>
+                  <p>
+                    <a class="link" href="../../reference/has_operator_logical_and.html" title="has_operator_logical_and"><code class="computeroutput"><span class="identifier">has_operator_logical_and</span></code></a>
+                  </p>
+                </td>
+</tr>
+<tr>
+<td>
+                  <p>
+                    <code class="computeroutput"><span class="special">||</span></code>
+                  </p>
+                </td>
+<td>
+                  <p>
+                    <code class="computeroutput"><span class="keyword">or</span></code>
+                  </p>
+                </td>
+<td>
+                  <p>
+                    <code class="computeroutput"><span class="identifier">logical_or</span></code>
+                  </p>
+                </td>
+<td>
+                  <p>
+                    <a class="link" href="../../reference/has_operator_logical_or.html" title="has_operator_logical_or"><code class="computeroutput"><span class="identifier">has_operator_logical_or</span></code></a>
+                  </p>
+                </td>
+</tr>
+<tr>
+<td>
+                </td>
+<td class="auto-generated">&#160;</td>
+<td class="auto-generated">&#160;</td>
+<td class="auto-generated">&#160;</td>
+</tr>
+<tr>
+<td>
+                  <p>
                     <code class="computeroutput"><span class="special">&amp;</span></code>
                   </p>
                 </td>
@@ -1189,12 +1269,12 @@
 <tr>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="special">&amp;=</span></code>
+                    <code class="computeroutput"><span class="special">&lt;&lt;</span></code>
                   </p>
                 </td>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="keyword">and_eq</span></code>
+                    &#248;
                   </p>
                 </td>
 <td>
@@ -1204,19 +1284,19 @@
                 </td>
 <td>
                   <p>
-                    <a class="link" href="../../reference/has_operator_bit_and_equal.html" title="has_operator_bit_and_equal"><code class="computeroutput"><span class="identifier">has_operator_bit_and_equal</span></code></a>
+                    <a class="link" href="../../reference/has_operator_left_shift.html" title="has_operator_left_shift"><code class="computeroutput"><span class="identifier">has_operator_left_shift</span></code></a>
                   </p>
                 </td>
 </tr>
 <tr>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="special">|=</span></code>
+                    <code class="computeroutput"><span class="special">&gt;&gt;</span></code>
                   </p>
                 </td>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="keyword">or_eq</span></code>
+                    &#248;
                   </p>
                 </td>
 <td>
@@ -1226,19 +1306,19 @@
                 </td>
 <td>
                   <p>
-                    <a class="link" href="../../reference/has_operator_bit_or_equal.html" title="has_operator_bit_or_equal"><code class="computeroutput"><span class="identifier">has_operator_bit_or_equal</span></code></a>
+                    <a class="link" href="../../reference/has_operator_right_shift.html" title="has_operator_right_shift"><code class="computeroutput"><span class="identifier">has_operator_right_shift</span></code></a>
                   </p>
                 </td>
 </tr>
 <tr>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="special">^=</span></code>
+                    <code class="computeroutput"><span class="special">&amp;=</span></code>
                   </p>
                 </td>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="keyword">xor_eq</span></code>
+                    <code class="computeroutput"><span class="keyword">and_eq</span></code>
                   </p>
                 </td>
 <td>
@@ -1248,19 +1328,19 @@
                 </td>
 <td>
                   <p>
-                    <a class="link" href="../../reference/has_operator_bit_xor_equal.html" title="has_operator_bit_xor_equal"><code class="computeroutput"><span class="identifier">has_operator_bit_xor_equal</span></code></a>
+                    <a class="link" href="../../reference/has_operator_bit_and_equal.html" title="has_operator_bit_and_equal"><code class="computeroutput"><span class="identifier">has_operator_bit_and_equal</span></code></a>
                   </p>
                 </td>
 </tr>
 <tr>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="special">&lt;&lt;</span></code>
+                    <code class="computeroutput"><span class="special">|=</span></code>
                   </p>
                 </td>
 <td>
                   <p>
-                    &#248;
+                    <code class="computeroutput"><span class="keyword">or_eq</span></code>
                   </p>
                 </td>
 <td>
@@ -1270,19 +1350,19 @@
                 </td>
 <td>
                   <p>
-                    <a class="link" href="../../reference/has_operator_left_shift.html" title="has_operator_left_shift"><code class="computeroutput"><span class="identifier">has_operator_left_shift</span></code></a>
+                    <a class="link" href="../../reference/has_operator_bit_or_equal.html" title="has_operator_bit_or_equal"><code class="computeroutput"><span class="identifier">has_operator_bit_or_equal</span></code></a>
                   </p>
                 </td>
 </tr>
 <tr>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="special">&gt;&gt;</span></code>
+                    <code class="computeroutput"><span class="special">^=</span></code>
                   </p>
                 </td>
 <td>
                   <p>
-                    &#248;
+                    <code class="computeroutput"><span class="keyword">xor_eq</span></code>
                   </p>
                 </td>
 <td>
@@ -1292,7 +1372,7 @@
                 </td>
 <td>
                   <p>
-                    <a class="link" href="../../reference/has_operator_right_shift.html" title="has_operator_right_shift"><code class="computeroutput"><span class="identifier">has_operator_right_shift</span></code></a>
+                    <a class="link" href="../../reference/has_operator_bit_xor_equal.html" title="has_operator_bit_xor_equal"><code class="computeroutput"><span class="identifier">has_operator_bit_xor_equal</span></code></a>
                   </p>
                 </td>
 </tr>
@@ -1342,6 +1422,9 @@
 </tr>
 <tr>
 <td>
+                  <p>
+                    prefix
+                  </p>
                 </td>
 <td class="auto-generated">&#160;</td>
 <td class="auto-generated">&#160;</td>
@@ -1350,56 +1433,46 @@
 <tr>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="special">&amp;&amp;</span></code>
+                    <code class="computeroutput"><span class="special">++</span></code>
                   </p>
                 </td>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="keyword">and</span></code>
+                    &#248;
                   </p>
                 </td>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="identifier">logical_and</span></code>
+                    <code class="computeroutput"><span class="identifier">advance</span></code>
                   </p>
                 </td>
 <td>
                   <p>
-                    <a class="link" href="../../reference/has_operator_logical_and.html" title="has_operator_logical_and"><code class="computeroutput"><span class="identifier">has_operator_logical_and</span></code></a>
+                    <a class="link" href="../../reference/has_operator_prefix_increment.html" title="has_operator_prefix_increment"><code class="computeroutput"><span class="identifier">has_operator_prefix_increment</span></code></a>
                   </p>
                 </td>
 </tr>
 <tr>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="special">||</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <code class="computeroutput"><span class="keyword">or</span></code>
+                    <code class="computeroutput"><span class="special">--</span></code>
                   </p>
                 </td>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="identifier">logical_or</span></code>
+                    &#248;
                   </p>
                 </td>
 <td>
                   <p>
-                    <a class="link" href="../../reference/has_operator_logical_or.html" title="has_operator_logical_or"><code class="computeroutput"><span class="identifier">has_operator_logical_or</span></code></a>
+                    &#248;
                   </p>
                 </td>
-</tr>
-<tr>
 <td>
                   <p>
-                    prefix
+                    <a class="link" href="../../reference/has_operator_prefix_decrement.html" title="has_operator_prefix_decrement"><code class="computeroutput"><span class="identifier">has_operator_prefix_decrement</span></code></a>
                   </p>
                 </td>
-<td class="auto-generated">&#160;</td>
-<td class="auto-generated">&#160;</td>
-<td class="auto-generated">&#160;</td>
 </tr>
 <tr>
 <td>
@@ -1448,28 +1521,6 @@
 <tr>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="special">~</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <code class="computeroutput"><span class="keyword">compl</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    &#248;
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <a class="link" href="../../reference/has_operator_complement.html" title="has_operator_complement"><code class="computeroutput"><span class="identifier">has_operator_complement</span></code></a>
-                  </p>
-                </td>
-</tr>
-<tr>
-<td>
-                  <p>
                     <code class="computeroutput"><span class="special">!</span></code>
                   </p>
                 </td>
@@ -1492,29 +1543,29 @@
 <tr>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="special">++</span></code>
+                    <code class="computeroutput"><span class="special">~</span></code>
                   </p>
                 </td>
 <td>
                   <p>
-                    &#248;
+                    <code class="computeroutput"><span class="keyword">compl</span></code>
                   </p>
                 </td>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="identifier">advance</span></code>
+                    &#248;
                   </p>
                 </td>
 <td>
                   <p>
-                    <a class="link" href="../../reference/has_operator_prefix_increment.html" title="has_operator_prefix_increment"><code class="computeroutput"><span class="identifier">has_operator_prefix_increment</span></code></a>
+                    <a class="link" href="../../reference/has_operator_complement.html" title="has_operator_complement"><code class="computeroutput"><span class="identifier">has_operator_complement</span></code></a>
                   </p>
                 </td>
 </tr>
 <tr>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="special">--</span></code>
+                    <code class="computeroutput"><span class="special">*</span></code>
                   </p>
                 </td>
 <td>
@@ -1529,7 +1580,7 @@
                 </td>
 <td>
                   <p>
-                    <a class="link" href="../../reference/has_operator_prefix_decrement.html" title="has_operator_prefix_decrement"><code class="computeroutput"><span class="identifier">has_operator_prefix_decrement</span></code></a>
+                    <a class="link" href="../../reference/has_operator_dereference.html" title="has_operator_dereference"><code class="computeroutput"><span class="identifier">has_operator_dereference</span></code></a>
                   </p>
                 </td>
 </tr>
@@ -1591,7 +1642,7 @@
 </table></div>
 </div>
 <br class="table-break"><a name="boost_typetraits.category.value_traits.operators.implementation"></a><h6>
-<a name="id3205404"></a>
+<a name="id3233700"></a>
           <a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.implementation">Implementation</a>
         </h6>
 </div>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/intrinsics.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/intrinsics.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/intrinsics.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -92,7 +92,7 @@
       of the following macros:
     </p>
 <div class="table">
-<a name="id3208484"></a><p class="title"><b>Table&#160;1.8.&#160;Macros for Compiler Intrinsics</b></p>
+<a name="id3236767"></a><p class="title"><b>Table&#160;1.8.&#160;Macros for Compiler Intrinsics</b></p>
 <div class="table-contents"><table class="table" summary="Macros for Compiler Intrinsics">
 <colgroup>
 <col>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference.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	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -49,6 +49,8 @@
       has_operator_bit_xor_equal</a></span></dt>
 <dt><span class="section"><a href="reference/has_operator_complement.html">
       has_operator_complement</a></span></dt>
+<dt><span class="section"><a href="reference/has_operator_dereference.html">
+      has_operator_dereference</a></span></dt>
 <dt><span class="section"> has_operator_divides</span></dt>
 <dt><span class="section"><a href="reference/has_operator_divides_equal.html">
       has_operator_divides_equal</a></span></dt>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_const.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_const.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_const.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -46,7 +46,7 @@
         or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <div class="table">
-<a name="id3213283"></a><p class="title"><b>Table&#160;1.9.&#160;Examples</b></p>
+<a name="id3241567"></a><p class="title"><b>Table&#160;1.9.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_cv.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_cv.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_cv.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -47,7 +47,7 @@
         or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <div class="table">
-<a name="id3213867"></a><p class="title"><b>Table&#160;1.10.&#160;Examples</b></p>
+<a name="id3242150"></a><p class="title"><b>Table&#160;1.10.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_pointer.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_pointer.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_pointer.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -49,7 +49,7 @@
         or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <div class="table">
-<a name="id3214519"></a><p class="title"><b>Table&#160;1.11.&#160;Examples</b></p>
+<a name="id3242803"></a><p class="title"><b>Table&#160;1.11.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_reference.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_reference.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_reference.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -46,7 +46,7 @@
         or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <div class="table">
-<a name="id3215105"></a><p class="title"><b>Table&#160;1.12.&#160;Examples</b></p>
+<a name="id3243389"></a><p class="title"><b>Table&#160;1.12.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_volatile.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_volatile.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_volatile.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -46,7 +46,7 @@
         or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <div class="table">
-<a name="id3215682"></a><p class="title"><b>Table&#160;1.13.&#160;Examples</b></p>
+<a name="id3243966"></a><p class="title"><b>Table&#160;1.13.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/decay.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/decay.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/decay.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -41,7 +41,7 @@
         or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <div class="table">
-<a name="id3217180"></a><p class="title"><b>Table&#160;1.14.&#160;Examples</b></p>
+<a name="id3245464"></a><p class="title"><b>Table&#160;1.14.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/floating_point_promotion.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/floating_point_promotion.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/floating_point_promotion.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -42,7 +42,7 @@
         or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <div class="table">
-<a name="id3218789"></a><p class="title"><b>Table&#160;1.15.&#160;Examples</b></p>
+<a name="id3247074"></a><p class="title"><b>Table&#160;1.15.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/function_traits.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/function_traits.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/function_traits.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -52,7 +52,7 @@
         </p></td></tr>
 </table></div>
 <div class="table">
-<a name="id3219235"></a><p class="title"><b>Table&#160;1.16.&#160;Function Traits Members</b></p>
+<a name="id3247518"></a><p class="title"><b>Table&#160;1.16.&#160;Function Traits Members</b></p>
 <div class="table-contents"><table class="table" summary="Function Traits Members">
 <colgroup>
 <col>
@@ -115,7 +115,7 @@
 </table></div>
 </div>
 <br class="table-break"><div class="table">
-<a name="id3219492"></a><p class="title"><b>Table&#160;1.17.&#160;Examples</b></p>
+<a name="id3247776"></a><p class="title"><b>Table&#160;1.17.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_and.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_and.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_and.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -32,12 +32,22 @@
       </p>
 <p>
         The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
-        to not check for the return value of <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
         is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
         type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">LHS</span> <span class="identifier">lhs</span><span class="special">;</span>
+<span class="identifier">RHS</span> <span class="identifier">rhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_operator_bit_and&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
       </p>
 <p>
-        This trait can not detect whether <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_bit_and</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
+        This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_bit_and</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
         reason <code class="computeroutput"><span class="identifier">has_operator_bit_and</span></code>
         can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;</span></code> or not.
       </p>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_and_equal.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_and_equal.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_and_equal.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -33,12 +33,22 @@
       </p>
 <p>
         The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
-        to not check for the return value of <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
         is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
         type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">LHS</span> <span class="identifier">lhs</span><span class="special">;</span>
+<span class="identifier">RHS</span> <span class="identifier">rhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">&amp;=</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_operator_bit_and_equal&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
       </p>
 <p>
-        This trait can not detect whether <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;=</span></code>
+        This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;=</span></code>
         is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code>
         then instantiating <code class="computeroutput"><span class="identifier">has_operator_bit_and_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
         reason <code class="computeroutput"><span class="identifier">has_operator_bit_and_equal</span></code>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_or.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_or.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_or.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -33,12 +33,22 @@
       </p>
 <p>
         The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
-        to not check for the return value of <code class="computeroutput"><span class="keyword">operator</span><span class="special">|</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">|</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
         is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
         type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">LHS</span> <span class="identifier">lhs</span><span class="special">;</span>
+<span class="identifier">RHS</span> <span class="identifier">rhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">|</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_operator_bit_or&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
       </p>
 <p>
-        This trait can not detect whether <code class="computeroutput"><span class="keyword">operator</span><span class="special">|</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">|</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_bit_or</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
+        This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">|</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">|</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_bit_or</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
         reason <code class="computeroutput"><span class="identifier">has_operator_bit_or</span></code>
         can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">|</span></code> or not.
       </p>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_or_equal.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_or_equal.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_or_equal.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -34,12 +34,22 @@
       </p>
 <p>
         The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
-        to not check for the return value of <code class="computeroutput"><span class="keyword">operator</span><span class="special">|=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">|=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
         is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
         type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">LHS</span> <span class="identifier">lhs</span><span class="special">;</span>
+<span class="identifier">RHS</span> <span class="identifier">rhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">|=</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_operator_bit_or_equal&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
       </p>
 <p>
-        This trait can not detect whether <code class="computeroutput"><span class="keyword">operator</span><span class="special">|=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">|=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_bit_or_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
+        This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">|=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">|=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_bit_or_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
         reason <code class="computeroutput"><span class="identifier">has_operator_bit_or_equal</span></code>
         can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">|=</span></code> or not.
       </p>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_xor.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_xor.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_xor.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -33,12 +33,22 @@
       </p>
 <p>
         The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
-        to not check for the return value of <code class="computeroutput"><span class="keyword">operator</span><span class="special">^</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">^</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
         is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
         type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">LHS</span> <span class="identifier">lhs</span><span class="special">;</span>
+<span class="identifier">RHS</span> <span class="identifier">rhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">^</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_operator_bit_xor&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
       </p>
 <p>
-        This trait can not detect whether <code class="computeroutput"><span class="keyword">operator</span><span class="special">^</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">^</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_bit_xor</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
+        This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">^</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">^</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_bit_xor</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
         reason <code class="computeroutput"><span class="identifier">has_operator_bit_xor</span></code>
         can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">^</span></code> or not.
       </p>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_xor_equal.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_xor_equal.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_bit_xor_equal.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -34,12 +34,22 @@
       </p>
 <p>
         The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
-        to not check for the return value of <code class="computeroutput"><span class="keyword">operator</span><span class="special">^=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">^=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
         is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
         type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">LHS</span> <span class="identifier">lhs</span><span class="special">;</span>
+<span class="identifier">RHS</span> <span class="identifier">rhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">^=</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_operator_bit_xor_equal&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
       </p>
 <p>
-        This trait can not detect whether <code class="computeroutput"><span class="keyword">operator</span><span class="special">^=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">^=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_bit_xor_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
+        This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">^=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">^=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_bit_xor_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
         reason <code class="computeroutput"><span class="identifier">has_operator_bit_xor_equal</span></code>
         can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">^=</span></code> or not.
       </p>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_complement.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_complement.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_complement.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -7,13 +7,13 @@
 <link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
 <link rel="up" href="../reference.html" title="Alphabetical Reference">
 <link rel="prev" href="has_operator_bit_xor_equal.html" title="has_operator_bit_xor_equal">
-<link rel="next" href="has_operator_divides.html" title="has_operator_divides">
+<link rel="next" href="has_operator_dereference.html" title="has_operator_dereference">
 </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_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.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_dereference.html"><img src="../../images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
@@ -37,6 +37,15 @@
         to not check for the return value of prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">~</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
         is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
         type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">RHS</span> <span class="identifier">rhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(~</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_operator_complement&lt;RHS, RET&gt;::value==true
+</span></pre>
+<p>
       </p>
 <p>
         This trait can not detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">~</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">~</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_complement</span><span class="special">&lt;</span><span class="identifier">RHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
@@ -96,7 +105,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<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.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_dereference.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_dereference.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_dereference.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -0,0 +1,103 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>has_operator_dereference</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&#160;1.&#160;Boost.TypeTraits">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="has_operator_complement.html" title="has_operator_complement">
+<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_complement.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_dereference"></a><a class="link" href="has_operator_dereference.html" title="has_operator_dereference">
+      has_operator_dereference</a>
+</h3></div></div></div>
+<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">has_operator_dereference</span> <span class="special">:</span> <span class="keyword">public</span> <em class="replaceable"><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></em> <span class="special">{};</span>
+</pre>
+<p>
+        <span class="bold"><strong>Inherits:</strong></span> If (i) <code class="computeroutput"><span class="identifier">rhs</span></code>
+        of type <code class="computeroutput"><span class="identifier">RHS</span></code> can be used in
+        expression <code class="computeroutput"><span class="special">*</span><span class="identifier">rhs</span></code>,
+        and (ii) <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code> or the result of expression <code class="computeroutput"><span class="special">*</span><span class="identifier">rhs</span></code> is
+        convertible to <code class="computeroutput"><span class="identifier">RET</span></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>.
+      </p>
+<p>
+        The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
+        to not check for the return value of prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
+        type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">RHS</span> <span class="identifier">rhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(*</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_operator_dereference&lt;RHS, RET&gt;::value==true
+</span></pre>
+<p>
+      </p>
+<p>
+        This trait can not detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_dereference</span><span class="special">&lt;</span><span class="identifier">RHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
+        reason <code class="computeroutput"><span class="identifier">has_operator_dereference</span></code>
+        can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> or not.
+      </p>
+<p>
+        <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"><span class="preprocessor">#include</span>
+        <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_operator_dereference</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+        or <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+      </p>
+<p>
+        <span class="bold"><strong>Examples:</strong></span>
+      </p>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">has_operator_dereference</span><span class="special">&lt;</span><span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</span><span class="special">&gt;::</span><span class="identifier">value_type</span></code>
+          is the type <code class="computeroutput"><span class="keyword">bool</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">has_operator_dereference</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*&gt;</span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">has_operator_dereference</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">has_operator_dereference</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">const</span> <span class="keyword">int</span><span class="special">&gt;</span></code>
+          inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">has_operator_dereference</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">*,</span> <span class="keyword">int</span><span class="special">&amp;&gt;</span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">false_type</a></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">has_operator_dereference</span><span class="special">&lt;</span><span class="keyword">long</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
+          is a <code class="computeroutput"><span class="keyword">bool</span></code> integral constant
+          expression that evaluates to <span class="emphasis"><em>true</em></span>.
+        </p></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 &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Fr&#233;d&#233;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<p>
+        Distributed under the Boost Software License, Version 1.0. (See accompanying
+        file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="has_operator_complement.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_divides.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_divides.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_divides.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -6,14 +6,14 @@
 <meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
 <link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
 <link rel="up" href="../reference.html" title="Alphabetical Reference">
-<link rel="prev" href="has_operator_complement.html" title="has_operator_complement">
+<link rel="prev" href="has_operator_dereference.html" title="has_operator_dereference">
 <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_complement.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>
+<a accesskey="p" href="has_operator_dereference.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">
@@ -33,12 +33,22 @@
       </p>
 <p>
         The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
-        to not check for the return value of <code class="computeroutput"><span class="keyword">operator</span><span class="special">/</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">/</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
         is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
         type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">LHS</span> <span class="identifier">lhs</span><span class="special">;</span>
+<span class="identifier">RHS</span> <span class="identifier">rhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">/</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_operator_divides&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
       </p>
 <p>
-        This trait can not detect whether <code class="computeroutput"><span class="keyword">operator</span><span class="special">/</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">/</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_divides</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
+        This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">/</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">/</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_divides</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
         reason <code class="computeroutput"><span class="identifier">has_operator_divides</span></code>
         can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">/</span></code> or not.
       </p>
@@ -94,7 +104,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="has_operator_complement.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>
+<a accesskey="p" href="has_operator_dereference.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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_divides_equal.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_divides_equal.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_divides_equal.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -34,12 +34,22 @@
       </p>
 <p>
         The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
-        to not check for the return value of <code class="computeroutput"><span class="keyword">operator</span><span class="special">/=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">/=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
         is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
         type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">LHS</span> <span class="identifier">lhs</span><span class="special">;</span>
+<span class="identifier">RHS</span> <span class="identifier">rhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">/=</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_operator_divides_equal&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
       </p>
 <p>
-        This trait can not detect whether <code class="computeroutput"><span class="keyword">operator</span><span class="special">/=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">/=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_divides_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
+        This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">/=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">/=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_divides_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
         reason <code class="computeroutput"><span class="identifier">has_operator_divides_equal</span></code>
         can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">/=</span></code> or not.
       </p>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_equal_to.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_equal_to.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_equal_to.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -33,12 +33,22 @@
       </p>
 <p>
         The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
-        to not check for the return value of <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
         is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
         type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">LHS</span> <span class="identifier">lhs</span><span class="special">;</span>
+<span class="identifier">RHS</span> <span class="identifier">rhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">==</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_operator_equal_to&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
       </p>
 <p>
-        This trait can not detect whether <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_equal_to</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
+        This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_equal_to</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
         reason <code class="computeroutput"><span class="identifier">has_operator_equal_to</span></code>
         can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code> or not.
       </p>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_greater.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_greater.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_greater.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -32,12 +32,22 @@
       </p>
 <p>
         The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
-        to not check for the return value of <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
         is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
         type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">LHS</span> <span class="identifier">lhs</span><span class="special">;</span>
+<span class="identifier">RHS</span> <span class="identifier">rhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">&gt;</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_operator_greater&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
       </p>
 <p>
-        This trait can not detect whether <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_greater</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
+        This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_greater</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
         reason <code class="computeroutput"><span class="identifier">has_operator_greater</span></code>
         can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;</span></code> or not.
       </p>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_greater_equal.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_greater_equal.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_greater_equal.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -33,12 +33,22 @@
       </p>
 <p>
         The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
-        to not check for the return value of <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
         is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
         type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">LHS</span> <span class="identifier">lhs</span><span class="special">;</span>
+<span class="identifier">RHS</span> <span class="identifier">rhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">&gt;=</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_operator_greater_equal&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
       </p>
 <p>
-        This trait can not detect whether <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_greater_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
+        This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_greater_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
         reason <code class="computeroutput"><span class="identifier">has_operator_greater_equal</span></code>
         can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;=</span></code> or not.
       </p>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_left_shift.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_left_shift.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_left_shift.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -33,12 +33,22 @@
       </p>
 <p>
         The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
-        to not check for the return value of <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
         is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
         type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">LHS</span> <span class="identifier">lhs</span><span class="special">;</span>
+<span class="identifier">RHS</span> <span class="identifier">rhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">&lt;&lt;</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_operator_left_shift&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
       </p>
 <p>
-        This trait can not detect whether <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></code>
+        This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></code>
         is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code>
         then instantiating <code class="computeroutput"><span class="identifier">has_operator_left_shift</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
         reason <code class="computeroutput"><span class="identifier">has_operator_left_shift</span></code>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_left_shift_equal.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_left_shift_equal.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_left_shift_equal.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -33,12 +33,22 @@
       </p>
 <p>
         The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
-        to not check for the return value of <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
         is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
         type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">LHS</span> <span class="identifier">lhs</span><span class="special">;</span>
+<span class="identifier">RHS</span> <span class="identifier">rhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">&lt;&lt;=</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_operator_left_shift_equal&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
       </p>
 <p>
-        This trait can not detect whether <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;=</span></code>
+        This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;=</span></code>
         is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code>
         then instantiating <code class="computeroutput"><span class="identifier">has_operator_left_shift_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
         reason <code class="computeroutput"><span class="identifier">has_operator_left_shift_equal</span></code>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_less.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_less.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_less.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -32,12 +32,22 @@
       </p>
 <p>
         The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
-        to not check for the return value of <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
         is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
         type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">LHS</span> <span class="identifier">lhs</span><span class="special">;</span>
+<span class="identifier">RHS</span> <span class="identifier">rhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">&lt;</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_operator_less&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
       </p>
 <p>
-        This trait can not detect whether <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_less</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
+        This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_less</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
         reason <code class="computeroutput"><span class="identifier">has_operator_less</span></code>
         can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;</span></code> or not.
       </p>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_less_equal.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_less_equal.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_less_equal.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -33,12 +33,22 @@
       </p>
 <p>
         The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
-        to not check for the return value of <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
         is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
         type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">LHS</span> <span class="identifier">lhs</span><span class="special">;</span>
+<span class="identifier">RHS</span> <span class="identifier">rhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">&lt;=</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_operator_less_equal&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
       </p>
 <p>
-        This trait can not detect whether <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_less_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
+        This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_less_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
         reason <code class="computeroutput"><span class="identifier">has_operator_less_equal</span></code>
         can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;=</span></code> or not.
       </p>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_logical_and.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_logical_and.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_logical_and.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -33,12 +33,22 @@
       </p>
 <p>
         The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
-        to not check for the return value of <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;&amp;</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;&amp;</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
         is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
         type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">LHS</span> <span class="identifier">lhs</span><span class="special">;</span>
+<span class="identifier">RHS</span> <span class="identifier">rhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">&amp;&amp;</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_operator_logical_and&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
       </p>
 <p>
-        This trait can not detect whether <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;&amp;</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;&amp;</span></code>
+        This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;&amp;</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;&amp;</span></code>
         is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code>
         then instantiating <code class="computeroutput"><span class="identifier">has_operator_logical_and</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
         reason <code class="computeroutput"><span class="identifier">has_operator_logical_and</span></code>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_logical_not.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_logical_not.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_logical_not.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -34,12 +34,21 @@
       </p>
 <p>
         The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
-        to not check for the return value of <code class="computeroutput"><span class="keyword">operator</span><span class="special">!</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        to not check for the return value of prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">!</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
         is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
         type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">RHS</span> <span class="identifier">rhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(!</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_operator_logical_not&lt;RHS, RET&gt;::value==true
+</span></pre>
+<p>
       </p>
 <p>
-        This trait can not detect whether <code class="computeroutput"><span class="keyword">operator</span><span class="special">!</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">!</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_logical_not</span><span class="special">&lt;</span><span class="identifier">RHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
+        This trait can not detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">!</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">!</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_logical_not</span><span class="special">&lt;</span><span class="identifier">RHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
         reason <code class="computeroutput"><span class="identifier">has_operator_logical_not</span></code>
         can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">!</span></code> or not.
       </p>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_logical_or.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_logical_or.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_logical_or.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -34,12 +34,22 @@
       </p>
 <p>
         The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
-        to not check for the return value of <code class="computeroutput"><span class="keyword">operator</span><span class="special">||</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">||</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
         is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
         type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">LHS</span> <span class="identifier">lhs</span><span class="special">;</span>
+<span class="identifier">RHS</span> <span class="identifier">rhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">||</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_operator_logical_or&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
       </p>
 <p>
-        This trait can not detect whether <code class="computeroutput"><span class="keyword">operator</span><span class="special">||</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">||</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_logical_or</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
+        This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">||</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">||</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_logical_or</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
         reason <code class="computeroutput"><span class="identifier">has_operator_logical_or</span></code>
         can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">||</span></code> or not.
       </p>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_minus.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_minus.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_minus.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -33,12 +33,22 @@
       </p>
 <p>
         The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
-        to not check for the return value of <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
         is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
         type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">LHS</span> <span class="identifier">lhs</span><span class="special">;</span>
+<span class="identifier">RHS</span> <span class="identifier">rhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">-</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_operator_minus&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
       </p>
 <p>
-        This trait can not detect whether <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_minus</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
+        This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_minus</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
         reason <code class="computeroutput"><span class="identifier">has_operator_minus</span></code>
         can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> or not.
       </p>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_minus_equal.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_minus_equal.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_minus_equal.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -34,12 +34,22 @@
       </p>
 <p>
         The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
-        to not check for the return value of <code class="computeroutput"><span class="keyword">operator</span><span class="special">-=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">-=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
         is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
         type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">LHS</span> <span class="identifier">lhs</span><span class="special">;</span>
+<span class="identifier">RHS</span> <span class="identifier">rhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">-=</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_operator_minus_equal&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
       </p>
 <p>
-        This trait can not detect whether <code class="computeroutput"><span class="keyword">operator</span><span class="special">-=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">-=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_minus_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
+        This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">-=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">-=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_minus_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
         reason <code class="computeroutput"><span class="identifier">has_operator_minus_equal</span></code>
         can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">-=</span></code> or not.
       </p>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_modulus.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_modulus.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_modulus.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -33,12 +33,22 @@
       </p>
 <p>
         The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
-        to not check for the return value of <code class="computeroutput"><span class="keyword">operator</span><span class="special">%</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">%</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
         is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
         type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">LHS</span> <span class="identifier">lhs</span><span class="special">;</span>
+<span class="identifier">RHS</span> <span class="identifier">rhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">%</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_operator_modulus&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
       </p>
 <p>
-        This trait can not detect whether <code class="computeroutput"><span class="keyword">operator</span><span class="special">%</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">%</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_modulus</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
+        This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">%</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">%</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_modulus</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
         reason <code class="computeroutput"><span class="identifier">has_operator_modulus</span></code>
         can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">%</span></code> or not.
       </p>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_modulus_equal.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_modulus_equal.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_modulus_equal.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -34,12 +34,22 @@
       </p>
 <p>
         The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
-        to not check for the return value of <code class="computeroutput"><span class="keyword">operator</span><span class="special">%=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">%=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
         is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
         type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">LHS</span> <span class="identifier">lhs</span><span class="special">;</span>
+<span class="identifier">RHS</span> <span class="identifier">rhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">%=</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_operator_modulus_equal&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
       </p>
 <p>
-        This trait can not detect whether <code class="computeroutput"><span class="keyword">operator</span><span class="special">%=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">%=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_modulus_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
+        This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">%=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">%=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_modulus_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
         reason <code class="computeroutput"><span class="identifier">has_operator_modulus_equal</span></code>
         can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">%=</span></code> or not.
       </p>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_multiplies.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_multiplies.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_multiplies.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -34,12 +34,22 @@
       </p>
 <p>
         The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
-        to not check for the return value of <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
         is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
         type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">LHS</span> <span class="identifier">lhs</span><span class="special">;</span>
+<span class="identifier">RHS</span> <span class="identifier">rhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">*</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_operator_multiplies&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
       </p>
 <p>
-        This trait can not detect whether <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_multiplies</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
+        This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_multiplies</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
         reason <code class="computeroutput"><span class="identifier">has_operator_multiplies</span></code>
         can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> or not.
       </p>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_multiplies_equal.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_multiplies_equal.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_multiplies_equal.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -34,12 +34,22 @@
       </p>
 <p>
         The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
-        to not check for the return value of <code class="computeroutput"><span class="keyword">operator</span><span class="special">*=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">*=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
         is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
         type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">LHS</span> <span class="identifier">lhs</span><span class="special">;</span>
+<span class="identifier">RHS</span> <span class="identifier">rhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">*=</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_operator_multiplies_equal&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
       </p>
 <p>
-        This trait can not detect whether <code class="computeroutput"><span class="keyword">operator</span><span class="special">*=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">*=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_multiplies_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
+        This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">*=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">*=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_multiplies_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
         reason <code class="computeroutput"><span class="identifier">has_operator_multiplies_equal</span></code>
         can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">*=</span></code> or not.
       </p>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_not_equal_to.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_not_equal_to.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_not_equal_to.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -34,12 +34,22 @@
       </p>
 <p>
         The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
-        to not check for the return value of <code class="computeroutput"><span class="keyword">operator</span><span class="special">!=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">!=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
         is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
         type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">LHS</span> <span class="identifier">lhs</span><span class="special">;</span>
+<span class="identifier">RHS</span> <span class="identifier">rhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">!=</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_operator_not_equal_to&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
       </p>
 <p>
-        This trait can not detect whether <code class="computeroutput"><span class="keyword">operator</span><span class="special">!=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">!=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_not_equal_to</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
+        This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">!=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">!=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_not_equal_to</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
         reason <code class="computeroutput"><span class="identifier">has_operator_not_equal_to</span></code>
         can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">!=</span></code> or not.
       </p>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_plus.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_plus.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_plus.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -33,12 +33,22 @@
       </p>
 <p>
         The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
-        to not check for the return value of <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
         is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
         type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">LHS</span> <span class="identifier">lhs</span><span class="special">;</span>
+<span class="identifier">RHS</span> <span class="identifier">rhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">+</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_operator_plus&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
       </p>
 <p>
-        This trait can not detect whether <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_plus</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
+        This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_plus</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
         reason <code class="computeroutput"><span class="identifier">has_operator_plus</span></code>
         can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> or not.
       </p>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_plus_equal.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_plus_equal.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_plus_equal.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -34,12 +34,22 @@
       </p>
 <p>
         The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
-        to not check for the return value of <code class="computeroutput"><span class="keyword">operator</span><span class="special">+=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">+=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
         is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
         type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">LHS</span> <span class="identifier">lhs</span><span class="special">;</span>
+<span class="identifier">RHS</span> <span class="identifier">rhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">+=</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_operator_plus_equal&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
       </p>
 <p>
-        This trait can not detect whether <code class="computeroutput"><span class="keyword">operator</span><span class="special">+=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">+=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_plus_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
+        This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">+=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">+=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_plus_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
         reason <code class="computeroutput"><span class="identifier">has_operator_plus_equal</span></code>
         can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">+=</span></code> or not.
       </p>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_postfix_decrement.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_postfix_decrement.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_postfix_decrement.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -37,6 +37,15 @@
         to not check for the return value of postfix <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
         is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
         type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">LHS</span> <span class="identifier">lhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">--);</span> <span class="comment">// is valid if has_operator_postfix_decrement&lt;LHS, RET&gt;::value==true
+</span></pre>
+<p>
       </p>
 <p>
         This trait can not detect whether postfix <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_postfix_decrement</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_postfix_increment.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_postfix_increment.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_postfix_increment.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -37,6 +37,15 @@
         to not check for the return value of postfix <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
         is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
         type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">LHS</span> <span class="identifier">lhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">++);</span> <span class="comment">// is valid if has_operator_postfix_increment&lt;LHS, RET&gt;::value==true
+</span></pre>
+<p>
       </p>
 <p>
         This trait can not detect whether postfix <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_postfix_increment</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_prefix_decrement.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_prefix_decrement.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_prefix_decrement.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -37,6 +37,15 @@
         to not check for the return value of prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
         is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
         type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">RHS</span> <span class="identifier">rhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(--</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_operator_prefix_decrement&lt;RHS, RET&gt;::value==true
+</span></pre>
+<p>
       </p>
 <p>
         This trait can not detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_prefix_decrement</span><span class="special">&lt;</span><span class="identifier">RHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_prefix_increment.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_prefix_increment.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_prefix_increment.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -37,6 +37,15 @@
         to not check for the return value of prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
         is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
         type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">RHS</span> <span class="identifier">rhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(++</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_operator_prefix_increment&lt;RHS, RET&gt;::value==true
+</span></pre>
+<p>
       </p>
 <p>
         This trait can not detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_prefix_increment</span><span class="special">&lt;</span><span class="identifier">RHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_right_shift.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_right_shift.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_right_shift.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -33,12 +33,22 @@
       </p>
 <p>
         The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
-        to not check for the return value of <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;&gt;</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;&gt;</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
         is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
         type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">LHS</span> <span class="identifier">lhs</span><span class="special">;</span>
+<span class="identifier">RHS</span> <span class="identifier">rhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">&gt;&gt;</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_operator_right_shift&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
       </p>
 <p>
-        This trait can not detect whether <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;&gt;</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;&gt;</span></code>
+        This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;&gt;</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;&gt;</span></code>
         is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code>
         then instantiating <code class="computeroutput"><span class="identifier">has_operator_right_shift</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
         reason <code class="computeroutput"><span class="identifier">has_operator_right_shift</span></code>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_right_shift_equal.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_right_shift_equal.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_right_shift_equal.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -33,12 +33,22 @@
       </p>
 <p>
         The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
-        to not check for the return value of <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;&gt;=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;&gt;=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
         is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
         type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">LHS</span> <span class="identifier">lhs</span><span class="special">;</span>
+<span class="identifier">RHS</span> <span class="identifier">rhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">&gt;&gt;=</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_operator_right_shift_equal&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
       </p>
 <p>
-        This trait can not detect whether <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;&gt;=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;&gt;=</span></code>
+        This trait can not detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;&gt;=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;&gt;=</span></code>
         is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code>
         then instantiating <code class="computeroutput"><span class="identifier">has_operator_right_shift_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
         reason <code class="computeroutput"><span class="identifier">has_operator_right_shift_equal</span></code>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_unary_minus.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_unary_minus.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_unary_minus.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -34,12 +34,21 @@
       </p>
 <p>
         The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
-        to not check for the return value of <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        to not check for the return value of prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
         is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
         type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">RHS</span> <span class="identifier">rhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(-</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_operator_unary_minus&lt;RHS, RET&gt;::value==true
+</span></pre>
+<p>
       </p>
 <p>
-        This trait can not detect whether <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_unary_minus</span><span class="special">&lt;</span><span class="identifier">RHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
+        This trait can not detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_unary_minus</span><span class="special">&lt;</span><span class="identifier">RHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
         reason <code class="computeroutput"><span class="identifier">has_operator_unary_minus</span></code>
         can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> or not.
       </p>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_unary_plus.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_unary_plus.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_unary_plus.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -34,12 +34,21 @@
       </p>
 <p>
         The default behaviour (<code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>) is
-        to not check for the return value of <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        to not check for the return value of prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
         is different from the default <code class="computeroutput"><span class="keyword">void</span></code>
         type, the return value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
+        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+        that the return value of the operator can be used as argument to a function
+        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
+</p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
+<span class="identifier">RHS</span> <span class="identifier">rhs</span><span class="special">;</span>
+<span class="identifier">f</span><span class="special">(+</span><span class="identifier">rhs</span><span class="special">);</span> <span class="comment">// is valid if has_operator_unary_plus&lt;RHS, RET&gt;::value==true
+</span></pre>
+<p>
       </p>
 <p>
-        This trait can not detect whether <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_unary_plus</span><span class="special">&lt;</span><span class="identifier">RHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
+        This trait can not detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_unary_plus</span><span class="special">&lt;</span><span class="identifier">RHS</span><span class="special">&gt;</span></code> will produce a compiler error. For this
         reason <code class="computeroutput"><span class="identifier">has_operator_unary_plus</span></code>
         can not be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> or not.
       </p>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/integral_promotion.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/integral_promotion.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/integral_promotion.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -42,7 +42,7 @@
         or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <div class="table">
-<a name="id3259116"></a><p class="title"><b>Table&#160;1.18.&#160;Examples</b></p>
+<a name="id3292365"></a><p class="title"><b>Table&#160;1.18.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/make_signed.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/make_signed.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/make_signed.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -47,7 +47,7 @@
         or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <div class="table">
-<a name="id3277040"></a><p class="title"><b>Table&#160;1.19.&#160;Examples</b></p>
+<a name="id3310292"></a><p class="title"><b>Table&#160;1.19.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/make_unsigned.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/make_unsigned.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/make_unsigned.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -47,7 +47,7 @@
         or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <div class="table">
-<a name="id3277620"></a><p class="title"><b>Table&#160;1.20.&#160;Examples</b></p>
+<a name="id3310873"></a><p class="title"><b>Table&#160;1.20.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/member_object.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/member_object.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/member_object.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -44,7 +44,7 @@
         or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <div class="table">
-<a name="id3278225"></a><p class="title"><b>Table&#160;1.21.&#160;Examples</b></p>
+<a name="id3311477"></a><p class="title"><b>Table&#160;1.21.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/promote.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/promote.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/promote.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -44,7 +44,7 @@
         or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <div class="table">
-<a name="id3278984"></a><p class="title"><b>Table&#160;1.22.&#160;Examples</b></p>
+<a name="id3312237"></a><p class="title"><b>Table&#160;1.22.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_all_extents.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_all_extents.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_all_extents.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -47,7 +47,7 @@
         or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <div class="table">
-<a name="id3280271"></a><p class="title"><b>Table&#160;1.23.&#160;Examples</b></p>
+<a name="id3313524"></a><p class="title"><b>Table&#160;1.23.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_const.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_const.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_const.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -46,7 +46,7 @@
         or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <div class="table">
-<a name="id3280933"></a><p class="title"><b>Table&#160;1.24.&#160;Examples</b></p>
+<a name="id3314186"></a><p class="title"><b>Table&#160;1.24.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_cv.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_cv.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_cv.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -46,7 +46,7 @@
         or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <div class="table">
-<a name="id3281578"></a><p class="title"><b>Table&#160;1.25.&#160;Examples</b></p>
+<a name="id3314831"></a><p class="title"><b>Table&#160;1.25.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_extent.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_extent.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_extent.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -47,7 +47,7 @@
         or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <div class="table">
-<a name="id3282225"></a><p class="title"><b>Table&#160;1.26.&#160;Examples</b></p>
+<a name="id3315478"></a><p class="title"><b>Table&#160;1.26.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_member_pointer.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_member_pointer.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_member_pointer.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -42,7 +42,7 @@
         or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <div class="table">
-<a name="id3283493"></a><p class="title"><b>Table&#160;1.28.&#160;Examples</b></p>
+<a name="id3316746"></a><p class="title"><b>Table&#160;1.28.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_pointer.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_pointer.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_pointer.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -46,7 +46,7 @@
         or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <div class="table">
-<a name="id3282901"></a><p class="title"><b>Table&#160;1.27.&#160;Examples</b></p>
+<a name="id3316154"></a><p class="title"><b>Table&#160;1.27.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_reference.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_reference.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_reference.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -46,7 +46,7 @@
         or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <div class="table">
-<a name="id3284282"></a><p class="title"><b>Table&#160;1.29.&#160;Examples</b></p>
+<a name="id3317536"></a><p class="title"><b>Table&#160;1.29.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_volatile.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_volatile.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_volatile.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -46,7 +46,7 @@
         or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
 <div class="table">
-<a name="id3284838"></a><p class="title"><b>Table&#160;1.30.&#160;Examples</b></p>
+<a name="id3318091"></a><p class="title"><b>Table&#160;1.30.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>

Modified: sandbox/type_traits/libs/type_traits/doc/html/index.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/index.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/index.html	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -24,7 +24,7 @@
       Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven
       Watanabe</p></div>
 <div><div class="legalnotice">
-<a name="id3184015"></a><p>
+<a name="id3212004"></a><p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
       </p>
@@ -103,6 +103,8 @@
       has_operator_bit_xor_equal</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/has_operator_complement.html">
       has_operator_complement</a></span></dt>
+<dt><span class="section"><a href="boost_typetraits/reference/has_operator_dereference.html">
+      has_operator_dereference</a></span></dt>
 <dt><span class="section"> has_operator_divides</span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/has_operator_divides_equal.html">
       has_operator_divides_equal</a></span></dt>

Modified: sandbox/type_traits/libs/type_traits/doc/operators.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/operators.qbk	(original)
+++ sandbox/type_traits/libs/type_traits/doc/operators.qbk	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -40,7 +40,16 @@
 * `LHS` is the type used at the left hand side of `operator op`,
 * `RHS` is the type used at the right hand side of `operator op`,
 * `RET` is the type for which we want to know if the result of `operator op` can be converted to.
-  Note that if `RET` is `void` (default), the return type is not checked.
+
+The default behaviour (`RET=void`) is to not check for the return value of the operator.
+If `RET` is different from the default `void`, the return value is checked to be convertible to `RET`.
+Convertible to `RET` means that the return value can be used as argument to a function expecting `RET`:
+``
+void f(RET);
+LHS lhs;
+RHS rhs;
+f(lhs+rhs); // is valid if has_operator_plus<LHS, RHS, RET>::value==true
+``
 
 Similarly, the syntax for postfix and prefix operators is the following:
 ``
@@ -55,10 +64,10 @@
 
    [[`==`]    [[link boost_typetraits.reference.has_operator_equal_to `has_operator_equal_to __binary_temp`]]]
    [[`!=`]    [[link boost_typetraits.reference.has_operator_not_equal_to `has_operator_not_equal_to __binary_temp`]]]
-   [[`>`]     [[link boost_typetraits.reference.has_operator_greater `has_operator_greater __binary_temp`]]]
-   [[`>=`]    [[link boost_typetraits.reference.has_operator_greater_equal `has_operator_greater_equal __binary_temp`]]]
    [[`<`]     [[link boost_typetraits.reference.has_operator_less `has_operator_less __binary_temp`]]]
    [[`<=`]    [[link boost_typetraits.reference.has_operator_less_equal `has_operator_less_equal __binary_temp`]]]
+   [[`>`]     [[link boost_typetraits.reference.has_operator_greater `has_operator_greater __binary_temp`]]]
+   [[`>=`]    [[link boost_typetraits.reference.has_operator_greater_equal `has_operator_greater_equal __binary_temp`]]]
 
    [[`+`]     [[link boost_typetraits.reference.has_operator_plus `has_operator_plus __binary_temp`]]]
    [[`-`]     [[link boost_typetraits.reference.has_operator_minus `has_operator_minus __binary_temp`]]]
@@ -88,18 +97,19 @@
 
 [table Supported prefix operators
    [[operator]                   [trait name]]
+   [[`++`]   [[link boost_typetraits.reference.has_operator_prefix_increment `has_operator_prefix_increment __prefix_temp`]]]
+   [[`--`]   [[link boost_typetraits.reference.has_operator_prefix_decrement `has_operator_prefix_decrement __prefix_temp`]]]
    [[`+`]   [[link boost_typetraits.reference.has_operator_unary_plus `has_operator_unary_plus __prefix_temp`]]]
    [[`-`]   [[link boost_typetraits.reference.has_operator_unary_minus `has_operator_unary_minus __prefix_temp`]]]
    [[`!`]   [[link boost_typetraits.reference.has_operator_logical_not `has_operator_logical_not __prefix_temp`]]]
    [[`~`]   [[link boost_typetraits.reference.has_operator_complement `has_operator_complement __prefix_temp`]]]
-   [[`--`]   [[link boost_typetraits.reference.has_operator_prefix_decrement `has_operator_prefix_decrement __prefix_temp`]]]
-   [[`++`]   [[link boost_typetraits.reference.has_operator_prefix_increment `has_operator_prefix_increment __prefix_temp`]]]
+   [[`*`]   [[link boost_typetraits.reference.has_operator_dereference `has_operator_dereference __prefix_temp`]]]
 ]
 
 [table Supported postfix operators
    [[operator]                   [trait name]]
-   [[`--`]   [[link boost_typetraits.reference.has_operator_postfix_decrement `has_operator_postfix_decrement __postfix_temp`]]]
    [[`++`]   [[link boost_typetraits.reference.has_operator_postfix_increment `has_operator_postfix_increment __postfix_temp`]]]
+   [[`--`]   [[link boost_typetraits.reference.has_operator_postfix_decrement `has_operator_postfix_decrement __postfix_temp`]]]
 ]
 
 
@@ -127,26 +137,27 @@
 [[`/=`]     [\u00F8]                      [\u00F8]                                     [[link boost_typetraits.reference.has_operator_divides_equal     `has_operator_divides_equal`]]]
 [[`%=`]     [\u00F8]                      [\u00F8]                                     [[link boost_typetraits.reference.has_operator_modulus_equal     `has_operator_modulus_equal`]]]
 [[ ]]
+[[`&&`]     [`and`]                       [`logical_and`]                              [[link boost_typetraits.reference.has_operator_logical_and       `has_operator_logical_and`]]]
+[[`||`]     [`or`]                        [`logical_or`]                               [[link boost_typetraits.reference.has_operator_logical_or        `has_operator_logical_or`]]]
+[[ ]]
 [[`&`]      [`bitand`]                    [`bit_and`]                                  [[link boost_typetraits.reference.has_operator_bit_and           `has_operator_bit_and`]]]
 [[`|`]      [`bitor`]                     [`bit_or`]                                   [[link boost_typetraits.reference.has_operator_bit_or            `has_operator_bit_or`]]]
 [[`^`]      [`xor`]                       [`bit_xor`]                                  [[link boost_typetraits.reference.has_operator_bit_xor           `has_operator_bit_xor`]]]
+[[`<<`]     [\u00F8]                      [\u00F8]                                     [[link boost_typetraits.reference.has_operator_left_shift        `has_operator_left_shift`]]]
+[[`>>`]     [\u00F8]                      [\u00F8]                                     [[link boost_typetraits.reference.has_operator_right_shift       `has_operator_right_shift`]]]
 [[`&=`]     [`and_eq`]                    [\u00F8]                                     [[link boost_typetraits.reference.has_operator_bit_and_equal     `has_operator_bit_and_equal`]]]
 [[`|=`]     [`or_eq`]                     [\u00F8]                                     [[link boost_typetraits.reference.has_operator_bit_or_equal      `has_operator_bit_or_equal`]]]
 [[`^=`]     [`xor_eq`]                    [\u00F8]                                     [[link boost_typetraits.reference.has_operator_bit_xor_equal     `has_operator_bit_xor_equal`]]]
-[[`<<`]     [\u00F8]                      [\u00F8]                                     [[link boost_typetraits.reference.has_operator_left_shift        `has_operator_left_shift`]]]
-[[`>>`]     [\u00F8]                      [\u00F8]                                     [[link boost_typetraits.reference.has_operator_right_shift       `has_operator_right_shift`]]]
 [[`<<=`]    [\u00F8]                      [\u00F8]                                     [[link boost_typetraits.reference.has_operator_left_shift_equal  `has_operator_left_shift_equal`]]]
 [[`>>=`]    [\u00F8]                      [\u00F8]                                     [[link boost_typetraits.reference.has_operator_right_shift_equal `has_operator_right_shift_equal`]]]
-[[ ]]
-[[`&&`]     [`and`]                       [`logical_and`]                              [[link boost_typetraits.reference.has_operator_logical_and       `has_operator_logical_and`]]]
-[[`||`]     [`or`]                        [`logical_or`]                               [[link boost_typetraits.reference.has_operator_logical_or        `has_operator_logical_or`]]]
 [[prefix]]
+[[`++`]     [\u00F8]                      [`advance`]                                  [[link boost_typetraits.reference.has_operator_prefix_increment  `has_operator_prefix_increment`]]]
+[[`--`]     [\u00F8]                      [\u00F8]                                     [[link boost_typetraits.reference.has_operator_prefix_decrement  `has_operator_prefix_decrement`]]]
 [[`+`]      [\u00F8]                      [\u00F8]                                     [[link boost_typetraits.reference.has_operator_unary_plus        `has_operator_unary_plus`]]]
 [[`-`]      [\u00F8]                      [`negate`]                                   [[link boost_typetraits.reference.has_operator_unary_minus       `has_operator_unary_minus`]]]
-[[`~`]      [`compl`]                     [\u00F8]                                     [[link boost_typetraits.reference.has_operator_complement        `has_operator_complement`]]]
 [[`!`]      [`not`]                       [`logical_not`]                              [[link boost_typetraits.reference.has_operator_logical_not       `has_operator_logical_not`]]]
-[[`++`]     [\u00F8]                      [`advance`]                                  [[link boost_typetraits.reference.has_operator_prefix_increment  `has_operator_prefix_increment`]]]
-[[`--`]     [\u00F8]                      [\u00F8]                                     [[link boost_typetraits.reference.has_operator_prefix_decrement  `has_operator_prefix_decrement`]]]
+[[`~`]      [`compl`]                     [\u00F8]                                     [[link boost_typetraits.reference.has_operator_complement        `has_operator_complement`]]]
+[[`*`]      [\u00F8]                      [\u00F8]                                     [[link boost_typetraits.reference.has_operator_dereference       `has_operator_dereference`]]]
 [[postfix]]
 [[`++`]     [\u00F8]                      [`advance`]                                  [[link boost_typetraits.reference.has_operator_postfix_increment `has_operator_postfix_increment`]]]
 [[`--`]     [\u00F8]                      [\u00F8]                                     [[link boost_typetraits.reference.has_operator_postfix_decrement `has_operator_postfix_decrement`]]]

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	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -186,6 +186,7 @@
 [include has_operator_bit_xor.qbk]
 [include has_operator_bit_xor_equal.qbk]
 [include has_operator_complement.qbk]
+[include has_operator_dereference.qbk]
 [include has_operator_divides.qbk]
 [include has_operator_divides_equal.qbk]
 [include has_operator_equal_to.qbk]

Modified: sandbox/type_traits/libs/type_traits/test/has_binary_logical_operator_test.hpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_binary_logical_operator_test.hpp	(original)
+++ sandbox/type_traits/libs/type_traits/test/has_binary_logical_operator_test.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -67,6 +67,7 @@
 
 void run() {
    // test with only one template parameter
+   TEST_T(void, false);
    TEST_T(bool, true);
    TEST_T(char, true);
    TEST_T(signed char, true);
@@ -114,6 +115,9 @@
    TEST_T(CV(double), true);
 
    // test with only two template parameters
+   TEST_TT(void, int, false);
+   TEST_TT(int, void, false);
+   TEST_TT(void, void, false);
    TEST_TT(bool, bool, true);
    TEST_TT(bool, char, true);
    TEST_TT(bool, signed char, true);

Modified: sandbox/type_traits/libs/type_traits/test/has_binary_minus_operator_test.hpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_binary_minus_operator_test.hpp	(original)
+++ sandbox/type_traits/libs/type_traits/test/has_binary_minus_operator_test.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -67,6 +67,7 @@
 
 void run() {
    // test with only one template parameter
+   TEST_T(void, false);
    TEST_T(bool, true);
    TEST_T(char, true);
    TEST_T(signed char, true);
@@ -114,6 +115,9 @@
    TEST_T(CV(double), true);
 
    // test with only two template parameters
+   TEST_TT(void, int, false);
+   TEST_TT(int, void, false);
+   TEST_TT(void, void, false);
    TEST_TT(bool, bool, true);
    TEST_TT(bool, char, true);
    TEST_TT(bool, signed char, true);

Modified: sandbox/type_traits/libs/type_traits/test/has_binary_plus_operator_test.hpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_binary_plus_operator_test.hpp	(original)
+++ sandbox/type_traits/libs/type_traits/test/has_binary_plus_operator_test.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -67,6 +67,7 @@
 
 void run() {
    // test with only one template parameter
+   TEST_T(void, false);
    TEST_T(bool, true);
    TEST_T(char, true);
    TEST_T(signed char, true);
@@ -114,6 +115,9 @@
    TEST_T(CV(double), true);
 
    // test with only two template parameters
+   TEST_TT(void, int, false);
+   TEST_TT(int, void, false);
+   TEST_TT(void, void, false);
    TEST_TT(bool, bool, true);
    TEST_TT(bool, char, true);
    TEST_TT(bool, signed char, true);

Modified: sandbox/type_traits/libs/type_traits/test/has_comparison_operator_test.hpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_comparison_operator_test.hpp	(original)
+++ sandbox/type_traits/libs/type_traits/test/has_comparison_operator_test.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -67,6 +67,7 @@
 
 void run() {
    // test with only one template parameter
+   TEST_T(void, false);
    TEST_T(bool, true);
    TEST_T(char, true);
    TEST_T(signed char, true);
@@ -114,6 +115,9 @@
    TEST_T(CV(double), true);
 
    // test with only two template parameters
+   TEST_TT(void, int, false);
+   TEST_TT(int, void, false);
+   TEST_TT(void, void, false);
    TEST_TT(bool, bool, true);
    TEST_TT(bool, char, true);
    TEST_TT(bool, signed char, true);

Added: sandbox/type_traits/libs/type_traits/test/has_dereference_operator_test.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/has_dereference_operator_test.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -0,0 +1,187 @@
+//  (C) Copyright Frederic Bron 2009-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 <iostream>
+#include <typeinfo>
+#include <string>
+
+// test with one template parameter
+#define TEST_T(TYPE,RESULT) BOOST_CHECK_INTEGRAL_CONSTANT((::tt::BOOST_TT_TRAIT_NAME<TYPE>::value), RESULT)
+// test with one template parameter plus return value
+#define TEST_TR(TYPE,RET,RESULT) BOOST_CHECK_INTEGRAL_CONSTANT((::tt::BOOST_TT_TRAIT_NAME<TYPE,RET>::value), RESULT)
+
+namespace {
+
+struct ret { };
+
+struct without { };
+
+struct internal { ret operator BOOST_TT_TRAIT_OP () const; };
+
+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 (); };
+
+struct returns_void_star { void *operator BOOST_TT_TRAIT_OP (); };
+
+struct returns_double { double operator BOOST_TT_TRAIT_OP (); };
+
+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 (); };
+
+class Base1 { };
+class Derived1 : public Base1 { };
+
+bool operator BOOST_TT_TRAIT_OP (const Base1&) { return true; }
+
+class Base2 { };
+struct Derived2 : public Base2 {
+   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; }
+
+struct tag { };
+
+void run() {
+   // test with only one template parameter
+   TEST_T(void, false);
+   TEST_T(bool, false);
+   TEST_T(char, false);
+   TEST_T(signed char, false);
+   TEST_T(short int, false);
+   TEST_T(int, false);
+   TEST_T(long int, false);
+   TEST_T(unsigned char, false);
+   TEST_T(unsigned short int, false);
+   TEST_T(unsigned int, false);
+   TEST_T(unsigned long int, false);
+   TEST_T(wchar_t, false);
+   TEST_T(float, false);
+   TEST_T(double, false);
+   TEST_T(long double, false);
+   TEST_T(void, false);
+#	undef CV
+#	define CV(T) const T
+   TEST_T(CV(bool), false);
+   TEST_T(CV(int), false);
+   TEST_T(CV(double), false);
+#	undef CV
+#	define CV(T) volatile T
+   TEST_T(CV(bool), false);
+   TEST_T(CV(int), false);
+   TEST_T(CV(double), false);
+#	undef CV
+#	define CV(T) const volatile T
+   TEST_T(CV(bool), false);
+   TEST_T(CV(int), false);
+   TEST_T(CV(double), false);
+#	undef CV
+#	define CV(T) const T&
+   TEST_T(CV(bool), false);
+   TEST_T(CV(int), false);
+   TEST_T(CV(double), false);
+#	undef CV
+#	define CV(T) volatile T&
+   TEST_T(CV(bool), false);
+   TEST_T(CV(int), false);
+   TEST_T(CV(double), false);
+#	undef CV
+#	define CV(T) const volatile T&
+   TEST_T(CV(bool), false);
+   TEST_T(CV(int), false);
+   TEST_T(CV(double), false);
+
+   // test with three template parameters
+   TEST_TR(bool, bool, false);
+   TEST_TR(char, bool, false);
+   TEST_TR(signed char, bool, false);
+   TEST_TR(short int, bool, false);
+   TEST_TR(int, bool, false);
+   TEST_TR(long int, bool, false);
+   TEST_TR(unsigned char, bool, false);
+   TEST_TR(unsigned short int, bool, false);
+   TEST_TR(unsigned int, bool, false);
+   TEST_TR(unsigned long int, bool, false);
+   TEST_TR(wchar_t, bool, false);
+   TEST_TR(float, bool, false);
+   TEST_TR(double, bool, false);
+   TEST_TR(long double, bool, false);
+   TEST_TR(bool, tag, false);
+   TEST_TR(char, tag, false);
+   TEST_TR(signed char, tag, false);
+   TEST_TR(short int, tag, false);
+   TEST_TR(int, tag, false);
+   TEST_TR(long int, tag, false);
+   TEST_TR(unsigned char, tag, false);
+   TEST_TR(unsigned short int, tag, false);
+   TEST_TR(unsigned int, tag, false);
+   TEST_TR(unsigned long int, tag, false);
+   TEST_TR(wchar_t, tag, false);
+   TEST_TR(float, tag, false);
+   TEST_TR(double, tag, false);
+   TEST_TR(long double, tag, false);
+
+   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);
+   // pointers
+   TEST_T(void*, false);
+   TEST_T(bool*, true);
+   TEST_T(char*, true);
+   TEST_T(int*, true);
+   TEST_T(long*, true);
+   TEST_T(wchar_t*, true);
+   TEST_T(double*, true);
+   TEST_T(without*, true);
+   TEST_TR(char*, char, true);
+   TEST_TR(const char*, char, true);
+   TEST_TR(const char*, char&, false);
+   TEST_TR(char*, const char, true);
+}
+}
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run();
+TT_TEST_END

Modified: sandbox/type_traits/libs/type_traits/test/has_integral_no_constlhs_operator_test.hpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_integral_no_constlhs_operator_test.hpp	(original)
+++ sandbox/type_traits/libs/type_traits/test/has_integral_no_constlhs_operator_test.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -67,6 +67,7 @@
 
 void run() {
    // test with only one template parameter
+   TEST_T(void, false);
    TEST_T(bool, true);
    TEST_T(char, true);
    TEST_T(signed char, true);
@@ -114,6 +115,9 @@
    TEST_T(CV(double), false);
 
    // test with only two template parameters
+   TEST_TT(void, int, false);
+   TEST_TT(int, void, false);
+   TEST_TT(void, void, false);
    TEST_TT(bool, bool, true);
    TEST_TT(bool, char, true);
    TEST_TT(bool, signed char, 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	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -67,6 +67,7 @@
 
 void run() {
    // test with only one template parameter
+   TEST_T(void, false);
    TEST_T(bool, true);
    TEST_T(char, true);
    TEST_T(signed char, true);
@@ -114,6 +115,9 @@
    TEST_T(CV(double), false);
 
    // test with only two template parameters
+   TEST_TT(void, int, false);
+   TEST_TT(int, void, false);
+   TEST_TT(void, void, false);
    TEST_TT(bool, bool, true);
    TEST_TT(bool, char, true);
    TEST_TT(bool, signed char, true);

Modified: sandbox/type_traits/libs/type_traits/test/has_minus_equal_operator_test.hpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_minus_equal_operator_test.hpp	(original)
+++ sandbox/type_traits/libs/type_traits/test/has_minus_equal_operator_test.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -67,6 +67,7 @@
 
 void run() {
    // test with only one template parameter
+   TEST_T(void, false);
    TEST_T(bool, true);
    TEST_T(char, true);
    TEST_T(signed char, true);
@@ -114,6 +115,9 @@
    TEST_T(CV(double), false);
 
    // test with only two template parameters
+   TEST_TT(void, int, false);
+   TEST_TT(int, void, false);
+   TEST_TT(void, void, false);
    TEST_TT(bool, bool, true);
    TEST_TT(bool, char, true);
    TEST_TT(bool, signed char, true);

Modified: sandbox/type_traits/libs/type_traits/test/has_no_pointer_no_constlhs_operator_test.hpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_no_pointer_no_constlhs_operator_test.hpp	(original)
+++ sandbox/type_traits/libs/type_traits/test/has_no_pointer_no_constlhs_operator_test.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -67,6 +67,7 @@
 
 void run() {
    // test with only one template parameter
+   TEST_T(void, false);
    TEST_T(bool, true);
    TEST_T(char, true);
    TEST_T(signed char, true);
@@ -114,6 +115,9 @@
    TEST_T(CV(double), false);
 
    // test with only two template parameters
+   TEST_TT(void, int, false);
+   TEST_TT(int, void, false);
+   TEST_TT(void, void, false);
    TEST_TT(bool, bool, true);
    TEST_TT(bool, char, true);
    TEST_TT(bool, signed char, true);

Modified: sandbox/type_traits/libs/type_traits/test/has_no_pointer_operator_test.hpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_no_pointer_operator_test.hpp	(original)
+++ sandbox/type_traits/libs/type_traits/test/has_no_pointer_operator_test.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -67,6 +67,7 @@
 
 void run() {
    // test with only one template parameter
+   TEST_T(void, false);
    TEST_T(bool, true);
    TEST_T(char, true);
    TEST_T(signed char, true);
@@ -114,6 +115,9 @@
    TEST_T(CV(double), true);
 
    // test with only two template parameters
+   TEST_TT(void, int, false);
+   TEST_TT(int, void, false);
+   TEST_TT(void, void, false);
    TEST_TT(bool, bool, true);
    TEST_TT(bool, char, true);
    TEST_TT(bool, signed char, true);

Added: sandbox/type_traits/libs/type_traits/test/has_operator_dereference_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/has_operator_dereference_test.cpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -0,0 +1,18 @@
+//  (C) Copyright 2009-2011 Frédéric Bron (frederic.bron_at_[hidden])
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "test.hpp"
+#include "check_integral_constant.hpp"
+
+#ifdef TEST_STD
+#  include <type_traits>
+#else
+#  include <boost/type_traits/has_operator_dereference.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME has_operator_dereference
+#define BOOST_TT_TRAIT_OP *
+
+#include "has_dereference_operator_test.hpp"

Modified: sandbox/type_traits/libs/type_traits/test/has_plus_equal_operator_test.hpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_plus_equal_operator_test.hpp	(original)
+++ sandbox/type_traits/libs/type_traits/test/has_plus_equal_operator_test.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -67,6 +67,7 @@
 
 void run() {
    // test with only one template parameter
+   TEST_T(void, false);
    TEST_T(bool, true);
    TEST_T(char, true);
    TEST_T(signed char, true);
@@ -114,6 +115,9 @@
    TEST_T(CV(double), false);
 
    // test with only two template parameters
+   TEST_TT(void, int, false);
+   TEST_TT(int, void, false);
+   TEST_TT(void, void, false);
    TEST_TT(bool, bool, true);
    TEST_TT(bool, char, true);
    TEST_TT(bool, signed char, true);

Modified: sandbox/type_traits/libs/type_traits/test/has_postfix_decrement_operator_test.hpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_postfix_decrement_operator_test.hpp	(original)
+++ sandbox/type_traits/libs/type_traits/test/has_postfix_decrement_operator_test.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -54,6 +54,7 @@
 
 void run() {
    // test with only one template parameter
+   TEST_T(void, false);
    TEST_T(bool, false);
    TEST_T(char, true);
    TEST_T(signed char, true);

Modified: sandbox/type_traits/libs/type_traits/test/has_postfix_increment_operator_test.hpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_postfix_increment_operator_test.hpp	(original)
+++ sandbox/type_traits/libs/type_traits/test/has_postfix_increment_operator_test.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -54,6 +54,7 @@
 
 void run() {
    // test with only one template parameter
+   TEST_T(void, false);
    TEST_T(bool, true);
    TEST_T(char, true);
    TEST_T(signed char, true);

Modified: sandbox/type_traits/libs/type_traits/test/has_prefix_complement_operator_test.hpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_prefix_complement_operator_test.hpp	(original)
+++ sandbox/type_traits/libs/type_traits/test/has_prefix_complement_operator_test.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -54,6 +54,7 @@
 
 void run() {
    // test with only one template parameter
+   TEST_T(void, false);
    TEST_T(bool, true);
    TEST_T(char, true);
    TEST_T(signed char, true);

Modified: sandbox/type_traits/libs/type_traits/test/has_prefix_decrement_operator_test.hpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_prefix_decrement_operator_test.hpp	(original)
+++ sandbox/type_traits/libs/type_traits/test/has_prefix_decrement_operator_test.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -54,6 +54,7 @@
 
 void run() {
    // test with only one template parameter
+   TEST_T(void, false);
    TEST_T(bool, false);
    TEST_T(char, true);
    TEST_T(signed char, true);

Modified: sandbox/type_traits/libs/type_traits/test/has_prefix_increment_operator_test.hpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_prefix_increment_operator_test.hpp	(original)
+++ sandbox/type_traits/libs/type_traits/test/has_prefix_increment_operator_test.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -54,6 +54,7 @@
 
 void run() {
    // test with only one template parameter
+   TEST_T(void, false);
    TEST_T(bool, true);
    TEST_T(char, true);
    TEST_T(signed char, true);

Modified: sandbox/type_traits/libs/type_traits/test/has_prefix_minus_operator_test.hpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_prefix_minus_operator_test.hpp	(original)
+++ sandbox/type_traits/libs/type_traits/test/has_prefix_minus_operator_test.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -54,6 +54,7 @@
 
 void run() {
    // test with only one template parameter
+   TEST_T(void, false);
    TEST_T(bool, true);
    TEST_T(char, true);
    TEST_T(signed char, true);

Modified: sandbox/type_traits/libs/type_traits/test/has_prefix_plus_not_operator_test.hpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_prefix_plus_not_operator_test.hpp	(original)
+++ sandbox/type_traits/libs/type_traits/test/has_prefix_plus_not_operator_test.hpp	2011-02-26 16:36:25 EST (Sat, 26 Feb 2011)
@@ -54,6 +54,7 @@
 
 void run() {
    // test with only one template parameter
+   TEST_T(void, false);
    TEST_T(bool, true);
    TEST_T(char, true);
    TEST_T(signed char, true);