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

Subject: [Boost-commit] svn:boost r71384 - in sandbox/type_traits: boost/type_traits boost/type_traits/detail libs/type_traits/doc libs/type_traits/doc/html libs/type_traits/doc/html/boost_typetraits libs/type_traits/doc/html/boost_typetraits/category libs/type_traits/doc/html/boost_typetraits/category/value_traits libs/type_traits/doc/html/boost_typetraits/examples libs/type_traits/doc/html/boost_typetraits/reference libs/type_traits/test
From: frederic.bron_at_[hidden]
Date: 2011-04-19 18:00:34

Author: bronf
Date: 2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
New Revision: 71384
URL: http://svn.boost.org/trac/boost/changeset/71384

Log:
operator traits:
- simpler names for helper traits
- fixed typos in documentation
- new names beginning with can_call
- dont_care as default return type; check for void return if needed
- names of template parameters now begin with a capital letter followed by lower case letters (RHS->Rhs, LHS->Lhs, RET->Ret...)
- removed non ASCII characters

Added:
   sandbox/type_traits/boost/type_traits/can_call.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_addition.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_addition_assignment.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_and.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_bitwise_and.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_bitwise_and_assignment.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_bitwise_or.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_bitwise_or_assignment.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_bitwise_xor.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_bitwise_xor_assignment.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_complement.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_dereference.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_division.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_division_assignment.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_equal.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_greater.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_greater_equal.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_left_shift.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_left_shift_assignment.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_less.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_less_equal.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_modulus.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_modulus_assignment.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_multiplication.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_multiplication_assignment.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_not.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_not_equal.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_or.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_post_decrement.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_post_increment.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_pre_decrement.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_pre_increment.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_right_shift.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_right_shift_assignment.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_subtraction.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_subtraction_assignment.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_unary_minus.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/can_call_unary_plus.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/detail/can_call_binary_operator.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/detail/can_call_postfix_operator.hpp   (contents, props changed)
   sandbox/type_traits/boost/type_traits/detail/can_call_prefix_operator.hpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_addition.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_addition_assignment.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_and.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_bitwise_and.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_bitwise_and_assignment.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_bitwise_or.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_bitwise_or_assignment.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_bitwise_xor.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_bitwise_xor_assignment.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_complement.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_dereference.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_division.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_division_assignment.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_equal.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_greater.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_greater_equal.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_left_shift.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_left_shift_assignment.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_less.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_less_equal.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_modulus.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_modulus_assignment.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_multiplication.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_multiplication_assignment.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_not.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_not_equal.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_or.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_post_decrement.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_post_increment.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_pre_decrement.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_pre_increment.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_right_shift.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_right_shift_assignment.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_subtraction.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_subtraction_assignment.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_unary_minus.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/can_call_unary_plus.qbk   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_addition.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_addition_assignment.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_and.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_bitwise_and.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_bitwise_and_assignment.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_bitwise_or.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_bitwise_or_assignment.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_bitwise_xor.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_bitwise_xor_assignment.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_complement.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_dereference.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_division.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_division_assignment.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_equal.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_greater.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_greater_equal.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_left_shift.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_left_shift_assignment.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_less.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_less_equal.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_modulus.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_modulus_assignment.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_multiplication.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_multiplication_assignment.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_not.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_not_equal.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_or.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_post_decrement.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_post_increment.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_pre_decrement.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_pre_increment.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_right_shift.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_right_shift_assignment.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_subtraction.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_subtraction_assignment.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_unary_minus.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_unary_plus.html   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_addition_assignment_test.cpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_addition_assignment_test.hpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_addition_test.cpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_addition_test.hpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_and_test.cpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_binary_logical_test.hpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_binary_operators.hpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_bitwise_and_assignment_test.cpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_bitwise_and_test.cpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_bitwise_or_assignment_test.cpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_bitwise_or_test.cpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_bitwise_xor_assignment_test.cpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_bitwise_xor_test.cpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_comparison_test.hpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_complement_test.cpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_complement_test.hpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_dereference_test.cpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_dereference_test.hpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_division_assignment_test.cpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_division_test.cpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_equal_test.cpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_greater_equal_test.cpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_greater_test.cpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_integral_no_constlhs_test.hpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_integral_test.hpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_left_shift_assignment_test.cpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_left_shift_test.cpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_less_equal_test.cpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_less_test.cpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_modulus_assignment_test.cpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_modulus_test.cpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_multiplication_assignment_test.cpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_multiplication_test.cpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_no_pointer_no_constlhs_test.hpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_no_pointer_test.hpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_not_equal_test.cpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_not_test.cpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_or_test.cpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_post_decrement_test.cpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_post_decrement_test.hpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_post_increment_test.cpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_post_increment_test.hpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_postfix_operators.hpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_pre_decrement_test.cpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_pre_decrement_test.hpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_pre_increment_test.cpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_pre_increment_test.hpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_prefix_operators.hpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_right_shift_assignment_test.cpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_right_shift_test.cpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_subtraction_assignment_test.cpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_subtraction_assignment_test.hpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_subtraction_test.cpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_subtraction_test.hpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_unary_minus_test.cpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_unary_minus_test.hpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_unary_plus_not_test.hpp   (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_unary_plus_test.cpp   (contents, props changed)
Removed:
   sandbox/type_traits/boost/type_traits/detail/has_binary_operator.hpp
   sandbox/type_traits/boost/type_traits/detail/has_postfix_operator.hpp
   sandbox/type_traits/boost/type_traits/detail/has_prefix_operator.hpp
   sandbox/type_traits/boost/type_traits/has_operator_bit_and.hpp
   sandbox/type_traits/boost/type_traits/has_operator_bit_and_equal.hpp
   sandbox/type_traits/boost/type_traits/has_operator_bit_or.hpp
   sandbox/type_traits/boost/type_traits/has_operator_bit_or_equal.hpp
   sandbox/type_traits/boost/type_traits/has_operator_bit_xor.hpp
   sandbox/type_traits/boost/type_traits/has_operator_bit_xor_equal.hpp
   sandbox/type_traits/boost/type_traits/has_operator_complement.hpp
   sandbox/type_traits/boost/type_traits/has_operator_dereference.hpp
   sandbox/type_traits/boost/type_traits/has_operator_divides.hpp
   sandbox/type_traits/boost/type_traits/has_operator_divides_equal.hpp
   sandbox/type_traits/boost/type_traits/has_operator_equal_to.hpp
   sandbox/type_traits/boost/type_traits/has_operator_greater.hpp
   sandbox/type_traits/boost/type_traits/has_operator_greater_equal.hpp
   sandbox/type_traits/boost/type_traits/has_operator_left_shift.hpp
   sandbox/type_traits/boost/type_traits/has_operator_left_shift_equal.hpp
   sandbox/type_traits/boost/type_traits/has_operator_less.hpp
   sandbox/type_traits/boost/type_traits/has_operator_less_equal.hpp
   sandbox/type_traits/boost/type_traits/has_operator_logical_and.hpp
   sandbox/type_traits/boost/type_traits/has_operator_logical_not.hpp
   sandbox/type_traits/boost/type_traits/has_operator_logical_or.hpp
   sandbox/type_traits/boost/type_traits/has_operator_minus.hpp
   sandbox/type_traits/boost/type_traits/has_operator_minus_equal.hpp
   sandbox/type_traits/boost/type_traits/has_operator_modulus.hpp
   sandbox/type_traits/boost/type_traits/has_operator_modulus_equal.hpp
   sandbox/type_traits/boost/type_traits/has_operator_multiplies.hpp
   sandbox/type_traits/boost/type_traits/has_operator_multiplies_equal.hpp
   sandbox/type_traits/boost/type_traits/has_operator_not_equal_to.hpp
   sandbox/type_traits/boost/type_traits/has_operator_plus.hpp
   sandbox/type_traits/boost/type_traits/has_operator_plus_equal.hpp
   sandbox/type_traits/boost/type_traits/has_operator_postfix_decrement.hpp
   sandbox/type_traits/boost/type_traits/has_operator_postfix_increment.hpp
   sandbox/type_traits/boost/type_traits/has_operator_prefix_decrement.hpp
   sandbox/type_traits/boost/type_traits/has_operator_prefix_increment.hpp
   sandbox/type_traits/boost/type_traits/has_operator_right_shift.hpp
   sandbox/type_traits/boost/type_traits/has_operator_right_shift_equal.hpp
   sandbox/type_traits/boost/type_traits/has_operator_unary_minus.hpp
   sandbox/type_traits/boost/type_traits/has_operator_unary_plus.hpp
   sandbox/type_traits/boost/type_traits/operators.hpp
   sandbox/type_traits/libs/type_traits/doc/has_operator_bit_and.qbk
   sandbox/type_traits/libs/type_traits/doc/has_operator_bit_and_equal.qbk
   sandbox/type_traits/libs/type_traits/doc/has_operator_bit_or.qbk
   sandbox/type_traits/libs/type_traits/doc/has_operator_bit_or_equal.qbk
   sandbox/type_traits/libs/type_traits/doc/has_operator_bit_xor.qbk
   sandbox/type_traits/libs/type_traits/doc/has_operator_bit_xor_equal.qbk
   sandbox/type_traits/libs/type_traits/doc/has_operator_complement.qbk
   sandbox/type_traits/libs/type_traits/doc/has_operator_dereference.qbk
   sandbox/type_traits/libs/type_traits/doc/has_operator_divides.qbk
   sandbox/type_traits/libs/type_traits/doc/has_operator_divides_equal.qbk
   sandbox/type_traits/libs/type_traits/doc/has_operator_equal_to.qbk
   sandbox/type_traits/libs/type_traits/doc/has_operator_greater.qbk
   sandbox/type_traits/libs/type_traits/doc/has_operator_greater_equal.qbk
   sandbox/type_traits/libs/type_traits/doc/has_operator_left_shift.qbk
   sandbox/type_traits/libs/type_traits/doc/has_operator_left_shift_equal.qbk
   sandbox/type_traits/libs/type_traits/doc/has_operator_less.qbk
   sandbox/type_traits/libs/type_traits/doc/has_operator_less_equal.qbk
   sandbox/type_traits/libs/type_traits/doc/has_operator_logical_and.qbk
   sandbox/type_traits/libs/type_traits/doc/has_operator_logical_not.qbk
   sandbox/type_traits/libs/type_traits/doc/has_operator_logical_or.qbk
   sandbox/type_traits/libs/type_traits/doc/has_operator_minus.qbk
   sandbox/type_traits/libs/type_traits/doc/has_operator_minus_equal.qbk
   sandbox/type_traits/libs/type_traits/doc/has_operator_modulus.qbk
   sandbox/type_traits/libs/type_traits/doc/has_operator_modulus_equal.qbk
   sandbox/type_traits/libs/type_traits/doc/has_operator_multiplies.qbk
   sandbox/type_traits/libs/type_traits/doc/has_operator_multiplies_equal.qbk
   sandbox/type_traits/libs/type_traits/doc/has_operator_not_equal_to.qbk
   sandbox/type_traits/libs/type_traits/doc/has_operator_plus.qbk
   sandbox/type_traits/libs/type_traits/doc/has_operator_plus_equal.qbk
   sandbox/type_traits/libs/type_traits/doc/has_operator_postfix_decrement.qbk
   sandbox/type_traits/libs/type_traits/doc/has_operator_postfix_increment.qbk
   sandbox/type_traits/libs/type_traits/doc/has_operator_prefix_decrement.qbk
   sandbox/type_traits/libs/type_traits/doc/has_operator_prefix_increment.qbk
   sandbox/type_traits/libs/type_traits/doc/has_operator_right_shift.qbk
   sandbox/type_traits/libs/type_traits/doc/has_operator_right_shift_equal.qbk
   sandbox/type_traits/libs/type_traits/doc/has_operator_unary_minus.qbk
   sandbox/type_traits/libs/type_traits/doc/has_operator_unary_plus.qbk
   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_equal.html
   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_equal.html
   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_equal.html
   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_dereference.html
   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_equal.html
   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_greater.html
   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_left_shift.html
   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_less.html
   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_logical_and.html
   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_or.html
   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_equal.html
   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_equal.html
   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_equal.html
   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_plus.html
   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_postfix_decrement.html
   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_prefix_decrement.html
   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_right_shift.html
   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_unary_minus.html
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_unary_plus.html
   sandbox/type_traits/libs/type_traits/test/has_binary_logical_operator_test.hpp
   sandbox/type_traits/libs/type_traits/test/has_binary_minus_operator_test.hpp
   sandbox/type_traits/libs/type_traits/test/has_binary_operator_test.hpp
   sandbox/type_traits/libs/type_traits/test/has_binary_plus_operator_test.hpp
   sandbox/type_traits/libs/type_traits/test/has_comparison_operator_test.hpp
   sandbox/type_traits/libs/type_traits/test/has_dereference_operator_test.hpp
   sandbox/type_traits/libs/type_traits/test/has_integral_no_constlhs_operator_test.hpp
   sandbox/type_traits/libs/type_traits/test/has_integral_operator_test.hpp
   sandbox/type_traits/libs/type_traits/test/has_minus_equal_operator_test.hpp
   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_operator_test.hpp
   sandbox/type_traits/libs/type_traits/test/has_operator_bit_and_equal_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_operator_bit_and_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_operator_bit_or_equal_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_operator_bit_or_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_operator_bit_xor_equal_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_operator_bit_xor_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_operator_complement_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_operator_dereference_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_operator_divides_equal_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_operator_divides_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_operator_equal_to_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_operator_greater_equal_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_operator_greater_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_operator_left_shift_equal_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_operator_left_shift_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_operator_less_equal_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_operator_less_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_operator_logical_and_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_operator_logical_not_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_operator_logical_or_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_operator_minus_equal_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_operator_minus_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_operator_modulus_equal_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_operator_modulus_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_operator_multiplies_equal_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_operator_multiplies_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_operator_not_equal_to_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_operator_plus_equal_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_operator_plus_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_operator_postfix_decrement_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_operator_postfix_increment_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_operator_prefix_decrement_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_operator_prefix_increment_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_operator_right_shift_equal_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_operator_right_shift_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_operator_unary_minus_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_operator_unary_plus_test.cpp
   sandbox/type_traits/libs/type_traits/test/has_plus_equal_operator_test.hpp
   sandbox/type_traits/libs/type_traits/test/has_postfix_decrement_operator_test.hpp
   sandbox/type_traits/libs/type_traits/test/has_postfix_increment_operator_test.hpp
   sandbox/type_traits/libs/type_traits/test/has_postfix_operator_test.hpp
   sandbox/type_traits/libs/type_traits/test/has_prefix_complement_operator_test.hpp
   sandbox/type_traits/libs/type_traits/test/has_prefix_decrement_operator_test.hpp
   sandbox/type_traits/libs/type_traits/test/has_prefix_increment_operator_test.hpp
   sandbox/type_traits/libs/type_traits/test/has_prefix_minus_operator_test.hpp
   sandbox/type_traits/libs/type_traits/test/has_prefix_operator_test.hpp
   sandbox/type_traits/libs/type_traits/test/has_prefix_plus_not_operator_test.hpp
Text files modified: 
   sandbox/type_traits/libs/type_traits/doc/credits.qbk                                                     |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/background.html                           |    24                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category.html                             |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/alignment.html                   |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/function.html                    |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/transform.html                   |     4                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/value_traits.html                |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/value_traits/operators.html      |  1680 +++++++++------------------------------ 
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/value_traits/primary.html        |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/value_traits/properties.html     |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/value_traits/relate.html         |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/credits.html                              |     4                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/examples.html                             |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/examples/copy.html                        |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/examples/destruct.html                    |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/examples/fill.html                        |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/examples/iter.html                        |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/examples/to_double.html                   |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/intrinsics.html                           |     4                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/intro.html                                |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/mpl.html                                  |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference.html                            |   116 +-                                      
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_const.html                  |     4                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_cv.html                     |     4                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_pointer.html                |     4                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_reference.html              |     4                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/add_volatile.html               |     4                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/aligned_storage.html            |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/alignment_of.html               |     8                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/decay.html                      |    10                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/extent.html                     |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/floating_point_promotion.html   |     4                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/function_traits.html            |     6                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_no_throw_def_cons.html      |     8                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_assign.html         |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_constructor.html    |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_copy.html           |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_cp_cons.html        |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_assign.html         |     8                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_constructor.html    |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_copy.html           |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_cp_cons.html        |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_def_cons.html       |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_destructor.html     |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_virtual_destructor.html     |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/integral_constant.html          |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/integral_promotion.html         |     4                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_abstract.html                |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_arithmetic.html              |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_array.html                   |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_base_of.html                 |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_class.html                   |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_complex.html                 |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_compound.html                |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_const.html                   |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_convertible.html             |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_empty.html                   |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_enum.html                    |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_floating_point.html          |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_function.html                |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_fundamental.html             |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_integral.html                |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_member_function_pointer.html |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_member_object_pointer.html   |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_member_pointer.html          |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_object.html                  |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_pod.html                     |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_pointer.html                 |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_polymorphic.html             |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_reference.html               |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_same.html                    |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_scalar.html                  |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_signed.html                  |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_stateless.html               |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_union.html                   |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_unsigned.html                |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_void.html                    |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_volatile.html                |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/make_signed.html                |     4                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/make_unsigned.html              |     4                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/member_object.html              |     4                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/promote.html                    |     4                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/rank.html                       |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_all_extents.html         |     4                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_const.html               |     4                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_cv.html                  |     4                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_extent.html              |     4                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_member_pointer.html      |     4                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_pointer.html             |     4                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_reference.html           |     4                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/remove_volatile.html            |     4                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/type_with_alignment.html        |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/user_defined.html                         |     2                                         
   sandbox/type_traits/libs/type_traits/doc/html/index.html                                                 |   118 +-                                      
   sandbox/type_traits/libs/type_traits/doc/operators.qbk                                                   |   392 ++++-----                               
   sandbox/type_traits/libs/type_traits/doc/type_traits.qbk                                                 |    76                                         
   sandbox/type_traits/libs/type_traits/test/Jamfile.v2                                                     |     4                                         
   97 files changed, 863 insertions(+), 1801 deletions(-)

Added: sandbox/type_traits/boost/type_traits/can_call.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,51 @@
+//  (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_CAN_CALL_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_HPP_INCLUDED
+
+#include <boost/type_traits/can_call_addition.hpp>
+#include <boost/type_traits/can_call_addition_assignment.hpp>
+#include <boost/type_traits/can_call_and.hpp>
+#include <boost/type_traits/can_call_bitwise_and.hpp>
+#include <boost/type_traits/can_call_bitwise_and_assignment.hpp>
+#include <boost/type_traits/can_call_bitwise_or.hpp>
+#include <boost/type_traits/can_call_bitwise_or_assignment.hpp>
+#include <boost/type_traits/can_call_bitwise_xor.hpp>
+#include <boost/type_traits/can_call_bitwise_xor_assignment.hpp>
+#include <boost/type_traits/can_call_complement.hpp>
+#include <boost/type_traits/can_call_dereference.hpp>
+#include <boost/type_traits/can_call_division.hpp>
+#include <boost/type_traits/can_call_division_assignment.hpp>
+#include <boost/type_traits/can_call_equal.hpp>
+#include <boost/type_traits/can_call_greater.hpp>
+#include <boost/type_traits/can_call_greater_equal.hpp>
+#include <boost/type_traits/can_call.hpp>
+#include <boost/type_traits/can_call_less.hpp>
+#include <boost/type_traits/can_call_less_equal.hpp>
+#include <boost/type_traits/can_call_modulus.hpp>
+#include <boost/type_traits/can_call_modulus_assignment.hpp>
+#include <boost/type_traits/can_call_multiplication.hpp>
+#include <boost/type_traits/can_call_multiplication_assignment.hpp>
+#include <boost/type_traits/can_call_not_equal.hpp>
+#include <boost/type_traits/can_call_not.hpp>
+#include <boost/type_traits/can_call_or.hpp>
+#include <boost/type_traits/can_call_post_decrement.hpp>
+#include <boost/type_traits/can_call_post_increment.hpp>
+#include <boost/type_traits/can_call_pre_decrement.hpp>
+#include <boost/type_traits/can_call_pre_increment.hpp>
+#include <boost/type_traits/can_call_shift_left.hpp>
+#include <boost/type_traits/can_call_shift_left_assignment.hpp>
+#include <boost/type_traits/can_call_shift_right.hpp>
+#include <boost/type_traits/can_call_shift_right_assignment.hpp>
+#include <boost/type_traits/can_call_subtraction.hpp>
+#include <boost/type_traits/can_call_subtraction_assignment.hpp>
+#include <boost/type_traits/can_call_unary_minus.hpp>
+#include <boost/type_traits/can_call_unary_plus.hpp>
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_addition.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_addition.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,52 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_ADDITION_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_ADDITION_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_addition
+#define BOOST_TT_TRAIT_OP +
+#define BOOST_TT_FORBIDDEN_IF\
+   ::boost::type_traits::ice_or<\
+      /* pointer with pointer */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::is_pointer< Rhs_noref >::value\
+      >::value,\
+      /* pointer with fundamental non integral */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::is_fundamental< Rhs_nocv >::value,\
+         ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
+      >::value,\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Rhs_noref >::value,\
+         ::boost::is_fundamental< Lhs_nocv >::value,\
+         ::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value\
+      >::value,\
+      /* void* with fundamental */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::is_void< Lhs_noptr >::value,\
+         ::boost::is_fundamental< Rhs_nocv >::value\
+      >::value,\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Rhs_noref >::value,\
+         ::boost::is_void< Rhs_noptr >::value,\
+         ::boost::is_fundamental< Lhs_nocv >::value\
+      >::value\
+   >::value
+
+
+#include <boost/type_traits/detail/can_call_binary_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_addition_assignment.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_addition_assignment.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,59 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_ADDITION_ASSIGNMENT_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_ADDITION_ASSIGNMENT_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_addition_assignment
+#define BOOST_TT_TRAIT_OP +=
+#define BOOST_TT_FORBIDDEN_IF\
+   ::boost::type_traits::ice_or<\
+      /* LHS is fundamental and const, RHS is fundamental */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_fundamental< Lhs_nocv >::value,\
+         ::boost::is_const< Lhs_noref >::value,\
+         ::boost::is_fundamental< Rhs_nocv >::value\
+      >::value,\
+      /* two pointers */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::is_pointer< Rhs_noref >::value\
+      >::value,\
+      /* void* with fundamental */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::is_void< Lhs_noptr >::value,\
+         ::boost::is_fundamental< Rhs_nocv >::value\
+      >::value,\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Rhs_noref >::value,\
+         ::boost::is_void< Rhs_noptr >::value,\
+         ::boost::is_fundamental< Lhs_nocv >::value\
+      >::value,\
+      /* LHS==pointer and RHS==fundamental non integral */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::is_fundamental< Rhs_nocv >::value,\
+         ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
+      >::value,\
+      /* LHS==non bool fundamental and RHS==pointer */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_fundamental< Lhs_nocv >::value,\
+         ::boost::type_traits::ice_not< ::boost::is_same< bool, Lhs_nocv >::value >::value,\
+         ::boost::is_pointer< Rhs_noref >::value\
+      >::value\
+   >::value
+
+
+#include <boost/type_traits/detail/can_call_binary_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_and.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_and.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,40 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_AND_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_AND_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_and
+#define BOOST_TT_TRAIT_OP &&
+#define BOOST_TT_FORBIDDEN_IF\
+   /* pointer with fundamental non convertible to bool */\
+   ::boost::type_traits::ice_or<\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::type_traits::ice_and<\
+            ::boost::is_fundamental< Rhs_nocv >::value,\
+            ::boost::type_traits::ice_not< ::boost::is_convertible< Rhs_nocv, bool >::value >::value\
+         >::value\
+      >::value,\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Rhs_noref >::value,\
+         ::boost::type_traits::ice_and<\
+            ::boost::is_fundamental< Lhs_nocv >::value,\
+            ::boost::type_traits::ice_not< ::boost::is_convertible< Lhs_nocv, bool >::value >::value\
+         >::value\
+      >::value\
+   >::value
+
+
+#include <boost/type_traits/detail/can_call_binary_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_bitwise_and.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_bitwise_and.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,50 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_BITWISE_AND_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_BITWISE_AND_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_bitwise_and
+#define BOOST_TT_TRAIT_OP &
+#define BOOST_TT_FORBIDDEN_IF\
+   ::boost::type_traits::ice_or<\
+      /* two fundamental, one non integral */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_fundamental< Lhs_nocv >::value,\
+         ::boost::is_fundamental< Rhs_nocv >::value,\
+         ::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\
+         >::value\
+      >::value,\
+      /* one fundamental, one pointer */\
+      ::boost::type_traits::ice_or<\
+         ::boost::type_traits::ice_and<\
+            ::boost::is_fundamental< Lhs_nocv >::value,\
+            ::boost::is_pointer< Rhs_noref >::value\
+         >::value,\
+         ::boost::type_traits::ice_and<\
+            ::boost::is_fundamental< Rhs_nocv >::value,\
+            ::boost::is_pointer< Lhs_noref >::value\
+         >::value\
+      >::value,\
+      /* two pointers */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::is_pointer< Rhs_noref >::value\
+      >::value\
+   >::value
+
+
+#include <boost/type_traits/detail/can_call_binary_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_bitwise_and_assignment.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_bitwise_and_assignment.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,51 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_BITWISE_AND_ASSIGNMENT_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_BITWISE_AND_ASSIGNMENT_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_bitwise_and_assignment
+#define BOOST_TT_TRAIT_OP &=
+#define BOOST_TT_FORBIDDEN_IF\
+   ::boost::type_traits::ice_or<\
+      /* two fundamental, one non integral or lhs is const*/\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_fundamental< Lhs_nocv >::value,\
+         ::boost::is_fundamental< Rhs_nocv >::value,\
+         ::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\
+         >::value\
+      >::value,\
+      /* one fundamental, one pointer */\
+      ::boost::type_traits::ice_or<\
+         ::boost::type_traits::ice_and<\
+            ::boost::is_fundamental< Lhs_nocv >::value,\
+            ::boost::is_pointer< Rhs_noref >::value\
+         >::value,\
+         ::boost::type_traits::ice_and<\
+            ::boost::is_fundamental< Rhs_nocv >::value,\
+            ::boost::is_pointer< Lhs_noref >::value\
+         >::value\
+      >::value,\
+      /* two pointers */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::is_pointer< Rhs_noref >::value\
+      >::value\
+   >::value
+
+
+#include <boost/type_traits/detail/can_call_binary_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_bitwise_or.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_bitwise_or.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,50 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_BITWISE_OR_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_BITWISE_OR_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_bitwise_or
+#define BOOST_TT_TRAIT_OP |
+#define BOOST_TT_FORBIDDEN_IF\
+   ::boost::type_traits::ice_or<\
+      /* two fundamental, one non integral */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_fundamental< Lhs_nocv >::value,\
+         ::boost::is_fundamental< Rhs_nocv >::value,\
+         ::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\
+         >::value\
+      >::value,\
+      /* one fundamental, one pointer */\
+      ::boost::type_traits::ice_or<\
+         ::boost::type_traits::ice_and<\
+            ::boost::is_fundamental< Lhs_nocv >::value,\
+            ::boost::is_pointer< Rhs_noref >::value\
+         >::value,\
+         ::boost::type_traits::ice_and<\
+            ::boost::is_fundamental< Rhs_nocv >::value,\
+            ::boost::is_pointer< Lhs_noref >::value\
+         >::value\
+      >::value,\
+      /* two pointers */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::is_pointer< Rhs_noref >::value\
+      >::value\
+   >::value
+
+
+#include <boost/type_traits/detail/can_call_binary_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_bitwise_or_assignment.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_bitwise_or_assignment.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,51 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_BITWISE_OR_ASSIGNMENT_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_BITWISE_OR_ASSIGNMENT_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_bitwise_or_assignment
+#define BOOST_TT_TRAIT_OP |=
+#define BOOST_TT_FORBIDDEN_IF\
+   ::boost::type_traits::ice_or<\
+      /* two fundamental, one non integral or lhs is const*/\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_fundamental< Lhs_nocv >::value,\
+         ::boost::is_fundamental< Rhs_nocv >::value,\
+         ::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\
+         >::value\
+      >::value,\
+      /* one fundamental, one pointer */\
+      ::boost::type_traits::ice_or<\
+         ::boost::type_traits::ice_and<\
+            ::boost::is_fundamental< Lhs_nocv >::value,\
+            ::boost::is_pointer< Rhs_noref >::value\
+         >::value,\
+         ::boost::type_traits::ice_and<\
+            ::boost::is_fundamental< Rhs_nocv >::value,\
+            ::boost::is_pointer< Lhs_noref >::value\
+         >::value\
+      >::value,\
+      /* two pointers */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::is_pointer< Rhs_noref >::value\
+      >::value\
+   >::value
+
+
+#include <boost/type_traits/detail/can_call_binary_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_bitwise_xor.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_bitwise_xor.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,50 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_BITWISE_XOR_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_BITWISE_XOR_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_bitwise_xor
+#define BOOST_TT_TRAIT_OP ^
+#define BOOST_TT_FORBIDDEN_IF\
+   ::boost::type_traits::ice_or<\
+      /* two fundamental, one non integral */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_fundamental< Lhs_nocv >::value,\
+         ::boost::is_fundamental< Rhs_nocv >::value,\
+         ::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\
+         >::value\
+      >::value,\
+      /* one fundamental, one pointer */\
+      ::boost::type_traits::ice_or<\
+         ::boost::type_traits::ice_and<\
+            ::boost::is_fundamental< Lhs_nocv >::value,\
+            ::boost::is_pointer< Rhs_noref >::value\
+         >::value,\
+         ::boost::type_traits::ice_and<\
+            ::boost::is_fundamental< Rhs_nocv >::value,\
+            ::boost::is_pointer< Lhs_noref >::value\
+         >::value\
+      >::value,\
+      /* two pointers */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::is_pointer< Rhs_noref >::value\
+      >::value\
+   >::value
+
+
+#include <boost/type_traits/detail/can_call_binary_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_bitwise_xor_assignment.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_bitwise_xor_assignment.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,51 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_BITWISE_XOR_ASSIGNMENT_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_BITWISE_XOR_ASSIGNMENT_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_bitwise_xor_assignment
+#define BOOST_TT_TRAIT_OP ^=
+#define BOOST_TT_FORBIDDEN_IF\
+   ::boost::type_traits::ice_or<\
+      /* two fundamental, one non integral or lhs is const*/\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_fundamental< Lhs_nocv >::value,\
+         ::boost::is_fundamental< Rhs_nocv >::value,\
+         ::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\
+         >::value\
+      >::value,\
+      /* one fundamental, one pointer */\
+      ::boost::type_traits::ice_or<\
+         ::boost::type_traits::ice_and<\
+            ::boost::is_fundamental< Lhs_nocv >::value,\
+            ::boost::is_pointer< Rhs_noref >::value\
+         >::value,\
+         ::boost::type_traits::ice_and<\
+            ::boost::is_fundamental< Rhs_nocv >::value,\
+            ::boost::is_pointer< Lhs_noref >::value\
+         >::value\
+      >::value,\
+      /* two pointers */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::is_pointer< Rhs_noref >::value\
+      >::value\
+   >::value
+
+
+#include <boost/type_traits/detail/can_call_binary_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_complement.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_complement.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,32 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_COMPLEMENT_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_COMPLEMENT_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_complement
+#define BOOST_TT_TRAIT_OP ~
+#define BOOST_TT_FORBIDDEN_IF\
+   ::boost::type_traits::ice_or<\
+      /* pointer */\
+      ::boost::is_pointer< Rhs_noref >::value,\
+      /* fundamental non integral */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_fundamental< Rhs_noref >::value,\
+         ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
+      >::value\
+   >::value
+
+
+#include <boost/type_traits/detail/can_call_prefix_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_dereference.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_dereference.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,31 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_DEREFERENCE_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_DEREFERENCE_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_dereference
+#define BOOST_TT_TRAIT_OP *
+#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< Rhs_noptr >::value\
+      >::value,\
+      ::boost::is_fundamental< Rhs_nocv >::value\
+   >::value
+
+
+#include <boost/type_traits/detail/can_call_prefix_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_division.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_division.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,40 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_DIVISION_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_DIVISION_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_division
+#define BOOST_TT_TRAIT_OP /
+#define BOOST_TT_FORBIDDEN_IF\
+   /* pointer with pointer or fundamental */\
+   ::boost::type_traits::ice_or<\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::type_traits::ice_or<\
+            ::boost::is_fundamental< Rhs_nocv >::value,\
+            ::boost::is_pointer< Rhs_noref >::value\
+         >::value\
+      >::value,\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Rhs_noref >::value,\
+         ::boost::type_traits::ice_or<\
+            ::boost::is_fundamental< Lhs_nocv >::value,\
+            ::boost::is_pointer< Lhs_noref >::value\
+         >::value\
+      >::value\
+   >::value
+
+
+#include <boost/type_traits/detail/can_call_binary_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_division_assignment.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_division_assignment.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,46 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_DIVISION_ASSIGNMENT_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_DIVISION_ASSIGNMENT_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_division_assignment
+#define BOOST_TT_TRAIT_OP /=
+#define BOOST_TT_FORBIDDEN_IF\
+   ::boost::type_traits::ice_or<\
+      /* LHS is fundamental and const, RHS is fundamental */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_fundamental< Lhs_nocv >::value,\
+         ::boost::is_const< Lhs_noref >::value,\
+         ::boost::is_fundamental< Rhs_nocv >::value\
+      >::value,\
+      /* pointer with pointer or fundamental */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::type_traits::ice_or<\
+            ::boost::is_fundamental< Rhs_nocv >::value,\
+            ::boost::is_pointer< Rhs_noref >::value\
+         >::value\
+      >::value,\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Rhs_noref >::value,\
+         ::boost::type_traits::ice_or<\
+            ::boost::is_fundamental< Lhs_nocv >::value,\
+            ::boost::is_pointer< Lhs_noref >::value\
+         >::value\
+      >::value\
+   >::value
+
+
+#include <boost/type_traits/detail/can_call_binary_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_equal.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_equal.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,48 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_EQUAL_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_EQUAL_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_equal
+#define BOOST_TT_TRAIT_OP ==
+#define BOOST_TT_FORBIDDEN_IF\
+   ::boost::type_traits::ice_or<\
+      /* pointer and fundamental */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::is_fundamental< Rhs_nocv >::value\
+      >::value,\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Rhs_noref >::value,\
+         ::boost::is_fundamental< Lhs_nocv >::value\
+      >::value,\
+      /* two pointers but no inheritance or no void* */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::is_pointer< Rhs_noref >::value,\
+         ::boost::type_traits::ice_not<\
+            ::boost::type_traits::ice_or<\
+               ::boost::is_base_of< Lhs_noptr, Rhs_noptr >::value,\
+               ::boost::is_base_of< Rhs_noptr, Lhs_noptr >::value,\
+               ::boost::is_same< Lhs_noptr, Rhs_noptr >::value,\
+               ::boost::is_void< Lhs_noptr >::value,\
+               ::boost::is_void< Rhs_noptr >::value\
+            >::value\
+         >::value\
+      >::value\
+   >::value
+
+
+#include <boost/type_traits/detail/can_call_binary_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_greater.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_greater.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,48 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_GREATER_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_GREATER_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_greater
+#define BOOST_TT_TRAIT_OP >
+#define BOOST_TT_FORBIDDEN_IF\
+   ::boost::type_traits::ice_or<\
+      /* pointer and fundamental */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::is_fundamental< Rhs_nocv >::value\
+      >::value,\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Rhs_noref >::value,\
+         ::boost::is_fundamental< Lhs_nocv >::value\
+      >::value,\
+      /* two pointers but no inheritance or no void* */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::is_pointer< Rhs_noref >::value,\
+         ::boost::type_traits::ice_not<\
+            ::boost::type_traits::ice_or<\
+               ::boost::is_base_of< Lhs_noptr, Rhs_noptr >::value,\
+               ::boost::is_base_of< Rhs_noptr, Lhs_noptr >::value,\
+               ::boost::is_same< Lhs_noptr, Rhs_noptr >::value,\
+               ::boost::is_void< Lhs_noptr >::value,\
+               ::boost::is_void< Rhs_noptr >::value\
+            >::value\
+         >::value\
+      >::value\
+   >::value
+
+
+#include <boost/type_traits/detail/can_call_binary_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_greater_equal.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_greater_equal.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,48 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_GREATER_EQUAL_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_GREATER_EQUAL_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_greater_equal
+#define BOOST_TT_TRAIT_OP >=
+#define BOOST_TT_FORBIDDEN_IF\
+   ::boost::type_traits::ice_or<\
+      /* pointer and fundamental */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::is_fundamental< Rhs_nocv >::value\
+      >::value,\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Rhs_noref >::value,\
+         ::boost::is_fundamental< Lhs_nocv >::value\
+      >::value,\
+      /* two pointers but no inheritance or no void* */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::is_pointer< Rhs_noref >::value,\
+         ::boost::type_traits::ice_not<\
+            ::boost::type_traits::ice_or<\
+               ::boost::is_base_of< Lhs_noptr, Rhs_noptr >::value,\
+               ::boost::is_base_of< Rhs_noptr, Lhs_noptr >::value,\
+               ::boost::is_same< Lhs_noptr, Rhs_noptr >::value,\
+               ::boost::is_void< Lhs_noptr >::value,\
+               ::boost::is_void< Rhs_noptr >::value\
+            >::value\
+         >::value\
+      >::value\
+   >::value
+
+
+#include <boost/type_traits/detail/can_call_binary_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_left_shift.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_left_shift.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,50 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_LEFT_SHIFT_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_LEFT_SHIFT_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_left_shift
+#define BOOST_TT_TRAIT_OP <<
+#define BOOST_TT_FORBIDDEN_IF\
+   ::boost::type_traits::ice_or<\
+      /* two fundamental, one non integral */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_fundamental< Lhs_nocv >::value,\
+         ::boost::is_fundamental< Rhs_nocv >::value,\
+         ::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\
+         >::value\
+      >::value,\
+      /* one fundamental, one pointer */\
+      ::boost::type_traits::ice_or<\
+         ::boost::type_traits::ice_and<\
+            ::boost::is_fundamental< Lhs_nocv >::value,\
+            ::boost::is_pointer< Rhs_noref >::value\
+         >::value,\
+         ::boost::type_traits::ice_and<\
+            ::boost::is_fundamental< Rhs_nocv >::value,\
+            ::boost::is_pointer< Lhs_noref >::value\
+         >::value\
+      >::value,\
+      /* two pointers */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::is_pointer< Rhs_noref >::value\
+      >::value\
+   >::value
+
+
+#include <boost/type_traits/detail/can_call_binary_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_left_shift_assignment.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_left_shift_assignment.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,51 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_LEFT_SHIFT_ASSIGNMENT_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_LEFT_SHIFT_ASSIGNMENT_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_left_shift_assignment
+#define BOOST_TT_TRAIT_OP <<=
+#define BOOST_TT_FORBIDDEN_IF\
+   ::boost::type_traits::ice_or<\
+      /* two fundamental, one non integral or lhs is const*/\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_fundamental< Lhs_nocv >::value,\
+         ::boost::is_fundamental< Rhs_nocv >::value,\
+         ::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\
+         >::value\
+      >::value,\
+      /* one fundamental, one pointer */\
+      ::boost::type_traits::ice_or<\
+         ::boost::type_traits::ice_and<\
+            ::boost::is_fundamental< Lhs_nocv >::value,\
+            ::boost::is_pointer< Rhs_noref >::value\
+         >::value,\
+         ::boost::type_traits::ice_and<\
+            ::boost::is_fundamental< Rhs_nocv >::value,\
+            ::boost::is_pointer< Lhs_noref >::value\
+         >::value\
+      >::value,\
+      /* two pointers */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::is_pointer< Rhs_noref >::value\
+      >::value\
+   >::value
+
+
+#include <boost/type_traits/detail/can_call_binary_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_less.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_less.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,48 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_LESS_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_LESS_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_less
+#define BOOST_TT_TRAIT_OP <
+#define BOOST_TT_FORBIDDEN_IF\
+   ::boost::type_traits::ice_or<\
+      /* pointer and fundamental */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::is_fundamental< Rhs_nocv >::value\
+      >::value,\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Rhs_noref >::value,\
+         ::boost::is_fundamental< Lhs_nocv >::value\
+      >::value,\
+      /* two pointers but no inheritance or no void* */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::is_pointer< Rhs_noref >::value,\
+         ::boost::type_traits::ice_not<\
+            ::boost::type_traits::ice_or<\
+               ::boost::is_base_of< Lhs_noptr, Rhs_noptr >::value,\
+               ::boost::is_base_of< Rhs_noptr, Lhs_noptr >::value,\
+               ::boost::is_same< Lhs_noptr, Rhs_noptr >::value,\
+               ::boost::is_void< Lhs_noptr >::value,\
+               ::boost::is_void< Rhs_noptr >::value\
+            >::value\
+         >::value\
+      >::value\
+   >::value
+
+
+#include <boost/type_traits/detail/can_call_binary_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_less_equal.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_less_equal.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,48 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_LESS_EQUAL_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_LESS_EQUAL_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_less_equal
+#define BOOST_TT_TRAIT_OP <=
+#define BOOST_TT_FORBIDDEN_IF\
+   ::boost::type_traits::ice_or<\
+      /* pointer and fundamental */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::is_fundamental< Rhs_nocv >::value\
+      >::value,\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Rhs_noref >::value,\
+         ::boost::is_fundamental< Lhs_nocv >::value\
+      >::value,\
+      /* two pointers but no inheritance or no void* */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::is_pointer< Rhs_noref >::value,\
+         ::boost::type_traits::ice_not<\
+            ::boost::type_traits::ice_or<\
+               ::boost::is_base_of< Lhs_noptr, Rhs_noptr >::value,\
+               ::boost::is_base_of< Rhs_noptr, Lhs_noptr >::value,\
+               ::boost::is_same< Lhs_noptr, Rhs_noptr >::value,\
+               ::boost::is_void< Lhs_noptr >::value,\
+               ::boost::is_void< Rhs_noptr >::value\
+            >::value\
+         >::value\
+      >::value\
+   >::value
+
+
+#include <boost/type_traits/detail/can_call_binary_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_modulus.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_modulus.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,50 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_MODULUS_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_MODULUS_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_modulus
+#define BOOST_TT_TRAIT_OP %
+#define BOOST_TT_FORBIDDEN_IF\
+   ::boost::type_traits::ice_or<\
+      /* two fundamental, one non integral */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_fundamental< Lhs_nocv >::value,\
+         ::boost::is_fundamental< Rhs_nocv >::value,\
+         ::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\
+         >::value\
+      >::value,\
+      /* one fundamental, one pointer */\
+      ::boost::type_traits::ice_or<\
+         ::boost::type_traits::ice_and<\
+            ::boost::is_fundamental< Lhs_nocv >::value,\
+            ::boost::is_pointer< Rhs_noref >::value\
+         >::value,\
+         ::boost::type_traits::ice_and<\
+            ::boost::is_fundamental< Rhs_nocv >::value,\
+            ::boost::is_pointer< Lhs_noref >::value\
+         >::value\
+      >::value,\
+      /* two pointers */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::is_pointer< Rhs_noref >::value\
+      >::value\
+   >::value
+
+
+#include <boost/type_traits/detail/can_call_binary_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_modulus_assignment.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_modulus_assignment.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,51 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_MODULUS_ASSIGNMENT_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_MODULUS_ASSIGNMENT_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_modulus_assignment
+#define BOOST_TT_TRAIT_OP %=
+#define BOOST_TT_FORBIDDEN_IF\
+   ::boost::type_traits::ice_or<\
+      /* two fundamental, one non integral or lhs is const*/\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_fundamental< Lhs_nocv >::value,\
+         ::boost::is_fundamental< Rhs_nocv >::value,\
+         ::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\
+         >::value\
+      >::value,\
+      /* one fundamental, one pointer */\
+      ::boost::type_traits::ice_or<\
+         ::boost::type_traits::ice_and<\
+            ::boost::is_fundamental< Lhs_nocv >::value,\
+            ::boost::is_pointer< Rhs_noref >::value\
+         >::value,\
+         ::boost::type_traits::ice_and<\
+            ::boost::is_fundamental< Rhs_nocv >::value,\
+            ::boost::is_pointer< Lhs_noref >::value\
+         >::value\
+      >::value,\
+      /* two pointers */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::is_pointer< Rhs_noref >::value\
+      >::value\
+   >::value
+
+
+#include <boost/type_traits/detail/can_call_binary_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_multiplication.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_multiplication.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,40 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_MULTIPLICATION_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_MULTIPLICATION_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_multiplication
+#define BOOST_TT_TRAIT_OP *
+#define BOOST_TT_FORBIDDEN_IF\
+   /* pointer with pointer or fundamental */\
+   ::boost::type_traits::ice_or<\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::type_traits::ice_or<\
+            ::boost::is_fundamental< Rhs_nocv >::value,\
+            ::boost::is_pointer< Rhs_noref >::value\
+         >::value\
+      >::value,\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Rhs_noref >::value,\
+         ::boost::type_traits::ice_or<\
+            ::boost::is_fundamental< Lhs_nocv >::value,\
+            ::boost::is_pointer< Lhs_noref >::value\
+         >::value\
+      >::value\
+   >::value
+
+
+#include <boost/type_traits/detail/can_call_binary_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_multiplication_assignment.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_multiplication_assignment.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,46 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_MULTIPLICATION_ASSIGNMENT_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_MULTIPLICATION_ASSIGNMENT_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_multiplication_assignment
+#define BOOST_TT_TRAIT_OP *=
+#define BOOST_TT_FORBIDDEN_IF\
+   ::boost::type_traits::ice_or<\
+      /* LHS is fundamental and const, RHS is fundamental */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_fundamental< Lhs_nocv >::value,\
+         ::boost::is_const< Lhs_noref >::value,\
+         ::boost::is_fundamental< Rhs_nocv >::value\
+      >::value,\
+      /* pointer with pointer or fundamental */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::type_traits::ice_or<\
+            ::boost::is_fundamental< Rhs_nocv >::value,\
+            ::boost::is_pointer< Rhs_noref >::value\
+         >::value\
+      >::value,\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Rhs_noref >::value,\
+         ::boost::type_traits::ice_or<\
+            ::boost::is_fundamental< Lhs_nocv >::value,\
+            ::boost::is_pointer< Lhs_noref >::value\
+         >::value\
+      >::value\
+   >::value
+
+
+#include <boost/type_traits/detail/can_call_binary_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_not.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_not.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,23 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_NOT_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_NOT_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_not
+#define BOOST_TT_TRAIT_OP !
+#define BOOST_TT_FORBIDDEN_IF\
+   false
+
+#include <boost/type_traits/detail/can_call_prefix_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_not_equal.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_not_equal.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,48 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_NOT_EQUAL_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_NOT_EQUAL_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_not_equal
+#define BOOST_TT_TRAIT_OP !=
+#define BOOST_TT_FORBIDDEN_IF\
+   ::boost::type_traits::ice_or<\
+      /* pointer and fundamental */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::is_fundamental< Rhs_nocv >::value\
+      >::value,\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Rhs_noref >::value,\
+         ::boost::is_fundamental< Lhs_nocv >::value\
+      >::value,\
+      /* two pointers but no inheritance or no void* */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::is_pointer< Rhs_noref >::value,\
+         ::boost::type_traits::ice_not<\
+            ::boost::type_traits::ice_or<\
+               ::boost::is_base_of< Lhs_noptr, Rhs_noptr >::value,\
+               ::boost::is_base_of< Rhs_noptr, Lhs_noptr >::value,\
+               ::boost::is_same< Lhs_noptr, Rhs_noptr >::value,\
+               ::boost::is_void< Lhs_noptr >::value,\
+               ::boost::is_void< Rhs_noptr >::value\
+            >::value\
+         >::value\
+      >::value\
+   >::value
+
+
+#include <boost/type_traits/detail/can_call_binary_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_or.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_or.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,40 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_OR_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_OR_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_or
+#define BOOST_TT_TRAIT_OP ||
+#define BOOST_TT_FORBIDDEN_IF\
+   /* pointer with fundamental non convertible to bool */\
+   ::boost::type_traits::ice_or<\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::type_traits::ice_and<\
+            ::boost::is_fundamental< Rhs_nocv >::value,\
+            ::boost::type_traits::ice_not< ::boost::is_convertible< Rhs_nocv, bool >::value >::value\
+         >::value\
+      >::value,\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Rhs_noref >::value,\
+         ::boost::type_traits::ice_and<\
+            ::boost::is_fundamental< Lhs_nocv >::value,\
+            ::boost::type_traits::ice_not< ::boost::is_convertible< Lhs_nocv, bool >::value >::value\
+         >::value\
+      >::value\
+   >::value
+
+
+#include <boost/type_traits/detail/can_call_binary_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_post_decrement.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_post_decrement.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,35 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_POST_DECREMENT_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_POST_DECREMENT_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_post_decrement
+#define BOOST_TT_TRAIT_OP --
+#define BOOST_TT_FORBIDDEN_IF\
+   /* bool or void* or const fundamental */\
+   ::boost::type_traits::ice_or<\
+      ::boost::is_same< bool, Lhs_nocv >::value,\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::is_void< Lhs_noptr >::value\
+      >::value,\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_fundamental< Lhs_nocv >::value,\
+         ::boost::is_const< Lhs_noref >::value\
+     >::value\
+   >::value
+
+
+#include <boost/type_traits/detail/can_call_postfix_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_post_increment.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_post_increment.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,34 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_POST_INCREMENT_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_POST_INCREMENT_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_post_increment
+#define BOOST_TT_TRAIT_OP ++
+#define BOOST_TT_FORBIDDEN_IF\
+   /* void* or const fundamental */\
+   ::boost::type_traits::ice_or<\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::is_void< Lhs_noptr >::value\
+      >::value,\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_fundamental< Lhs_nocv >::value,\
+         ::boost::is_const< Lhs_noref >::value\
+     >::value\
+   >::value
+
+
+#include <boost/type_traits/detail/can_call_postfix_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_pre_decrement.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_pre_decrement.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,35 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_PRE_DECREMENT_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_PRE_DECREMENT_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_pre_decrement
+#define BOOST_TT_TRAIT_OP --
+#define BOOST_TT_FORBIDDEN_IF\
+   /* bool or void* or const fundamental */\
+   ::boost::type_traits::ice_or<\
+      ::boost::is_same< bool, Rhs_nocv >::value,\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Rhs_noref >::value,\
+         ::boost::is_void< Rhs_noptr >::value\
+      >::value,\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_fundamental< Rhs_nocv >::value,\
+         ::boost::is_const< Rhs_noref >::value\
+     >::value\
+   >::value
+
+
+#include <boost/type_traits/detail/can_call_prefix_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_pre_increment.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_pre_increment.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,34 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_PRE_INCREMENT_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_PRE_INCREMENT_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_pre_increment
+#define BOOST_TT_TRAIT_OP ++
+#define BOOST_TT_FORBIDDEN_IF\
+   /* void* or const fundamental */\
+   ::boost::type_traits::ice_or<\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Rhs_noref >::value,\
+         ::boost::is_void< Rhs_noptr >::value\
+      >::value,\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_fundamental< Rhs_nocv >::value,\
+         ::boost::is_const< Rhs_noref >::value\
+     >::value\
+   >::value
+
+
+#include <boost/type_traits/detail/can_call_prefix_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_right_shift.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_right_shift.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,50 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_RIGHT_SHIFT_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_RIGHT_SHIFT_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_right_shift
+#define BOOST_TT_TRAIT_OP >>
+#define BOOST_TT_FORBIDDEN_IF\
+   ::boost::type_traits::ice_or<\
+      /* two fundamental, one non integral */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_fundamental< Lhs_nocv >::value,\
+         ::boost::is_fundamental< Rhs_nocv >::value,\
+         ::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\
+         >::value\
+      >::value,\
+      /* one fundamental, one pointer */\
+      ::boost::type_traits::ice_or<\
+         ::boost::type_traits::ice_and<\
+            ::boost::is_fundamental< Lhs_nocv >::value,\
+            ::boost::is_pointer< Rhs_noref >::value\
+         >::value,\
+         ::boost::type_traits::ice_and<\
+            ::boost::is_fundamental< Rhs_nocv >::value,\
+            ::boost::is_pointer< Lhs_noref >::value\
+         >::value\
+      >::value,\
+      /* two pointers */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::is_pointer< Rhs_noref >::value\
+      >::value\
+   >::value
+
+
+#include <boost/type_traits/detail/can_call_binary_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_right_shift_assignment.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_right_shift_assignment.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,51 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_RIGHT_SHIFT_ASSIGNMENT_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_RIGHT_SHIFT_ASSIGNMENT_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_right_shift_assignment
+#define BOOST_TT_TRAIT_OP >>=
+#define BOOST_TT_FORBIDDEN_IF\
+   ::boost::type_traits::ice_or<\
+      /* two fundamental, one non integral or lhs is const*/\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_fundamental< Lhs_nocv >::value,\
+         ::boost::is_fundamental< Rhs_nocv >::value,\
+         ::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\
+         >::value\
+      >::value,\
+      /* one fundamental, one pointer */\
+      ::boost::type_traits::ice_or<\
+         ::boost::type_traits::ice_and<\
+            ::boost::is_fundamental< Lhs_nocv >::value,\
+            ::boost::is_pointer< Rhs_noref >::value\
+         >::value,\
+         ::boost::type_traits::ice_and<\
+            ::boost::is_fundamental< Rhs_nocv >::value,\
+            ::boost::is_pointer< Lhs_noref >::value\
+         >::value\
+      >::value,\
+      /* two pointers */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::is_pointer< Rhs_noref >::value\
+      >::value\
+   >::value
+
+
+#include <boost/type_traits/detail/can_call_binary_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_subtraction.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_subtraction.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,60 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_SUBTRACTION_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_SUBTRACTION_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_subtraction
+#define BOOST_TT_TRAIT_OP -
+#define BOOST_TT_FORBIDDEN_IF\
+   ::boost::type_traits::ice_or<\
+      /* void* with fundamental or pointer */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::is_void< Lhs_noptr >::value,\
+         ::boost::type_traits::ice_or<\
+            ::boost::is_fundamental< Rhs_nocv >::value,\
+            ::boost::is_pointer< Rhs_noref >::value\
+         >::value\
+      >::value,\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Rhs_noref >::value,\
+         ::boost::is_void< Rhs_noptr >::value,\
+         ::boost::type_traits::ice_or<\
+            ::boost::is_fundamental< Lhs_nocv >::value,\
+            ::boost::is_pointer< Lhs_noref >::value\
+         >::value\
+      >::value,\
+      /* LHS==pointer!=void* and RHS==fundamental non integral */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::type_traits::ice_not< ::boost::is_void< Lhs_noptr >::value >::value,\
+         ::boost::is_fundamental< Rhs_nocv >::value,\
+         ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
+      >::value,\
+      /* LHS=fundamental and RHS=pointer */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_fundamental< Lhs_nocv >::value,\
+         ::boost::is_pointer< Rhs_noref >::value\
+      >::value,\
+      /* two different pointers */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::is_pointer< Rhs_noref >::value,\
+         ::boost::type_traits::ice_not< ::boost::is_same< Lhs_nocv, Rhs_nocv >::value >::value\
+      >::value\
+   >::value
+
+
+#include <boost/type_traits/detail/can_call_binary_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_subtraction_assignment.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_subtraction_assignment.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,48 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_SUBTRACTION_ASSIGNMENT_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_SUBTRACTION_ASSIGNMENT_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_subtraction_assignment
+#define BOOST_TT_TRAIT_OP -=
+#define BOOST_TT_FORBIDDEN_IF\
+   ::boost::type_traits::ice_or<\
+      /* LHS is fundamental and const, RHS is fundamental */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_fundamental< Lhs_nocv >::value,\
+         ::boost::is_const< Lhs_noref >::value,\
+         ::boost::is_fundamental< Rhs_nocv >::value\
+      >::value,\
+      /* RHS==pointer */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Rhs_noref >::value,\
+         ::boost::type_traits::ice_or<\
+            ::boost::is_fundamental< Lhs_nocv >::value,\
+            ::boost::is_pointer< Lhs_noref >::value\
+         >::value\
+      >::value,\
+      /* LHS==pointer and RHS==fundamental and (LHS==void* or RHS!=integral) */\
+      ::boost::type_traits::ice_and<\
+         ::boost::is_pointer< Lhs_noref >::value,\
+         ::boost::is_fundamental< Rhs_nocv >::value,\
+         ::boost::type_traits::ice_or<\
+            ::boost::is_void< Lhs_noptr >::value,\
+            ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
+         >::value\
+      >::value\
+   >::value
+
+
+#include <boost/type_traits/detail/can_call_binary_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_unary_minus.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_unary_minus.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,25 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_UNARY_MINUS_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_UNARY_MINUS_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_unary_minus
+#define BOOST_TT_TRAIT_OP -
+#define BOOST_TT_FORBIDDEN_IF\
+   /* pointer */\
+   ::boost::is_pointer< Rhs_noref >::value
+
+
+#include <boost/type_traits/detail/can_call_prefix_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/can_call_unary_plus.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/can_call_unary_plus.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,23 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//
+//  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_CAN_CALL_UNARY_PLUS_HPP_INCLUDED
+#define BOOST_TT_CAN_CALL_UNARY_PLUS_HPP_INCLUDED
+
+#define BOOST_TT_TRAIT_NAME can_call_unary_plus
+#define BOOST_TT_TRAIT_OP +
+#define BOOST_TT_FORBIDDEN_IF\
+   false
+
+#include <boost/type_traits/detail/can_call_prefix_operator.hpp>
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+
+#endif

Added: sandbox/type_traits/boost/type_traits/detail/can_call_binary_operator.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/detail/can_call_binary_operator.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,227 @@
+//  (C) Copyright 2009-2011 Frederic Bron, Robert Stewart, Steven Watanabe & Roman Perepelitsa.
+//
+//  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.
+
+#include <boost/config.hpp>
+#include <boost/type_traits/ice.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/type_traits/is_base_of.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/is_fundamental.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_void.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/type_traits/remove_pointer.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+// should be the last #include
+#include <boost/type_traits/detail/bool_trait_def.hpp>
+
+// cannot include this header without getting warnings of the kind:
+// gcc:
+//    warning: value computed is not used
+//    warning: comparison between signed and unsigned integer expressions
+// msvc:
+//    warning C4018: '<' : signed/unsigned mismatch
+//    warning C4244: '+=' : conversion from 'double' to 'char', possible loss of data
+//    warning C4547: '*'Â : operator before comma has no effect; expected operator with side-effect
+//    warning C4800: 'int' : forcing value to bool 'true' or 'false' (performance warning)
+//    warning C4804: '<' : unsafe use of type 'bool' in operation
+//    warning C4805: '==' : unsafe mix of type 'bool' and type 'char' in operation
+// cannot find another implementation -> declared as system header to suppress these warnings.
+#if defined(__GNUC__) && ((__GNUC__==3 && __GNUC_MINOR__>=1) || (__GNUC__>3))
+#   pragma GCC system_header
+#elif BOOST_MSVC
+#   pragma warning ( push )
+#   pragma warning ( disable : 4018 4244 4547 4800 4804 4805 )
+#endif
+
+namespace boost {
+namespace detail {
+
+// This namespace ensures that ADL does not mess things up.
+namespace BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl) {
+
+// 1. a function to have an instance of type T without requiring T to be default
+// constructible
+template <typename T> T &make();
+
+
+// 2. checks if operator BOOST_TT_TRAIT_OP returns void or not
+// conditions: Lhs!=void and Rhs!=void
+
+// we first redefine "operator," so that we have no compilation error if
+// operator BOOST_TT_TRAIT_OP returns void and we can use the return type of
+// (lhs BOOST_TT_TRAIT_OP rhs, returns_void_t()) to deduce if
+// operator BOOST_TT_TRAIT_OP returns void or not:
+// - operator BOOST_TT_TRAIT_OP returns void   -> (lhs BOOST_TT_TRAIT_OP rhs, returns_void_t()) returns returns_void_t
+// - operator BOOST_TT_TRAIT_OP returns !=void -> (lhs BOOST_TT_TRAIT_OP rhs, returns_void_t()) returns int
+struct returns_void_t {};
+template <typename T> int operator,(T const &, returns_void_t);
+
+// this intermediate trait has member value of type bool:
+// - value==true -> operator BOOST_TT_TRAIT_OP returns void
+// - value==false -> operator BOOST_TT_TRAIT_OP does not return void
+template < typename Lhs, typename Rhs >
+struct operator_returns_void {
+   // overloads of function returns_void make the difference
+   // yes_type and no_type have different size by construction
+   static ::boost::type_traits::yes_type returns_void(returns_void_t);
+   static ::boost::type_traits::no_type returns_void(int);
+   BOOST_STATIC_CONSTANT(bool, value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() BOOST_TT_TRAIT_OP make<Rhs>(),returns_void_t())))));
+};
+
+
+// 3. check for return type if Ret!=dont_care
+// conditions: Lhs!=void and Rhs!=void
+
+struct dont_care { };
+
+template < typename Lhs, typename Rhs, typename Ret, bool Returns_void >
+struct operator_returns_Ret;
+
+template < typename Lhs, typename Rhs >
+struct operator_returns_Ret < Lhs, Rhs, dont_care, true > {
+   BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+template < typename Lhs, typename Rhs >
+struct operator_returns_Ret < Lhs, Rhs, dont_care, false > {
+   BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+template < typename Lhs, typename Rhs >
+struct operator_returns_Ret < Lhs, Rhs, void, true > {
+   BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+template < typename Lhs, typename Rhs >
+struct operator_returns_Ret < Lhs, Rhs, void, false > {
+   BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+template < typename Lhs, typename Rhs, typename Ret >
+struct operator_returns_Ret < Lhs, Rhs, Ret, true > {
+   BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+// when Ret!=void, checks if it is convertible to Ret using the sizeof trick
+// based on overload resolution
+template < typename Lhs, typename Rhs, typename Ret >
+struct operator_returns_Ret < Lhs, Rhs, Ret, false > {
+   static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret); // this version is preferred for types convertible to Ret
+   static ::boost::type_traits::no_type is_convertible_to_Ret(...); // this version is used otherwise
+
+   BOOST_STATIC_CONSTANT(bool, value = (sizeof(is_convertible_to_Ret(make<Lhs>() BOOST_TT_TRAIT_OP make<Rhs>()))==sizeof(::boost::type_traits::yes_type)));
+};
+
+
+// 4. we provide our operator definition for types that do not have one already
+
+// a type returned from operator BOOST_TT_TRAIT_OP when no such operator is
+// found in the type's own namespace so that we have a means to know that our
+// operator was used
+struct tag { };
+
+// this class allows implicit conversions and makes the following operator
+// definition less-preferred than any other such operators that might be found
+// via argument-dependent name lookup
+struct any { template <class T> any(T const&); };
+
+// when operator BOOST_TT_TRAIT_OP is not available, this one is used
+tag operator BOOST_TT_TRAIT_OP (const any&, const any&);
+
+
+// 5. check for operator existence
+// condition: Lhs!=void and Rhs!=void
+
+// check if our definition of operator BOOST_TT_TRAIT_OP is used or an other
+// existing one;
+// this is done with redefinition of "operator," that returns tag or tag2
+struct tag2 { };
+tag operator,(tag, tag2);
+
+template < typename Lhs, typename Rhs >
+struct operator_exists {
+   static ::boost::type_traits::yes_type check(tag2); // this version is preferred when operator exists
+   static ::boost::type_traits::no_type check(tag); // this version is used otherwise
+
+   BOOST_STATIC_CONSTANT(bool, value = (sizeof(check(((make<Lhs>() BOOST_TT_TRAIT_OP make<Rhs>()),make<tag2>())))==sizeof(::boost::type_traits::yes_type)));
+};
+
+
+// 5. main trait: to avoid any compilation error, this struct behaves
+// differently when:
+// - operator BOOST_TT_TRAIT_OP(Lhs, Rhs) is forbidden by the standard
+// Forbidden_if is a bool that is:
+// - true when the operator BOOST_TT_TRAIT_OP(Lhs, Rhs) is forbidden by the standard
+//   (would yield compilation error if used)
+// - false otherwise
+template < typename Lhs, typename Rhs, typename Ret, bool Forbidden_if >
+struct trait_impl1;
+
+template < typename Lhs, typename Rhs, typename Ret >
+struct trait_impl1 < Lhs, Rhs, Ret, true > {
+   BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+template < typename Lhs, typename Rhs, typename Ret >
+struct trait_impl1 < Lhs, Rhs, Ret, false > {
+   BOOST_STATIC_CONSTANT(bool,
+      value = (
+         ::boost::type_traits::ice_and<
+            operator_exists < Lhs, Rhs >::value,
+            operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value
+         >::value
+      )
+   );
+};
+
+// some specializations needs to be declared for the special void case
+template < typename Rhs, typename Ret >
+struct trait_impl1 < void, Rhs, Ret, false > {
+   BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+template < typename Lhs, typename Ret >
+struct trait_impl1 < Lhs, void, Ret, false > {
+   BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+template < typename Ret >
+struct trait_impl1 < void, void, Ret, false > {
+   BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+// defines some typedef for convenience
+template < typename Lhs, typename Rhs, typename Ret >
+struct trait_impl {
+   typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
+   typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
+   typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
+   typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
+   typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
+   typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
+   BOOST_STATIC_CONSTANT(bool, value = (trait_impl1 < Lhs_noref, Rhs_noref, Ret, BOOST_TT_FORBIDDEN_IF >::value));
+};
+
+} // namespace impl
+} // namespace detail
+
+// this is the accessible definition of the trait to end user
+BOOST_TT_AUX_BOOL_TRAIT_DEF3(BOOST_TT_TRAIT_NAME, Lhs, Rhs=Lhs, Ret=::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)::dont_care, (::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)::trait_impl < Lhs, Rhs, Ret >::value))
+
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#   pragma warning ( pop )
+#endif
+
+#include <boost/type_traits/detail/bool_trait_undef.hpp>

Added: sandbox/type_traits/boost/type_traits/detail/can_call_postfix_operator.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/detail/can_call_postfix_operator.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,188 @@
+//  (C) Copyright 2009-2011 Frederic Bron, Robert Stewart, Steven Watanabe & Roman Perepelitsa.
+//
+//  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.
+
+#include <boost/config.hpp>
+#include <boost/type_traits/ice.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/is_fundamental.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_void.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/type_traits/remove_pointer.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+// should be the last #include
+#include <boost/type_traits/detail/bool_trait_def.hpp>
+
+namespace boost {
+namespace detail {
+
+// This namespace ensures that ADL does not mess things up.
+namespace BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl) {
+
+// 1. a function to have an instance of type T without requiring T to be default
+// constructible
+template <typename T> T &make();
+
+
+// 2. checks if operator BOOST_TT_TRAIT_OP returns void or not
+// conditions: Lhs!=void
+
+// we first redefine "operator," so that we have no compilation error if
+// operator BOOST_TT_TRAIT_OP returns void and we can use the return type of
+// (lhs BOOST_TT_TRAIT_OP, returns_void_t()) to deduce if
+// operator BOOST_TT_TRAIT_OP returns void or not:
+// - operator BOOST_TT_TRAIT_OP returns void   -> (lhs BOOST_TT_TRAIT_OP, returns_void_t()) returns returns_void_t
+// - operator BOOST_TT_TRAIT_OP returns !=void -> (lhs BOOST_TT_TRAIT_OP, returns_void_t()) returns int
+struct returns_void_t {};
+template <typename T> int operator,(T const &, returns_void_t);
+
+// this intermediate trait has member value of type bool:
+// - value==true -> operator BOOST_TT_TRAIT_OP returns void
+// - value==false -> operator BOOST_TT_TRAIT_OP does not return void
+template < typename Lhs >
+struct operator_returns_void {
+   // overloads of function returns_void make the difference
+   // yes_type and no_type have different size by construction
+   static ::boost::type_traits::yes_type returns_void(returns_void_t);
+   static ::boost::type_traits::no_type returns_void(int);
+   BOOST_STATIC_CONSTANT(bool, value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() BOOST_TT_TRAIT_OP,returns_void_t())))));
+};
+
+
+// 3. check for return type if Ret!=dont_care
+// conditions: Lhs!=void
+
+struct dont_care { };
+
+template < typename Lhs, typename Ret, bool Returns_void >
+struct operator_returns_Ret;
+
+template < typename Lhs >
+struct operator_returns_Ret < Lhs, dont_care, true > {
+   BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+template < typename Lhs >
+struct operator_returns_Ret < Lhs, dont_care, false > {
+   BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+template < typename Lhs >
+struct operator_returns_Ret < Lhs, void, true > {
+   BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+template < typename Lhs >
+struct operator_returns_Ret < Lhs, void, false > {
+   BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+template < typename Lhs, typename Ret >
+struct operator_returns_Ret < Lhs, Ret, true > {
+   BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+// when Ret!=void, checks if it is convertible to Ret using the sizeof trick
+// based on overload resolution
+template < typename Lhs, typename Ret >
+struct operator_returns_Ret < Lhs, Ret, false > {
+   static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret); // this version is preferred for types convertible to Ret
+   static ::boost::type_traits::no_type is_convertible_to_Ret(...); // this version is used otherwise
+
+   BOOST_STATIC_CONSTANT(bool, value = (sizeof(is_convertible_to_Ret(make<Lhs>() BOOST_TT_TRAIT_OP))==sizeof(::boost::type_traits::yes_type)));
+};
+
+
+// 4. we provide our operator definition for types that do not have one already
+
+// a type returned from operator BOOST_TT_TRAIT_OP when no such operator is
+// found in the type's own namespace so that we have a means to know that our
+// operator was used
+struct tag { };
+
+// this class allows implicit conversions and makes the following operator
+// definition less-preferred than any other such operators that might be found
+// via argument-dependent name lookup
+struct any { template <class T> any(T const&); };
+
+// when operator BOOST_TT_TRAIT_OP is not available, this one is used
+tag operator BOOST_TT_TRAIT_OP (const any&, int);
+
+
+// 5. check for operator existence
+// condition: Lhs!=void
+
+// check if our definition of operator BOOST_TT_TRAIT_OP is used or an other
+// existing one;
+// this is done with redefinition of "operator," that returns tag or tag2
+struct tag2 { };
+tag operator,(tag, tag2);
+
+template < typename Lhs >
+struct operator_exists {
+   static ::boost::type_traits::yes_type check(tag2); // this version is preferred when operator exists
+   static ::boost::type_traits::no_type check(tag); // this version is used otherwise
+
+   BOOST_STATIC_CONSTANT(bool, value = (sizeof(check(((make<Lhs>() BOOST_TT_TRAIT_OP),make<tag2>())))==sizeof(::boost::type_traits::yes_type)));
+};
+
+
+// 5. main trait: to avoid any compilation error, this struct behaves
+// differently when:
+// - operator BOOST_TT_TRAIT_OP(Lhs) is forbidden by the standard
+// Forbidden_if is a bool that is:
+// - true when the operator BOOST_TT_TRAIT_OP(Lhs) is forbidden by the standard
+//   (would yield compilation error if used)
+// - false otherwise
+template < typename Lhs, typename Ret, bool Forbidden_if >
+struct trait_impl1;
+
+template < typename Lhs, typename Ret >
+struct trait_impl1 < Lhs, Ret, true > {
+   BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+template < typename Lhs, typename Ret >
+struct trait_impl1 < Lhs, Ret, false > {
+   BOOST_STATIC_CONSTANT(bool,
+      value = (
+         ::boost::type_traits::ice_and<
+            operator_exists < Lhs >::value,
+            operator_returns_Ret < Lhs, Ret, operator_returns_void < Lhs >::value >::value
+         >::value
+      )
+   );
+};
+
+// specialization needs to be declared for the special void case
+template < typename Ret >
+struct trait_impl1 < void, Ret, false > {
+   BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+// defines some typedef for convenience
+template < typename Lhs, typename Ret >
+struct trait_impl {
+   typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
+   typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
+   typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
+   BOOST_STATIC_CONSTANT(bool, value = (trait_impl1 < Lhs_noref, Ret, BOOST_TT_FORBIDDEN_IF >::value));
+};
+
+} // namespace impl
+} // namespace detail
+
+// this is the accessible definition of the trait to end user
+BOOST_TT_AUX_BOOL_TRAIT_DEF2(BOOST_TT_TRAIT_NAME, Lhs, Ret=::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)::dont_care, (::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)::trait_impl< Lhs, Ret >::value))
+
+} // namespace boost
+
+#include <boost/type_traits/detail/bool_trait_undef.hpp>

Added: sandbox/type_traits/boost/type_traits/detail/can_call_prefix_operator.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/boost/type_traits/detail/can_call_prefix_operator.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,208 @@
+//  (C) Copyright 2009-2011 Frederic Bron, Robert Stewart, Steven Watanabe & Roman Perepelitsa.
+//
+//  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.
+
+#include <boost/config.hpp>
+#include <boost/type_traits/ice.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/is_fundamental.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_void.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/type_traits/remove_pointer.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+// should be the last #include
+#include <boost/type_traits/detail/bool_trait_def.hpp>
+
+// cannot include this header without getting warnings of the kind:
+// gcc:
+//    warning: value computed is not used
+//    warning: comparison between signed and unsigned integer expressions
+// msvc:
+//    warning C4146: unary minus operator applied to unsigned type, result still unsigned
+//    warning C4804: '-' : unsafe use of type 'bool' in operation
+// cannot find another implementation -> declared as system header to suppress these warnings.
+#if defined(__GNUC__) && ((__GNUC__==3 && __GNUC_MINOR__>=1) || (__GNUC__>3))
+#   pragma GCC system_header
+#elif BOOST_MSVC
+#   pragma warning ( push )
+#   pragma warning ( disable : 4146 4804 )
+#endif
+
+namespace boost {
+namespace detail {
+
+// This namespace ensures that ADL does not mess things up.
+namespace BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl) {
+
+// 1. a function to have an instance of type T without requiring T to be default
+// constructible
+template <typename T> T &make();
+
+
+// 2. checks if operator BOOST_TT_TRAIT_OP returns void or not
+// conditions: Rhs!=void
+
+// we first redefine "operator," so that we have no compilation error if
+// operator BOOST_TT_TRAIT_OP returns void and we can use the return type of
+// (BOOST_TT_TRAIT_OP rhs, returns_void_t()) to deduce if
+// operator BOOST_TT_TRAIT_OP returns void or not:
+// - operator BOOST_TT_TRAIT_OP returns void   -> (BOOST_TT_TRAIT_OP rhs, returns_void_t()) returns returns_void_t
+// - operator BOOST_TT_TRAIT_OP returns !=void -> (BOOST_TT_TRAIT_OP rhs, returns_void_t()) returns int
+struct returns_void_t {};
+template <typename T> int operator,(T const &, returns_void_t);
+
+// this intermediate trait has member value of type bool:
+// - value==true -> operator BOOST_TT_TRAIT_OP returns void
+// - value==false -> operator BOOST_TT_TRAIT_OP does not return void
+template < typename Rhs >
+struct operator_returns_void {
+   // overloads of function returns_void make the difference
+   // yes_type and no_type have different size by construction
+   static ::boost::type_traits::yes_type returns_void(returns_void_t);
+   static ::boost::type_traits::no_type returns_void(int);
+   BOOST_STATIC_CONSTANT(bool, value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((BOOST_TT_TRAIT_OP make<Rhs>(),returns_void_t())))));
+};
+
+
+// 3. check for return type if Ret!=dont_care
+// conditions: Rhs!=void
+
+struct dont_care { };
+
+template < typename Rhs, typename Ret, bool Returns_void >
+struct operator_returns_Ret;
+
+template < typename Rhs >
+struct operator_returns_Ret < Rhs, dont_care, true > {
+   BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+template < typename Rhs >
+struct operator_returns_Ret < Rhs, dont_care, false > {
+   BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+template < typename Rhs >
+struct operator_returns_Ret < Rhs, void, true > {
+   BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+template < typename Rhs >
+struct operator_returns_Ret < Rhs, void, false > {
+   BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+template < typename Rhs, typename Ret >
+struct operator_returns_Ret < Rhs, Ret, true > {
+   BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+// when Ret!=void, checks if it is convertible to Ret using the sizeof trick
+// based on overload resolution
+template < typename Rhs, typename Ret >
+struct operator_returns_Ret < Rhs, Ret, false > {
+   static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret); // this version is preferred for types convertible to Ret
+   static ::boost::type_traits::no_type is_convertible_to_Ret(...); // this version is used otherwise
+
+   BOOST_STATIC_CONSTANT(bool, value = (sizeof(is_convertible_to_Ret(BOOST_TT_TRAIT_OP make<Rhs>()))==sizeof(::boost::type_traits::yes_type)));
+};
+
+
+// 4. we provide our operator definition for types that do not have one already
+
+// a type returned from operator BOOST_TT_TRAIT_OP when no such operator is
+// found in the type's own namespace so that we have a means to know that our
+// operator was used
+struct tag { };
+
+// this class allows implicit conversions and makes the following operator
+// definition less-preferred than any other such operators that might be found
+// via argument-dependent name lookup
+struct any { template <class T> any(T const&); };
+
+// when operator BOOST_TT_TRAIT_OP is not available, this one is used
+tag operator BOOST_TT_TRAIT_OP (const any&);
+
+
+// 5. check for operator existence
+// condition: Rhs!=void
+
+// check if our definition of operator BOOST_TT_TRAIT_OP is used or an other
+// existing one;
+// this is done with redefinition of "operator," that returns tag or tag2
+struct tag2 { };
+tag operator,(tag, tag2);
+
+template < typename Rhs >
+struct operator_exists {
+   static ::boost::type_traits::yes_type check(tag2); // this version is preferred when operator exists
+   static ::boost::type_traits::no_type check(tag); // this version is used otherwise
+
+   BOOST_STATIC_CONSTANT(bool, value = (sizeof(check(((BOOST_TT_TRAIT_OP make<Rhs>()),make<tag2>())))==sizeof(::boost::type_traits::yes_type)));
+};
+
+
+// 5. main trait: to avoid any compilation error, this struct behaves
+// differently when:
+// - operator BOOST_TT_TRAIT_OP(Rhs) is forbidden by the standard
+// Forbidden_if is a bool that is:
+// - true when the operator BOOST_TT_TRAIT_OP(Rhs) is forbidden by the standard
+//   (would yield compilation error if used)
+// - false otherwise
+template < typename Rhs, typename Ret, bool Forbidden_if >
+struct trait_impl1;
+
+template < typename Rhs, typename Ret >
+struct trait_impl1 < Rhs, Ret, true > {
+   BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+template < typename Rhs, typename Ret >
+struct trait_impl1 < Rhs, Ret, false > {
+   BOOST_STATIC_CONSTANT(bool,
+      value = (
+         ::boost::type_traits::ice_and<
+            operator_exists < Rhs >::value,
+            operator_returns_Ret < Rhs, Ret, operator_returns_void < Rhs >::value >::value
+         >::value
+      )
+   );
+};
+
+// specialization needs to be declared for the special void case
+template < typename Ret >
+struct trait_impl1 < void, Ret, false > {
+   BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+// defines some typedef for convenience
+template < typename Rhs, typename Ret >
+struct trait_impl {
+   typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
+   typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
+   typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
+   BOOST_STATIC_CONSTANT(bool, value = (trait_impl1 < Rhs_noref, Ret, BOOST_TT_FORBIDDEN_IF >::value));
+};
+
+} // namespace impl
+} // namespace detail
+
+// this is the accessible definition of the trait to end user
+BOOST_TT_AUX_BOOL_TRAIT_DEF2(BOOST_TT_TRAIT_NAME, Rhs, Ret=::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)::dont_care, (::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)::trait_impl < Rhs, Ret >::value))
+
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#   pragma warning ( pop )
+#endif
+
+#include <boost/type_traits/detail/bool_trait_undef.hpp>

Deleted: sandbox/type_traits/boost/type_traits/detail/has_binary_operator.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/detail/has_binary_operator.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,214 +0,0 @@
-//  (C) Copyright 2009-2011 Frédéric Bron, Robert Stewart, Steven Watanabe & Roman Perepelitsa
-//
-//  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.
-
-#include <boost/config.hpp>
-#include <boost/type_traits/ice.hpp>
-#include <boost/type_traits/integral_constant.hpp>
-#include <boost/type_traits/is_base_of.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/is_convertible.hpp>
-#include <boost/type_traits/is_fundamental.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/is_void.hpp>
-#include <boost/type_traits/remove_cv.hpp>
-#include <boost/type_traits/remove_pointer.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-
-// should be the last #include
-#include <boost/type_traits/detail/bool_trait_def.hpp>
-
-// cannot include this header without getting warnings of the kind:
-// gcc:
-//    warning: value computed is not used
-//    warning: comparison between signed and unsigned integer expressions
-// msvc:
-//    warning C4018: '<' : signed/unsigned mismatch
-//    warning C4244: '+=' : conversion from 'double' to 'char', possible loss of data
-//    warning C4547: '*'Â : operator before comma has no effect; expected operator with side-effect
-//    warning C4800: 'int' : forcing value to bool 'true' or 'false' (performance warning)
-//    warning C4804: '<' : unsafe use of type 'bool' in operation
-//    warning C4805: '==' : unsafe mix of type 'bool' and type 'char' in operation
-// cannot find another implementation -> declared as system header to suppress these warnings.
-#if defined(__GNUC__) && ((__GNUC__==3 && __GNUC_MINOR__>=1) || (__GNUC__>3))
-#   pragma GCC system_header
-#elif BOOST_MSVC
-#   pragma warning ( push )
-#   pragma warning ( disable : 4018 4244 4547 4800 4804 4805 )
-#endif
-
-namespace boost {
-namespace detail {
-
-// This namespace ensures that ADL does not mess things up.
-namespace BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl) {
-
-// 1. a function to have an instance of type T without requiring T to be default
-// constructible
-namespace {
-   template <typename T> T &make();
-}
-
-// 2. we provide our operator definition for types that do not have one already
-
-// a type returned from operator BOOST_TT_TRAIT_OP when no such operator is
-// found in the type's own namespace so that we have a means to know that our
-// operator was used
-struct tag { };
-
-// this class allows implicit conversions and makes the following operator
-// definition less-preferred than any other such operators that might be found
-// via argument-dependent name lookup
-struct any { template <class T> any(T const&); };
-
-// when operator BOOST_TT_TRAIT_OP is not available, this one is used
-tag operator BOOST_TT_TRAIT_OP (const any&, const any&);
-
-// 3. if the return type has to be checked, we need to determine if
-// operator BOOST_TT_TRAIT_OP returns void or not
-
-// we first redefine "operator," so that we have no compilation error if
-// operator BOOST_TT_TRAIT_OP returns void and we can use the return type of
-// (lhs BOOST_TT_TRAIT_OP rhs, returns_void_t()) to deduce if
-// operator BOOST_TT_TRAIT_OP returns void or not:
-// - operator BOOST_TT_TRAIT_OP returns void   -> (lhs BOOST_TT_TRAIT_OP rhs, returns_void_t()) returns returns_void_t
-// - operator BOOST_TT_TRAIT_OP returns !=void -> (lhs BOOST_TT_TRAIT_OP rhs, returns_void_t()) returns int
-struct returns_void_t {};
-template <typename T> int operator,(T const &, returns_void_t);
-
-// this intermediate trait has member value of type bool:
-// - value==true -> operator BOOST_TT_TRAIT_OP returns void
-// - value==false -> operator BOOST_TT_TRAIT_OP does not return void
-template < typename LHS, typename RHS >
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_returns_void) {
-   // overloads of function returns_void make the difference
-   // yes_type and no_type have different size by construction
-   static ::boost::type_traits::yes_type returns_void(returns_void_t);
-   static ::boost::type_traits::no_type returns_void(int);
-   BOOST_STATIC_CONSTANT(bool, value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<LHS>() BOOST_TT_TRAIT_OP make<RHS>(),returns_void_t())))));
-};
-
-// 4. check for return type when RET is non void
-
-// this class is used only when RET is non void, therefore it is specialized to
-// have its value==false when the operator returns void
-template < typename LHS, typename RHS, typename RET, typename RETURNS_VOID >
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl2);
-
-// operator BOOST_TT_TRAIT_OP does not return void, checks if it is convertible to
-// RET using the sizeof trick based on overload resolution
-template < typename LHS, typename RHS, typename RET >
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl2)< LHS, RHS, RET, ::boost::false_type > {
-   static ::boost::type_traits::yes_type is_convertible_to_RET(RET); // this version is preferred for types convertible to RET
-   static ::boost::type_traits::no_type is_convertible_to_RET(...); // this version is used otherwise
-
-   BOOST_STATIC_CONSTANT(bool, value=(sizeof(is_convertible_to_RET(make<LHS>() BOOST_TT_TRAIT_OP make<RHS>()))==sizeof(::boost::type_traits::yes_type)));
-};
-
-// operator BOOST_TT_TRAIT_OP returns void!=RET -> specialization to return
-// value==false
-template < typename LHS, typename RHS, typename RET >
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl2)< LHS, RHS, RET, ::boost::true_type > {
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-// 5. main struct: to avoid any compilation error, this struct behaves
-// differently when:
-// - RET is void or non void
-// - operator BOOST_TT_TRAIT_OP(LHS, RHS) is forbidden by the standard
-// forbidden_if is a bool that is:
-// - true when the operator BOOST_TT_TRAIT_OP(LHS, RHS) is forbidden by the standard
-//   (would yield compilation error if used)
-// - false otherwise
-template < typename LHS, typename RHS, typename RET, bool forbidden_if >
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1);
-
-template < typename LHS, typename RHS, typename RET >
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1) < LHS, RHS, RET, true > {
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-// checks for return type if template parameter RET is non void: use previously
-// defined struct
-template < typename LHS, typename RHS, typename RET >
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1) < LHS, RHS, RET, false > {
-   BOOST_STATIC_CONSTANT(bool, value = (BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl2)< LHS, RHS, RET, typename ::boost::integral_constant< bool, BOOST_JOIN(BOOST_TT_TRAIT_NAME,_returns_void)< LHS, RHS >::value > >::value));
-};
-
-// in case we do not want to check for return type, we still need to know if our
-// definition of operator BOOST_TT_TRAIT_OP is used or an other existing one;
-// this is done with redefinition of "operator," that returns tag or tag2
-struct tag2 { };
-tag operator,(tag, tag2);
-
-// do not check for return type if template parameter RET is void
-template < typename LHS, typename RHS >
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1)< LHS, RHS, void, false > {
-   static ::boost::type_traits::yes_type check(tag2); // this version is preferred when operator exists
-   static ::boost::type_traits::no_type check(tag); // this version is used otherwise
-
-   BOOST_STATIC_CONSTANT(bool, value = (sizeof(check(((make<LHS>() BOOST_TT_TRAIT_OP make<RHS>()),make<tag2>())))==sizeof(::boost::type_traits::yes_type)));
-};
-
-// some specializations needs to be declared for the special void case
-template < typename RHS, typename RET >
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1)< void, RHS, RET, false > {
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-template < typename LHS, typename RET >
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1)< LHS, void, RET, false > {
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-template < typename LHS >
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1)< LHS, void, void, false > {
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-template < typename RHS >
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1)< void, RHS, void, false > {
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-template < typename RET >
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1)< void, void, RET, false > {
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-template <>
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1)< void, void, void, false > {
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-// defines some typedef for convenience
-template < typename LHS, typename RHS, typename RET >
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl) {
-   typedef typename ::boost::remove_reference<LHS>::type lhs_noref;
-   typedef typename ::boost::remove_reference<RHS>::type rhs_noref;
-   typedef typename ::boost::remove_cv<lhs_noref>::type lhs_nocv;
-   typedef typename ::boost::remove_cv<rhs_noref>::type rhs_nocv;
-   typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<lhs_noref>::type >::type >::type lhs_noptr;
-   typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<rhs_noref>::type >::type >::type rhs_noptr;
-   BOOST_STATIC_CONSTANT(bool, value = (BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1) < lhs_noref, rhs_noref, RET, BOOST_TT_FORBIDDEN_IF >::value));
-};
-
-} // namespace impl
-} // namespace detail
-
-// this is the accessible definition of the trait to end user
-BOOST_TT_AUX_BOOL_TRAIT_DEF3(BOOST_TT_TRAIT_NAME, LHS, RHS=LHS, RET=BOOST_TT_DEFAULT_RET, (::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)< LHS, RHS, RET >::value))
-
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#   pragma warning ( pop )
-#endif
-
-#include <boost/type_traits/detail/bool_trait_undef.hpp>

Deleted: sandbox/type_traits/boost/type_traits/detail/has_postfix_operator.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/detail/has_postfix_operator.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,165 +0,0 @@
-//  (C) Copyright 2009-2011 Frédéric Bron, Robert Stewart, Steven Watanabe & Roman Perepelitsa
-//
-//  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.
-
-#include <boost/config.hpp>
-#include <boost/type_traits/ice.hpp>
-#include <boost/type_traits/integral_constant.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/is_fundamental.hpp>
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/is_void.hpp>
-#include <boost/type_traits/remove_cv.hpp>
-#include <boost/type_traits/remove_pointer.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-
-// should be the last #include
-#include <boost/type_traits/detail/bool_trait_def.hpp>
-
-namespace boost {
-namespace detail {
-
-// This namespace ensures that ADL does not mess things up.
-namespace BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl) {
-
-// 1. a function to have an instance of type T without requiring T to be default
-// constructible
-namespace {
-   template <typename T> T &make();
-}
-
-// 2. we provide our operator definition for types that do not have one already
-
-// a type returned from operator BOOST_TT_TRAIT_OP when no such operator is
-// found in the type's own namespace so that we have a means to know that our
-// operator was used
-struct tag { };
-
-// this class allows implicit conversions and makes the following operator
-// definition less-preferred than any other such operators that might be found
-// via argument-dependent name lookup
-struct any { template <class T> any(T const&); };
-
-// when operator BOOST_TT_TRAIT_OP is not available, this one is used
-tag operator BOOST_TT_TRAIT_OP (const any&, int);
-
-// 3. if the return type has to be checked, we need to determine if
-// operator BOOST_TT_TRAIT_OP returns void or not
-
-// we first redefine "operator," so that we have no compilation error if
-// operator BOOST_TT_TRAIT_OP returns void and we can use the return type of
-// (lhs BOOST_TT_TRAIT_OP, returns_void_t()) to deduce if
-// operator BOOST_TT_TRAIT_OP returns void or not:
-// - operator BOOST_TT_TRAIT_OP returns void   -> (lhs BOOST_TT_TRAIT_OP, returns_void_t()) returns returns_void_t
-// - operator BOOST_TT_TRAIT_OP returns !=void -> (lhs BOOST_TT_TRAIT_OP, returns_void_t()) returns int
-struct returns_void_t {};
-template <typename T> int operator,(T const &, returns_void_t);
-
-// this intermediate trait has member value of type bool:
-// - value==true -> operator BOOST_TT_TRAIT_OP returns void
-// - value==false -> operator BOOST_TT_TRAIT_OP does not return void
-template < typename LHS >
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_returns_void) {
-   // overloads of function returns_void make the difference
-   // yes_type and no_type have different size by construction
-   static ::boost::type_traits::yes_type returns_void(returns_void_t);
-   static ::boost::type_traits::no_type returns_void(int);
-   BOOST_STATIC_CONSTANT(bool, value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<LHS>() BOOST_TT_TRAIT_OP,returns_void_t())))));
-};
-
-// 4. check for return type when RET is non void
-
-// this class is used only when RET is non void, therefore it is specialized to
-// have its value==false when the operator returns void
-template < typename LHS, typename RET, typename RETURNS_VOID >
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl2);
-
-// operator BOOST_TT_TRAIT_OP does not return void, checks if it is convertible to
-// RET using the sizeof trick based on overload resolution
-template < typename LHS, typename RET >
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl2)< LHS, RET, ::boost::false_type > {
-   static ::boost::type_traits::yes_type is_convertible_to_RET(RET); // this version is preferred for types convertible to RET
-   static ::boost::type_traits::no_type is_convertible_to_RET(...); // this version is used otherwise
-
-   BOOST_STATIC_CONSTANT(bool, value = (sizeof(is_convertible_to_RET(make<LHS>() BOOST_TT_TRAIT_OP))==sizeof(::boost::type_traits::yes_type)));
-};
-
-// operator BOOST_TT_TRAIT_OP returns void!=RET -> specialization to return
-// value==false
-template < typename LHS, typename RET >
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl2)< LHS, RET, ::boost::true_type > {
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-// 5. main struct: to avoid any compilation error, this struct behaves
-// differently when:
-// - RET is void or non void
-// - operator BOOST_TT_TRAIT_OP(LHS) is forbidden by the standard
-// forbidden_if is a bool that is:
-// - true when the operator BOOST_TT_TRAIT_OP(LHS) is forbidden by the standard
-//   (would yield compilation error if used)
-// - false otherwise
-template < typename LHS, typename RET, bool forbidden_if >
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1);
-
-template < typename LHS, typename RET >
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1) < LHS, RET, true > {
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-// checks for return type if template parameter RET is non void: use previously
-// defined struct
-template < typename LHS, typename RET >
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1) < LHS, RET, false > {
-   BOOST_STATIC_CONSTANT(bool, value = (BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl2)< LHS, RET, typename ::boost::integral_constant< bool, BOOST_JOIN(BOOST_TT_TRAIT_NAME,_returns_void)< LHS >::value > >::value));
-};
-
-// in case we do not want to check for return type, we still need to know if our
-// definition of operator BOOST_TT_TRAIT_OP is used or an other existing one;
-// this is done with redefinition of "operator," that returns tag or tag2
-struct tag2 { };
-tag operator,(tag, tag2);
-
-// do not check for return type if template parameter RET is void
-template < typename LHS >
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1)< LHS, void, false > {
-   static ::boost::type_traits::yes_type check(tag2); // this version is preferred when operator exists
-   static ::boost::type_traits::no_type check(tag); // this version is used otherwise
-
-   BOOST_STATIC_CONSTANT(bool, value = (sizeof(check(((make<LHS>() BOOST_TT_TRAIT_OP),make<tag2>())))==sizeof(::boost::type_traits::yes_type)));
-};
-
-// some specializations needs to be declared for the special void case
-template < typename RET >
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1)< void, RET, false > {
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-template <>
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1)< void, void, false > {
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-// defines some typedef for convenience
-template < typename LHS, typename RET >
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl) {
-   typedef typename ::boost::remove_reference<LHS>::type lhs_noref;
-   typedef typename ::boost::remove_cv<lhs_noref>::type lhs_nocv;
-   typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<lhs_noref>::type >::type >::type lhs_noptr;
-   BOOST_STATIC_CONSTANT(bool, value = (BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1) < lhs_noref, RET, BOOST_TT_FORBIDDEN_IF >::value));
-};
-
-} // namespace impl
-} // namespace detail
-
-// this is the accessible definition of the trait to end user
-BOOST_TT_AUX_BOOL_TRAIT_DEF2(BOOST_TT_TRAIT_NAME, LHS, RET=BOOST_TT_DEFAULT_RET, (::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)< LHS, RET >::value))
-
-} // namespace boost
-
-#include <boost/type_traits/detail/bool_trait_undef.hpp>

Deleted: sandbox/type_traits/boost/type_traits/detail/has_prefix_operator.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/detail/has_prefix_operator.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,186 +0,0 @@
-//  (C) Copyright 2009-2011 Frédéric Bron, Robert Stewart, Steven Watanabe & Roman Perepelitsa
-//
-//  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.
-
-#include <boost/config.hpp>
-#include <boost/type_traits/ice.hpp>
-#include <boost/type_traits/integral_constant.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/is_fundamental.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/is_void.hpp>
-#include <boost/type_traits/remove_cv.hpp>
-#include <boost/type_traits/remove_pointer.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-
-// should be the last #include
-#include <boost/type_traits/detail/bool_trait_def.hpp>
-
-// cannot include this header without getting warnings of the kind:
-// gcc:
-//    warning: value computed is not used
-//    warning: comparison between signed and unsigned integer expressions
-// msvc:
-//    warning C4146: unary minus operator applied to unsigned type, result still unsigned
-//    warning C4804: '-' : unsafe use of type 'bool' in operation
-// cannot find another implementation -> declared as system header to suppress these warnings.
-#if defined(__GNUC__) && ((__GNUC__==3 && __GNUC_MINOR__>=1) || (__GNUC__>3))
-#   pragma GCC system_header
-#elif BOOST_MSVC
-#   pragma warning ( push )
-#   pragma warning ( disable : 4146 4804 )
-#endif
-
-namespace boost {
-namespace detail {
-
-// This namespace ensures that ADL does not mess things up.
-namespace BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl) {
-
-// 1. a function to have an instance of type T without requiring T to be default
-// constructible
-namespace {
-   template <typename T> T &make();
-}
-
-// 2. we provide our operator definition for types that do not have one already
-
-// a type returned from operator BOOST_TT_TRAIT_OP when no such operator is
-// found in the type's own namespace so that we have a means to know that our
-// operator was used
-struct tag { };
-
-// this class allows implicit conversions and makes the following operator
-// definition less-preferred than any other such operators that might be found
-// via argument-dependent name lookup
-struct any { template <class T> any(T const&); };
-
-// when operator BOOST_TT_TRAIT_OP is not available, this one is used
-tag operator BOOST_TT_TRAIT_OP (const any&);
-
-// 3. if the return type has to be checked, we need to determine if
-// operator BOOST_TT_TRAIT_OP returns void or not
-
-// we first redefine "operator," so that we have no compilation error if
-// operator BOOST_TT_TRAIT_OP returns void and we can use the return type of
-// (BOOST_TT_TRAIT_OP rhs, returns_void_t()) to deduce if
-// operator BOOST_TT_TRAIT_OP returns void or not:
-// - operator BOOST_TT_TRAIT_OP returns void   -> (BOOST_TT_TRAIT_OP rhs, returns_void_t()) returns returns_void_t
-// - operator BOOST_TT_TRAIT_OP returns !=void -> (BOOST_TT_TRAIT_OP rhs, returns_void_t()) returns int
-struct returns_void_t {};
-template <typename T> int operator,(T const &, returns_void_t);
-
-// this intermediate trait has member value of type bool:
-// - value==true -> operator BOOST_TT_TRAIT_OP returns void
-// - value==false -> operator BOOST_TT_TRAIT_OP does not return void
-template < typename RHS >
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_returns_void) {
-   // overloads of function returns_void make the difference
-   // yes_type and no_type have different size by construction
-   static ::boost::type_traits::yes_type returns_void(returns_void_t);
-   static ::boost::type_traits::no_type returns_void(int);
-   BOOST_STATIC_CONSTANT(bool, value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((BOOST_TT_TRAIT_OP make<RHS>(),returns_void_t())))));
-};
-
-// 4. check for return type when RET is non void
-
-// this class is used only when RET is non void, therefore it is specialized to
-// have its value==false when the operator returns void
-template < typename RHS, typename RET, typename RETURNS_VOID >
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl2);
-
-// operator BOOST_TT_TRAIT_OP does not return void, checks if it is convertible to
-// RET using the sizeof trick based on overload resolution
-template < typename RHS, typename RET >
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl2)< RHS, RET, ::boost::false_type > {
-   static ::boost::type_traits::yes_type is_convertible_to_RET(RET); // this version is preferred for types convertible to RET
-   static ::boost::type_traits::no_type is_convertible_to_RET(...); // this version is used otherwise
-
-   BOOST_STATIC_CONSTANT(bool, value = (sizeof(is_convertible_to_RET(BOOST_TT_TRAIT_OP make<RHS>()))==sizeof(::boost::type_traits::yes_type)));
-};
-
-// operator BOOST_TT_TRAIT_OP returns void!=RET -> specialization to return
-// value==false
-template < typename RHS, typename RET >
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl2)< RHS, RET, ::boost::true_type > {
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-// 5. main struct: to avoid any compilation error, this struct behaves
-// differently when:
-// - RET is void or non void
-// - operator BOOST_TT_TRAIT_OP(RHS) is forbidden by the standard
-// forbidden_if is a bool that is:
-// - true when the operator BOOST_TT_TRAIT_OP(RHS) is forbidden by the standard
-//   (would yield compilation error if used)
-// - false otherwise
-template < typename RHS, typename RET, bool forbidden_if >
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1);
-
-// specialization to avoid compilation error when forbidden by the standard
-template < typename RHS, typename RET >
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1) < RHS, RET, true > {
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-// checks for return type if template parameter RET is non void: use previously
-// defined struct
-template < typename RHS, typename RET >
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1) < RHS, RET, false > {
-   BOOST_STATIC_CONSTANT(bool, value = (BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl2)< RHS, RET, typename ::boost::integral_constant< bool, BOOST_JOIN(BOOST_TT_TRAIT_NAME,_returns_void)< RHS >::value > >::value));
-};
-
-// in case we do not want to check for return type, we still need to know if our
-// definition of operator BOOST_TT_TRAIT_OP is used or an other existing one;
-// this is done with redefinition of "operator," that returns tag or tag2
-struct tag2 { };
-tag operator,(tag, tag2);
-
-// do not check for return type if template parameter RET is void
-template < typename RHS >
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1)< RHS, void, false > {
-   static ::boost::type_traits::yes_type check(tag2); // this version is preferred when operator exists
-   static ::boost::type_traits::no_type check(tag); // this version is used otherwise
-
-   BOOST_STATIC_CONSTANT(bool, value = (sizeof(check(((BOOST_TT_TRAIT_OP make<RHS>()),make<tag2>())))==sizeof(::boost::type_traits::yes_type)));
-};
-
-// some specializations needs to be declared for the special void case
-template < typename RET >
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1)< void, RET, false > {
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-template <>
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1)< void, void, false > {
-   BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-// defines some typedef for convenience
-template < typename RHS, typename RET >
-struct BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl) {
-   typedef typename ::boost::remove_reference<RHS>::type rhs_noref;
-   typedef typename ::boost::remove_cv<rhs_noref>::type rhs_nocv;
-   typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<rhs_noref>::type >::type >::type rhs_noptr;
-   BOOST_STATIC_CONSTANT(bool, value = (BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl1) < rhs_noref, RET, BOOST_TT_FORBIDDEN_IF >::value));
-};
-
-} // namespace impl
-} // namespace detail
-
-// this is the accessible definition of the trait to end user
-BOOST_TT_AUX_BOOL_TRAIT_DEF2(BOOST_TT_TRAIT_NAME, RHS, RET=BOOST_TT_DEFAULT_RET, (::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)< RHS, RET >::value))
-
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#   pragma warning ( pop )
-#endif
-
-#include <boost/type_traits/detail/bool_trait_undef.hpp>

Deleted: sandbox/type_traits/boost/type_traits/has_operator_bit_and.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_bit_and.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,52 +0,0 @@
-//  (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_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 &
-#define BOOST_TT_DEFAULT_RET void
-#define BOOST_TT_FORBIDDEN_IF\
-   ::boost::type_traits::ice_or<\
-      /* two fundamental, one non integral */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_fundamental< lhs_nocv >::value,\
-         ::boost::is_fundamental< rhs_nocv >::value,\
-         ::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\
-         >::value\
-      >::value,\
-      /* one fundamental, one pointer */\
-      ::boost::type_traits::ice_or<\
-         ::boost::type_traits::ice_and<\
-            ::boost::is_fundamental< lhs_nocv >::value,\
-            ::boost::is_pointer< rhs_noref >::value\
-         >::value,\
-         ::boost::type_traits::ice_and<\
-            ::boost::is_fundamental< rhs_nocv >::value,\
-            ::boost::is_pointer< lhs_noref >::value\
-         >::value\
-      >::value,\
-      /* two pointers */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::is_pointer< rhs_noref >::value\
-      >::value\
-   >::value
-
-
-#include <boost/type_traits/detail/has_binary_operator.hpp>
-
-#undef BOOST_TT_TRAIT_NAME
-#undef BOOST_TT_TRAIT_OP
-#undef BOOST_TT_DEFAULT_RET
-#undef BOOST_TT_FORBIDDEN_IF
-
-#endif

Deleted: sandbox/type_traits/boost/type_traits/has_operator_bit_and_equal.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_bit_and_equal.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,53 +0,0 @@
-//  (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_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 &=
-#define BOOST_TT_DEFAULT_RET void
-#define BOOST_TT_FORBIDDEN_IF\
-   ::boost::type_traits::ice_or<\
-      /* two fundamental, one non integral or lhs is const*/\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_fundamental< lhs_nocv >::value,\
-         ::boost::is_fundamental< rhs_nocv >::value,\
-         ::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\
-         >::value\
-      >::value,\
-      /* one fundamental, one pointer */\
-      ::boost::type_traits::ice_or<\
-         ::boost::type_traits::ice_and<\
-            ::boost::is_fundamental< lhs_nocv >::value,\
-            ::boost::is_pointer< rhs_noref >::value\
-         >::value,\
-         ::boost::type_traits::ice_and<\
-            ::boost::is_fundamental< rhs_nocv >::value,\
-            ::boost::is_pointer< lhs_noref >::value\
-         >::value\
-      >::value,\
-      /* two pointers */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::is_pointer< rhs_noref >::value\
-      >::value\
-   >::value
-
-
-#include <boost/type_traits/detail/has_binary_operator.hpp>
-
-#undef BOOST_TT_TRAIT_NAME
-#undef BOOST_TT_TRAIT_OP
-#undef BOOST_TT_DEFAULT_RET
-#undef BOOST_TT_FORBIDDEN_IF
-
-#endif

Deleted: sandbox/type_traits/boost/type_traits/has_operator_bit_or.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_bit_or.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,52 +0,0 @@
-//  (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_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 |
-#define BOOST_TT_DEFAULT_RET void
-#define BOOST_TT_FORBIDDEN_IF\
-   ::boost::type_traits::ice_or<\
-      /* two fundamental, one non integral */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_fundamental< lhs_nocv >::value,\
-         ::boost::is_fundamental< rhs_nocv >::value,\
-         ::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\
-         >::value\
-      >::value,\
-      /* one fundamental, one pointer */\
-      ::boost::type_traits::ice_or<\
-         ::boost::type_traits::ice_and<\
-            ::boost::is_fundamental< lhs_nocv >::value,\
-            ::boost::is_pointer< rhs_noref >::value\
-         >::value,\
-         ::boost::type_traits::ice_and<\
-            ::boost::is_fundamental< rhs_nocv >::value,\
-            ::boost::is_pointer< lhs_noref >::value\
-         >::value\
-      >::value,\
-      /* two pointers */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::is_pointer< rhs_noref >::value\
-      >::value\
-   >::value
-
-
-#include <boost/type_traits/detail/has_binary_operator.hpp>
-
-#undef BOOST_TT_TRAIT_NAME
-#undef BOOST_TT_TRAIT_OP
-#undef BOOST_TT_DEFAULT_RET
-#undef BOOST_TT_FORBIDDEN_IF
-
-#endif

Deleted: sandbox/type_traits/boost/type_traits/has_operator_bit_or_equal.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_bit_or_equal.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,53 +0,0 @@
-//  (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_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 |=
-#define BOOST_TT_DEFAULT_RET void
-#define BOOST_TT_FORBIDDEN_IF\
-   ::boost::type_traits::ice_or<\
-      /* two fundamental, one non integral or lhs is const*/\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_fundamental< lhs_nocv >::value,\
-         ::boost::is_fundamental< rhs_nocv >::value,\
-         ::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\
-         >::value\
-      >::value,\
-      /* one fundamental, one pointer */\
-      ::boost::type_traits::ice_or<\
-         ::boost::type_traits::ice_and<\
-            ::boost::is_fundamental< lhs_nocv >::value,\
-            ::boost::is_pointer< rhs_noref >::value\
-         >::value,\
-         ::boost::type_traits::ice_and<\
-            ::boost::is_fundamental< rhs_nocv >::value,\
-            ::boost::is_pointer< lhs_noref >::value\
-         >::value\
-      >::value,\
-      /* two pointers */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::is_pointer< rhs_noref >::value\
-      >::value\
-   >::value
-
-
-#include <boost/type_traits/detail/has_binary_operator.hpp>
-
-#undef BOOST_TT_TRAIT_NAME
-#undef BOOST_TT_TRAIT_OP
-#undef BOOST_TT_DEFAULT_RET
-#undef BOOST_TT_FORBIDDEN_IF
-
-#endif

Deleted: sandbox/type_traits/boost/type_traits/has_operator_bit_xor.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_bit_xor.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,52 +0,0 @@
-//  (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_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 ^
-#define BOOST_TT_DEFAULT_RET void
-#define BOOST_TT_FORBIDDEN_IF\
-   ::boost::type_traits::ice_or<\
-      /* two fundamental, one non integral */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_fundamental< lhs_nocv >::value,\
-         ::boost::is_fundamental< rhs_nocv >::value,\
-         ::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\
-         >::value\
-      >::value,\
-      /* one fundamental, one pointer */\
-      ::boost::type_traits::ice_or<\
-         ::boost::type_traits::ice_and<\
-            ::boost::is_fundamental< lhs_nocv >::value,\
-            ::boost::is_pointer< rhs_noref >::value\
-         >::value,\
-         ::boost::type_traits::ice_and<\
-            ::boost::is_fundamental< rhs_nocv >::value,\
-            ::boost::is_pointer< lhs_noref >::value\
-         >::value\
-      >::value,\
-      /* two pointers */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::is_pointer< rhs_noref >::value\
-      >::value\
-   >::value
-
-
-#include <boost/type_traits/detail/has_binary_operator.hpp>
-
-#undef BOOST_TT_TRAIT_NAME
-#undef BOOST_TT_TRAIT_OP
-#undef BOOST_TT_DEFAULT_RET
-#undef BOOST_TT_FORBIDDEN_IF
-
-#endif

Deleted: sandbox/type_traits/boost/type_traits/has_operator_bit_xor_equal.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_bit_xor_equal.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,53 +0,0 @@
-//  (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_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 ^=
-#define BOOST_TT_DEFAULT_RET void
-#define BOOST_TT_FORBIDDEN_IF\
-   ::boost::type_traits::ice_or<\
-      /* two fundamental, one non integral or lhs is const*/\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_fundamental< lhs_nocv >::value,\
-         ::boost::is_fundamental< rhs_nocv >::value,\
-         ::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\
-         >::value\
-      >::value,\
-      /* one fundamental, one pointer */\
-      ::boost::type_traits::ice_or<\
-         ::boost::type_traits::ice_and<\
-            ::boost::is_fundamental< lhs_nocv >::value,\
-            ::boost::is_pointer< rhs_noref >::value\
-         >::value,\
-         ::boost::type_traits::ice_and<\
-            ::boost::is_fundamental< rhs_nocv >::value,\
-            ::boost::is_pointer< lhs_noref >::value\
-         >::value\
-      >::value,\
-      /* two pointers */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::is_pointer< rhs_noref >::value\
-      >::value\
-   >::value
-
-
-#include <boost/type_traits/detail/has_binary_operator.hpp>
-
-#undef BOOST_TT_TRAIT_NAME
-#undef BOOST_TT_TRAIT_OP
-#undef BOOST_TT_DEFAULT_RET
-#undef BOOST_TT_FORBIDDEN_IF
-
-#endif

Deleted: sandbox/type_traits/boost/type_traits/has_operator_complement.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_complement.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,34 +0,0 @@
-//  (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_COMPLEMENT_HPP_INCLUDED
-#define BOOST_TT_HAS_OPERATOR_COMPLEMENT_HPP_INCLUDED
-
-#define BOOST_TT_TRAIT_NAME has_operator_complement
-#define BOOST_TT_TRAIT_OP ~
-#define BOOST_TT_DEFAULT_RET void
-#define BOOST_TT_FORBIDDEN_IF\
-   ::boost::type_traits::ice_or<\
-      /* pointer */\
-      ::boost::is_pointer< rhs_noref >::value,\
-      /* fundamental non integral */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_fundamental< rhs_noref >::value,\
-         ::boost::type_traits::ice_not< ::boost::is_integral< rhs_noref >::value >::value\
-      >::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

Deleted: sandbox/type_traits/boost/type_traits/has_operator_dereference.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_dereference.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,33 +0,0 @@
-//  (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< rhs_noptr >::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

Deleted: sandbox/type_traits/boost/type_traits/has_operator_divides.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_divides.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,42 +0,0 @@
-//  (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_DIVIDES_HPP_INCLUDED
-#define BOOST_TT_HAS_OPERATOR_DIVIDES_HPP_INCLUDED
-
-#define BOOST_TT_TRAIT_NAME has_operator_divides
-#define BOOST_TT_TRAIT_OP /
-#define BOOST_TT_DEFAULT_RET void
-#define BOOST_TT_FORBIDDEN_IF\
-   /* pointer with pointer or fundamental */\
-   ::boost::type_traits::ice_or<\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::type_traits::ice_or<\
-            ::boost::is_fundamental< rhs_nocv >::value,\
-            ::boost::is_pointer< rhs_noref >::value\
-         >::value\
-      >::value,\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< rhs_noref >::value,\
-         ::boost::type_traits::ice_or<\
-            ::boost::is_fundamental< lhs_nocv >::value,\
-            ::boost::is_pointer< lhs_noref >::value\
-         >::value\
-      >::value\
-   >::value
-
-
-#include <boost/type_traits/detail/has_binary_operator.hpp>
-
-#undef BOOST_TT_TRAIT_NAME
-#undef BOOST_TT_TRAIT_OP
-#undef BOOST_TT_DEFAULT_RET
-#undef BOOST_TT_FORBIDDEN_IF
-
-#endif

Deleted: sandbox/type_traits/boost/type_traits/has_operator_divides_equal.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_divides_equal.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,48 +0,0 @@
-//  (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_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 /=
-#define BOOST_TT_DEFAULT_RET void
-#define BOOST_TT_FORBIDDEN_IF\
-   ::boost::type_traits::ice_or<\
-      /* LHS is fundamental and const, RHS is fundamental */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_fundamental< lhs_nocv >::value,\
-         ::boost::is_const< lhs_noref >::value,\
-         ::boost::is_fundamental< rhs_nocv >::value\
-      >::value,\
-      /* pointer with pointer or fundamental */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::type_traits::ice_or<\
-            ::boost::is_fundamental< rhs_nocv >::value,\
-            ::boost::is_pointer< rhs_noref >::value\
-         >::value\
-      >::value,\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< rhs_noref >::value,\
-         ::boost::type_traits::ice_or<\
-            ::boost::is_fundamental< lhs_nocv >::value,\
-            ::boost::is_pointer< lhs_noref >::value\
-         >::value\
-      >::value\
-   >::value
-
-
-#include <boost/type_traits/detail/has_binary_operator.hpp>
-
-#undef BOOST_TT_TRAIT_NAME
-#undef BOOST_TT_TRAIT_OP
-#undef BOOST_TT_DEFAULT_RET
-#undef BOOST_TT_FORBIDDEN_IF
-
-#endif

Deleted: sandbox/type_traits/boost/type_traits/has_operator_equal_to.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_equal_to.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,50 +0,0 @@
-//  (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_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 ==
-#define BOOST_TT_DEFAULT_RET void
-#define BOOST_TT_FORBIDDEN_IF\
-   ::boost::type_traits::ice_or<\
-      /* pointer and fundamental */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::is_fundamental< rhs_nocv >::value\
-      >::value,\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< rhs_noref >::value,\
-         ::boost::is_fundamental< lhs_nocv >::value\
-      >::value,\
-      /* two pointers but no inheritance or no void* */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::is_pointer< rhs_noref >::value,\
-         ::boost::type_traits::ice_not<\
-            ::boost::type_traits::ice_or<\
-               ::boost::is_base_of< lhs_noptr, rhs_noptr >::value,\
-               ::boost::is_base_of< rhs_noptr, lhs_noptr >::value,\
-               ::boost::is_same< lhs_noptr, rhs_noptr >::value,\
-               ::boost::is_void< lhs_noptr >::value,\
-               ::boost::is_void< rhs_noptr >::value\
-            >::value\
-         >::value\
-      >::value\
-   >::value
-
-
-#include <boost/type_traits/detail/has_binary_operator.hpp>
-
-#undef BOOST_TT_TRAIT_NAME
-#undef BOOST_TT_TRAIT_OP
-#undef BOOST_TT_DEFAULT_RET
-#undef BOOST_TT_FORBIDDEN_IF
-
-#endif

Deleted: sandbox/type_traits/boost/type_traits/has_operator_greater.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_greater.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,50 +0,0 @@
-//  (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_GREATER_HPP_INCLUDED
-#define BOOST_TT_HAS_OPERATOR_GREATER_HPP_INCLUDED
-
-#define BOOST_TT_TRAIT_NAME has_operator_greater
-#define BOOST_TT_TRAIT_OP >
-#define BOOST_TT_DEFAULT_RET void
-#define BOOST_TT_FORBIDDEN_IF\
-   ::boost::type_traits::ice_or<\
-      /* pointer and fundamental */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::is_fundamental< rhs_nocv >::value\
-      >::value,\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< rhs_noref >::value,\
-         ::boost::is_fundamental< lhs_nocv >::value\
-      >::value,\
-      /* two pointers but no inheritance or no void* */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::is_pointer< rhs_noref >::value,\
-         ::boost::type_traits::ice_not<\
-            ::boost::type_traits::ice_or<\
-               ::boost::is_base_of< lhs_noptr, rhs_noptr >::value,\
-               ::boost::is_base_of< rhs_noptr, lhs_noptr >::value,\
-               ::boost::is_same< lhs_noptr, rhs_noptr >::value,\
-               ::boost::is_void< lhs_noptr >::value,\
-               ::boost::is_void< rhs_noptr >::value\
-            >::value\
-         >::value\
-      >::value\
-   >::value
-
-
-#include <boost/type_traits/detail/has_binary_operator.hpp>
-
-#undef BOOST_TT_TRAIT_NAME
-#undef BOOST_TT_TRAIT_OP
-#undef BOOST_TT_DEFAULT_RET
-#undef BOOST_TT_FORBIDDEN_IF
-
-#endif

Deleted: sandbox/type_traits/boost/type_traits/has_operator_greater_equal.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_greater_equal.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,50 +0,0 @@
-//  (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_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 >=
-#define BOOST_TT_DEFAULT_RET void
-#define BOOST_TT_FORBIDDEN_IF\
-   ::boost::type_traits::ice_or<\
-      /* pointer and fundamental */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::is_fundamental< rhs_nocv >::value\
-      >::value,\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< rhs_noref >::value,\
-         ::boost::is_fundamental< lhs_nocv >::value\
-      >::value,\
-      /* two pointers but no inheritance or no void* */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::is_pointer< rhs_noref >::value,\
-         ::boost::type_traits::ice_not<\
-            ::boost::type_traits::ice_or<\
-               ::boost::is_base_of< lhs_noptr, rhs_noptr >::value,\
-               ::boost::is_base_of< rhs_noptr, lhs_noptr >::value,\
-               ::boost::is_same< lhs_noptr, rhs_noptr >::value,\
-               ::boost::is_void< lhs_noptr >::value,\
-               ::boost::is_void< rhs_noptr >::value\
-            >::value\
-         >::value\
-      >::value\
-   >::value
-
-
-#include <boost/type_traits/detail/has_binary_operator.hpp>
-
-#undef BOOST_TT_TRAIT_NAME
-#undef BOOST_TT_TRAIT_OP
-#undef BOOST_TT_DEFAULT_RET
-#undef BOOST_TT_FORBIDDEN_IF
-
-#endif

Deleted: sandbox/type_traits/boost/type_traits/has_operator_left_shift.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_left_shift.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,52 +0,0 @@
-//  (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_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 <<
-#define BOOST_TT_DEFAULT_RET void
-#define BOOST_TT_FORBIDDEN_IF\
-   ::boost::type_traits::ice_or<\
-      /* two fundamental, one non integral */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_fundamental< lhs_nocv >::value,\
-         ::boost::is_fundamental< rhs_nocv >::value,\
-         ::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\
-         >::value\
-      >::value,\
-      /* one fundamental, one pointer */\
-      ::boost::type_traits::ice_or<\
-         ::boost::type_traits::ice_and<\
-            ::boost::is_fundamental< lhs_nocv >::value,\
-            ::boost::is_pointer< rhs_noref >::value\
-         >::value,\
-         ::boost::type_traits::ice_and<\
-            ::boost::is_fundamental< rhs_nocv >::value,\
-            ::boost::is_pointer< lhs_noref >::value\
-         >::value\
-      >::value,\
-      /* two pointers */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::is_pointer< rhs_noref >::value\
-      >::value\
-   >::value
-
-
-#include <boost/type_traits/detail/has_binary_operator.hpp>
-
-#undef BOOST_TT_TRAIT_NAME
-#undef BOOST_TT_TRAIT_OP
-#undef BOOST_TT_DEFAULT_RET
-#undef BOOST_TT_FORBIDDEN_IF
-
-#endif

Deleted: sandbox/type_traits/boost/type_traits/has_operator_left_shift_equal.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_left_shift_equal.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,53 +0,0 @@
-//  (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_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 <<=
-#define BOOST_TT_DEFAULT_RET void
-#define BOOST_TT_FORBIDDEN_IF\
-   ::boost::type_traits::ice_or<\
-      /* two fundamental, one non integral or lhs is const*/\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_fundamental< lhs_nocv >::value,\
-         ::boost::is_fundamental< rhs_nocv >::value,\
-         ::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\
-         >::value\
-      >::value,\
-      /* one fundamental, one pointer */\
-      ::boost::type_traits::ice_or<\
-         ::boost::type_traits::ice_and<\
-            ::boost::is_fundamental< lhs_nocv >::value,\
-            ::boost::is_pointer< rhs_noref >::value\
-         >::value,\
-         ::boost::type_traits::ice_and<\
-            ::boost::is_fundamental< rhs_nocv >::value,\
-            ::boost::is_pointer< lhs_noref >::value\
-         >::value\
-      >::value,\
-      /* two pointers */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::is_pointer< rhs_noref >::value\
-      >::value\
-   >::value
-
-
-#include <boost/type_traits/detail/has_binary_operator.hpp>
-
-#undef BOOST_TT_TRAIT_NAME
-#undef BOOST_TT_TRAIT_OP
-#undef BOOST_TT_DEFAULT_RET
-#undef BOOST_TT_FORBIDDEN_IF
-
-#endif

Deleted: sandbox/type_traits/boost/type_traits/has_operator_less.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_less.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,50 +0,0 @@
-//  (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_LESS_HPP_INCLUDED
-#define BOOST_TT_HAS_OPERATOR_LESS_HPP_INCLUDED
-
-#define BOOST_TT_TRAIT_NAME has_operator_less
-#define BOOST_TT_TRAIT_OP <
-#define BOOST_TT_DEFAULT_RET void
-#define BOOST_TT_FORBIDDEN_IF\
-   ::boost::type_traits::ice_or<\
-      /* pointer and fundamental */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::is_fundamental< rhs_nocv >::value\
-      >::value,\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< rhs_noref >::value,\
-         ::boost::is_fundamental< lhs_nocv >::value\
-      >::value,\
-      /* two pointers but no inheritance or no void* */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::is_pointer< rhs_noref >::value,\
-         ::boost::type_traits::ice_not<\
-            ::boost::type_traits::ice_or<\
-               ::boost::is_base_of< lhs_noptr, rhs_noptr >::value,\
-               ::boost::is_base_of< rhs_noptr, lhs_noptr >::value,\
-               ::boost::is_same< lhs_noptr, rhs_noptr >::value,\
-               ::boost::is_void< lhs_noptr >::value,\
-               ::boost::is_void< rhs_noptr >::value\
-            >::value\
-         >::value\
-      >::value\
-   >::value
-
-
-#include <boost/type_traits/detail/has_binary_operator.hpp>
-
-#undef BOOST_TT_TRAIT_NAME
-#undef BOOST_TT_TRAIT_OP
-#undef BOOST_TT_DEFAULT_RET
-#undef BOOST_TT_FORBIDDEN_IF
-
-#endif

Deleted: sandbox/type_traits/boost/type_traits/has_operator_less_equal.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_less_equal.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,50 +0,0 @@
-//  (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_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 <=
-#define BOOST_TT_DEFAULT_RET void
-#define BOOST_TT_FORBIDDEN_IF\
-   ::boost::type_traits::ice_or<\
-      /* pointer and fundamental */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::is_fundamental< rhs_nocv >::value\
-      >::value,\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< rhs_noref >::value,\
-         ::boost::is_fundamental< lhs_nocv >::value\
-      >::value,\
-      /* two pointers but no inheritance or no void* */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::is_pointer< rhs_noref >::value,\
-         ::boost::type_traits::ice_not<\
-            ::boost::type_traits::ice_or<\
-               ::boost::is_base_of< lhs_noptr, rhs_noptr >::value,\
-               ::boost::is_base_of< rhs_noptr, lhs_noptr >::value,\
-               ::boost::is_same< lhs_noptr, rhs_noptr >::value,\
-               ::boost::is_void< lhs_noptr >::value,\
-               ::boost::is_void< rhs_noptr >::value\
-            >::value\
-         >::value\
-      >::value\
-   >::value
-
-
-#include <boost/type_traits/detail/has_binary_operator.hpp>
-
-#undef BOOST_TT_TRAIT_NAME
-#undef BOOST_TT_TRAIT_OP
-#undef BOOST_TT_DEFAULT_RET
-#undef BOOST_TT_FORBIDDEN_IF
-
-#endif

Deleted: sandbox/type_traits/boost/type_traits/has_operator_logical_and.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_logical_and.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,42 +0,0 @@
-//  (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_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 &&
-#define BOOST_TT_DEFAULT_RET void
-#define BOOST_TT_FORBIDDEN_IF\
-   /* pointer with fundamental non convertible to bool */\
-   ::boost::type_traits::ice_or<\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::type_traits::ice_and<\
-            ::boost::is_fundamental< rhs_nocv >::value,\
-            ::boost::type_traits::ice_not< ::boost::is_convertible< rhs_nocv, bool >::value >::value\
-         >::value\
-      >::value,\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< rhs_noref >::value,\
-         ::boost::type_traits::ice_and<\
-            ::boost::is_fundamental< lhs_nocv >::value,\
-            ::boost::type_traits::ice_not< ::boost::is_convertible< lhs_nocv, bool >::value >::value\
-         >::value\
-      >::value\
-   >::value
-
-
-#include <boost/type_traits/detail/has_binary_operator.hpp>
-
-#undef BOOST_TT_TRAIT_NAME
-#undef BOOST_TT_TRAIT_OP
-#undef BOOST_TT_DEFAULT_RET
-#undef BOOST_TT_FORBIDDEN_IF
-
-#endif

Deleted: sandbox/type_traits/boost/type_traits/has_operator_logical_not.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_logical_not.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,25 +0,0 @@
-//  (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_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 !
-#define BOOST_TT_DEFAULT_RET void
-#define BOOST_TT_FORBIDDEN_IF\
-   false
-
-#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

Deleted: sandbox/type_traits/boost/type_traits/has_operator_logical_or.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_logical_or.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,42 +0,0 @@
-//  (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_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 ||
-#define BOOST_TT_DEFAULT_RET void
-#define BOOST_TT_FORBIDDEN_IF\
-   /* pointer with fundamental non convertible to bool */\
-   ::boost::type_traits::ice_or<\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::type_traits::ice_and<\
-            ::boost::is_fundamental< rhs_nocv >::value,\
-            ::boost::type_traits::ice_not< ::boost::is_convertible< rhs_nocv, bool >::value >::value\
-         >::value\
-      >::value,\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< rhs_noref >::value,\
-         ::boost::type_traits::ice_and<\
-            ::boost::is_fundamental< lhs_nocv >::value,\
-            ::boost::type_traits::ice_not< ::boost::is_convertible< lhs_nocv, bool >::value >::value\
-         >::value\
-      >::value\
-   >::value
-
-
-#include <boost/type_traits/detail/has_binary_operator.hpp>
-
-#undef BOOST_TT_TRAIT_NAME
-#undef BOOST_TT_TRAIT_OP
-#undef BOOST_TT_DEFAULT_RET
-#undef BOOST_TT_FORBIDDEN_IF
-
-#endif

Deleted: sandbox/type_traits/boost/type_traits/has_operator_minus.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_minus.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,62 +0,0 @@
-//  (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_MINUS_HPP_INCLUDED
-#define BOOST_TT_HAS_OPERATOR_MINUS_HPP_INCLUDED
-
-#define BOOST_TT_TRAIT_NAME has_operator_minus
-#define BOOST_TT_TRAIT_OP -
-#define BOOST_TT_DEFAULT_RET void
-#define BOOST_TT_FORBIDDEN_IF\
-   ::boost::type_traits::ice_or<\
-      /* void* with fundamental or pointer */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::is_void< lhs_noptr >::value,\
-         ::boost::type_traits::ice_or<\
-            ::boost::is_fundamental< rhs_nocv >::value,\
-            ::boost::is_pointer< rhs_noref >::value\
-         >::value\
-      >::value,\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< rhs_noref >::value,\
-         ::boost::is_void< rhs_noptr >::value,\
-         ::boost::type_traits::ice_or<\
-            ::boost::is_fundamental< lhs_nocv >::value,\
-            ::boost::is_pointer< lhs_noref >::value\
-         >::value\
-      >::value,\
-      /* LHS==pointer!=void* and RHS==fundamental non integral */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::type_traits::ice_not< ::boost::is_void< lhs_noptr >::value >::value,\
-         ::boost::is_fundamental< rhs_nocv >::value,\
-         ::boost::type_traits::ice_not< ::boost::is_integral< rhs_noref >::value >::value\
-      >::value,\
-      /* LHS=fundamental and RHS=pointer */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_fundamental< lhs_nocv >::value,\
-         ::boost::is_pointer< rhs_noref >::value\
-      >::value,\
-      /* two different pointers */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::is_pointer< rhs_noref >::value,\
-         ::boost::type_traits::ice_not< ::boost::is_same< lhs_nocv, rhs_nocv >::value >::value\
-      >::value\
-   >::value
-
-
-#include <boost/type_traits/detail/has_binary_operator.hpp>
-
-#undef BOOST_TT_TRAIT_NAME
-#undef BOOST_TT_TRAIT_OP
-#undef BOOST_TT_DEFAULT_RET
-#undef BOOST_TT_FORBIDDEN_IF
-
-#endif

Deleted: sandbox/type_traits/boost/type_traits/has_operator_minus_equal.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_minus_equal.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,50 +0,0 @@
-//  (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_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 -=
-#define BOOST_TT_DEFAULT_RET void
-#define BOOST_TT_FORBIDDEN_IF\
-   ::boost::type_traits::ice_or<\
-      /* LHS is fundamental and const, RHS is fundamental */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_fundamental< lhs_nocv >::value,\
-         ::boost::is_const< lhs_noref >::value,\
-         ::boost::is_fundamental< rhs_nocv >::value\
-      >::value,\
-      /* RHS==pointer */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< rhs_noref >::value,\
-         ::boost::type_traits::ice_or<\
-            ::boost::is_fundamental< lhs_nocv >::value,\
-            ::boost::is_pointer< lhs_noref >::value\
-         >::value\
-      >::value,\
-      /* LHS==pointer and RHS==fundamental and (LHS==void* or RHS!=integral) */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::is_fundamental< rhs_nocv >::value,\
-         ::boost::type_traits::ice_or<\
-            ::boost::is_void< lhs_noptr >::value,\
-            ::boost::type_traits::ice_not< ::boost::is_integral< rhs_noref >::value >::value\
-         >::value\
-      >::value\
-   >::value
-
-
-#include <boost/type_traits/detail/has_binary_operator.hpp>
-
-#undef BOOST_TT_TRAIT_NAME
-#undef BOOST_TT_TRAIT_OP
-#undef BOOST_TT_DEFAULT_RET
-#undef BOOST_TT_FORBIDDEN_IF
-
-#endif

Deleted: sandbox/type_traits/boost/type_traits/has_operator_modulus.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_modulus.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,52 +0,0 @@
-//  (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_MODULUS_HPP_INCLUDED
-#define BOOST_TT_HAS_OPERATOR_MODULUS_HPP_INCLUDED
-
-#define BOOST_TT_TRAIT_NAME has_operator_modulus
-#define BOOST_TT_TRAIT_OP %
-#define BOOST_TT_DEFAULT_RET void
-#define BOOST_TT_FORBIDDEN_IF\
-   ::boost::type_traits::ice_or<\
-      /* two fundamental, one non integral */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_fundamental< lhs_nocv >::value,\
-         ::boost::is_fundamental< rhs_nocv >::value,\
-         ::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\
-         >::value\
-      >::value,\
-      /* one fundamental, one pointer */\
-      ::boost::type_traits::ice_or<\
-         ::boost::type_traits::ice_and<\
-            ::boost::is_fundamental< lhs_nocv >::value,\
-            ::boost::is_pointer< rhs_noref >::value\
-         >::value,\
-         ::boost::type_traits::ice_and<\
-            ::boost::is_fundamental< rhs_nocv >::value,\
-            ::boost::is_pointer< lhs_noref >::value\
-         >::value\
-      >::value,\
-      /* two pointers */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::is_pointer< rhs_noref >::value\
-      >::value\
-   >::value
-
-
-#include <boost/type_traits/detail/has_binary_operator.hpp>
-
-#undef BOOST_TT_TRAIT_NAME
-#undef BOOST_TT_TRAIT_OP
-#undef BOOST_TT_DEFAULT_RET
-#undef BOOST_TT_FORBIDDEN_IF
-
-#endif

Deleted: sandbox/type_traits/boost/type_traits/has_operator_modulus_equal.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_modulus_equal.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,53 +0,0 @@
-//  (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_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 %=
-#define BOOST_TT_DEFAULT_RET void
-#define BOOST_TT_FORBIDDEN_IF\
-   ::boost::type_traits::ice_or<\
-      /* two fundamental, one non integral or lhs is const*/\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_fundamental< lhs_nocv >::value,\
-         ::boost::is_fundamental< rhs_nocv >::value,\
-         ::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\
-         >::value\
-      >::value,\
-      /* one fundamental, one pointer */\
-      ::boost::type_traits::ice_or<\
-         ::boost::type_traits::ice_and<\
-            ::boost::is_fundamental< lhs_nocv >::value,\
-            ::boost::is_pointer< rhs_noref >::value\
-         >::value,\
-         ::boost::type_traits::ice_and<\
-            ::boost::is_fundamental< rhs_nocv >::value,\
-            ::boost::is_pointer< lhs_noref >::value\
-         >::value\
-      >::value,\
-      /* two pointers */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::is_pointer< rhs_noref >::value\
-      >::value\
-   >::value
-
-
-#include <boost/type_traits/detail/has_binary_operator.hpp>
-
-#undef BOOST_TT_TRAIT_NAME
-#undef BOOST_TT_TRAIT_OP
-#undef BOOST_TT_DEFAULT_RET
-#undef BOOST_TT_FORBIDDEN_IF
-
-#endif

Deleted: sandbox/type_traits/boost/type_traits/has_operator_multiplies.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_multiplies.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,42 +0,0 @@
-//  (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_MULTIPLIES_HPP_INCLUDED
-#define BOOST_TT_HAS_OPERATOR_MULTIPLIES_HPP_INCLUDED
-
-#define BOOST_TT_TRAIT_NAME has_operator_multiplies
-#define BOOST_TT_TRAIT_OP *
-#define BOOST_TT_DEFAULT_RET void
-#define BOOST_TT_FORBIDDEN_IF\
-   /* pointer with pointer or fundamental */\
-   ::boost::type_traits::ice_or<\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::type_traits::ice_or<\
-            ::boost::is_fundamental< rhs_nocv >::value,\
-            ::boost::is_pointer< rhs_noref >::value\
-         >::value\
-      >::value,\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< rhs_noref >::value,\
-         ::boost::type_traits::ice_or<\
-            ::boost::is_fundamental< lhs_nocv >::value,\
-            ::boost::is_pointer< lhs_noref >::value\
-         >::value\
-      >::value\
-   >::value
-
-
-#include <boost/type_traits/detail/has_binary_operator.hpp>
-
-#undef BOOST_TT_TRAIT_NAME
-#undef BOOST_TT_TRAIT_OP
-#undef BOOST_TT_DEFAULT_RET
-#undef BOOST_TT_FORBIDDEN_IF
-
-#endif

Deleted: sandbox/type_traits/boost/type_traits/has_operator_multiplies_equal.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_multiplies_equal.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,48 +0,0 @@
-//  (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_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 *=
-#define BOOST_TT_DEFAULT_RET void
-#define BOOST_TT_FORBIDDEN_IF\
-   ::boost::type_traits::ice_or<\
-      /* LHS is fundamental and const, RHS is fundamental */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_fundamental< lhs_nocv >::value,\
-         ::boost::is_const< lhs_noref >::value,\
-         ::boost::is_fundamental< rhs_nocv >::value\
-      >::value,\
-      /* pointer with pointer or fundamental */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::type_traits::ice_or<\
-            ::boost::is_fundamental< rhs_nocv >::value,\
-            ::boost::is_pointer< rhs_noref >::value\
-         >::value\
-      >::value,\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< rhs_noref >::value,\
-         ::boost::type_traits::ice_or<\
-            ::boost::is_fundamental< lhs_nocv >::value,\
-            ::boost::is_pointer< lhs_noref >::value\
-         >::value\
-      >::value\
-   >::value
-
-
-#include <boost/type_traits/detail/has_binary_operator.hpp>
-
-#undef BOOST_TT_TRAIT_NAME
-#undef BOOST_TT_TRAIT_OP
-#undef BOOST_TT_DEFAULT_RET
-#undef BOOST_TT_FORBIDDEN_IF
-
-#endif

Deleted: sandbox/type_traits/boost/type_traits/has_operator_not_equal_to.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_not_equal_to.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,50 +0,0 @@
-//  (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_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 !=
-#define BOOST_TT_DEFAULT_RET void
-#define BOOST_TT_FORBIDDEN_IF\
-   ::boost::type_traits::ice_or<\
-      /* pointer and fundamental */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::is_fundamental< rhs_nocv >::value\
-      >::value,\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< rhs_noref >::value,\
-         ::boost::is_fundamental< lhs_nocv >::value\
-      >::value,\
-      /* two pointers but no inheritance or no void* */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::is_pointer< rhs_noref >::value,\
-         ::boost::type_traits::ice_not<\
-            ::boost::type_traits::ice_or<\
-               ::boost::is_base_of< lhs_noptr, rhs_noptr >::value,\
-               ::boost::is_base_of< rhs_noptr, lhs_noptr >::value,\
-               ::boost::is_same< lhs_noptr, rhs_noptr >::value,\
-               ::boost::is_void< lhs_noptr >::value,\
-               ::boost::is_void< rhs_noptr >::value\
-            >::value\
-         >::value\
-      >::value\
-   >::value
-
-
-#include <boost/type_traits/detail/has_binary_operator.hpp>
-
-#undef BOOST_TT_TRAIT_NAME
-#undef BOOST_TT_TRAIT_OP
-#undef BOOST_TT_DEFAULT_RET
-#undef BOOST_TT_FORBIDDEN_IF
-
-#endif

Deleted: sandbox/type_traits/boost/type_traits/has_operator_plus.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_plus.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,54 +0,0 @@
-//  (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_PLUS_HPP_INCLUDED
-#define BOOST_TT_HAS_OPERATOR_PLUS_HPP_INCLUDED
-
-#define BOOST_TT_TRAIT_NAME has_operator_plus
-#define BOOST_TT_TRAIT_OP +
-#define BOOST_TT_DEFAULT_RET void
-#define BOOST_TT_FORBIDDEN_IF\
-   ::boost::type_traits::ice_or<\
-      /* pointer with pointer */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::is_pointer< rhs_noref >::value\
-      >::value,\
-      /* pointer with fundamental non integral */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::is_fundamental< rhs_nocv >::value,\
-         ::boost::type_traits::ice_not< ::boost::is_integral< rhs_noref >::value >::value\
-      >::value,\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< rhs_noref >::value,\
-         ::boost::is_fundamental< lhs_nocv >::value,\
-         ::boost::type_traits::ice_not< ::boost::is_integral< lhs_noref >::value >::value\
-      >::value,\
-      /* void* with fundamental */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::is_void< lhs_noptr >::value,\
-         ::boost::is_fundamental< rhs_nocv >::value\
-      >::value,\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< rhs_noref >::value,\
-         ::boost::is_void< rhs_noptr >::value,\
-         ::boost::is_fundamental< lhs_nocv >::value\
-      >::value\
-   >::value
-
-
-#include <boost/type_traits/detail/has_binary_operator.hpp>
-
-#undef BOOST_TT_TRAIT_NAME
-#undef BOOST_TT_TRAIT_OP
-#undef BOOST_TT_DEFAULT_RET
-#undef BOOST_TT_FORBIDDEN_IF
-
-#endif

Deleted: sandbox/type_traits/boost/type_traits/has_operator_plus_equal.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_plus_equal.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,61 +0,0 @@
-//  (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_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 +=
-#define BOOST_TT_DEFAULT_RET void
-#define BOOST_TT_FORBIDDEN_IF\
-   ::boost::type_traits::ice_or<\
-      /* LHS is fundamental and const, RHS is fundamental */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_fundamental< lhs_nocv >::value,\
-         ::boost::is_const< lhs_noref >::value,\
-         ::boost::is_fundamental< rhs_nocv >::value\
-      >::value,\
-      /* two pointers */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::is_pointer< rhs_noref >::value\
-      >::value,\
-      /* void* with fundamental */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::is_void< lhs_noptr >::value,\
-         ::boost::is_fundamental< rhs_nocv >::value\
-      >::value,\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< rhs_noref >::value,\
-         ::boost::is_void< rhs_noptr >::value,\
-         ::boost::is_fundamental< lhs_nocv >::value\
-      >::value,\
-      /* LHS==pointer and RHS==fundamental non integral */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::is_fundamental< rhs_nocv >::value,\
-         ::boost::type_traits::ice_not< ::boost::is_integral< rhs_noref >::value >::value\
-      >::value,\
-      /* LHS==non bool fundamental and RHS==pointer */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_fundamental< lhs_nocv >::value,\
-         ::boost::type_traits::ice_not< ::boost::is_same< bool, lhs_nocv >::value >::value,\
-         ::boost::is_pointer< rhs_noref >::value\
-      >::value\
-   >::value
-
-
-#include <boost/type_traits/detail/has_binary_operator.hpp>
-
-#undef BOOST_TT_TRAIT_NAME
-#undef BOOST_TT_TRAIT_OP
-#undef BOOST_TT_DEFAULT_RET
-#undef BOOST_TT_FORBIDDEN_IF
-
-#endif

Deleted: sandbox/type_traits/boost/type_traits/has_operator_postfix_decrement.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_postfix_decrement.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,37 +0,0 @@
-//  (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_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 --
-#define BOOST_TT_DEFAULT_RET void
-#define BOOST_TT_FORBIDDEN_IF\
-   /* bool or void* or const fundamental */\
-   ::boost::type_traits::ice_or<\
-      ::boost::is_same< bool, lhs_nocv >::value,\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::is_void< lhs_noptr >::value\
-      >::value,\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_fundamental< lhs_nocv >::value,\
-         ::boost::is_const< lhs_noref >::value\
-     >::value\
-   >::value
-
-
-#include <boost/type_traits/detail/has_postfix_operator.hpp>
-
-#undef BOOST_TT_TRAIT_NAME
-#undef BOOST_TT_TRAIT_OP
-#undef BOOST_TT_DEFAULT_RET
-#undef BOOST_TT_FORBIDDEN_IF
-
-#endif

Deleted: sandbox/type_traits/boost/type_traits/has_operator_postfix_increment.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_postfix_increment.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,36 +0,0 @@
-//  (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_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 ++
-#define BOOST_TT_DEFAULT_RET void
-#define BOOST_TT_FORBIDDEN_IF\
-   /* void* or const fundamental */\
-   ::boost::type_traits::ice_or<\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::is_void< lhs_noptr >::value\
-      >::value,\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_fundamental< lhs_nocv >::value,\
-         ::boost::is_const< lhs_noref >::value\
-     >::value\
-   >::value
-
-
-#include <boost/type_traits/detail/has_postfix_operator.hpp>
-
-#undef BOOST_TT_TRAIT_NAME
-#undef BOOST_TT_TRAIT_OP
-#undef BOOST_TT_DEFAULT_RET
-#undef BOOST_TT_FORBIDDEN_IF
-
-#endif

Deleted: sandbox/type_traits/boost/type_traits/has_operator_prefix_decrement.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_prefix_decrement.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,37 +0,0 @@
-//  (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_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 --
-#define BOOST_TT_DEFAULT_RET void
-#define BOOST_TT_FORBIDDEN_IF\
-   /* bool or void* or const fundamental */\
-   ::boost::type_traits::ice_or<\
-      ::boost::is_same< bool, rhs_nocv >::value,\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< rhs_noref >::value,\
-         ::boost::is_void< rhs_noptr >::value\
-      >::value,\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_fundamental< rhs_nocv >::value,\
-         ::boost::is_const< rhs_noref >::value\
-     >::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

Deleted: sandbox/type_traits/boost/type_traits/has_operator_prefix_increment.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_prefix_increment.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,36 +0,0 @@
-//  (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_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 ++
-#define BOOST_TT_DEFAULT_RET void
-#define BOOST_TT_FORBIDDEN_IF\
-   /* void* or const fundamental */\
-   ::boost::type_traits::ice_or<\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< rhs_noref >::value,\
-         ::boost::is_void< rhs_noptr >::value\
-      >::value,\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_fundamental< rhs_nocv >::value,\
-         ::boost::is_const< rhs_noref >::value\
-     >::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

Deleted: sandbox/type_traits/boost/type_traits/has_operator_right_shift.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_right_shift.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,52 +0,0 @@
-//  (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_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 >>
-#define BOOST_TT_DEFAULT_RET void
-#define BOOST_TT_FORBIDDEN_IF\
-   ::boost::type_traits::ice_or<\
-      /* two fundamental, one non integral */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_fundamental< lhs_nocv >::value,\
-         ::boost::is_fundamental< rhs_nocv >::value,\
-         ::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\
-         >::value\
-      >::value,\
-      /* one fundamental, one pointer */\
-      ::boost::type_traits::ice_or<\
-         ::boost::type_traits::ice_and<\
-            ::boost::is_fundamental< lhs_nocv >::value,\
-            ::boost::is_pointer< rhs_noref >::value\
-         >::value,\
-         ::boost::type_traits::ice_and<\
-            ::boost::is_fundamental< rhs_nocv >::value,\
-            ::boost::is_pointer< lhs_noref >::value\
-         >::value\
-      >::value,\
-      /* two pointers */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::is_pointer< rhs_noref >::value\
-      >::value\
-   >::value
-
-
-#include <boost/type_traits/detail/has_binary_operator.hpp>
-
-#undef BOOST_TT_TRAIT_NAME
-#undef BOOST_TT_TRAIT_OP
-#undef BOOST_TT_DEFAULT_RET
-#undef BOOST_TT_FORBIDDEN_IF
-
-#endif

Deleted: sandbox/type_traits/boost/type_traits/has_operator_right_shift_equal.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_right_shift_equal.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,53 +0,0 @@
-//  (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_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 >>=
-#define BOOST_TT_DEFAULT_RET void
-#define BOOST_TT_FORBIDDEN_IF\
-   ::boost::type_traits::ice_or<\
-      /* two fundamental, one non integral or lhs is const*/\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_fundamental< lhs_nocv >::value,\
-         ::boost::is_fundamental< rhs_nocv >::value,\
-         ::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\
-         >::value\
-      >::value,\
-      /* one fundamental, one pointer */\
-      ::boost::type_traits::ice_or<\
-         ::boost::type_traits::ice_and<\
-            ::boost::is_fundamental< lhs_nocv >::value,\
-            ::boost::is_pointer< rhs_noref >::value\
-         >::value,\
-         ::boost::type_traits::ice_and<\
-            ::boost::is_fundamental< rhs_nocv >::value,\
-            ::boost::is_pointer< lhs_noref >::value\
-         >::value\
-      >::value,\
-      /* two pointers */\
-      ::boost::type_traits::ice_and<\
-         ::boost::is_pointer< lhs_noref >::value,\
-         ::boost::is_pointer< rhs_noref >::value\
-      >::value\
-   >::value
-
-
-#include <boost/type_traits/detail/has_binary_operator.hpp>
-
-#undef BOOST_TT_TRAIT_NAME
-#undef BOOST_TT_TRAIT_OP
-#undef BOOST_TT_DEFAULT_RET
-#undef BOOST_TT_FORBIDDEN_IF
-
-#endif

Deleted: sandbox/type_traits/boost/type_traits/has_operator_unary_minus.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_unary_minus.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,27 +0,0 @@
-//  (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_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 -
-#define BOOST_TT_DEFAULT_RET void
-#define BOOST_TT_FORBIDDEN_IF\
-   /* pointer */\
-   ::boost::is_pointer< rhs_noref >::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

Deleted: sandbox/type_traits/boost/type_traits/has_operator_unary_plus.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/has_operator_unary_plus.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,25 +0,0 @@
-//  (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_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 +
-#define BOOST_TT_DEFAULT_RET void
-#define BOOST_TT_FORBIDDEN_IF\
-   false
-
-#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

Deleted: sandbox/type_traits/boost/type_traits/operators.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/operators.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,50 +0,0 @@
-//  (C) Copyright 2009-2011 Frédéric Bron (frederic.bron_at_[hidden])
-//
-//  Use, modification and distribution are subject to the Boost Software License,
-//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt).
-//
-//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
-
-#ifndef BOOST_TT_OPERATORS_HPP_INCLUDED
-#define BOOST_TT_OPERATORS_HPP_INCLUDED
-
-#include <boost/type_traits/has_operator_bit_and_equal.hpp>
-#include <boost/type_traits/has_operator_bit_and.hpp>
-#include <boost/type_traits/has_operator_bit_or_equal.hpp>
-#include <boost/type_traits/has_operator_bit_or.hpp>
-#include <boost/type_traits/has_operator_bit_xor_equal.hpp>
-#include <boost/type_traits/has_operator_bit_xor.hpp>
-#include <boost/type_traits/has_operator_complement.hpp>
-#include <boost/type_traits/has_operator_dereference.hpp>
-#include <boost/type_traits/has_operator_divides_equal.hpp>
-#include <boost/type_traits/has_operator_divides.hpp>
-#include <boost/type_traits/has_operator_equal_to.hpp>
-#include <boost/type_traits/has_operator_greater_equal.hpp>
-#include <boost/type_traits/has_operator_greater.hpp>
-#include <boost/type_traits/has_operator_left_shift_equal.hpp>
-#include <boost/type_traits/has_operator_left_shift.hpp>
-#include <boost/type_traits/has_operator_less_equal.hpp>
-#include <boost/type_traits/has_operator_less.hpp>
-#include <boost/type_traits/has_operator_logical_and.hpp>
-#include <boost/type_traits/has_operator_logical_not.hpp>
-#include <boost/type_traits/has_operator_logical_or.hpp>
-#include <boost/type_traits/has_operator_minus_equal.hpp>
-#include <boost/type_traits/has_operator_minus.hpp>
-#include <boost/type_traits/has_operator_modulus_equal.hpp>
-#include <boost/type_traits/has_operator_modulus.hpp>
-#include <boost/type_traits/has_operator_multiplies_equal.hpp>
-#include <boost/type_traits/has_operator_multiplies.hpp>
-#include <boost/type_traits/has_operator_not_equal_to.hpp>
-#include <boost/type_traits/has_operator_plus_equal.hpp>
-#include <boost/type_traits/has_operator_plus.hpp>
-#include <boost/type_traits/has_operator_postfix_decrement.hpp>
-#include <boost/type_traits/has_operator_postfix_increment.hpp>
-#include <boost/type_traits/has_operator_prefix_decrement.hpp>
-#include <boost/type_traits/has_operator_prefix_increment.hpp>
-#include <boost/type_traits/has_operator_right_shift_equal.hpp>
-#include <boost/type_traits/has_operator_right_shift.hpp>
-#include <boost/type_traits/has_operator_unary_minus.hpp>
-#include <boost/type_traits/has_operator_unary_plus.hpp>
-
-#endif

Added: sandbox/type_traits/libs/type_traits/doc/can_call_addition.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_addition.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,69 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_addition can_call_addition]
+   template <class LHS, class RHS=LHS, class RET=dont_care>
+   struct can_call_addition : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs+rhs`,
+and (ii) `RET=dont_care` or the result of expression `lhs+rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of binary `operator+`.
+If `RET` is different from the default `dont_care` 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 can_call_addition<LHS, RHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_addition.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_addition<LHS, RHS, RET>::value_type` is the type `bool`.]
+[:`can_call_addition<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_addition<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_addition<long>` inherits from `__true_type`.]
+
+[:`can_call_addition<int, int, int>` inherits from `__true_type`.]
+[:`can_call_addition<int, int, long>` inherits from `__true_type`.]
+[:`can_call_addition<int, double, double>` inherits from `__true_type`.]
+[:`can_call_addition<int, double, int>` inherits from `__true_type`.]
+[:`can_call_addition<const int, int>::value` inherits from `__true_type`.]
+
+[:`can_call_addition<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether binary `operator+` is public or not:
+if `operator+` is defined as a private member of `LHS` then
+instantiating `can_call_addition<LHS>` will produce a compiler error.
+For this reason `can_call_addition` cannot be used to determine whether a type has a public `operator+` or not.
+``
+struct A { private: void operator+(const A&); };
+boost::can_call_addition<A>::value; // error: A::operator+(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator+(const A&, const A&);
+struct B { operator A(); };
+boost::can_call_addition<A>::value; // this is fine
+boost::can_call_addition<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/can_call_addition_assignment.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_addition_assignment.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,69 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_addition_assignment can_call_addition_assignment]
+   template <class LHS, class RHS=LHS, class RET=dont_care>
+   struct can_call_addition_assignment : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs+=rhs`,
+and (ii) `RET=dont_care` or the result of expression `lhs+=rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of binary `operator+=`.
+If `RET` is different from the default `dont_care` 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 can_call_addition_assignment<LHS, RHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_addition_assignment.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_addition_assignment<LHS, RHS, RET>::value_type` is the type `bool`.]
+[:`can_call_addition_assignment<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_addition_assignment<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_addition_assignment<long>` inherits from `__true_type`.]
+
+[:`can_call_addition_assignment<int, int, int>` inherits from `__true_type`.]
+[:`can_call_addition_assignment<int, int, long>` inherits from `__true_type`.]
+[:`can_call_addition_assignment<int, double, double>` inherits from `__true_type`.]
+[:`can_call_addition_assignment<int, double, int>` inherits from `__true_type`.]
+
+[:`can_call_addition_assignment<const int, int>::value` inherits from `__false_type`.]
+[:`can_call_addition_assignment<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether binary `operator+=` is public or not:
+if `operator+=` is defined as a private member of `LHS` then
+instantiating `can_call_addition_assignment<LHS>` will produce a compiler error.
+For this reason `can_call_addition_assignment` cannot be used to determine whether a type has a public `operator+=` or not.
+``
+struct A { private: void operator+=(const A&); };
+boost::can_call_addition_assignment<A>::value; // error: A::operator+=(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator+=(const A&, const A&);
+struct B { operator A(); };
+boost::can_call_addition_assignment<A>::value; // this is fine
+boost::can_call_addition_assignment<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/can_call_and.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_and.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,68 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_and can_call_and]
+   template <class LHS, class RHS=LHS, class RET=dont_care>
+   struct can_call_and : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs&&rhs`,
+and (ii) `RET=dont_care` or the result of expression `lhs&&rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of binary `operator&&`.
+If `RET` is different from the default `dont_care` 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 can_call_and<LHS, RHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_and.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_and<LHS, RHS, RET>::value_type` is the type `bool`.]
+[:`can_call_and<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_and<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_and<bool>` inherits from `__true_type`.]
+
+[:`can_call_and<int, int, bool>` inherits from `__true_type`.]
+[:`can_call_and<int, int, long>` inherits from `__true_type`.]
+[:`can_call_and<int, double, bool>` inherits from `__true_type`.]
+[:`can_call_and<const int, int>::value` inherits from `__true_type`.]
+
+[:`can_call_and<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether binary `operator&&` is public or not:
+if `operator&&` is defined as a private member of `LHS` then
+instantiating `can_call_and<LHS>` will produce a compiler error.
+For this reason `can_call_and` cannot be used to determine whether a type has a public `operator&&` or not.
+``
+struct A { private: void operator&&(const A&); };
+boost::can_call_and<A>::value; // error: A::operator&&(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator&&(const A&, const A&);
+struct B { operator A(); };
+boost::can_call_and<A>::value; // this is fine
+boost::can_call_and<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/can_call_bitwise_and.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_bitwise_and.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,67 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_bitwise_and can_call_bitwise_and]
+   template <class LHS, class RHS=LHS, class RET=dont_care>
+   struct can_call_bitwise_and : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs&rhs`,
+and (ii) `RET=dont_care` or the result of expression `lhs&rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of binary `operator&`.
+If `RET` is different from the default `dont_care` 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 can_call_bitwise_and<LHS, RHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_bitwise_and.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_bitwise_and<LHS, RHS, RET>::value_type` is the type `bool`.]
+[:`can_call_bitwise_and<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_bitwise_and<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_bitwise_and<long>` inherits from `__true_type`.]
+
+[:`can_call_bitwise_and<int, int, int>` inherits from `__true_type`.]
+[:`can_call_bitwise_and<const int, int>` inherits from `__true_type`.]
+
+[:`can_call_bitwise_and<int, double, bool>` inherits from `__false_type`.]
+[:`can_call_bitwise_and<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether binary `operator&` is public or not:
+if `operator&` is defined as a private member of `LHS` then
+instantiating `can_call_bitwise_and<LHS>` will produce a compiler error.
+For this reason `can_call_bitwise_and` cannot be used to determine whether a type has a public `operator&` or not.
+``
+struct A { private: void operator&(const A&); };
+boost::can_call_bitwise_and<A>::value; // error: A::operator&(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator&(const A&, const A&);
+struct B { operator A(); };
+boost::can_call_bitwise_and<A>::value; // this is fine
+boost::can_call_bitwise_and<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/can_call_bitwise_and_assignment.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_bitwise_and_assignment.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,67 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_bitwise_and_assignment can_call_bitwise_and_assignment]
+   template <class LHS, class RHS=LHS, class RET=dont_care>
+   struct can_call_bitwise_and_assignment : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs&=rhs`,
+and (ii) `RET=dont_care` or the result of expression `lhs&=rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of binary `operator&=`.
+If `RET` is different from the default `dont_care` 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 can_call_bitwise_and_assignment<LHS, RHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_bitwise_and_assignment.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_bitwise_and_assignment<LHS, RHS, RET>::value_type` is the type `bool`.]
+[:`can_call_bitwise_and_assignment<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_bitwise_and_assignment<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_bitwise_and_assignment<long>` inherits from `__true_type`.]
+
+[:`can_call_bitwise_and_assignment<int, int, int>` inherits from `__true_type`.]
+
+[:`can_call_bitwise_and_assignment<const int, int>` inherits from `__false_type`.]
+[:`can_call_bitwise_and_assignment<int, double, bool>` inherits from `__false_type`.]
+[:`can_call_bitwise_and_assignment<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether binary `operator&=` is public or not:
+if `operator&=` is defined as a private member of `LHS` then
+instantiating `can_call_bitwise_and_assignment<LHS>` will produce a compiler error.
+For this reason `can_call_bitwise_and_assignment` cannot be used to determine whether a type has a public `operator&=` or not.
+``
+struct A { private: void operator&=(const A&); };
+boost::can_call_bitwise_and_assignment<A>::value; // error: A::operator&=(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator&=(const A&, const A&);
+struct B { operator A(); };
+boost::can_call_bitwise_and_assignment<A>::value; // this is fine
+boost::can_call_bitwise_and_assignment<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/can_call_bitwise_or.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_bitwise_or.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,67 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_bitwise_or can_call_bitwise_or]
+   template <class LHS, class RHS=LHS, class RET=dont_care>
+   struct can_call_bitwise_or : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs|rhs`,
+and (ii) `RET=dont_care` or the result of expression `lhs|rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of binary `operator|`.
+If `RET` is different from the default `dont_care` 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 can_call_bitwise_or<LHS, RHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_bitwise_or.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_bitwise_or<LHS, RHS, RET>::value_type` is the type `bool`.]
+[:`can_call_bitwise_or<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_bitwise_or<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_bitwise_or<long>` inherits from `__true_type`.]
+
+[:`can_call_bitwise_or<int, int, int>` inherits from `__true_type`.]
+[:`can_call_bitwise_or<const int, int>` inherits from `__true_type`.]
+
+[:`can_call_bitwise_or<int, double, bool>` inherits from `__false_type`.]
+[:`can_call_bitwise_or<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether binary `operator|` is public or not:
+if `operator|` is defined as a private member of `LHS` then
+instantiating `can_call_bitwise_or<LHS>` will produce a compiler error.
+For this reason `can_call_bitwise_or` cannot be used to determine whether a type has a public `operator|` or not.
+``
+struct A { private: void operator|(const A&); };
+boost::can_call_bitwise_or<A>::value; // error: A::operator|(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator|(const A&, const A&);
+struct B { operator A(); };
+boost::can_call_bitwise_or<A>::value; // this is fine
+boost::can_call_bitwise_or<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/can_call_bitwise_or_assignment.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_bitwise_or_assignment.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,67 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_bitwise_or_assignment can_call_bitwise_or_assignment]
+   template <class LHS, class RHS=LHS, class RET=dont_care>
+   struct can_call_bitwise_or_assignment : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs|=rhs`,
+and (ii) `RET=dont_care` or the result of expression `lhs|=rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of binary `operator|=`.
+If `RET` is different from the default `dont_care` 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 can_call_bitwise_or_assignment<LHS, RHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_bitwise_or_assignment.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_bitwise_or_assignment<LHS, RHS, RET>::value_type` is the type `bool`.]
+[:`can_call_bitwise_or_assignment<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_bitwise_or_assignment<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_bitwise_or_assignment<long>` inherits from `__true_type`.]
+
+[:`can_call_bitwise_or_assignment<int, int, int>` inherits from `__true_type`.]
+
+[:`can_call_bitwise_or_assignment<const int, int>` inherits from `__false_type`.]
+[:`can_call_bitwise_or_assignment<int, double, bool>` inherits from `__false_type`.]
+[:`can_call_bitwise_or_assignment<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether binary `operator|=` is public or not:
+if `operator|=` is defined as a private member of `LHS` then
+instantiating `can_call_bitwise_or_assignment<LHS>` will produce a compiler error.
+For this reason `can_call_bitwise_or_assignment` cannot be used to determine whether a type has a public `operator|=` or not.
+``
+struct A { private: void operator|=(const A&); };
+boost::can_call_bitwise_or_assignment<A>::value; // error: A::operator|=(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator|=(const A&, const A&);
+struct B { operator A(); };
+boost::can_call_bitwise_or_assignment<A>::value; // this is fine
+boost::can_call_bitwise_or_assignment<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/can_call_bitwise_xor.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_bitwise_xor.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,67 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_bitwise_xor can_call_bitwise_xor]
+   template <class LHS, class RHS=LHS, class RET=dont_care>
+   struct can_call_bitwise_xor : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs^rhs`,
+and (ii) `RET=dont_care` or the result of expression `lhs^rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of binary `operator^`.
+If `RET` is different from the default `dont_care` 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 can_call_bitwise_xor<LHS, RHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_bitwise_xor.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_bitwise_xor<LHS, RHS, RET>::value_type` is the type `bool`.]
+[:`can_call_bitwise_xor<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_bitwise_xor<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_bitwise_xor<long>` inherits from `__true_type`.]
+
+[:`can_call_bitwise_xor<int, int, int>` inherits from `__true_type`.]
+[:`can_call_bitwise_xor<const int, int>` inherits from `__true_type`.]
+
+[:`can_call_bitwise_xor<int, double, bool>` inherits from `__false_type`.]
+[:`can_call_bitwise_xor<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether binary `operator^` is public or not:
+if `operator^` is defined as a private member of `LHS` then
+instantiating `can_call_bitwise_xor<LHS>` will produce a compiler error.
+For this reason `can_call_bitwise_xor` cannot be used to determine whether a type has a public `operator^` or not.
+``
+struct A { private: void operator^(const A&); };
+boost::can_call_bitwise_xor<A>::value; // error: A::operator^(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator^(const A&, const A&);
+struct B { operator A(); };
+boost::can_call_bitwise_xor<A>::value; // this is fine
+boost::can_call_bitwise_xor<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/can_call_bitwise_xor_assignment.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_bitwise_xor_assignment.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,67 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_bitwise_xor_assignment can_call_bitwise_xor_assignment]
+   template <class LHS, class RHS=LHS, class RET=dont_care>
+   struct can_call_bitwise_xor_assignment : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs^=rhs`,
+and (ii) `RET=dont_care` or the result of expression `lhs^=rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of binary `operator^=`.
+If `RET` is different from the default `dont_care` 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 can_call_bitwise_xor_assignment<LHS, RHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_bitwise_xor_assignment.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_bitwise_xor_assignment<LHS, RHS, RET>::value_type` is the type `bool`.]
+[:`can_call_bitwise_xor_assignment<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_bitwise_xor_assignment<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_bitwise_xor_assignment<long>` inherits from `__true_type`.]
+
+[:`can_call_bitwise_xor_assignment<int, int, int>` inherits from `__true_type`.]
+
+[:`can_call_bitwise_xor_assignment<const int, int>` inherits from `__false_type`.]
+[:`can_call_bitwise_xor_assignment<int, double, bool>` inherits from `__false_type`.]
+[:`can_call_bitwise_xor_assignment<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether binary `operator^=` is public or not:
+if `operator^=` is defined as a private member of `LHS` then
+instantiating `can_call_bitwise_xor_assignment<LHS>` will produce a compiler error.
+For this reason `can_call_bitwise_xor_assignment` cannot be used to determine whether a type has a public `operator^=` or not.
+``
+struct A { private: void operator^=(const A&); };
+boost::can_call_bitwise_xor_assignment<A>::value; // error: A::operator^=(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator^=(const A&, const A&);
+struct B { operator A(); };
+boost::can_call_bitwise_xor_assignment<A>::value; // this is fine
+boost::can_call_bitwise_xor_assignment<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/can_call_complement.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_complement.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,69 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_complement can_call_complement]
+   template <class RHS, class RET=dont_care>
+   struct can_call_complement : public __tof {};
+
+__inherit
+If (i) `rhs` of type `RHS` can be used in expression `~rhs`,
+and (ii) `RET=dont_care` or the result of expression `~rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of prefix `operator~`.
+If `RET` is different from the default `dont_care` 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 can_call_complement<RHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_complement.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_complement<RHS, RET>::value_type` is the type `bool`.]
+[:`can_call_complement<RHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_complement<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_complement<long>` inherits from `__true_type`.]
+
+[:`can_call_complement<int, int>` inherits from `__true_type`.]
+[:`can_call_complement<int, long>` inherits from `__true_type`.]
+[:`can_call_complement<const int>` inherits from `__true_type`.]
+
+[:`can_call_complement<int*>` inherits from `__false_type`.]
+[:`can_call_complement<double, double>` inherits from `__false_type`.]
+[:`can_call_complement<double, int>` inherits from `__false_type`.]
+[:`can_call_complement<int, std::string>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether prefix `operator~` is public or not:
+if `operator~` is defined as a private member of `RHS` then
+instantiating `can_call_complement<RHS>` will produce a compiler error.
+For this reason `can_call_complement` cannot be used to determine whether a type has a public `operator~` or not.
+``
+struct A { private: void operator~(); };
+boost::can_call_complement<A>::value; // error: A::operator~() is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator~(const A&);
+struct B { operator A(); };
+boost::can_call_complement<A>::value; // this is fine
+boost::can_call_complement<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/can_call_dereference.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_dereference.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,72 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_dereference can_call_dereference]
+   template <class RHS, class RET=dont_care>
+   struct can_call_dereference : public __tof {};
+
+__inherit
+If (i) `rhs` of type `RHS` can be used in expression `*rhs`,
+and (ii) `RET=dont_care` or the result of expression `*rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of prefix `operator*`.
+If `RET` is different from the default `dont_care` 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 can_call_dereference<RHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_dereference.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_dereference<RHS, RET>::value_type` is the type `bool`.]
+[:`can_call_dereference<RHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_dereference<int*>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_dereference<long*>` inherits from `__true_type`.]
+
+
+[:`can_call_dereference<int*, int>` inherits from `__true_type`.]
+[:`can_call_dereference<int*, const int>` inherits from `__true_type`.]
+[:`can_call_dereference<int const *>` inherits from `__true_type`.]
+[:`can_call_dereference<int * const>` inherits from `__true_type`.]
+[:`can_call_dereference<int const * const>` inherits from `__true_type`.]
+
+[:`can_call_dereference<int>` inherits from `__false_type`.]
+[:`can_call_dereference<double>` inherits from `__false_type`.]
+[:`can_call_dereference<void*>` inherits from `__false_type`.]
+[:`can_call_dereference<const int*, int&>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether prefix `operator*` is public or not:
+if `operator*` is defined as a private member of `RHS` then
+instantiating `can_call_dereference<RHS>` will produce a compiler error.
+For this reason `can_call_dereference` cannot be used to determine whether a type has a public `operator*` or not.
+``
+struct A { private: void operator*(); };
+boost::can_call_dereference<A>::value; // error: A::operator*() is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator*(const A&);
+struct B { operator A(); };
+boost::can_call_dereference<A>::value; // this is fine
+boost::can_call_dereference<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/can_call_division.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_division.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,69 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_division can_call_division]
+   template <class LHS, class RHS=LHS, class RET=dont_care>
+   struct can_call_division : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs/rhs`,
+and (ii) `RET=dont_care` or the result of expression `lhs/rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of binary `operator/`.
+If `RET` is different from the default `dont_care` 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 can_call_division<LHS, RHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_division.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_division<LHS, RHS, RET>::value_type` is the type `bool`.]
+[:`can_call_division<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_division<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_division<long>` inherits from `__true_type`.]
+
+[:`can_call_division<int, int, int>` inherits from `__true_type`.]
+[:`can_call_division<int, int, long>` inherits from `__true_type`.]
+[:`can_call_division<int, double, double>` inherits from `__true_type`.]
+[:`can_call_division<int, double, int>` inherits from `__true_type`.]
+[:`can_call_division<const int, int>::value` inherits from `__true_type`.]
+
+[:`can_call_division<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether binary `operator/` is public or not:
+if `operator/` is defined as a private member of `LHS` then
+instantiating `can_call_division<LHS>` will produce a compiler error.
+For this reason `can_call_division` cannot be used to determine whether a type has a public `operator/` or not.
+``
+struct A { private: void operator/(const A&); };
+boost::can_call_division<A>::value; // error: A::operator/(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator/(const A&, const A&);
+struct B { operator A(); };
+boost::can_call_division<A>::value; // this is fine
+boost::can_call_division<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/can_call_division_assignment.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_division_assignment.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,69 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_division_assignment can_call_division_assignment]
+   template <class LHS, class RHS=LHS, class RET=dont_care>
+   struct can_call_division_assignment : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs/=rhs`,
+and (ii) `RET=dont_care` or the result of expression `lhs/=rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of binary `operator/=`.
+If `RET` is different from the default `dont_care` 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 can_call_division_assignment<LHS, RHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_division_assignment.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_division_assignment<LHS, RHS, RET>::value_type` is the type `bool`.]
+[:`can_call_division_assignment<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_division_assignment<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_division_assignment<long>` inherits from `__true_type`.]
+
+[:`can_call_division_assignment<int, int, int>` inherits from `__true_type`.]
+[:`can_call_division_assignment<int, int, long>` inherits from `__true_type`.]
+[:`can_call_division_assignment<int, double, double>` inherits from `__true_type`.]
+[:`can_call_division_assignment<int, double, int>` inherits from `__true_type`.]
+
+[:`can_call_division_assignment<const int, int>::value` inherits from `__false_type`.]
+[:`can_call_division_assignment<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether binary `operator/=` is public or not:
+if `operator/=` is defined as a private member of `LHS` then
+instantiating `can_call_division_assignment<LHS>` will produce a compiler error.
+For this reason `can_call_division_assignment` cannot be used to determine whether a type has a public `operator/=` or not.
+``
+struct A { private: void operator/=(const A&); };
+boost::can_call_division_assignment<A>::value; // error: A::operator/=(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator/=(const A&, const A&);
+struct B { operator A(); };
+boost::can_call_division_assignment<A>::value; // this is fine
+boost::can_call_division_assignment<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/can_call_equal.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_equal.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,69 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_equal can_call_equal]
+   template <class LHS, class RHS=LHS, class RET=dont_care>
+   struct can_call_equal : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs==rhs`,
+and (ii) `RET=dont_care` or the result of expression `lhs==rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of binary `operator==`.
+If `RET` is different from the default `dont_care` 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 can_call_equal<LHS, RHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_equal.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
+[:`can_call_equal<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_equal<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_equal<long>` inherits from `__true_type`.]
+
+[:`can_call_equal<int, int, bool>` inherits from `__true_type`.]
+[:`can_call_equal<int, double, bool>` inherits from `__true_type`.]
+[:`can_call_equal<const int>` inherits from `__true_type`.]
+
+[:`can_call_equal<int*, int>` inherits from `__false_type`.]
+[:`can_call_equal<int*, double*>` inherits from `__false_type`.]
+[:`can_call_equal<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether binary `operator==` is public or not:
+if `operator==` is defined as a private member of `LHS` then
+instantiating `can_call_equal<LHS>` will produce a compiler error.
+For this reason `can_call_equal` cannot be used to determine whether a type has a public `operator==` or not.
+``
+struct A { private: void operator==(const A&); };
+boost::can_call_equal<A>::value; // error: A::operator==(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator==(const A&, const A&);
+struct B { operator A(); };
+boost::can_call_equal<A>::value; // this is fine
+boost::can_call_equal<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/can_call_greater.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_greater.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,69 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_greater can_call_greater]
+   template <class LHS, class RHS=LHS, class RET=dont_care>
+   struct can_call_greater : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs>rhs`,
+and (ii) `RET=dont_care` or the result of expression `lhs>rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of binary `operator>`.
+If `RET` is different from the default `dont_care` 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 can_call_greater<LHS, RHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_greater.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_greater<LHS, RHS, RET>::value_type` is the type `bool`.]
+[:`can_call_greater<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_greater<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_greater<long>` inherits from `__true_type`.]
+
+[:`can_call_greater<int, int, bool>` inherits from `__true_type`.]
+[:`can_call_greater<int, double, bool>` inherits from `__true_type`.]
+[:`can_call_greater<const int>` inherits from `__true_type`.]
+
+[:`can_call_greater<int*, int>` inherits from `__false_type`.]
+[:`can_call_greater<int*, double*>` inherits from `__false_type`.]
+[:`can_call_greater<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether binary `operator>` is public or not:
+if `operator>` is defined as a private member of `LHS` then
+instantiating `can_call_greater<LHS>` will produce a compiler error.
+For this reason `can_call_greater` cannot be used to determine whether a type has a public `operator>` or not.
+``
+struct A { private: void operator>(const A&); };
+boost::can_call_greater<A>::value; // error: A::operator>(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator>(const A&, const A&);
+struct B { operator A(); };
+boost::can_call_greater<A>::value; // this is fine
+boost::can_call_greater<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/can_call_greater_equal.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_greater_equal.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,69 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_greater_equal can_call_greater_equal]
+   template <class LHS, class RHS=LHS, class RET=dont_care>
+   struct can_call_greater_equal : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs>=rhs`,
+and (ii) `RET=dont_care` or the result of expression `lhs>=rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of binary `operator>=`.
+If `RET` is different from the default `dont_care` 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 can_call_greater_equal<LHS, RHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_greater_equal.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_greater_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
+[:`can_call_greater_equal<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_greater_equal<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_greater_equal<long>` inherits from `__true_type`.]
+
+[:`can_call_greater_equal<int, int, bool>` inherits from `__true_type`.]
+[:`can_call_greater_equal<int, double, bool>` inherits from `__true_type`.]
+[:`can_call_greater_equal<const int>` inherits from `__true_type`.]
+
+[:`can_call_greater_equal<int*, int>` inherits from `__false_type`.]
+[:`can_call_greater_equal<int*, double*>` inherits from `__false_type`.]
+[:`can_call_greater_equal<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether binary `operator>=` is public or not:
+if `operator>=` is defined as a private member of `LHS` then
+instantiating `can_call_greater_equal<LHS>` will produce a compiler error.
+For this reason `can_call_greater_equal` cannot be used to determine whether a type has a public `operator>=` or not.
+``
+struct A { private: void operator>=(const A&); };
+boost::can_call_greater_equal<A>::value; // error: A::operator>=(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator>=(const A&, const A&);
+struct B { operator A(); };
+boost::can_call_greater_equal<A>::value; // this is fine
+boost::can_call_greater_equal<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/can_call_left_shift.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_left_shift.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,70 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_left_shift can_call_left_shift]
+   template <class LHS, class RHS=LHS, class RET=dont_care>
+   struct can_call_left_shift : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs<<rhs`,
+and (ii) `RET=dont_care` or the result of expression `lhs<<rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of binary `operator<<`.
+If `RET` is different from the default `dont_care` 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 can_call_left_shift<LHS, RHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_left_shift.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_left_shift<LHS, RHS, RET>::value_type` is the type `bool`.]
+[:`can_call_left_shift<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_left_shift<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_left_shift<long>` inherits from `__true_type`.]
+
+[:`can_call_left_shift<int, int, int>` inherits from `__true_type`.]
+[:`can_call_left_shift<const int, int>` inherits from `__true_type`.]
+[:`can_call_left_shift<std::ostream, int>` inherits from `__true_type`.]
+[:`can_call_left_shift<std::ostream, char*, std::ostream>` inherits from `__true_type`.]
+[:`can_call_left_shift<std::ostream, std::string>` inherits from `__true_type`.]
+
+[:`can_call_left_shift<int, double, bool>` inherits from `__false_type`.]
+[:`can_call_left_shift<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether binary `operator<<` is public or not:
+if `operator<<` is defined as a private member of `LHS` then
+instantiating `can_call_left_shift<LHS>` will produce a compiler error.
+For this reason `can_call_left_shift` cannot be used to determine whether a type has a public `operator<<` or not.
+``
+struct A { private: void operator<<(const A&); };
+boost::can_call_left_shift<A>::value; // error: A::operator<<(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator<<(const A&, const A&);
+struct B { operator A(); };
+boost::can_call_left_shift<A>::value; // this is fine
+boost::can_call_left_shift<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/can_call_left_shift_assignment.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_left_shift_assignment.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,67 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_left_shift_assignment can_call_left_shift_assignment]
+   template <class LHS, class RHS=LHS, class RET=dont_care>
+   struct can_call_left_shift_assignment : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs<<=rhs`,
+and (ii) `RET=dont_care` or the result of expression `lhs<<=rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of binary `operator<<=`.
+If `RET` is different from the default `dont_care` 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 can_call_left_shift_assignment<LHS, RHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_left_shift_assignment.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_left_shift_assignment<LHS, RHS, RET>::value_type` is the type `bool`.]
+[:`can_call_left_shift_assignment<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_left_shift_assignment<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_left_shift_assignment<long>` inherits from `__true_type`.]
+
+[:`can_call_left_shift_assignment<int, int, int>` inherits from `__true_type`.]
+
+[:`can_call_left_shift_assignment<const int, int>` inherits from `__false_type`.]
+[:`can_call_left_shift_assignment<int, double, bool>` inherits from `__false_type`.]
+[:`can_call_left_shift_assignment<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether binary `operator<<=` is public or not:
+if `operator<<=` is defined as a private member of `LHS` then
+instantiating `can_call_left_shift_assignment<LHS>` will produce a compiler error.
+For this reason `can_call_left_shift_assignment` cannot be used to determine whether a type has a public `operator<<=` or not.
+``
+struct A { private: void operator<<=(const A&); };
+boost::can_call_left_shift_assignment<A>::value; // error: A::operator<<=(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator<<=(const A&, const A&);
+struct B { operator A(); };
+boost::can_call_left_shift_assignment<A>::value; // this is fine
+boost::can_call_left_shift_assignment<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/can_call_less.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_less.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,69 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_less can_call_less]
+   template <class LHS, class RHS=LHS, class RET=dont_care>
+   struct can_call_less : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs<rhs`,
+and (ii) `RET=dont_care` or the result of expression `lhs<rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of binary `operator<`.
+If `RET` is different from the default `dont_care` 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 can_call_less<LHS, RHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_less.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_less<LHS, RHS, RET>::value_type` is the type `bool`.]
+[:`can_call_less<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_less<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_less<long>` inherits from `__true_type`.]
+
+[:`can_call_less<int, int, bool>` inherits from `__true_type`.]
+[:`can_call_less<int, double, bool>` inherits from `__true_type`.]
+[:`can_call_less<const int>` inherits from `__true_type`.]
+
+[:`can_call_less<int*, int>` inherits from `__false_type`.]
+[:`can_call_less<int*, double*>` inherits from `__false_type`.]
+[:`can_call_less<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether binary `operator<` is public or not:
+if `operator<` is defined as a private member of `LHS` then
+instantiating `can_call_less<LHS>` will produce a compiler error.
+For this reason `can_call_less` cannot be used to determine whether a type has a public `operator<` or not.
+``
+struct A { private: void operator<(const A&); };
+boost::can_call_less<A>::value; // error: A::operator<(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator<(const A&, const A&);
+struct B { operator A(); };
+boost::can_call_less<A>::value; // this is fine
+boost::can_call_less<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/can_call_less_equal.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_less_equal.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,69 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_less_equal can_call_less_equal]
+   template <class LHS, class RHS=LHS, class RET=dont_care>
+   struct can_call_less_equal : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs<=rhs`,
+and (ii) `RET=dont_care` or the result of expression `lhs<=rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of binary `operator<=`.
+If `RET` is different from the default `dont_care` 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 can_call_less_equal<LHS, RHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_less_equal.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_less_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
+[:`can_call_less_equal<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_less_equal<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_less_equal<long>` inherits from `__true_type`.]
+
+[:`can_call_less_equal<int, int, bool>` inherits from `__true_type`.]
+[:`can_call_less_equal<int, double, bool>` inherits from `__true_type`.]
+[:`can_call_less_equal<const int>` inherits from `__true_type`.]
+
+[:`can_call_less_equal<int*, int>` inherits from `__false_type`.]
+[:`can_call_less_equal<int*, double*>` inherits from `__false_type`.]
+[:`can_call_less_equal<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether binary `operator<=` is public or not:
+if `operator<=` is defined as a private member of `LHS` then
+instantiating `can_call_less_equal<LHS>` will produce a compiler error.
+For this reason `can_call_less_equal` cannot be used to determine whether a type has a public `operator<=` or not.
+``
+struct A { private: void operator<=(const A&); };
+boost::can_call_less_equal<A>::value; // error: A::operator<=(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator<=(const A&, const A&);
+struct B { operator A(); };
+boost::can_call_less_equal<A>::value; // this is fine
+boost::can_call_less_equal<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/can_call_modulus.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_modulus.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,67 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_modulus can_call_modulus]
+   template <class LHS, class RHS=LHS, class RET=dont_care>
+   struct can_call_modulus : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs%rhs`,
+and (ii) `RET=dont_care` or the result of expression `lhs%rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of binary `operator%`.
+If `RET` is different from the default `dont_care` 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 can_call_modulus<LHS, RHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_modulus.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_modulus<LHS, RHS, RET>::value_type` is the type `bool`.]
+[:`can_call_modulus<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_modulus<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_modulus<long>` inherits from `__true_type`.]
+
+[:`can_call_modulus<int, int, int>` inherits from `__true_type`.]
+[:`can_call_modulus<int, int, long>` inherits from `__true_type`.]
+[:`can_call_modulus<const int, int>::value` inherits from `__true_type`.]
+
+[:`can_call_modulus<int, double>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether binary `operator%` is public or not:
+if `operator%` is defined as a private member of `LHS` then
+instantiating `can_call_modulus<LHS>` will produce a compiler error.
+For this reason `can_call_modulus` cannot be used to determine whether a type has a public `operator%` or not.
+``
+struct A { private: void operator%(const A&); };
+boost::can_call_modulus<A>::value; // error: A::operator%(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator%(const A&, const A&);
+struct B { operator A(); };
+boost::can_call_modulus<A>::value; // this is fine
+boost::can_call_modulus<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/can_call_modulus_assignment.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_modulus_assignment.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,67 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_modulus_assignment can_call_modulus_assignment]
+   template <class LHS, class RHS=LHS, class RET=dont_care>
+   struct can_call_modulus_assignment : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs%=rhs`,
+and (ii) `RET=dont_care` or the result of expression `lhs%=rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of binary `operator%=`.
+If `RET` is different from the default `dont_care` 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 can_call_modulus_assignment<LHS, RHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_modulus_assignment.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_modulus_assignment<LHS, RHS, RET>::value_type` is the type `bool`.]
+[:`can_call_modulus_assignment<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_modulus_assignment<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_modulus_assignment<long>` inherits from `__true_type`.]
+
+[:`can_call_modulus_assignment<int, int, int>` inherits from `__true_type`.]
+[:`can_call_modulus_assignment<int, int, long>` inherits from `__true_type`.]
+
+[:`can_call_modulus_assignment<const int, int>::value` inherits from `__false_type`.]
+[:`can_call_modulus_assignment<int, double>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether binary `operator%=` is public or not:
+if `operator%=` is defined as a private member of `LHS` then
+instantiating `can_call_modulus_assignment<LHS>` will produce a compiler error.
+For this reason `can_call_modulus_assignment` cannot be used to determine whether a type has a public `operator%=` or not.
+``
+struct A { private: void operator%=(const A&); };
+boost::can_call_modulus_assignment<A>::value; // error: A::operator%=(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator%=(const A&, const A&);
+struct B { operator A(); };
+boost::can_call_modulus_assignment<A>::value; // this is fine
+boost::can_call_modulus_assignment<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/can_call_multiplication.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_multiplication.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,69 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_multiplication can_call_multiplication]
+   template <class LHS, class RHS=LHS, class RET=dont_care>
+   struct can_call_multiplication : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs*rhs`,
+and (ii) `RET=dont_care` or the result of expression `lhs*rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of binary `operator*`.
+If `RET` is different from the default `dont_care` 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 can_call_multiplication<LHS, RHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_multiplication.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_multiplication<LHS, RHS, RET>::value_type` is the type `bool`.]
+[:`can_call_multiplication<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_multiplication<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_multiplication<long>` inherits from `__true_type`.]
+
+[:`can_call_multiplication<int, int, int>` inherits from `__true_type`.]
+[:`can_call_multiplication<int, int, long>` inherits from `__true_type`.]
+[:`can_call_multiplication<int, double, double>` inherits from `__true_type`.]
+[:`can_call_multiplication<int, double, int>` inherits from `__true_type`.]
+[:`can_call_multiplication<const int, int>::value` inherits from `__true_type`.]
+
+[:`can_call_multiplication<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether binary `operator*` is public or not:
+if `operator*` is defined as a private member of `LHS` then
+instantiating `can_call_multiplication<LHS>` will produce a compiler error.
+For this reason `can_call_multiplication` cannot be used to determine whether a type has a public `operator*` or not.
+``
+struct A { private: void operator*(const A&); };
+boost::can_call_multiplication<A>::value; // error: A::operator*(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator*(const A&, const A&);
+struct B { operator A(); };
+boost::can_call_multiplication<A>::value; // this is fine
+boost::can_call_multiplication<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/can_call_multiplication_assignment.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_multiplication_assignment.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,69 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_multiplication_assignment can_call_multiplication_assignment]
+   template <class LHS, class RHS=LHS, class RET=dont_care>
+   struct can_call_multiplication_assignment : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs*=rhs`,
+and (ii) `RET=dont_care` or the result of expression `lhs*=rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of binary `operator*=`.
+If `RET` is different from the default `dont_care` 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 can_call_multiplication_assignment<LHS, RHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_multiplication_assignment.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_multiplication_assignment<LHS, RHS, RET>::value_type` is the type `bool`.]
+[:`can_call_multiplication_assignment<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_multiplication_assignment<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_multiplication_assignment<long>` inherits from `__true_type`.]
+
+[:`can_call_multiplication_assignment<int, int, int>` inherits from `__true_type`.]
+[:`can_call_multiplication_assignment<int, int, long>` inherits from `__true_type`.]
+[:`can_call_multiplication_assignment<int, double, double>` inherits from `__true_type`.]
+[:`can_call_multiplication_assignment<int, double, int>` inherits from `__true_type`.]
+
+[:`can_call_multiplication_assignment<const int, int>::value` inherits from `__false_type`.]
+[:`can_call_multiplication_assignment<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether binary `operator*=` is public or not:
+if `operator*=` is defined as a private member of `LHS` then
+instantiating `can_call_multiplication_assignment<LHS>` will produce a compiler error.
+For this reason `can_call_multiplication_assignment` cannot be used to determine whether a type has a public `operator*=` or not.
+``
+struct A { private: void operator*=(const A&); };
+boost::can_call_multiplication_assignment<A>::value; // error: A::operator*=(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator*=(const A&, const A&);
+struct B { operator A(); };
+boost::can_call_multiplication_assignment<A>::value; // this is fine
+boost::can_call_multiplication_assignment<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/can_call_not.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_not.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,68 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_not can_call_not]
+   template <class RHS, class RET=dont_care>
+   struct can_call_not : public __tof {};
+
+__inherit
+If (i) `rhs` of type `RHS` can be used in expression `!rhs`,
+and (ii) `RET=dont_care` or the result of expression `!rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of prefix `operator!`.
+If `RET` is different from the default `dont_care` 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 can_call_not<RHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_not.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_not<RHS, RET>::value_type` is the type `bool`.]
+[:`can_call_not<RHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_not<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_not<bool>` inherits from `__true_type`.]
+
+[:`can_call_not<int, bool>` inherits from `__true_type`.]
+[:`can_call_not<int, long>` inherits from `__true_type`.]
+[:`can_call_not<double, double>` inherits from `__true_type`.]
+[:`can_call_not<double, bool>` inherits from `__true_type`.]
+[:`can_call_not<const bool>` inherits from `__true_type`.]
+
+[:`can_call_not<int, std::string>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether prefix `operator!` is public or not:
+if `operator!` is defined as a private member of `RHS` then
+instantiating `can_call_not<RHS>` will produce a compiler error.
+For this reason `can_call_not` cannot be used to determine whether a type has a public `operator!` or not.
+``
+struct A { private: void operator!(); };
+boost::can_call_not<A>::value; // error: A::operator!() is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator!(const A&);
+struct B { operator A(); };
+boost::can_call_not<A>::value; // this is fine
+boost::can_call_not<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/can_call_not_equal.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_not_equal.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,69 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_not_equal can_call_not_equal]
+   template <class LHS, class RHS=LHS, class RET=dont_care>
+   struct can_call_not_equal : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs!=rhs`,
+and (ii) `RET=dont_care` or the result of expression `lhs!=rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of binary `operator!=`.
+If `RET` is different from the default `dont_care` 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 can_call_not_equal<LHS, RHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_not_equal.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_not_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
+[:`can_call_not_equal<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_not_equal<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_not_equal<long>` inherits from `__true_type`.]
+
+[:`can_call_not_equal<int, int, bool>` inherits from `__true_type`.]
+[:`can_call_not_equal<int, double, bool>` inherits from `__true_type`.]
+[:`can_call_not_equal<const int>` inherits from `__true_type`.]
+
+[:`can_call_not_equal<int*, int>` inherits from `__false_type`.]
+[:`can_call_not_equal<int*, double*>` inherits from `__false_type`.]
+[:`can_call_not_equal<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether binary `operator!=` is public or not:
+if `operator!=` is defined as a private member of `LHS` then
+instantiating `can_call_not_equal<LHS>` will produce a compiler error.
+For this reason `can_call_not_equal` cannot be used to determine whether a type has a public `operator!=` or not.
+``
+struct A { private: void operator!=(const A&); };
+boost::can_call_not_equal<A>::value; // error: A::operator!=(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator!=(const A&, const A&);
+struct B { operator A(); };
+boost::can_call_not_equal<A>::value; // this is fine
+boost::can_call_not_equal<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/can_call_or.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_or.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,68 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_or can_call_or]
+   template <class LHS, class RHS=LHS, class RET=dont_care>
+   struct can_call_or : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs||rhs`,
+and (ii) `RET=dont_care` or the result of expression `lhs||rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of binary `operator||`.
+If `RET` is different from the default `dont_care` 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 can_call_or<LHS, RHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_or.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_or<LHS, RHS, RET>::value_type` is the type `bool`.]
+[:`can_call_or<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_or<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_or<bool>` inherits from `__true_type`.]
+
+[:`can_call_or<int, int, bool>` inherits from `__true_type`.]
+[:`can_call_or<int, int, long>` inherits from `__true_type`.]
+[:`can_call_or<int, double, bool>` inherits from `__true_type`.]
+[:`can_call_or<const int, int>::value` inherits from `__true_type`.]
+
+[:`can_call_or<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether binary `operator||` is public or not:
+if `operator||` is defined as a private member of `LHS` then
+instantiating `can_call_or<LHS>` will produce a compiler error.
+For this reason `can_call_or` cannot be used to determine whether a type has a public `operator||` or not.
+``
+struct A { private: void operator||(const A&); };
+boost::can_call_or<A>::value; // error: A::operator||(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator||(const A&, const A&);
+struct B { operator A(); };
+boost::can_call_or<A>::value; // this is fine
+boost::can_call_or<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/can_call_post_decrement.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_post_decrement.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,70 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_post_decrement can_call_post_decrement]
+   template <class LHS, class RET=dont_care>
+   struct can_call_post_decrement : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` can be used in expression `lhs--`,
+and (ii) `RET=dont_care` or the result of expression `lhs--` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of postfix `operator--`.
+If `RET` is different from the default `dont_care` 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;
+f(lhs--); // is valid if can_call_post_decrement<LHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_post_decrement.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_post_decrement<LHS, RET>::value_type` is the type `bool`.]
+[:`can_call_post_decrement<LHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_post_decrement<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_post_decrement<long>` inherits from `__true_type`.]
+
+[:`can_call_post_decrement<int, int>` inherits from `__true_type`.]
+[:`can_call_post_decrement<int, long>` inherits from `__true_type`.]
+[:`can_call_post_decrement<double, double>` inherits from `__true_type`.]
+[:`can_call_post_decrement<double, int>` inherits from `__true_type`.]
+
+[:`can_call_post_decrement<bool>` inherits from `__false_type`.]
+[:`can_call_post_decrement<const int>` inherits from `__false_type`.]
+[:`can_call_post_decrement<void*>` inherits from `__false_type`.]
+[:`can_call_post_decrement<int, std::string>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether postfix `operator--` is public or not:
+if `operator--` is defined as a private member of `LHS` then
+instantiating `can_call_post_decrement<LHS>` will produce a compiler error.
+For this reason `can_call_post_decrement` cannot be used to determine whether a type has a public `operator--` or not.
+``
+struct A { private: void operator--(int); };
+boost::can_call_post_decrement<A>::value; // error: A::operator--(int) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator--(const A&, int);
+struct B { operator A(); };
+boost::can_call_post_decrement<A>::value; // this is fine
+boost::can_call_post_decrement<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/can_call_post_increment.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_post_increment.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,70 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_post_increment can_call_post_increment]
+   template <class LHS, class RET=dont_care>
+   struct can_call_post_increment : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` can be used in expression `lhs++`,
+and (ii) `RET=dont_care` or the result of expression `lhs++` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of postfix `operator++`.
+If `RET` is different from the default `dont_care` 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;
+f(lhs++); // is valid if can_call_post_increment<LHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_post_increment.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_post_increment<LHS, RET>::value_type` is the type `bool`.]
+[:`can_call_post_increment<LHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_post_increment<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_post_increment<long>` inherits from `__true_type`.]
+
+[:`can_call_post_increment<int, int>` inherits from `__true_type`.]
+[:`can_call_post_increment<int, long>` inherits from `__true_type`.]
+[:`can_call_post_increment<double, double>` inherits from `__true_type`.]
+[:`can_call_post_increment<double, int>` inherits from `__true_type`.]
+[:`can_call_post_increment<bool>` inherits from `__true_type`.]
+
+[:`can_call_post_increment<const int>` inherits from `__false_type`.]
+[:`can_call_post_increment<void*>` inherits from `__false_type`.]
+[:`can_call_post_increment<int, std::string>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether postfix `operator++` is public or not:
+if `operator++` is defined as a private member of `LHS` then
+instantiating `can_call_post_increment<LHS>` will produce a compiler error.
+For this reason `can_call_post_increment` cannot be used to determine whether a type has a public `operator++` or not.
+``
+struct A { private: void operator++(int); };
+boost::can_call_post_increment<A>::value; // error: A::operator++(int) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator++(const A&, int);
+struct B { operator A(); };
+boost::can_call_post_increment<A>::value; // this is fine
+boost::can_call_post_increment<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/can_call_pre_decrement.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_pre_decrement.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,70 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_pre_decrement can_call_pre_decrement]
+   template <class RHS, class RET=dont_care>
+   struct can_call_pre_decrement : public __tof {};
+
+__inherit
+If (i) `rhs` of type `RHS` can be used in expression `--rhs`,
+and (ii) `RET=dont_care` or the result of expression `--rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of prefix `operator--`.
+If `RET` is different from the default `dont_care` 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 can_call_pre_decrement<RHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_pre_decrement.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_pre_decrement<RHS, RET>::value_type` is the type `bool`.]
+[:`can_call_pre_decrement<RHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_pre_decrement<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_pre_decrement<long>` inherits from `__true_type`.]
+
+[:`can_call_pre_decrement<int, int>` inherits from `__true_type`.]
+[:`can_call_pre_decrement<int, long>` inherits from `__true_type`.]
+[:`can_call_pre_decrement<double, double>` inherits from `__true_type`.]
+[:`can_call_pre_decrement<double, int>` inherits from `__true_type`.]
+
+[:`can_call_pre_decrement<bool>` inherits from `__false_type`.]
+[:`can_call_pre_decrement<const int>` inherits from `__false_type`.]
+[:`can_call_pre_decrement<void*>` inherits from `__false_type`.]
+[:`can_call_pre_decrement<int, std::string>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether prefix `operator--` is public or not:
+if `operator--` is defined as a private member of `RHS` then
+instantiating `can_call_pre_decrement<RHS>` will produce a compiler error.
+For this reason `can_call_pre_decrement` cannot be used to determine whether a type has a public `operator--` or not.
+``
+struct A { private: void operator--(); };
+boost::can_call_pre_decrement<A>::value; // error: A::operator--() is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator--(const A&);
+struct B { operator A(); };
+boost::can_call_pre_decrement<A>::value; // this is fine
+boost::can_call_pre_decrement<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/can_call_pre_increment.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_pre_increment.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,70 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_pre_increment can_call_pre_increment]
+   template <class RHS, class RET=dont_care>
+   struct can_call_pre_increment : public __tof {};
+
+__inherit
+If (i) `rhs` of type `RHS` can be used in expression `++rhs`,
+and (ii) `RET=dont_care` or the result of expression `++rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of prefix `operator++`.
+If `RET` is different from the default `dont_care` 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 can_call_pre_increment<RHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_pre_increment.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_pre_increment<RHS, RET>::value_type` is the type `bool`.]
+[:`can_call_pre_increment<RHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_pre_increment<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_pre_increment<long>` inherits from `__true_type`.]
+
+[:`can_call_pre_increment<int, int>` inherits from `__true_type`.]
+[:`can_call_pre_increment<int, long>` inherits from `__true_type`.]
+[:`can_call_pre_increment<double, double>` inherits from `__true_type`.]
+[:`can_call_pre_increment<double, int>` inherits from `__true_type`.]
+[:`can_call_pre_increment<bool>` inherits from `__true_type`.]
+
+[:`can_call_pre_increment<const int>` inherits from `__false_type`.]
+[:`can_call_pre_increment<void*>` inherits from `__false_type`.]
+[:`can_call_pre_increment<int, std::string>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether prefix `operator++` is public or not:
+if `operator++` is defined as a private member of `RHS` then
+instantiating `can_call_pre_increment<RHS>` will produce a compiler error.
+For this reason `can_call_pre_increment` cannot be used to determine whether a type has a public `operator++` or not.
+``
+struct A { private: void operator++(); };
+boost::can_call_pre_increment<A>::value; // error: A::operator++() is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator++(const A&);
+struct B { operator A(); };
+boost::can_call_pre_increment<A>::value; // this is fine
+boost::can_call_pre_increment<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/can_call_right_shift.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_right_shift.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,70 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_right_shift can_call_right_shift]
+   template <class LHS, class RHS=LHS, class RET=dont_care>
+   struct can_call_right_shift : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs>>rhs`,
+and (ii) `RET=dont_care` or the result of expression `lhs>>rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of binary `operator>>`.
+If `RET` is different from the default `dont_care` 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 can_call_right_shift<LHS, RHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_right_shift.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_right_shift<LHS, RHS, RET>::value_type` is the type `bool`.]
+[:`can_call_right_shift<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_right_shift<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_right_shift<long>` inherits from `__true_type`.]
+
+[:`can_call_right_shift<int, int, int>` inherits from `__true_type`.]
+[:`can_call_right_shift<const int, int>` inherits from `__true_type`.]
+[:`can_call_right_shift<std::istream, int&>` inherits from `__true_type`.]
+[:`can_call_right_shift<std::istream, char*, std::ostream>` inherits from `__true_type`.]
+[:`can_call_right_shift<std::istream, std::string&>` inherits from `__true_type`.]
+
+[:`can_call_right_shift<int, double, bool>` inherits from `__false_type`.]
+[:`can_call_right_shift<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether binary `operator>>` is public or not:
+if `operator>>` is defined as a private member of `LHS` then
+instantiating `can_call_right_shift<LHS>` will produce a compiler error.
+For this reason `can_call_right_shift` cannot be used to determine whether a type has a public `operator>>` or not.
+``
+struct A { private: void operator>>(const A&); };
+boost::can_call_right_shift<A>::value; // error: A::operator>>(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator>>(const A&, const A&);
+struct B { operator A(); };
+boost::can_call_right_shift<A>::value; // this is fine
+boost::can_call_right_shift<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/can_call_right_shift_assignment.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_right_shift_assignment.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,67 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_right_shift_assignment can_call_right_shift_assignment]
+   template <class LHS, class RHS=LHS, class RET=dont_care>
+   struct can_call_right_shift_assignment : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs>>=rhs`,
+and (ii) `RET=dont_care` or the result of expression `lhs>>=rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of binary `operator>>=`.
+If `RET` is different from the default `dont_care` 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 can_call_right_shift_assignment<LHS, RHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_right_shift_assignment.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_right_shift_assignment<LHS, RHS, RET>::value_type` is the type `bool`.]
+[:`can_call_right_shift_assignment<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_right_shift_assignment<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_right_shift_assignment<long>` inherits from `__true_type`.]
+
+[:`can_call_right_shift_assignment<int, int, int>` inherits from `__true_type`.]
+
+[:`can_call_right_shift_assignment<const int, int>` inherits from `__false_type`.]
+[:`can_call_right_shift_assignment<int, double, bool>` inherits from `__false_type`.]
+[:`can_call_right_shift_assignment<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether binary `operator>>=` is public or not:
+if `operator>>=` is defined as a private member of `LHS` then
+instantiating `can_call_right_shift_assignment<LHS>` will produce a compiler error.
+For this reason `can_call_right_shift_assignment` cannot be used to determine whether a type has a public `operator>>=` or not.
+``
+struct A { private: void operator>>=(const A&); };
+boost::can_call_right_shift_assignment<A>::value; // error: A::operator>>=(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator>>=(const A&, const A&);
+struct B { operator A(); };
+boost::can_call_right_shift_assignment<A>::value; // this is fine
+boost::can_call_right_shift_assignment<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/can_call_subtraction.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_subtraction.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,69 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_subtraction can_call_subtraction]
+   template <class LHS, class RHS=LHS, class RET=dont_care>
+   struct can_call_subtraction : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs-rhs`,
+and (ii) `RET=dont_care` or the result of expression `lhs-rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of binary `operator-`.
+If `RET` is different from the default `dont_care` 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 can_call_subtraction<LHS, RHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_subtraction.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_subtraction<LHS, RHS, RET>::value_type` is the type `bool`.]
+[:`can_call_subtraction<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_subtraction<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_subtraction<long>` inherits from `__true_type`.]
+
+[:`can_call_subtraction<int, int, int>` inherits from `__true_type`.]
+[:`can_call_subtraction<int, int, long>` inherits from `__true_type`.]
+[:`can_call_subtraction<int, double, double>` inherits from `__true_type`.]
+[:`can_call_subtraction<int, double, int>` inherits from `__true_type`.]
+[:`can_call_subtraction<const int, int>::value` inherits from `__true_type`.]
+
+[:`can_call_subtraction<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether binary `operator-` is public or not:
+if `operator-` is defined as a private member of `LHS` then
+instantiating `can_call_subtraction<LHS>` will produce a compiler error.
+For this reason `can_call_subtraction` cannot be used to determine whether a type has a public `operator-` or not.
+``
+struct A { private: void operator-(const A&); };
+boost::can_call_subtraction<A>::value; // error: A::operator-(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator-(const A&, const A&);
+struct B { operator A(); };
+boost::can_call_subtraction<A>::value; // this is fine
+boost::can_call_subtraction<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/can_call_subtraction_assignment.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_subtraction_assignment.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,69 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_subtraction_assignment can_call_subtraction_assignment]
+   template <class LHS, class RHS=LHS, class RET=dont_care>
+   struct can_call_subtraction_assignment : public __tof {};
+
+__inherit
+If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs-=rhs`,
+and (ii) `RET=dont_care` or the result of expression `lhs-=rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of binary `operator-=`.
+If `RET` is different from the default `dont_care` 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 can_call_subtraction_assignment<LHS, RHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_subtraction_assignment.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_subtraction_assignment<LHS, RHS, RET>::value_type` is the type `bool`.]
+[:`can_call_subtraction_assignment<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_subtraction_assignment<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_subtraction_assignment<long>` inherits from `__true_type`.]
+
+[:`can_call_subtraction_assignment<int, int, int>` inherits from `__true_type`.]
+[:`can_call_subtraction_assignment<int, int, long>` inherits from `__true_type`.]
+[:`can_call_subtraction_assignment<int, double, double>` inherits from `__true_type`.]
+[:`can_call_subtraction_assignment<int, double, int>` inherits from `__true_type`.]
+
+[:`can_call_subtraction_assignment<const int, int>::value` inherits from `__false_type`.]
+[:`can_call_subtraction_assignment<int, int, std::string>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether binary `operator-=` is public or not:
+if `operator-=` is defined as a private member of `LHS` then
+instantiating `can_call_subtraction_assignment<LHS>` will produce a compiler error.
+For this reason `can_call_subtraction_assignment` cannot be used to determine whether a type has a public `operator-=` or not.
+``
+struct A { private: void operator-=(const A&); };
+boost::can_call_subtraction_assignment<A>::value; // error: A::operator-=(const A&) is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator-=(const A&, const A&);
+struct B { operator A(); };
+boost::can_call_subtraction_assignment<A>::value; // this is fine
+boost::can_call_subtraction_assignment<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/can_call_unary_minus.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_unary_minus.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,68 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_unary_minus can_call_unary_minus]
+   template <class RHS, class RET=dont_care>
+   struct can_call_unary_minus : public __tof {};
+
+__inherit
+If (i) `rhs` of type `RHS` can be used in expression `-rhs`,
+and (ii) `RET=dont_care` or the result of expression `-rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of prefix `operator-`.
+If `RET` is different from the default `dont_care` 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 can_call_unary_minus<RHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_unary_minus.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_unary_minus<RHS, RET>::value_type` is the type `bool`.]
+[:`can_call_unary_minus<RHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_unary_minus<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_unary_minus<long>` inherits from `__true_type`.]
+
+[:`can_call_unary_minus<int, int>` inherits from `__true_type`.]
+[:`can_call_unary_minus<int, long>` inherits from `__true_type`.]
+[:`can_call_unary_minus<double, double>` inherits from `__true_type`.]
+[:`can_call_unary_minus<double, int>` inherits from `__true_type`.]
+[:`can_call_unary_minus<const int>` inherits from `__true_type`.]
+
+[:`can_call_unary_minus<int, std::string>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether prefix `operator-` is public or not:
+if `operator-` is defined as a private member of `RHS` then
+instantiating `can_call_unary_minus<RHS>` will produce a compiler error.
+For this reason `can_call_unary_minus` cannot be used to determine whether a type has a public `operator-` or not.
+``
+struct A { private: void operator-(); };
+boost::can_call_unary_minus<A>::value; // error: A::operator-() is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator-(const A&);
+struct B { operator A(); };
+boost::can_call_unary_minus<A>::value; // this is fine
+boost::can_call_unary_minus<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Added: sandbox/type_traits/libs/type_traits/doc/can_call_unary_plus.qbk
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/can_call_unary_plus.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,68 @@
+[/
+  (C) Copyright 2009-2011  Frederic 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:can_call_unary_plus can_call_unary_plus]
+   template <class RHS, class RET=dont_care>
+   struct can_call_unary_plus : public __tof {};
+
+__inherit
+If (i) `rhs` of type `RHS` can be used in expression `+rhs`,
+and (ii) `RET=dont_care` or the result of expression `+rhs` is convertible to `RET`
+then inherits from __true_type,
+otherwise inherits from __false_type.
+
+The default behaviour (`RET=dont_care`) is to not check for the return value of prefix `operator+`.
+If `RET` is different from the default `dont_care` 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 can_call_unary_plus<RHS, RET>::value==true
+``
+If `RET=void`, the return type is checked to be exactly `void`.
+
+__header `#include <boost/type_traits/can_call_unary_plus.hpp>` or `#include <boost/type_traits/can_call.hpp>`
+
+__examples
+
+[:`can_call_unary_plus<RHS, RET>::value_type` is the type `bool`.]
+[:`can_call_unary_plus<RHS, RET>::value` is a `bool` integral constant expression.]
+[:`can_call_unary_plus<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
+[:`can_call_unary_plus<long>` inherits from `__true_type`.]
+
+[:`can_call_unary_plus<int, int>` inherits from `__true_type`.]
+[:`can_call_unary_plus<int, long>` inherits from `__true_type`.]
+[:`can_call_unary_plus<double, double>` inherits from `__true_type`.]
+[:`can_call_unary_plus<double, int>` inherits from `__true_type`.]
+[:`can_call_unary_plus<const int>` inherits from `__true_type`.]
+
+[:`can_call_unary_plus<int, std::string>` inherits from `__false_type`.]
+
+
+[*Known issues:]
+
+This trait cannot detect whether prefix `operator+` is public or not:
+if `operator+` is defined as a private member of `RHS` then
+instantiating `can_call_unary_plus<RHS>` will produce a compiler error.
+For this reason `can_call_unary_plus` cannot be used to determine whether a type has a public `operator+` or not.
+``
+struct A { private: void operator+(); };
+boost::can_call_unary_plus<A>::value; // error: A::operator+() is private
+``
+
+There is an issue if the operator exists only for type `A` and `B` is
+convertible to `A`. In this case, the compiler will report an ambiguous overload.
+``
+struct A { };
+void operator+(const A&);
+struct B { operator A(); };
+boost::can_call_unary_plus<A>::value; // this is fine
+boost::can_call_unary_plus<B>::value; // error: ambiguous overload
+``
+
+[endsect]
+

Modified: sandbox/type_traits/libs/type_traits/doc/credits.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/credits.qbk	(original)
+++ sandbox/type_traits/libs/type_traits/doc/credits.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -16,7 +16,7 @@
 current maintainer of the library.
 
 This version of type traits library is based on contributions by 
-Adobe Systems Inc, David Abrahams, Frédéric Bron, Steve Cleary, 
+Adobe Systems Inc, David Abrahams, Frederic Bron, Steve Cleary, 
 Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat Marcus, 
 Itay Maman, John Maddock, Thorsten Ottosen, Roman Perepelitsa, Robert Ramey, 
 Jeremy Siek, Robert Stewart and Steven Watanabe.

Deleted: sandbox/type_traits/libs/type_traits/doc/has_operator_bit_and.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_bit_and.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,67 +0,0 @@
-[/
-  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_bit_and has_operator_bit_and]
-   template <class LHS, class RHS=LHS, class RET=void>
-   struct has_operator_bit_and : public __tof {};
-
-__inherit
-If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs&rhs`,
-and (ii) `RET=void` or the result of expression `lhs&rhs` is convertible to `RET`
-then inherits from __true_type,
-otherwise inherits from __false_type.
-
-The default behaviour (`RET=void`) is to not check for the return value of binary `operator&`.
-Be careful that it does not mean that `operator&` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-LHS lhs;
-RHS rhs;
-f(lhs&rhs); // is valid if has_operator_bit_and<LHS, RHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_bit_and.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_bit_and<LHS, RHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_bit_and<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_bit_and<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_bit_and<long>` inherits from `__true_type`.]
-
-[:`has_operator_bit_and<int, int, int>` inherits from `__true_type`.]
-[:`has_operator_bit_and<const int, int>` inherits from `__true_type`.]
-
-[:`has_operator_bit_and<int, double, bool>` inherits from `__false_type`.]
-[:`has_operator_bit_and<int, int, std::string>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether binary `operator&` is public or not:
-if `operator&` is defined as a private member of `LHS` then
-instantiating `has_operator_bit_and<LHS>` will produce a compiler error.
-For this reason `has_operator_bit_and` cannot be used to determine whether a type has a public `operator&` or not.
-``
-struct A { private: void operator&(const A&); };
-boost::has_operator_bit_and<A>::value; // error: A::operator&(const A&) is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator&(const A&, const A&);
-struct B { operator A(); };
-boost::has_operator_bit_and<A>::value; // this is fine
-boost::has_operator_bit_and<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,67 +0,0 @@
-[/
-  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_bit_and_equal has_operator_bit_and_equal]
-   template <class LHS, class RHS=LHS, class RET=void>
-   struct has_operator_bit_and_equal : public __tof {};
-
-__inherit
-If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs&=rhs`,
-and (ii) `RET=void` or the result of expression `lhs&=rhs` is convertible to `RET`
-then inherits from __true_type,
-otherwise inherits from __false_type.
-
-The default behaviour (`RET=void`) is to not check for the return value of binary `operator&=`.
-Be careful that it does not mean that `operator&=` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-LHS lhs;
-RHS rhs;
-f(lhs&=rhs); // is valid if has_operator_bit_and_equal<LHS, RHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_bit_and_equal.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_bit_and_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_bit_and_equal<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_bit_and_equal<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_bit_and_equal<long>` inherits from `__true_type`.]
-
-[:`has_operator_bit_and_equal<int, int, int>` inherits from `__true_type`.]
-
-[:`has_operator_bit_and_equal<const int, int>` inherits from `__false_type`.]
-[:`has_operator_bit_and_equal<int, double, bool>` inherits from `__false_type`.]
-[:`has_operator_bit_and_equal<int, int, std::string>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether binary `operator&=` is public or not:
-if `operator&=` is defined as a private member of `LHS` then
-instantiating `has_operator_bit_and_equal<LHS>` will produce a compiler error.
-For this reason `has_operator_bit_and_equal` cannot be used to determine whether a type has a public `operator&=` or not.
-``
-struct A { private: void operator&=(const A&); };
-boost::has_operator_bit_and_equal<A>::value; // error: A::operator&=(const A&) is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator&=(const A&, const A&);
-struct B { operator A(); };
-boost::has_operator_bit_and_equal<A>::value; // this is fine
-boost::has_operator_bit_and_equal<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Deleted: sandbox/type_traits/libs/type_traits/doc/has_operator_bit_or.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_bit_or.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,67 +0,0 @@
-[/
-  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_bit_or has_operator_bit_or]
-   template <class LHS, class RHS=LHS, class RET=void>
-   struct has_operator_bit_or : public __tof {};
-
-__inherit
-If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs|rhs`,
-and (ii) `RET=void` or the result of expression `lhs|rhs` is convertible to `RET`
-then inherits from __true_type,
-otherwise inherits from __false_type.
-
-The default behaviour (`RET=void`) is to not check for the return value of binary `operator|`.
-Be careful that it does not mean that `operator|` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-LHS lhs;
-RHS rhs;
-f(lhs|rhs); // is valid if has_operator_bit_or<LHS, RHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_bit_or.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_bit_or<LHS, RHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_bit_or<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_bit_or<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_bit_or<long>` inherits from `__true_type`.]
-
-[:`has_operator_bit_or<int, int, int>` inherits from `__true_type`.]
-[:`has_operator_bit_or<const int, int>` inherits from `__true_type`.]
-
-[:`has_operator_bit_or<int, double, bool>` inherits from `__false_type`.]
-[:`has_operator_bit_or<int, int, std::string>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether binary `operator|` is public or not:
-if `operator|` is defined as a private member of `LHS` then
-instantiating `has_operator_bit_or<LHS>` will produce a compiler error.
-For this reason `has_operator_bit_or` cannot be used to determine whether a type has a public `operator|` or not.
-``
-struct A { private: void operator|(const A&); };
-boost::has_operator_bit_or<A>::value; // error: A::operator|(const A&) is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator|(const A&, const A&);
-struct B { operator A(); };
-boost::has_operator_bit_or<A>::value; // this is fine
-boost::has_operator_bit_or<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,67 +0,0 @@
-[/
-  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_bit_or_equal has_operator_bit_or_equal]
-   template <class LHS, class RHS=LHS, class RET=void>
-   struct has_operator_bit_or_equal : public __tof {};
-
-__inherit
-If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs|=rhs`,
-and (ii) `RET=void` or the result of expression `lhs|=rhs` is convertible to `RET`
-then inherits from __true_type,
-otherwise inherits from __false_type.
-
-The default behaviour (`RET=void`) is to not check for the return value of binary `operator|=`.
-Be careful that it does not mean that `operator|=` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-LHS lhs;
-RHS rhs;
-f(lhs|=rhs); // is valid if has_operator_bit_or_equal<LHS, RHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_bit_or_equal.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_bit_or_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_bit_or_equal<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_bit_or_equal<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_bit_or_equal<long>` inherits from `__true_type`.]
-
-[:`has_operator_bit_or_equal<int, int, int>` inherits from `__true_type`.]
-
-[:`has_operator_bit_or_equal<const int, int>` inherits from `__false_type`.]
-[:`has_operator_bit_or_equal<int, double, bool>` inherits from `__false_type`.]
-[:`has_operator_bit_or_equal<int, int, std::string>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether binary `operator|=` is public or not:
-if `operator|=` is defined as a private member of `LHS` then
-instantiating `has_operator_bit_or_equal<LHS>` will produce a compiler error.
-For this reason `has_operator_bit_or_equal` cannot be used to determine whether a type has a public `operator|=` or not.
-``
-struct A { private: void operator|=(const A&); };
-boost::has_operator_bit_or_equal<A>::value; // error: A::operator|=(const A&) is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator|=(const A&, const A&);
-struct B { operator A(); };
-boost::has_operator_bit_or_equal<A>::value; // this is fine
-boost::has_operator_bit_or_equal<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Deleted: sandbox/type_traits/libs/type_traits/doc/has_operator_bit_xor.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_bit_xor.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,67 +0,0 @@
-[/
-  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_bit_xor has_operator_bit_xor]
-   template <class LHS, class RHS=LHS, class RET=void>
-   struct has_operator_bit_xor : public __tof {};
-
-__inherit
-If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs^rhs`,
-and (ii) `RET=void` or the result of expression `lhs^rhs` is convertible to `RET`
-then inherits from __true_type,
-otherwise inherits from __false_type.
-
-The default behaviour (`RET=void`) is to not check for the return value of binary `operator^`.
-Be careful that it does not mean that `operator^` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-LHS lhs;
-RHS rhs;
-f(lhs^rhs); // is valid if has_operator_bit_xor<LHS, RHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_bit_xor.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_bit_xor<LHS, RHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_bit_xor<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_bit_xor<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_bit_xor<long>` inherits from `__true_type`.]
-
-[:`has_operator_bit_xor<int, int, int>` inherits from `__true_type`.]
-[:`has_operator_bit_xor<const int, int>` inherits from `__true_type`.]
-
-[:`has_operator_bit_xor<int, double, bool>` inherits from `__false_type`.]
-[:`has_operator_bit_xor<int, int, std::string>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether binary `operator^` is public or not:
-if `operator^` is defined as a private member of `LHS` then
-instantiating `has_operator_bit_xor<LHS>` will produce a compiler error.
-For this reason `has_operator_bit_xor` cannot be used to determine whether a type has a public `operator^` or not.
-``
-struct A { private: void operator^(const A&); };
-boost::has_operator_bit_xor<A>::value; // error: A::operator^(const A&) is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator^(const A&, const A&);
-struct B { operator A(); };
-boost::has_operator_bit_xor<A>::value; // this is fine
-boost::has_operator_bit_xor<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,67 +0,0 @@
-[/
-  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_bit_xor_equal has_operator_bit_xor_equal]
-   template <class LHS, class RHS=LHS, class RET=void>
-   struct has_operator_bit_xor_equal : public __tof {};
-
-__inherit
-If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs^=rhs`,
-and (ii) `RET=void` or the result of expression `lhs^=rhs` is convertible to `RET`
-then inherits from __true_type,
-otherwise inherits from __false_type.
-
-The default behaviour (`RET=void`) is to not check for the return value of binary `operator^=`.
-Be careful that it does not mean that `operator^=` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-LHS lhs;
-RHS rhs;
-f(lhs^=rhs); // is valid if has_operator_bit_xor_equal<LHS, RHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_bit_xor_equal.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_bit_xor_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_bit_xor_equal<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_bit_xor_equal<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_bit_xor_equal<long>` inherits from `__true_type`.]
-
-[:`has_operator_bit_xor_equal<int, int, int>` inherits from `__true_type`.]
-
-[:`has_operator_bit_xor_equal<const int, int>` inherits from `__false_type`.]
-[:`has_operator_bit_xor_equal<int, double, bool>` inherits from `__false_type`.]
-[:`has_operator_bit_xor_equal<int, int, std::string>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether binary `operator^=` is public or not:
-if `operator^=` is defined as a private member of `LHS` then
-instantiating `has_operator_bit_xor_equal<LHS>` will produce a compiler error.
-For this reason `has_operator_bit_xor_equal` cannot be used to determine whether a type has a public `operator^=` or not.
-``
-struct A { private: void operator^=(const A&); };
-boost::has_operator_bit_xor_equal<A>::value; // error: A::operator^=(const A&) is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator^=(const A&, const A&);
-struct B { operator A(); };
-boost::has_operator_bit_xor_equal<A>::value; // this is fine
-boost::has_operator_bit_xor_equal<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Deleted: sandbox/type_traits/libs/type_traits/doc/has_operator_complement.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_complement.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,69 +0,0 @@
-[/
-  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_complement has_operator_complement]
-   template <class RHS, class RET=void>
-   struct has_operator_complement : 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~`.
-Be careful that it does not mean that `operator~` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-RHS rhs;
-f(~rhs); // is valid if has_operator_complement<RHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_complement.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_complement<RHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_complement<RHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_complement<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_complement<long>` inherits from `__true_type`.]
-
-[:`has_operator_complement<int, int>` inherits from `__true_type`.]
-[:`has_operator_complement<int, long>` inherits from `__true_type`.]
-[:`has_operator_complement<const int>` inherits from `__true_type`.]
-
-[:`has_operator_complement<int*>` inherits from `__false_type`.]
-[:`has_operator_complement<double, double>` inherits from `__false_type`.]
-[:`has_operator_complement<double, int>` inherits from `__false_type`.]
-[:`has_operator_complement<int, std::string>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether prefix `operator~` is public or not:
-if `operator~` is defined as a private member of `RHS` then
-instantiating `has_operator_complement<RHS>` will produce a compiler error.
-For this reason `has_operator_complement` cannot be used to determine whether a type has a public `operator~` or not.
-``
-struct A { private: void operator~(); };
-boost::has_operator_complement<A>::value; // error: A::operator~() is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator~(const A&);
-struct B { operator A(); };
-boost::has_operator_complement<A>::value; // this is fine
-boost::has_operator_complement<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Deleted: sandbox/type_traits/libs/type_traits/doc/has_operator_dereference.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_dereference.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,72 +0,0 @@
-[/
-  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*`.
-Be careful that it does not mean that `operator*` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-RHS rhs;
-f(*rhs); // is valid if has_operator_dereference<RHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_dereference.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_dereference<RHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_dereference<RHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_dereference<int*>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_dereference<long*>` inherits from `__true_type`.]
-
-
-[:`has_operator_dereference<int*, int>` inherits from `__true_type`.]
-[:`has_operator_dereference<int*, const int>` inherits from `__true_type`.]
-[:`has_operator_dereference<int const *>` inherits from `__true_type`.]
-[:`has_operator_dereference<int * const>` inherits from `__true_type`.]
-[:`has_operator_dereference<int const * const>` inherits from `__true_type`.]
-
-[:`has_operator_dereference<int>` inherits from `__false_type`.]
-[:`has_operator_dereference<double>` inherits from `__false_type`.]
-[:`has_operator_dereference<void*>` inherits from `__false_type`.]
-[:`has_operator_dereference<const int*, int&>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether prefix `operator*` is public or not:
-if `operator*` is defined as a private member of `RHS` then
-instantiating `has_operator_dereference<RHS>` will produce a compiler error.
-For this reason `has_operator_dereference` cannot be used to determine whether a type has a public `operator*` or not.
-``
-struct A { private: void operator*(); };
-boost::has_operator_dereference<A>::value; // error: A::operator*() is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator*(const A&);
-struct B { operator A(); };
-boost::has_operator_dereference<A>::value; // this is fine
-boost::has_operator_dereference<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Deleted: sandbox/type_traits/libs/type_traits/doc/has_operator_divides.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_divides.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,69 +0,0 @@
-[/
-  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_divides has_operator_divides]
-   template <class LHS, class RHS=LHS, class RET=void>
-   struct has_operator_divides : public __tof {};
-
-__inherit
-If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs/rhs`,
-and (ii) `RET=void` or the result of expression `lhs/rhs` is convertible to `RET`
-then inherits from __true_type,
-otherwise inherits from __false_type.
-
-The default behaviour (`RET=void`) is to not check for the return value of binary `operator/`.
-Be careful that it does not mean that `operator/` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-LHS lhs;
-RHS rhs;
-f(lhs/rhs); // is valid if has_operator_divides<LHS, RHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_divides.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_divides<LHS, RHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_divides<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_divides<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_divides<long>` inherits from `__true_type`.]
-
-[:`has_operator_divides<int, int, int>` inherits from `__true_type`.]
-[:`has_operator_divides<int, int, long>` inherits from `__true_type`.]
-[:`has_operator_divides<int, double, double>` inherits from `__true_type`.]
-[:`has_operator_divides<int, double, int>` inherits from `__true_type`.]
-[:`has_operator_divides<const int, int>::value` inherits from `__true_type`.]
-
-[:`has_operator_divides<int, int, std::string>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether binary `operator/` is public or not:
-if `operator/` is defined as a private member of `LHS` then
-instantiating `has_operator_divides<LHS>` will produce a compiler error.
-For this reason `has_operator_divides` cannot be used to determine whether a type has a public `operator/` or not.
-``
-struct A { private: void operator/(const A&); };
-boost::has_operator_divides<A>::value; // error: A::operator/(const A&) is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator/(const A&, const A&);
-struct B { operator A(); };
-boost::has_operator_divides<A>::value; // this is fine
-boost::has_operator_divides<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Deleted: sandbox/type_traits/libs/type_traits/doc/has_operator_divides_equal.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_divides_equal.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,69 +0,0 @@
-[/
-  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_divides_equal has_operator_divides_equal]
-   template <class LHS, class RHS=LHS, class RET=void>
-   struct has_operator_divides_equal : public __tof {};
-
-__inherit
-If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs/=rhs`,
-and (ii) `RET=void` or the result of expression `lhs/=rhs` is convertible to `RET`
-then inherits from __true_type,
-otherwise inherits from __false_type.
-
-The default behaviour (`RET=void`) is to not check for the return value of binary `operator/=`.
-Be careful that it does not mean that `operator/=` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-LHS lhs;
-RHS rhs;
-f(lhs/=rhs); // is valid if has_operator_divides_equal<LHS, RHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_divides_equal.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_divides_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_divides_equal<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_divides_equal<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_divides_equal<long>` inherits from `__true_type`.]
-
-[:`has_operator_divides_equal<int, int, int>` inherits from `__true_type`.]
-[:`has_operator_divides_equal<int, int, long>` inherits from `__true_type`.]
-[:`has_operator_divides_equal<int, double, double>` inherits from `__true_type`.]
-[:`has_operator_divides_equal<int, double, int>` inherits from `__true_type`.]
-
-[:`has_operator_divides_equal<const int, int>::value` inherits from `__false_type`.]
-[:`has_operator_divides_equal<int, int, std::string>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether binary `operator/=` is public or not:
-if `operator/=` is defined as a private member of `LHS` then
-instantiating `has_operator_divides_equal<LHS>` will produce a compiler error.
-For this reason `has_operator_divides_equal` cannot be used to determine whether a type has a public `operator/=` or not.
-``
-struct A { private: void operator/=(const A&); };
-boost::has_operator_divides_equal<A>::value; // error: A::operator/=(const A&) is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator/=(const A&, const A&);
-struct B { operator A(); };
-boost::has_operator_divides_equal<A>::value; // this is fine
-boost::has_operator_divides_equal<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Deleted: sandbox/type_traits/libs/type_traits/doc/has_operator_equal_to.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_equal_to.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,69 +0,0 @@
-[/
-  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_equal_to has_operator_equal_to]
-   template <class LHS, class RHS=LHS, class RET=void>
-   struct has_operator_equal_to : public __tof {};
-
-__inherit
-If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs==rhs`,
-and (ii) `RET=void` or the result of expression `lhs==rhs` is convertible to `RET`
-then inherits from __true_type,
-otherwise inherits from __false_type.
-
-The default behaviour (`RET=void`) is to not check for the return value of binary `operator==`.
-Be careful that it does not mean that `operator==` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-LHS lhs;
-RHS rhs;
-f(lhs==rhs); // is valid if has_operator_equal_to<LHS, RHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_equal_to.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_equal_to<LHS, RHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_equal_to<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_equal_to<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_equal_to<long>` inherits from `__true_type`.]
-
-[:`has_operator_equal_to<int, int, bool>` inherits from `__true_type`.]
-[:`has_operator_equal_to<int, double, bool>` inherits from `__true_type`.]
-[:`has_operator_equal_to<const int>` inherits from `__true_type`.]
-
-[:`has_operator_equal_to<int*, int>` inherits from `__false_type`.]
-[:`has_operator_equal_to<int*, double*>` inherits from `__false_type`.]
-[:`has_operator_equal_to<int, int, std::string>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether binary `operator==` is public or not:
-if `operator==` is defined as a private member of `LHS` then
-instantiating `has_operator_equal_to<LHS>` will produce a compiler error.
-For this reason `has_operator_equal_to` cannot be used to determine whether a type has a public `operator==` or not.
-``
-struct A { private: void operator==(const A&); };
-boost::has_operator_equal_to<A>::value; // error: A::operator==(const A&) is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator==(const A&, const A&);
-struct B { operator A(); };
-boost::has_operator_equal_to<A>::value; // this is fine
-boost::has_operator_equal_to<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Deleted: sandbox/type_traits/libs/type_traits/doc/has_operator_greater.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_greater.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,69 +0,0 @@
-[/
-  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_greater has_operator_greater]
-   template <class LHS, class RHS=LHS, class RET=void>
-   struct has_operator_greater : public __tof {};
-
-__inherit
-If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs>rhs`,
-and (ii) `RET=void` or the result of expression `lhs>rhs` is convertible to `RET`
-then inherits from __true_type,
-otherwise inherits from __false_type.
-
-The default behaviour (`RET=void`) is to not check for the return value of binary `operator>`.
-Be careful that it does not mean that `operator>` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-LHS lhs;
-RHS rhs;
-f(lhs>rhs); // is valid if has_operator_greater<LHS, RHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_greater.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_greater<LHS, RHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_greater<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_greater<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_greater<long>` inherits from `__true_type`.]
-
-[:`has_operator_greater<int, int, bool>` inherits from `__true_type`.]
-[:`has_operator_greater<int, double, bool>` inherits from `__true_type`.]
-[:`has_operator_greater<const int>` inherits from `__true_type`.]
-
-[:`has_operator_greater<int*, int>` inherits from `__false_type`.]
-[:`has_operator_greater<int*, double*>` inherits from `__false_type`.]
-[:`has_operator_greater<int, int, std::string>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether binary `operator>` is public or not:
-if `operator>` is defined as a private member of `LHS` then
-instantiating `has_operator_greater<LHS>` will produce a compiler error.
-For this reason `has_operator_greater` cannot be used to determine whether a type has a public `operator>` or not.
-``
-struct A { private: void operator>(const A&); };
-boost::has_operator_greater<A>::value; // error: A::operator>(const A&) is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator>(const A&, const A&);
-struct B { operator A(); };
-boost::has_operator_greater<A>::value; // this is fine
-boost::has_operator_greater<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Deleted: sandbox/type_traits/libs/type_traits/doc/has_operator_greater_equal.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_greater_equal.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,69 +0,0 @@
-[/
-  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_greater_equal has_operator_greater_equal]
-   template <class LHS, class RHS=LHS, class RET=void>
-   struct has_operator_greater_equal : public __tof {};
-
-__inherit
-If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs>=rhs`,
-and (ii) `RET=void` or the result of expression `lhs>=rhs` is convertible to `RET`
-then inherits from __true_type,
-otherwise inherits from __false_type.
-
-The default behaviour (`RET=void`) is to not check for the return value of binary `operator>=`.
-Be careful that it does not mean that `operator>=` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-LHS lhs;
-RHS rhs;
-f(lhs>=rhs); // is valid if has_operator_greater_equal<LHS, RHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_greater_equal.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_greater_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_greater_equal<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_greater_equal<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_greater_equal<long>` inherits from `__true_type`.]
-
-[:`has_operator_greater_equal<int, int, bool>` inherits from `__true_type`.]
-[:`has_operator_greater_equal<int, double, bool>` inherits from `__true_type`.]
-[:`has_operator_greater_equal<const int>` inherits from `__true_type`.]
-
-[:`has_operator_greater_equal<int*, int>` inherits from `__false_type`.]
-[:`has_operator_greater_equal<int*, double*>` inherits from `__false_type`.]
-[:`has_operator_greater_equal<int, int, std::string>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether binary `operator>=` is public or not:
-if `operator>=` is defined as a private member of `LHS` then
-instantiating `has_operator_greater_equal<LHS>` will produce a compiler error.
-For this reason `has_operator_greater_equal` cannot be used to determine whether a type has a public `operator>=` or not.
-``
-struct A { private: void operator>=(const A&); };
-boost::has_operator_greater_equal<A>::value; // error: A::operator>=(const A&) is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator>=(const A&, const A&);
-struct B { operator A(); };
-boost::has_operator_greater_equal<A>::value; // this is fine
-boost::has_operator_greater_equal<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Deleted: sandbox/type_traits/libs/type_traits/doc/has_operator_left_shift.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_left_shift.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,70 +0,0 @@
-[/
-  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_left_shift has_operator_left_shift]
-   template <class LHS, class RHS=LHS, class RET=void>
-   struct has_operator_left_shift : public __tof {};
-
-__inherit
-If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs<<rhs`,
-and (ii) `RET=void` or the result of expression `lhs<<rhs` is convertible to `RET`
-then inherits from __true_type,
-otherwise inherits from __false_type.
-
-The default behaviour (`RET=void`) is to not check for the return value of binary `operator<<`.
-Be careful that it does not mean that `operator<<` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-LHS lhs;
-RHS rhs;
-f(lhs<<rhs); // is valid if has_operator_left_shift<LHS, RHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_left_shift.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_left_shift<LHS, RHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_left_shift<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_left_shift<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_left_shift<long>` inherits from `__true_type`.]
-
-[:`has_operator_left_shift<int, int, int>` inherits from `__true_type`.]
-[:`has_operator_left_shift<const int, int>` inherits from `__true_type`.]
-[:`has_operator_left_shift<std::ostream, int>` inherits from `__true_type`.]
-[:`has_operator_left_shift<std::ostream, char*, std::ostream>` inherits from `__true_type`.]
-[:`has_operator_left_shift<std::ostream, std::string>` inherits from `__true_type`.]
-
-[:`has_operator_left_shift<int, double, bool>` inherits from `__false_type`.]
-[:`has_operator_left_shift<int, int, std::string>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether binary `operator<<` is public or not:
-if `operator<<` is defined as a private member of `LHS` then
-instantiating `has_operator_left_shift<LHS>` will produce a compiler error.
-For this reason `has_operator_left_shift` cannot be used to determine whether a type has a public `operator<<` or not.
-``
-struct A { private: void operator<<(const A&); };
-boost::has_operator_left_shift<A>::value; // error: A::operator<<(const A&) is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator<<(const A&, const A&);
-struct B { operator A(); };
-boost::has_operator_left_shift<A>::value; // this is fine
-boost::has_operator_left_shift<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,67 +0,0 @@
-[/
-  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_left_shift_equal has_operator_left_shift_equal]
-   template <class LHS, class RHS=LHS, class RET=void>
-   struct has_operator_left_shift_equal : public __tof {};
-
-__inherit
-If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs<<=rhs`,
-and (ii) `RET=void` or the result of expression `lhs<<=rhs` is convertible to `RET`
-then inherits from __true_type,
-otherwise inherits from __false_type.
-
-The default behaviour (`RET=void`) is to not check for the return value of binary `operator<<=`.
-Be careful that it does not mean that `operator<<=` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-LHS lhs;
-RHS rhs;
-f(lhs<<=rhs); // is valid if has_operator_left_shift_equal<LHS, RHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_left_shift_equal.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_left_shift_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_left_shift_equal<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_left_shift_equal<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_left_shift_equal<long>` inherits from `__true_type`.]
-
-[:`has_operator_left_shift_equal<int, int, int>` inherits from `__true_type`.]
-
-[:`has_operator_left_shift_equal<const int, int>` inherits from `__false_type`.]
-[:`has_operator_left_shift_equal<int, double, bool>` inherits from `__false_type`.]
-[:`has_operator_left_shift_equal<int, int, std::string>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether binary `operator<<=` is public or not:
-if `operator<<=` is defined as a private member of `LHS` then
-instantiating `has_operator_left_shift_equal<LHS>` will produce a compiler error.
-For this reason `has_operator_left_shift_equal` cannot be used to determine whether a type has a public `operator<<=` or not.
-``
-struct A { private: void operator<<=(const A&); };
-boost::has_operator_left_shift_equal<A>::value; // error: A::operator<<=(const A&) is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator<<=(const A&, const A&);
-struct B { operator A(); };
-boost::has_operator_left_shift_equal<A>::value; // this is fine
-boost::has_operator_left_shift_equal<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Deleted: sandbox/type_traits/libs/type_traits/doc/has_operator_less.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_less.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,69 +0,0 @@
-[/
-  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_less has_operator_less]
-   template <class LHS, class RHS=LHS, class RET=void>
-   struct has_operator_less : public __tof {};
-
-__inherit
-If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs<rhs`,
-and (ii) `RET=void` or the result of expression `lhs<rhs` is convertible to `RET`
-then inherits from __true_type,
-otherwise inherits from __false_type.
-
-The default behaviour (`RET=void`) is to not check for the return value of binary `operator<`.
-Be careful that it does not mean that `operator<` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-LHS lhs;
-RHS rhs;
-f(lhs<rhs); // is valid if has_operator_less<LHS, RHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_less.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_less<LHS, RHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_less<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_less<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_less<long>` inherits from `__true_type`.]
-
-[:`has_operator_less<int, int, bool>` inherits from `__true_type`.]
-[:`has_operator_less<int, double, bool>` inherits from `__true_type`.]
-[:`has_operator_less<const int>` inherits from `__true_type`.]
-
-[:`has_operator_less<int*, int>` inherits from `__false_type`.]
-[:`has_operator_less<int*, double*>` inherits from `__false_type`.]
-[:`has_operator_less<int, int, std::string>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether binary `operator<` is public or not:
-if `operator<` is defined as a private member of `LHS` then
-instantiating `has_operator_less<LHS>` will produce a compiler error.
-For this reason `has_operator_less` cannot be used to determine whether a type has a public `operator<` or not.
-``
-struct A { private: void operator<(const A&); };
-boost::has_operator_less<A>::value; // error: A::operator<(const A&) is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator<(const A&, const A&);
-struct B { operator A(); };
-boost::has_operator_less<A>::value; // this is fine
-boost::has_operator_less<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Deleted: sandbox/type_traits/libs/type_traits/doc/has_operator_less_equal.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_less_equal.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,69 +0,0 @@
-[/
-  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_less_equal has_operator_less_equal]
-   template <class LHS, class RHS=LHS, class RET=void>
-   struct has_operator_less_equal : public __tof {};
-
-__inherit
-If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs<=rhs`,
-and (ii) `RET=void` or the result of expression `lhs<=rhs` is convertible to `RET`
-then inherits from __true_type,
-otherwise inherits from __false_type.
-
-The default behaviour (`RET=void`) is to not check for the return value of binary `operator<=`.
-Be careful that it does not mean that `operator<=` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-LHS lhs;
-RHS rhs;
-f(lhs<=rhs); // is valid if has_operator_less_equal<LHS, RHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_less_equal.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_less_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_less_equal<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_less_equal<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_less_equal<long>` inherits from `__true_type`.]
-
-[:`has_operator_less_equal<int, int, bool>` inherits from `__true_type`.]
-[:`has_operator_less_equal<int, double, bool>` inherits from `__true_type`.]
-[:`has_operator_less_equal<const int>` inherits from `__true_type`.]
-
-[:`has_operator_less_equal<int*, int>` inherits from `__false_type`.]
-[:`has_operator_less_equal<int*, double*>` inherits from `__false_type`.]
-[:`has_operator_less_equal<int, int, std::string>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether binary `operator<=` is public or not:
-if `operator<=` is defined as a private member of `LHS` then
-instantiating `has_operator_less_equal<LHS>` will produce a compiler error.
-For this reason `has_operator_less_equal` cannot be used to determine whether a type has a public `operator<=` or not.
-``
-struct A { private: void operator<=(const A&); };
-boost::has_operator_less_equal<A>::value; // error: A::operator<=(const A&) is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator<=(const A&, const A&);
-struct B { operator A(); };
-boost::has_operator_less_equal<A>::value; // this is fine
-boost::has_operator_less_equal<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Deleted: sandbox/type_traits/libs/type_traits/doc/has_operator_logical_and.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_logical_and.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,68 +0,0 @@
-[/
-  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_logical_and has_operator_logical_and]
-   template <class LHS, class RHS=LHS, class RET=void>
-   struct has_operator_logical_and : public __tof {};
-
-__inherit
-If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs&&rhs`,
-and (ii) `RET=void` or the result of expression `lhs&&rhs` is convertible to `RET`
-then inherits from __true_type,
-otherwise inherits from __false_type.
-
-The default behaviour (`RET=void`) is to not check for the return value of binary `operator&&`.
-Be careful that it does not mean that `operator&&` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-LHS lhs;
-RHS rhs;
-f(lhs&&rhs); // is valid if has_operator_logical_and<LHS, RHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_logical_and.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_logical_and<LHS, RHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_logical_and<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_logical_and<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_logical_and<bool>` inherits from `__true_type`.]
-
-[:`has_operator_logical_and<int, int, bool>` inherits from `__true_type`.]
-[:`has_operator_logical_and<int, int, long>` inherits from `__true_type`.]
-[:`has_operator_logical_and<int, double, bool>` inherits from `__true_type`.]
-[:`has_operator_logical_and<const int, int>::value` inherits from `__true_type`.]
-
-[:`has_operator_logical_and<int, int, std::string>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether binary `operator&&` is public or not:
-if `operator&&` is defined as a private member of `LHS` then
-instantiating `has_operator_logical_and<LHS>` will produce a compiler error.
-For this reason `has_operator_logical_and` cannot be used to determine whether a type has a public `operator&&` or not.
-``
-struct A { private: void operator&&(const A&); };
-boost::has_operator_logical_and<A>::value; // error: A::operator&&(const A&) is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator&&(const A&, const A&);
-struct B { operator A(); };
-boost::has_operator_logical_and<A>::value; // this is fine
-boost::has_operator_logical_and<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Deleted: sandbox/type_traits/libs/type_traits/doc/has_operator_logical_not.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_logical_not.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,68 +0,0 @@
-[/
-  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_logical_not has_operator_logical_not]
-   template <class RHS, class RET=void>
-   struct has_operator_logical_not : public __tof {};
-
-__inherit
-If (i) `rhs` of type `RHS` can be used in expression `!rhs`,
-and (ii) `RET=void` or the result of expression `!rhs` is convertible to `RET`
-then inherits from __true_type,
-otherwise inherits from __false_type.
-
-The default behaviour (`RET=void`) is to not check for the return value of prefix `operator!`.
-Be careful that it does not mean that `operator!` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-RHS rhs;
-f(!rhs); // is valid if has_operator_logical_not<RHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_logical_not.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_logical_not<RHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_logical_not<RHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_logical_not<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_logical_not<bool>` inherits from `__true_type`.]
-
-[:`has_operator_logical_not<int, bool>` inherits from `__true_type`.]
-[:`has_operator_logical_not<int, long>` inherits from `__true_type`.]
-[:`has_operator_logical_not<double, double>` inherits from `__true_type`.]
-[:`has_operator_logical_not<double, bool>` inherits from `__true_type`.]
-[:`has_operator_logical_not<const bool>` inherits from `__true_type`.]
-
-[:`has_operator_logical_not<int, std::string>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether prefix `operator!` is public or not:
-if `operator!` is defined as a private member of `RHS` then
-instantiating `has_operator_logical_not<RHS>` will produce a compiler error.
-For this reason `has_operator_logical_not` cannot be used to determine whether a type has a public `operator!` or not.
-``
-struct A { private: void operator!(); };
-boost::has_operator_logical_not<A>::value; // error: A::operator!() is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator!(const A&);
-struct B { operator A(); };
-boost::has_operator_logical_not<A>::value; // this is fine
-boost::has_operator_logical_not<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Deleted: sandbox/type_traits/libs/type_traits/doc/has_operator_logical_or.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_logical_or.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,68 +0,0 @@
-[/
-  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_logical_or has_operator_logical_or]
-   template <class LHS, class RHS=LHS, class RET=void>
-   struct has_operator_logical_or : public __tof {};
-
-__inherit
-If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs||rhs`,
-and (ii) `RET=void` or the result of expression `lhs||rhs` is convertible to `RET`
-then inherits from __true_type,
-otherwise inherits from __false_type.
-
-The default behaviour (`RET=void`) is to not check for the return value of binary `operator||`.
-Be careful that it does not mean that `operator||` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-LHS lhs;
-RHS rhs;
-f(lhs||rhs); // is valid if has_operator_logical_or<LHS, RHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_logical_or.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_logical_or<LHS, RHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_logical_or<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_logical_or<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_logical_or<bool>` inherits from `__true_type`.]
-
-[:`has_operator_logical_or<int, int, bool>` inherits from `__true_type`.]
-[:`has_operator_logical_or<int, int, long>` inherits from `__true_type`.]
-[:`has_operator_logical_or<int, double, bool>` inherits from `__true_type`.]
-[:`has_operator_logical_or<const int, int>::value` inherits from `__true_type`.]
-
-[:`has_operator_logical_or<int, int, std::string>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether binary `operator||` is public or not:
-if `operator||` is defined as a private member of `LHS` then
-instantiating `has_operator_logical_or<LHS>` will produce a compiler error.
-For this reason `has_operator_logical_or` cannot be used to determine whether a type has a public `operator||` or not.
-``
-struct A { private: void operator||(const A&); };
-boost::has_operator_logical_or<A>::value; // error: A::operator||(const A&) is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator||(const A&, const A&);
-struct B { operator A(); };
-boost::has_operator_logical_or<A>::value; // this is fine
-boost::has_operator_logical_or<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Deleted: sandbox/type_traits/libs/type_traits/doc/has_operator_minus.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_minus.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,69 +0,0 @@
-[/
-  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_minus has_operator_minus]
-   template <class LHS, class RHS=LHS, class RET=void>
-   struct has_operator_minus : public __tof {};
-
-__inherit
-If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs-rhs`,
-and (ii) `RET=void` or the result of expression `lhs-rhs` is convertible to `RET`
-then inherits from __true_type,
-otherwise inherits from __false_type.
-
-The default behaviour (`RET=void`) is to not check for the return value of binary `operator-`.
-Be careful that it does not mean that `operator-` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-LHS lhs;
-RHS rhs;
-f(lhs-rhs); // is valid if has_operator_minus<LHS, RHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_minus.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_minus<LHS, RHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_minus<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_minus<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_minus<long>` inherits from `__true_type`.]
-
-[:`has_operator_minus<int, int, int>` inherits from `__true_type`.]
-[:`has_operator_minus<int, int, long>` inherits from `__true_type`.]
-[:`has_operator_minus<int, double, double>` inherits from `__true_type`.]
-[:`has_operator_minus<int, double, int>` inherits from `__true_type`.]
-[:`has_operator_minus<const int, int>::value` inherits from `__true_type`.]
-
-[:`has_operator_minus<int, int, std::string>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether binary `operator-` is public or not:
-if `operator-` is defined as a private member of `LHS` then
-instantiating `has_operator_minus<LHS>` will produce a compiler error.
-For this reason `has_operator_minus` cannot be used to determine whether a type has a public `operator-` or not.
-``
-struct A { private: void operator-(const A&); };
-boost::has_operator_minus<A>::value; // error: A::operator-(const A&) is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator-(const A&, const A&);
-struct B { operator A(); };
-boost::has_operator_minus<A>::value; // this is fine
-boost::has_operator_minus<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Deleted: sandbox/type_traits/libs/type_traits/doc/has_operator_minus_equal.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_minus_equal.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,69 +0,0 @@
-[/
-  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_minus_equal has_operator_minus_equal]
-   template <class LHS, class RHS=LHS, class RET=void>
-   struct has_operator_minus_equal : public __tof {};
-
-__inherit
-If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs-=rhs`,
-and (ii) `RET=void` or the result of expression `lhs-=rhs` is convertible to `RET`
-then inherits from __true_type,
-otherwise inherits from __false_type.
-
-The default behaviour (`RET=void`) is to not check for the return value of binary `operator-=`.
-Be careful that it does not mean that `operator-=` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-LHS lhs;
-RHS rhs;
-f(lhs-=rhs); // is valid if has_operator_minus_equal<LHS, RHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_minus_equal.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_minus_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_minus_equal<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_minus_equal<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_minus_equal<long>` inherits from `__true_type`.]
-
-[:`has_operator_minus_equal<int, int, int>` inherits from `__true_type`.]
-[:`has_operator_minus_equal<int, int, long>` inherits from `__true_type`.]
-[:`has_operator_minus_equal<int, double, double>` inherits from `__true_type`.]
-[:`has_operator_minus_equal<int, double, int>` inherits from `__true_type`.]
-
-[:`has_operator_minus_equal<const int, int>::value` inherits from `__false_type`.]
-[:`has_operator_minus_equal<int, int, std::string>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether binary `operator-=` is public or not:
-if `operator-=` is defined as a private member of `LHS` then
-instantiating `has_operator_minus_equal<LHS>` will produce a compiler error.
-For this reason `has_operator_minus_equal` cannot be used to determine whether a type has a public `operator-=` or not.
-``
-struct A { private: void operator-=(const A&); };
-boost::has_operator_minus_equal<A>::value; // error: A::operator-=(const A&) is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator-=(const A&, const A&);
-struct B { operator A(); };
-boost::has_operator_minus_equal<A>::value; // this is fine
-boost::has_operator_minus_equal<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Deleted: sandbox/type_traits/libs/type_traits/doc/has_operator_modulus.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_modulus.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,67 +0,0 @@
-[/
-  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_modulus has_operator_modulus]
-   template <class LHS, class RHS=LHS, class RET=void>
-   struct has_operator_modulus : public __tof {};
-
-__inherit
-If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs%rhs`,
-and (ii) `RET=void` or the result of expression `lhs%rhs` is convertible to `RET`
-then inherits from __true_type,
-otherwise inherits from __false_type.
-
-The default behaviour (`RET=void`) is to not check for the return value of binary `operator%`.
-Be careful that it does not mean that `operator%` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-LHS lhs;
-RHS rhs;
-f(lhs%rhs); // is valid if has_operator_modulus<LHS, RHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_modulus.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_modulus<LHS, RHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_modulus<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_modulus<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_modulus<long>` inherits from `__true_type`.]
-
-[:`has_operator_modulus<int, int, int>` inherits from `__true_type`.]
-[:`has_operator_modulus<int, int, long>` inherits from `__true_type`.]
-[:`has_operator_modulus<const int, int>::value` inherits from `__true_type`.]
-
-[:`has_operator_modulus<int, double>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether binary `operator%` is public or not:
-if `operator%` is defined as a private member of `LHS` then
-instantiating `has_operator_modulus<LHS>` will produce a compiler error.
-For this reason `has_operator_modulus` cannot be used to determine whether a type has a public `operator%` or not.
-``
-struct A { private: void operator%(const A&); };
-boost::has_operator_modulus<A>::value; // error: A::operator%(const A&) is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator%(const A&, const A&);
-struct B { operator A(); };
-boost::has_operator_modulus<A>::value; // this is fine
-boost::has_operator_modulus<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Deleted: sandbox/type_traits/libs/type_traits/doc/has_operator_modulus_equal.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_modulus_equal.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,67 +0,0 @@
-[/
-  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_modulus_equal has_operator_modulus_equal]
-   template <class LHS, class RHS=LHS, class RET=void>
-   struct has_operator_modulus_equal : public __tof {};
-
-__inherit
-If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs%=rhs`,
-and (ii) `RET=void` or the result of expression `lhs%=rhs` is convertible to `RET`
-then inherits from __true_type,
-otherwise inherits from __false_type.
-
-The default behaviour (`RET=void`) is to not check for the return value of binary `operator%=`.
-Be careful that it does not mean that `operator%=` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-LHS lhs;
-RHS rhs;
-f(lhs%=rhs); // is valid if has_operator_modulus_equal<LHS, RHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_modulus_equal.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_modulus_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_modulus_equal<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_modulus_equal<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_modulus_equal<long>` inherits from `__true_type`.]
-
-[:`has_operator_modulus_equal<int, int, int>` inherits from `__true_type`.]
-[:`has_operator_modulus_equal<int, int, long>` inherits from `__true_type`.]
-
-[:`has_operator_modulus_equal<const int, int>::value` inherits from `__false_type`.]
-[:`has_operator_modulus_equal<int, double>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether binary `operator%=` is public or not:
-if `operator%=` is defined as a private member of `LHS` then
-instantiating `has_operator_modulus_equal<LHS>` will produce a compiler error.
-For this reason `has_operator_modulus_equal` cannot be used to determine whether a type has a public `operator%=` or not.
-``
-struct A { private: void operator%=(const A&); };
-boost::has_operator_modulus_equal<A>::value; // error: A::operator%=(const A&) is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator%=(const A&, const A&);
-struct B { operator A(); };
-boost::has_operator_modulus_equal<A>::value; // this is fine
-boost::has_operator_modulus_equal<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Deleted: sandbox/type_traits/libs/type_traits/doc/has_operator_multiplies.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_multiplies.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,69 +0,0 @@
-[/
-  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_multiplies has_operator_multiplies]
-   template <class LHS, class RHS=LHS, class RET=void>
-   struct has_operator_multiplies : public __tof {};
-
-__inherit
-If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs*rhs`,
-and (ii) `RET=void` or the result of expression `lhs*rhs` is convertible to `RET`
-then inherits from __true_type,
-otherwise inherits from __false_type.
-
-The default behaviour (`RET=void`) is to not check for the return value of binary `operator*`.
-Be careful that it does not mean that `operator*` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-LHS lhs;
-RHS rhs;
-f(lhs*rhs); // is valid if has_operator_multiplies<LHS, RHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_multiplies.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_multiplies<LHS, RHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_multiplies<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_multiplies<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_multiplies<long>` inherits from `__true_type`.]
-
-[:`has_operator_multiplies<int, int, int>` inherits from `__true_type`.]
-[:`has_operator_multiplies<int, int, long>` inherits from `__true_type`.]
-[:`has_operator_multiplies<int, double, double>` inherits from `__true_type`.]
-[:`has_operator_multiplies<int, double, int>` inherits from `__true_type`.]
-[:`has_operator_multiplies<const int, int>::value` inherits from `__true_type`.]
-
-[:`has_operator_multiplies<int, int, std::string>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether binary `operator*` is public or not:
-if `operator*` is defined as a private member of `LHS` then
-instantiating `has_operator_multiplies<LHS>` will produce a compiler error.
-For this reason `has_operator_multiplies` cannot be used to determine whether a type has a public `operator*` or not.
-``
-struct A { private: void operator*(const A&); };
-boost::has_operator_multiplies<A>::value; // error: A::operator*(const A&) is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator*(const A&, const A&);
-struct B { operator A(); };
-boost::has_operator_multiplies<A>::value; // this is fine
-boost::has_operator_multiplies<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Deleted: sandbox/type_traits/libs/type_traits/doc/has_operator_multiplies_equal.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_multiplies_equal.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,69 +0,0 @@
-[/
-  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_multiplies_equal has_operator_multiplies_equal]
-   template <class LHS, class RHS=LHS, class RET=void>
-   struct has_operator_multiplies_equal : public __tof {};
-
-__inherit
-If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs*=rhs`,
-and (ii) `RET=void` or the result of expression `lhs*=rhs` is convertible to `RET`
-then inherits from __true_type,
-otherwise inherits from __false_type.
-
-The default behaviour (`RET=void`) is to not check for the return value of binary `operator*=`.
-Be careful that it does not mean that `operator*=` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-LHS lhs;
-RHS rhs;
-f(lhs*=rhs); // is valid if has_operator_multiplies_equal<LHS, RHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_multiplies_equal.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_multiplies_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_multiplies_equal<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_multiplies_equal<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_multiplies_equal<long>` inherits from `__true_type`.]
-
-[:`has_operator_multiplies_equal<int, int, int>` inherits from `__true_type`.]
-[:`has_operator_multiplies_equal<int, int, long>` inherits from `__true_type`.]
-[:`has_operator_multiplies_equal<int, double, double>` inherits from `__true_type`.]
-[:`has_operator_multiplies_equal<int, double, int>` inherits from `__true_type`.]
-
-[:`has_operator_multiplies_equal<const int, int>::value` inherits from `__false_type`.]
-[:`has_operator_multiplies_equal<int, int, std::string>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether binary `operator*=` is public or not:
-if `operator*=` is defined as a private member of `LHS` then
-instantiating `has_operator_multiplies_equal<LHS>` will produce a compiler error.
-For this reason `has_operator_multiplies_equal` cannot be used to determine whether a type has a public `operator*=` or not.
-``
-struct A { private: void operator*=(const A&); };
-boost::has_operator_multiplies_equal<A>::value; // error: A::operator*=(const A&) is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator*=(const A&, const A&);
-struct B { operator A(); };
-boost::has_operator_multiplies_equal<A>::value; // this is fine
-boost::has_operator_multiplies_equal<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,69 +0,0 @@
-[/
-  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_not_equal_to has_operator_not_equal_to]
-   template <class LHS, class RHS=LHS, class RET=void>
-   struct has_operator_not_equal_to : public __tof {};
-
-__inherit
-If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs!=rhs`,
-and (ii) `RET=void` or the result of expression `lhs!=rhs` is convertible to `RET`
-then inherits from __true_type,
-otherwise inherits from __false_type.
-
-The default behaviour (`RET=void`) is to not check for the return value of binary `operator!=`.
-Be careful that it does not mean that `operator!=` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-LHS lhs;
-RHS rhs;
-f(lhs!=rhs); // is valid if has_operator_not_equal_to<LHS, RHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_not_equal_to.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_not_equal_to<LHS, RHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_not_equal_to<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_not_equal_to<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_not_equal_to<long>` inherits from `__true_type`.]
-
-[:`has_operator_not_equal_to<int, int, bool>` inherits from `__true_type`.]
-[:`has_operator_not_equal_to<int, double, bool>` inherits from `__true_type`.]
-[:`has_operator_not_equal_to<const int>` inherits from `__true_type`.]
-
-[:`has_operator_not_equal_to<int*, int>` inherits from `__false_type`.]
-[:`has_operator_not_equal_to<int*, double*>` inherits from `__false_type`.]
-[:`has_operator_not_equal_to<int, int, std::string>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether binary `operator!=` is public or not:
-if `operator!=` is defined as a private member of `LHS` then
-instantiating `has_operator_not_equal_to<LHS>` will produce a compiler error.
-For this reason `has_operator_not_equal_to` cannot be used to determine whether a type has a public `operator!=` or not.
-``
-struct A { private: void operator!=(const A&); };
-boost::has_operator_not_equal_to<A>::value; // error: A::operator!=(const A&) is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator!=(const A&, const A&);
-struct B { operator A(); };
-boost::has_operator_not_equal_to<A>::value; // this is fine
-boost::has_operator_not_equal_to<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Deleted: sandbox/type_traits/libs/type_traits/doc/has_operator_plus.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_plus.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,69 +0,0 @@
-[/
-  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_plus has_operator_plus]
-   template <class LHS, class RHS=LHS, class RET=void>
-   struct has_operator_plus : public __tof {};
-
-__inherit
-If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs+rhs`,
-and (ii) `RET=void` or the result of expression `lhs+rhs` is convertible to `RET`
-then inherits from __true_type,
-otherwise inherits from __false_type.
-
-The default behaviour (`RET=void`) is to not check for the return value of binary `operator+`.
-Be careful that it does not mean that `operator+` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-LHS lhs;
-RHS rhs;
-f(lhs+rhs); // is valid if has_operator_plus<LHS, RHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_plus.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_plus<LHS, RHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_plus<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_plus<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_plus<long>` inherits from `__true_type`.]
-
-[:`has_operator_plus<int, int, int>` inherits from `__true_type`.]
-[:`has_operator_plus<int, int, long>` inherits from `__true_type`.]
-[:`has_operator_plus<int, double, double>` inherits from `__true_type`.]
-[:`has_operator_plus<int, double, int>` inherits from `__true_type`.]
-[:`has_operator_plus<const int, int>::value` inherits from `__true_type`.]
-
-[:`has_operator_plus<int, int, std::string>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether binary `operator+` is public or not:
-if `operator+` is defined as a private member of `LHS` then
-instantiating `has_operator_plus<LHS>` will produce a compiler error.
-For this reason `has_operator_plus` cannot be used to determine whether a type has a public `operator+` or not.
-``
-struct A { private: void operator+(const A&); };
-boost::has_operator_plus<A>::value; // error: A::operator+(const A&) is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator+(const A&, const A&);
-struct B { operator A(); };
-boost::has_operator_plus<A>::value; // this is fine
-boost::has_operator_plus<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Deleted: sandbox/type_traits/libs/type_traits/doc/has_operator_plus_equal.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_plus_equal.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,69 +0,0 @@
-[/
-  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_plus_equal has_operator_plus_equal]
-   template <class LHS, class RHS=LHS, class RET=void>
-   struct has_operator_plus_equal : public __tof {};
-
-__inherit
-If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs+=rhs`,
-and (ii) `RET=void` or the result of expression `lhs+=rhs` is convertible to `RET`
-then inherits from __true_type,
-otherwise inherits from __false_type.
-
-The default behaviour (`RET=void`) is to not check for the return value of binary `operator+=`.
-Be careful that it does not mean that `operator+=` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-LHS lhs;
-RHS rhs;
-f(lhs+=rhs); // is valid if has_operator_plus_equal<LHS, RHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_plus_equal.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_plus_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_plus_equal<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_plus_equal<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_plus_equal<long>` inherits from `__true_type`.]
-
-[:`has_operator_plus_equal<int, int, int>` inherits from `__true_type`.]
-[:`has_operator_plus_equal<int, int, long>` inherits from `__true_type`.]
-[:`has_operator_plus_equal<int, double, double>` inherits from `__true_type`.]
-[:`has_operator_plus_equal<int, double, int>` inherits from `__true_type`.]
-
-[:`has_operator_plus_equal<const int, int>::value` inherits from `__false_type`.]
-[:`has_operator_plus_equal<int, int, std::string>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether binary `operator+=` is public or not:
-if `operator+=` is defined as a private member of `LHS` then
-instantiating `has_operator_plus_equal<LHS>` will produce a compiler error.
-For this reason `has_operator_plus_equal` cannot be used to determine whether a type has a public `operator+=` or not.
-``
-struct A { private: void operator+=(const A&); };
-boost::has_operator_plus_equal<A>::value; // error: A::operator+=(const A&) is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator+=(const A&, const A&);
-struct B { operator A(); };
-boost::has_operator_plus_equal<A>::value; // this is fine
-boost::has_operator_plus_equal<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Deleted: sandbox/type_traits/libs/type_traits/doc/has_operator_postfix_decrement.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_postfix_decrement.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,70 +0,0 @@
-[/
-  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_postfix_decrement has_operator_postfix_decrement]
-   template <class LHS, class RET=void>
-   struct has_operator_postfix_decrement : public __tof {};
-
-__inherit
-If (i) `lhs` of type `LHS` can be used in expression `lhs--`,
-and (ii) `RET=void` or the result of expression `lhs--` 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 postfix `operator--`.
-Be careful that it does not mean that `operator--` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-LHS lhs;
-f(lhs--); // is valid if has_operator_postfix_decrement<LHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_postfix_decrement.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_postfix_decrement<LHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_postfix_decrement<LHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_postfix_decrement<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_postfix_decrement<long>` inherits from `__true_type`.]
-
-[:`has_operator_postfix_decrement<int, int>` inherits from `__true_type`.]
-[:`has_operator_postfix_decrement<int, long>` inherits from `__true_type`.]
-[:`has_operator_postfix_decrement<double, double>` inherits from `__true_type`.]
-[:`has_operator_postfix_decrement<double, int>` inherits from `__true_type`.]
-
-[:`has_operator_postfix_decrement<bool>` inherits from `__false_type`.]
-[:`has_operator_postfix_decrement<const int>` inherits from `__false_type`.]
-[:`has_operator_postfix_decrement<void*>` inherits from `__false_type`.]
-[:`has_operator_postfix_decrement<int, std::string>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether postfix `operator--` is public or not:
-if `operator--` is defined as a private member of `LHS` then
-instantiating `has_operator_postfix_decrement<LHS>` will produce a compiler error.
-For this reason `has_operator_postfix_decrement` cannot be used to determine whether a type has a public `operator--` or not.
-``
-struct A { private: void operator--(int); };
-boost::has_operator_postfix_decrement<A>::value; // error: A::operator--(int) is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator--(const A&, int);
-struct B { operator A(); };
-boost::has_operator_postfix_decrement<A>::value; // this is fine
-boost::has_operator_postfix_decrement<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Deleted: sandbox/type_traits/libs/type_traits/doc/has_operator_postfix_increment.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_postfix_increment.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,70 +0,0 @@
-[/
-  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_postfix_increment has_operator_postfix_increment]
-   template <class LHS, class RET=void>
-   struct has_operator_postfix_increment : public __tof {};
-
-__inherit
-If (i) `lhs` of type `LHS` can be used in expression `lhs++`,
-and (ii) `RET=void` or the result of expression `lhs++` 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 postfix `operator++`.
-Be careful that it does not mean that `operator++` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-LHS lhs;
-f(lhs++); // is valid if has_operator_postfix_increment<LHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_postfix_increment.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_postfix_increment<LHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_postfix_increment<LHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_postfix_increment<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_postfix_increment<long>` inherits from `__true_type`.]
-
-[:`has_operator_postfix_increment<int, int>` inherits from `__true_type`.]
-[:`has_operator_postfix_increment<int, long>` inherits from `__true_type`.]
-[:`has_operator_postfix_increment<double, double>` inherits from `__true_type`.]
-[:`has_operator_postfix_increment<double, int>` inherits from `__true_type`.]
-[:`has_operator_postfix_increment<bool>` inherits from `__true_type`.]
-
-[:`has_operator_postfix_increment<const int>` inherits from `__false_type`.]
-[:`has_operator_postfix_increment<void*>` inherits from `__false_type`.]
-[:`has_operator_postfix_increment<int, std::string>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether postfix `operator++` is public or not:
-if `operator++` is defined as a private member of `LHS` then
-instantiating `has_operator_postfix_increment<LHS>` will produce a compiler error.
-For this reason `has_operator_postfix_increment` cannot be used to determine whether a type has a public `operator++` or not.
-``
-struct A { private: void operator++(int); };
-boost::has_operator_postfix_increment<A>::value; // error: A::operator++(int) is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator++(const A&, int);
-struct B { operator A(); };
-boost::has_operator_postfix_increment<A>::value; // this is fine
-boost::has_operator_postfix_increment<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Deleted: sandbox/type_traits/libs/type_traits/doc/has_operator_prefix_decrement.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_prefix_decrement.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,70 +0,0 @@
-[/
-  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_prefix_decrement has_operator_prefix_decrement]
-   template <class RHS, class RET=void>
-   struct has_operator_prefix_decrement : 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--`.
-Be careful that it does not mean that `operator--` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-RHS rhs;
-f(--rhs); // is valid if has_operator_prefix_decrement<RHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_prefix_decrement.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_prefix_decrement<RHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_prefix_decrement<RHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_prefix_decrement<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_prefix_decrement<long>` inherits from `__true_type`.]
-
-[:`has_operator_prefix_decrement<int, int>` inherits from `__true_type`.]
-[:`has_operator_prefix_decrement<int, long>` inherits from `__true_type`.]
-[:`has_operator_prefix_decrement<double, double>` inherits from `__true_type`.]
-[:`has_operator_prefix_decrement<double, int>` inherits from `__true_type`.]
-
-[:`has_operator_prefix_decrement<bool>` inherits from `__false_type`.]
-[:`has_operator_prefix_decrement<const int>` inherits from `__false_type`.]
-[:`has_operator_prefix_decrement<void*>` inherits from `__false_type`.]
-[:`has_operator_prefix_decrement<int, std::string>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether prefix `operator--` is public or not:
-if `operator--` is defined as a private member of `RHS` then
-instantiating `has_operator_prefix_decrement<RHS>` will produce a compiler error.
-For this reason `has_operator_prefix_decrement` cannot be used to determine whether a type has a public `operator--` or not.
-``
-struct A { private: void operator--(); };
-boost::has_operator_prefix_decrement<A>::value; // error: A::operator--() is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator--(const A&);
-struct B { operator A(); };
-boost::has_operator_prefix_decrement<A>::value; // this is fine
-boost::has_operator_prefix_decrement<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Deleted: sandbox/type_traits/libs/type_traits/doc/has_operator_prefix_increment.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_prefix_increment.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,70 +0,0 @@
-[/
-  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_prefix_increment has_operator_prefix_increment]
-   template <class RHS, class RET=void>
-   struct has_operator_prefix_increment : 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++`.
-Be careful that it does not mean that `operator++` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-RHS rhs;
-f(++rhs); // is valid if has_operator_prefix_increment<RHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_prefix_increment.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_prefix_increment<RHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_prefix_increment<RHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_prefix_increment<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_prefix_increment<long>` inherits from `__true_type`.]
-
-[:`has_operator_prefix_increment<int, int>` inherits from `__true_type`.]
-[:`has_operator_prefix_increment<int, long>` inherits from `__true_type`.]
-[:`has_operator_prefix_increment<double, double>` inherits from `__true_type`.]
-[:`has_operator_prefix_increment<double, int>` inherits from `__true_type`.]
-[:`has_operator_prefix_increment<bool>` inherits from `__true_type`.]
-
-[:`has_operator_prefix_increment<const int>` inherits from `__false_type`.]
-[:`has_operator_prefix_increment<void*>` inherits from `__false_type`.]
-[:`has_operator_prefix_increment<int, std::string>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether prefix `operator++` is public or not:
-if `operator++` is defined as a private member of `RHS` then
-instantiating `has_operator_prefix_increment<RHS>` will produce a compiler error.
-For this reason `has_operator_prefix_increment` cannot be used to determine whether a type has a public `operator++` or not.
-``
-struct A { private: void operator++(); };
-boost::has_operator_prefix_increment<A>::value; // error: A::operator++() is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator++(const A&);
-struct B { operator A(); };
-boost::has_operator_prefix_increment<A>::value; // this is fine
-boost::has_operator_prefix_increment<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Deleted: sandbox/type_traits/libs/type_traits/doc/has_operator_right_shift.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_right_shift.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,70 +0,0 @@
-[/
-  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_right_shift has_operator_right_shift]
-   template <class LHS, class RHS=LHS, class RET=void>
-   struct has_operator_right_shift : public __tof {};
-
-__inherit
-If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs>>rhs`,
-and (ii) `RET=void` or the result of expression `lhs>>rhs` is convertible to `RET`
-then inherits from __true_type,
-otherwise inherits from __false_type.
-
-The default behaviour (`RET=void`) is to not check for the return value of binary `operator>>`.
-Be careful that it does not mean that `operator>>` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-LHS lhs;
-RHS rhs;
-f(lhs>>rhs); // is valid if has_operator_right_shift<LHS, RHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_right_shift.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_right_shift<LHS, RHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_right_shift<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_right_shift<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_right_shift<long>` inherits from `__true_type`.]
-
-[:`has_operator_right_shift<int, int, int>` inherits from `__true_type`.]
-[:`has_operator_right_shift<const int, int>` inherits from `__true_type`.]
-[:`has_operator_right_shift<std::istream, int&>` inherits from `__true_type`.]
-[:`has_operator_right_shift<std::istream, char*, std::ostream>` inherits from `__true_type`.]
-[:`has_operator_right_shift<std::istream, std::string&>` inherits from `__true_type`.]
-
-[:`has_operator_right_shift<int, double, bool>` inherits from `__false_type`.]
-[:`has_operator_right_shift<int, int, std::string>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether binary `operator>>` is public or not:
-if `operator>>` is defined as a private member of `LHS` then
-instantiating `has_operator_right_shift<LHS>` will produce a compiler error.
-For this reason `has_operator_right_shift` cannot be used to determine whether a type has a public `operator>>` or not.
-``
-struct A { private: void operator>>(const A&); };
-boost::has_operator_right_shift<A>::value; // error: A::operator>>(const A&) is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator>>(const A&, const A&);
-struct B { operator A(); };
-boost::has_operator_right_shift<A>::value; // this is fine
-boost::has_operator_right_shift<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,67 +0,0 @@
-[/
-  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_right_shift_equal has_operator_right_shift_equal]
-   template <class LHS, class RHS=LHS, class RET=void>
-   struct has_operator_right_shift_equal : public __tof {};
-
-__inherit
-If (i) `lhs` of type `LHS` and `rhs` of type `RHS` can be used in expression `lhs>>=rhs`,
-and (ii) `RET=void` or the result of expression `lhs>>=rhs` is convertible to `RET`
-then inherits from __true_type,
-otherwise inherits from __false_type.
-
-The default behaviour (`RET=void`) is to not check for the return value of binary `operator>>=`.
-Be careful that it does not mean that `operator>>=` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-LHS lhs;
-RHS rhs;
-f(lhs>>=rhs); // is valid if has_operator_right_shift_equal<LHS, RHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_right_shift_equal.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_right_shift_equal<LHS, RHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_right_shift_equal<LHS, RHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_right_shift_equal<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_right_shift_equal<long>` inherits from `__true_type`.]
-
-[:`has_operator_right_shift_equal<int, int, int>` inherits from `__true_type`.]
-
-[:`has_operator_right_shift_equal<const int, int>` inherits from `__false_type`.]
-[:`has_operator_right_shift_equal<int, double, bool>` inherits from `__false_type`.]
-[:`has_operator_right_shift_equal<int, int, std::string>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether binary `operator>>=` is public or not:
-if `operator>>=` is defined as a private member of `LHS` then
-instantiating `has_operator_right_shift_equal<LHS>` will produce a compiler error.
-For this reason `has_operator_right_shift_equal` cannot be used to determine whether a type has a public `operator>>=` or not.
-``
-struct A { private: void operator>>=(const A&); };
-boost::has_operator_right_shift_equal<A>::value; // error: A::operator>>=(const A&) is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator>>=(const A&, const A&);
-struct B { operator A(); };
-boost::has_operator_right_shift_equal<A>::value; // this is fine
-boost::has_operator_right_shift_equal<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Deleted: sandbox/type_traits/libs/type_traits/doc/has_operator_unary_minus.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_unary_minus.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,68 +0,0 @@
-[/
-  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_unary_minus has_operator_unary_minus]
-   template <class RHS, class RET=void>
-   struct has_operator_unary_minus : public __tof {};
-
-__inherit
-If (i) `rhs` of type `RHS` can be used in expression `-rhs`,
-and (ii) `RET=void` or the result of expression `-rhs` is convertible to `RET`
-then inherits from __true_type,
-otherwise inherits from __false_type.
-
-The default behaviour (`RET=void`) is to not check for the return value of prefix `operator-`.
-Be careful that it does not mean that `operator-` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-RHS rhs;
-f(-rhs); // is valid if has_operator_unary_minus<RHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_unary_minus.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_unary_minus<RHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_unary_minus<RHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_unary_minus<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_unary_minus<long>` inherits from `__true_type`.]
-
-[:`has_operator_unary_minus<int, int>` inherits from `__true_type`.]
-[:`has_operator_unary_minus<int, long>` inherits from `__true_type`.]
-[:`has_operator_unary_minus<double, double>` inherits from `__true_type`.]
-[:`has_operator_unary_minus<double, int>` inherits from `__true_type`.]
-[:`has_operator_unary_minus<const int>` inherits from `__true_type`.]
-
-[:`has_operator_unary_minus<int, std::string>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether prefix `operator-` is public or not:
-if `operator-` is defined as a private member of `RHS` then
-instantiating `has_operator_unary_minus<RHS>` will produce a compiler error.
-For this reason `has_operator_unary_minus` cannot be used to determine whether a type has a public `operator-` or not.
-``
-struct A { private: void operator-(); };
-boost::has_operator_unary_minus<A>::value; // error: A::operator-() is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator-(const A&);
-struct B { operator A(); };
-boost::has_operator_unary_minus<A>::value; // this is fine
-boost::has_operator_unary_minus<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Deleted: sandbox/type_traits/libs/type_traits/doc/has_operator_unary_plus.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/has_operator_unary_plus.qbk	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,68 +0,0 @@
-[/
-  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_unary_plus has_operator_unary_plus]
-   template <class RHS, class RET=void>
-   struct has_operator_unary_plus : public __tof {};
-
-__inherit
-If (i) `rhs` of type `RHS` can be used in expression `+rhs`,
-and (ii) `RET=void` or the result of expression `+rhs` is convertible to `RET`
-then inherits from __true_type,
-otherwise inherits from __false_type.
-
-The default behaviour (`RET=void`) is to not check for the return value of prefix `operator+`.
-Be careful that it does not mean that `operator+` must return `void` to have the trait derive from __true_type.
-If `RET` is different from the default `void` type, the return value is checked to be convertible to `RET`.
-Convertible to `RET` means that the return value of the operator can be used as argument to a function expecting `RET`:
-``
-void f(RET);
-RHS rhs;
-f(+rhs); // is valid if has_operator_unary_plus<RHS, RET>::value==true
-``
-
-__header `#include <boost/type_traits/has_operator_unary_plus.hpp>` or `#include <boost/type_traits/operators.hpp>`
-
-__examples
-
-[:`has_operator_unary_plus<RHS, RET>::value_type` is the type `bool`.]
-[:`has_operator_unary_plus<RHS, RET>::value` is a `bool` integral constant expression.]
-[:`has_operator_unary_plus<int>::value` is a `bool` integral constant expression that evaluates to `true`.]
-[:`has_operator_unary_plus<long>` inherits from `__true_type`.]
-
-[:`has_operator_unary_plus<int, int>` inherits from `__true_type`.]
-[:`has_operator_unary_plus<int, long>` inherits from `__true_type`.]
-[:`has_operator_unary_plus<double, double>` inherits from `__true_type`.]
-[:`has_operator_unary_plus<double, int>` inherits from `__true_type`.]
-[:`has_operator_unary_plus<const int>` inherits from `__true_type`.]
-
-[:`has_operator_unary_plus<int, std::string>` inherits from `__false_type`.]
-
-
-[*Known issues:]
-
-This trait cannot detect whether prefix `operator+` is public or not:
-if `operator+` is defined as a private member of `RHS` then
-instantiating `has_operator_unary_plus<RHS>` will produce a compiler error.
-For this reason `has_operator_unary_plus` cannot be used to determine whether a type has a public `operator+` or not.
-``
-struct A { private: void operator+(); };
-boost::has_operator_unary_plus<A>::value; // error: A::operator+() is private
-``
-
-There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload.
-``
-struct A { };
-void operator+(const A&);
-struct B { operator A(); };
-boost::has_operator_unary_plus<A>::value; // this is fine
-boost::has_operator_unary_plus<B>::value; // error: ambigous overload
-``
-
-[endsect]
-

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/background.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/background.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/background.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -49,7 +49,7 @@
       method available to them.
     </p>
 <a name="boost_typetraits.background.type_traits"></a><h5>
-<a name="id3351948"></a>
+<a name="id3253775"></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="id3350991"></a>
+<a name="id3252822"></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="id3402476"></a>
+<a name="id3304305"></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="id3402939"></a>
+<a name="id3304768"></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="id3403007"></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="id3304836"></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="id3403159"></a>
+<a name="id3304988"></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="id3403466"></a><p class="title"><b>Table&#160;1.2.&#160;Required Constructor Argument Types</b></p>
+<a name="id3305295"></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="id3403582"></a><p class="title"><b>Table&#160;1.3.&#160;Using add_reference to synthesize the correct constructor type</b></p>
+<a name="id3305412"></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="id3404114"></a>
+<a name="id3305943"></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="id3404145"></a>
+<a name="id3305975"></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="id3404172"></a>
+<a name="id3306002"></a>
       <a class="link" href="background.html#boost_typetraits.background.references">References</a>
     </h5>
 <div class="orderedlist"><ol class="orderedlist" type="1">
@@ -663,7 +663,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -43,7 +43,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/alignment.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/alignment.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/alignment.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -39,7 +39,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/function.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/function.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/function.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -36,7 +36,7 @@
 <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,
+      Frederic 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>

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-04-19 17:59:57 EDT (Tue, 19 Apr 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="id3419063"></a>
+<a name="id3318508"></a>
         <a class="link" href="transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">Broken
         Compiler Workarounds:</a>
       </h5>
@@ -149,7 +149,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/value_traits.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/value_traits.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/value_traits.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -44,7 +44,7 @@
 <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,
+      Frederic 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>

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-04-19 17:59:57 EDT (Tue, 19 Apr 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="id3406786"></a>
+<a name="id3308615"></a>
           <a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.introduction">Introduction</a>
         </h6>
 <p>
@@ -32,7 +32,7 @@
           reflects the fact that given types can or not be used with given operators.
         </p>
 <p>
-          For example, <code class="computeroutput"><span class="identifier">has_operator_plus</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
+          For example, <code class="computeroutput"><span class="identifier">can_call_addition</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
           is a <code class="computeroutput"><span class="keyword">bool</span></code> which value is
           <code class="computeroutput"><span class="keyword">true</span></code> because it is possible
           to add a <code class="computeroutput"><span class="keyword">double</span></code> to an <code class="computeroutput"><span class="keyword">int</span></code> like in the following code: 
@@ -45,62 +45,60 @@
           It is also possible to know if the result of the operator is convertible
           or not to a given type: 
 </p>
-<pre class="programlisting"><span class="identifier">has_operator_plus</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// true: int+double is convertible to double
-</span><span class="identifier">has_operator_plus</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">char</span><span class="special">*&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// false: int+double is not convertible to char*
-</span><span class="identifier">has_operator_less</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// true: int&lt;double is convertible to bool
+<pre class="programlisting"><span class="identifier">can_call_addition</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// true: int+double is convertible to double
+</span><span class="identifier">can_call_addition</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">char</span><span class="special">*&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// false: int+double is not convertible to char*
+</span><span class="identifier">can_call_subtraction</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// true: int&lt;double is convertible to bool
 </span></pre>
 <p>
         </p>
 <p>
           The syntax for binary operators is the following: 
 </p>
-<pre class="programlisting"><span class="keyword">template</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> <span class="identifier">has_operator_op</span><span class="special">;</span>
+<pre class="programlisting"><span class="keyword">template</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="identifier">dont_care</span> <span class="special">&gt;</span></code> <span class="identifier">can_call_op</span><span class="special">;</span>
 </pre>
 <p>
           where:
         </p>
 <div class="itemizedlist"><ul class="itemizedlist" type="disc">
 <li class="listitem">
-              <code class="computeroutput"><span class="identifier">LHS</span></code> is the type used
+              <code class="computeroutput"><span class="identifier">Lhs</span></code> is the type used
               at the left hand side of <code class="computeroutput"><span class="keyword">operator</span>
               <span class="identifier">op</span></code>,
             </li>
 <li class="listitem">
-              <code class="computeroutput"><span class="identifier">RHS</span></code> is the type used
+              <code class="computeroutput"><span class="identifier">Rhs</span></code> is the type used
               at the right hand side of <code class="computeroutput"><span class="keyword">operator</span>
               <span class="identifier">op</span></code>,
             </li>
 <li class="listitem">
-              <code class="computeroutput"><span class="identifier">RET</span></code> is the type for
+              <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.
             </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. Be careful that it does
-          not mean that the operator must return <code class="computeroutput"><span class="keyword">void</span></code>
-          to have the trait value to be <code class="computeroutput"><span class="keyword">true</span></code>.
-          If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-          the default <code class="computeroutput"><span class="keyword">void</span></code>, the return
-          value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-          Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
+          The default behaviour (<code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="identifier">dont_care</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="identifier">dont_care</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>: 
+          <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
+<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 can_call_addition&lt;Lhs, Rhs, Ret&gt;::value==true
 </span></pre>
 <p>
+          If <code class="computeroutput"><span class="identifier">Ret</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+          <code class="computeroutput"><span class="keyword">void</span></code>.
         </p>
 <p>
           Similarly, the syntax for postfix and prefix operators is the following:
           
 </p>
-<pre class="programlisting"><span class="keyword">template</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> <span class="identifier">has_operator_prefixop</span><span class="special">;</span>
-<span class="keyword">template</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> <span class="identifier">has_operator_postfixop</span><span class="special">;</span>
+<pre class="programlisting"><span class="keyword">template</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="identifier">dont_care</span> <span class="special">&gt;</span></code> <span class="identifier">can_call_prefixop</span><span class="special">;</span>
+<span class="keyword">template</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="identifier">dont_care</span> <span class="special">&gt;</span></code> <span class="identifier">can_call_postfixop</span><span class="special">;</span>
 </pre>
 <p>
         </p>
@@ -109,7 +107,7 @@
           operators.
         </p>
 <div class="table">
-<a name="id3407621"></a><p class="title"><b>Table&#160;1.4.&#160;Supported binary operators</b></p>
+<a name="id3309458"></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>
@@ -131,1185 +129,199 @@
 <tr>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="special">==</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <a class="link" href="../../reference/has_operator_equal_to.html" title="has_operator_equal_to"><code class="computeroutput"><span class="identifier">has_operator_equal_to</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">!=</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <a class="link" href="../../reference/has_operator_not_equal_to.html" title="has_operator_not_equal_to"><code class="computeroutput"><span class="identifier">has_operator_not_equal_to</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>
-                  </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>
-                  </p>
-                </td>
-</tr>
-<tr>
-<td>
-                  <p>
-                    <code class="computeroutput"><span class="special">&lt;=</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>
-                    <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>
-                  </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>
-                  </p>
-                </td>
-</tr>
-<tr>
-<td>
-                  <p>
-                    <code class="computeroutput"><span class="special">&gt;=</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>
-                    <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">+</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <a class="link" href="../../reference/has_operator_plus.html" title="has_operator_plus"><code class="computeroutput"><span class="identifier">has_operator_plus</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">-</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <a class="link" href="../../reference/has_operator_minus.html" title="has_operator_minus"><code class="computeroutput"><span class="identifier">has_operator_minus</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">*</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <a class="link" href="../../reference/has_operator_multiplies.html" title="has_operator_multiplies"><code class="computeroutput"><span class="identifier">has_operator_multiplies</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">/</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <a class="link" href="../../reference/has_operator_divides.html" title="has_operator_divides"><code class="computeroutput"><span class="identifier">has_operator_divides</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">%</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <a class="link" href="../../reference/has_operator_modulus.html" title="has_operator_modulus"><code class="computeroutput"><span class="identifier">has_operator_modulus</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">+=</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <a class="link" href="../../reference/has_operator_plus_equal.html" title="has_operator_plus_equal"><code class="computeroutput"><span class="identifier">has_operator_plus_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>
-                  </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_minus_equal.html" title="has_operator_minus_equal"><code class="computeroutput"><span class="identifier">has_operator_minus_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>
-                  </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_multiplies_equal.html" title="has_operator_multiplies_equal"><code class="computeroutput"><span class="identifier">has_operator_multiplies_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>
-                  </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_divides_equal.html" title="has_operator_divides_equal"><code class="computeroutput"><span class="identifier">has_operator_divides_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>
-                  </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_modulus_equal.html" title="has_operator_modulus_equal"><code class="computeroutput"><span class="identifier">has_operator_modulus_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>
-                  </p>
-                </td>
-</tr>
-<tr>
-<td>
-                  <p>
-                    <code class="computeroutput"><span class="special">&amp;&amp;</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 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">||</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 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">&amp;</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <a class="link" href="../../reference/has_operator_bit_and.html" title="has_operator_bit_and"><code class="computeroutput"><span class="identifier">has_operator_bit_and</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">|</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <a class="link" href="../../reference/has_operator_bit_or.html" title="has_operator_bit_or"><code class="computeroutput"><span class="identifier">has_operator_bit_or</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">^</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <a class="link" href="../../reference/has_operator_bit_xor.html" title="has_operator_bit_xor"><code class="computeroutput"><span class="identifier">has_operator_bit_xor</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;&lt;</span></code>
-                  </p>
-                </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 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;&gt;</span></code>
-                  </p>
-                </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 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">&amp;=</span></code>
-                  </p>
-                </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 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">|=</span></code>
-                  </p>
-                </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 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">^=</span></code>
-                  </p>
-                </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 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;&lt;=</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <a class="link" href="../../reference/has_operator_left_shift_equal.html" title="has_operator_left_shift_equal"><code class="computeroutput"><span class="identifier">has_operator_left_shift_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>
-                  </p>
-                </td>
-</tr>
-<tr>
-<td>
-                  <p>
-                    <code class="computeroutput"><span class="special">&gt;&gt;=</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <a class="link" href="../../reference/has_operator_right_shift_equal.html" title="has_operator_right_shift_equal"><code class="computeroutput"><span class="identifier">has_operator_right_shift_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>
-                  </p>
-                </td>
-</tr>
-</tbody>
-</table></div>
-</div>
-<br class="table-break"><div class="table">
-<a name="id3410697"></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>
-<col>
-</colgroup>
-<thead><tr>
-<th>
-                  <p>
-                    operator
-                  </p>
-                </th>
-<th>
-                  <p>
-                    trait name
-                  </p>
-                </th>
-</tr></thead>
-<tbody>
-<tr>
-<td>
-                  <p>
-                    <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>
-                    <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_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>
-                  </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_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>
-                  </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_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>
-                  </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_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>
-                  </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_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>
-                  </p>
-                </td>
-</tr>
-</tbody>
-</table></div>
-</div>
-<br class="table-break"><div class="table">
-<a name="id3411335"></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>
-<col>
-</colgroup>
-<thead><tr>
-<th>
-                  <p>
-                    operator
-                  </p>
-                </th>
-<th>
-                  <p>
-                    trait name
-                  </p>
-                </th>
-</tr></thead>
-<tbody>
-<tr>
-<td>
-                  <p>
-                    <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>
-                    <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">--</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>
-                    <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>
-</tbody>
-</table></div>
-</div>
-<br class="table-break"><p>
-          The choice of trait names may seem unconsistent but it has not been possible
-          to propose a more consistent naming convention because the standard is
-          itself inconsistent. The following table shows the names found in the standard
-          for each operator and the corresponding trait name.
-        </p>
-<div class="table">
-<a name="id3411554"></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>
-<col>
-<col>
-<col>
-</colgroup>
-<thead><tr>
-<th>
-                  <p>
-                    operator
-                  </p>
-                </th>
-<th>
-                  <p>
-                    alternative token (<span class="bold"><strong>C++ Standard Reference:</strong></span>
-                    2.5)
-                  </p>
-                </th>
-<th>
-                  <p>
-                    name in <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">functionnal</span><span class="special">&gt;</span></code> or <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">iterator</span><span class="special">&gt;</span></code>
-                    (<span class="bold"><strong>C++ Standard Reference:</strong></span> 20.3
-                    and 24.2)
-                  </p>
-                </th>
-<th>
-                  <p>
-                    trait name
-                  </p>
-                </th>
-</tr></thead>
-<tbody>
-<tr>
-<td>
-                  <p>
-                    binary
-                  </p>
-                </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">==</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    &#248;
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <code class="computeroutput"><span class="identifier">equal_to</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <a class="link" href="../../reference/has_operator_equal_to.html" title="has_operator_equal_to"><code class="computeroutput"><span class="identifier">has_operator_equal_to</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">not_eq</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <code class="computeroutput"><span class="identifier">not_equal_to</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <a class="link" href="../../reference/has_operator_not_equal_to.html" title="has_operator_not_equal_to"><code class="computeroutput"><span class="identifier">has_operator_not_equal_to</span></code></a>
-                  </p>
-                </td>
-</tr>
-<tr>
-<td>
-                  <p>
-                    <code class="computeroutput"><span class="special">&lt;</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    &#248;
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <code class="computeroutput"><span class="identifier">less</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></a>
-                  </p>
-                </td>
-</tr>
-<tr>
-<td>
-                  <p>
-                    <code class="computeroutput"><span class="special">&lt;=</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    &#248;
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <code class="computeroutput"><span class="identifier">less_equal</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></a>
-                  </p>
-                </td>
-</tr>
-<tr>
-<td>
-                  <p>
-                    <code class="computeroutput"><span class="special">&gt;</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    &#248;
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <code class="computeroutput"><span class="identifier">greater</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></a>
-                  </p>
-                </td>
-</tr>
-<tr>
-<td>
-                  <p>
-                    <code class="computeroutput"><span class="special">&gt;=</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    &#248;
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <code class="computeroutput"><span class="identifier">greater_equal</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></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">+</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    &#248;
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <code class="computeroutput"><span class="identifier">plus</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <a class="link" href="../../reference/has_operator_plus.html" title="has_operator_plus"><code class="computeroutput"><span class="identifier">has_operator_plus</span></code></a>
-                  </p>
-                </td>
-</tr>
-<tr>
-<td>
-                  <p>
-                    <code class="computeroutput"><span class="special">-</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    &#248;
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <code class="computeroutput"><span class="identifier">minus</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <a class="link" href="../../reference/has_operator_minus.html" title="has_operator_minus"><code class="computeroutput"><span class="identifier">has_operator_minus</span></code></a>
-                  </p>
-                </td>
-</tr>
-<tr>
-<td>
-                  <p>
-                    <code class="computeroutput"><span class="special">*</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    &#248;
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <code class="computeroutput"><span class="identifier">multiplies</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <a class="link" href="../../reference/has_operator_multiplies.html" title="has_operator_multiplies"><code class="computeroutput"><span class="identifier">has_operator_multiplies</span></code></a>
-                  </p>
-                </td>
-</tr>
-<tr>
-<td>
-                  <p>
-                    <code class="computeroutput"><span class="special">/</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    &#248;
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <code class="computeroutput"><span class="identifier">divides</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <a class="link" href="../../reference/has_operator_divides.html" title="has_operator_divides"><code class="computeroutput"><span class="identifier">has_operator_divides</span></code></a>
-                  </p>
-                </td>
-</tr>
-<tr>
-<td>
-                  <p>
-                    <code class="computeroutput"><span class="special">%</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    &#248;
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <code class="computeroutput"><span class="identifier">modulus</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <a class="link" href="../../reference/has_operator_modulus.html" title="has_operator_modulus"><code class="computeroutput"><span class="identifier">has_operator_modulus</span></code></a>
-                  </p>
-                </td>
-</tr>
-<tr>
-<td>
-                  <p>
-                    <code class="computeroutput"><span class="special">+=</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    &#248;
-                  </p>
-                </td>
-<td>
-                  <p>
-                    &#248;
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <a class="link" href="../../reference/has_operator_plus_equal.html" title="has_operator_plus_equal"><code class="computeroutput"><span class="identifier">has_operator_plus_equal</span></code></a>
-                  </p>
-                </td>
-</tr>
-<tr>
-<td>
-                  <p>
-                    <code class="computeroutput"><span class="special">-=</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    &#248;
-                  </p>
-                </td>
-<td>
-                  <p>
-                    &#248;
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <a class="link" href="../../reference/has_operator_minus_equal.html" title="has_operator_minus_equal"><code class="computeroutput"><span class="identifier">has_operator_minus_equal</span></code></a>
-                  </p>
-                </td>
-</tr>
-<tr>
-<td>
-                  <p>
-                    <code class="computeroutput"><span class="special">*=</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    &#248;
-                  </p>
-                </td>
-<td>
-                  <p>
-                    &#248;
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <a class="link" href="../../reference/has_operator_multiplies_equal.html" title="has_operator_multiplies_equal"><code class="computeroutput"><span class="identifier">has_operator_multiplies_equal</span></code></a>
-                  </p>
-                </td>
-</tr>
-<tr>
-<td>
-                  <p>
-                    <code class="computeroutput"><span class="special">/=</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    &#248;
-                  </p>
-                </td>
-<td>
-                  <p>
-                    &#248;
+                    <code class="computeroutput"><span class="special">+</span></code>
                   </p>
                 </td>
 <td>
                   <p>
-                    <a class="link" href="../../reference/has_operator_divides_equal.html" title="has_operator_divides_equal"><code class="computeroutput"><span class="identifier">has_operator_divides_equal</span></code></a>
+                    <a class="link" href="../../reference/can_call_addition.html" title="can_call_addition"><code class="computeroutput"><span class="identifier">can_call_addition</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="identifier">dont_care</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>
-                    &#248;
-                  </p>
-                </td>
-<td>
-                  <p>
-                    &#248;
+                    <code class="computeroutput"><span class="special">-</span></code>
                   </p>
                 </td>
 <td>
                   <p>
-                    <a class="link" href="../../reference/has_operator_modulus_equal.html" title="has_operator_modulus_equal"><code class="computeroutput"><span class="identifier">has_operator_modulus_equal</span></code></a>
+                    <a class="link" href="../../reference/can_call_subtraction.html" title="can_call_subtraction"><code class="computeroutput"><span class="identifier">can_call_subtraction</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="identifier">dont_care</span> <span class="special">&gt;</span></code></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;&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>
+                    <code class="computeroutput"><span class="special">*</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/can_call_multiplication.html" title="can_call_multiplication"><code class="computeroutput"><span class="identifier">can_call_multiplication</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="identifier">dont_care</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>
-                    <code class="computeroutput"><span class="keyword">or</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <code class="computeroutput"><span class="identifier">logical_or</span></code>
+                    <code class="computeroutput"><span class="special">/</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>
+                    <a class="link" href="../../reference/can_call_division.html" title="can_call_division"><code class="computeroutput"><span class="identifier">can_call_division</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="identifier">dont_care</span>
+                    <span class="special">&gt;</span></code></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>
-<td>
-                  <p>
-                    <code class="computeroutput"><span class="keyword">bitand</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    <code class="computeroutput"><span class="identifier">bit_and</span></code>
+                    <code class="computeroutput"><span class="special">%</span></code>
                   </p>
                 </td>
 <td>
                   <p>
-                    <a class="link" href="../../reference/has_operator_bit_and.html" title="has_operator_bit_and"><code class="computeroutput"><span class="identifier">has_operator_bit_and</span></code></a>
+                    <a class="link" href="../../reference/can_call_modulus.html" title="can_call_modulus"><code class="computeroutput"><span class="identifier">can_call_modulus</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="identifier">dont_care</span>
+                    <span class="special">&gt;</span></code></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>
                   <p>
-                    <code class="computeroutput"><span class="keyword">bitor</span></code>
+                    <a class="link" href="../../reference/can_call_addition_assignment.html" title="can_call_addition_assignment"><code class="computeroutput"><span class="identifier">can_call_addition_assignment</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="identifier">dont_care</span> <span class="special">&gt;</span></code></code></a>
                   </p>
                 </td>
+</tr>
+<tr>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="identifier">bit_or</span></code>
+                    <code class="computeroutput"><span class="special">-=</span></code>
                   </p>
                 </td>
 <td>
                   <p>
-                    <a class="link" href="../../reference/has_operator_bit_or.html" title="has_operator_bit_or"><code class="computeroutput"><span class="identifier">has_operator_bit_or</span></code></a>
+                    <a class="link" href="../../reference/can_call_subtraction_assignment.html" title="can_call_subtraction_assignment"><code class="computeroutput"><span class="identifier">can_call_subtraction_assignment</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="identifier">dont_care</span> <span class="special">&gt;</span></code></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>
                   <p>
-                    <code class="computeroutput"><span class="keyword">xor</span></code>
+                    <a class="link" href="../../reference/can_call_multiplication_assignment.html" title="can_call_multiplication_assignment"><code class="computeroutput"><span class="identifier">can_call_multiplication_assignment</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="identifier">dont_care</span> <span class="special">&gt;</span></code></code></a>
                   </p>
                 </td>
+</tr>
+<tr>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="identifier">bit_xor</span></code>
+                    <code class="computeroutput"><span class="special">/=</span></code>
                   </p>
                 </td>
 <td>
                   <p>
-                    <a class="link" href="../../reference/has_operator_bit_xor.html" title="has_operator_bit_xor"><code class="computeroutput"><span class="identifier">has_operator_bit_xor</span></code></a>
+                    <a class="link" href="../../reference/can_call_division_assignment.html" title="can_call_division_assignment"><code class="computeroutput"><span class="identifier">can_call_division_assignment</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="identifier">dont_care</span> <span class="special">&gt;</span></code></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;
+                    <a class="link" href="../../reference/can_call_modulus_assignment.html" title="can_call_modulus_assignment"><code class="computeroutput"><span class="identifier">can_call_modulus_assignment</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="identifier">dont_care</span> <span class="special">&gt;</span></code></code></a>
                   </p>
                 </td>
+</tr>
+<tr>
 <td>
                   <p>
-                    &#248;
+                    <code class="computeroutput"><span class="special">&amp;</span></code>
                   </p>
                 </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/can_call_bitwise_and.html" title="can_call_bitwise_and"><code class="computeroutput"><span class="identifier">can_call_bitwise_and</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="identifier">dont_care</span> <span class="special">&gt;</span></code></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;
+                    <a class="link" href="../../reference/can_call_bitwise_or.html" title="can_call_bitwise_or"><code class="computeroutput"><span class="identifier">can_call_bitwise_or</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="identifier">dont_care</span> <span class="special">&gt;</span></code></code></a>
                   </p>
                 </td>
+</tr>
+<tr>
 <td>
                   <p>
-                    &#248;
+                    <code class="computeroutput"><span class="special">^</span></code>
                   </p>
                 </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/can_call_bitwise_xor.html" title="can_call_bitwise_xor"><code class="computeroutput"><span class="identifier">can_call_bitwise_xor</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="identifier">dont_care</span> <span class="special">&gt;</span></code></code></a>
                   </p>
                 </td>
 </tr>
@@ -1321,17 +333,10 @@
                 </td>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="keyword">and_eq</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    &#248;
-                  </p>
-                </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/can_call_bitwise_and_assignment.html" title="can_call_bitwise_and_assignment"><code class="computeroutput"><span class="identifier">can_call_bitwise_and_assignment</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="identifier">dont_care</span> <span class="special">&gt;</span></code></code></a>
                   </p>
                 </td>
 </tr>
@@ -1343,17 +348,10 @@
                 </td>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="keyword">or_eq</span></code>
-                  </p>
-                </td>
-<td>
-                  <p>
-                    &#248;
-                  </p>
-                </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/can_call_bitwise_or_assignment.html" title="can_call_bitwise_or_assignment"><code class="computeroutput"><span class="identifier">can_call_bitwise_or_assignment</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="identifier">dont_care</span> <span class="special">&gt;</span></code></code></a>
                   </p>
                 </td>
 </tr>
@@ -1365,39 +363,55 @@
                 </td>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="keyword">xor_eq</span></code>
+                    <a class="link" href="../../reference/can_call_bitwise_xor_assignment.html" title="can_call_bitwise_xor_assignment"><code class="computeroutput"><span class="identifier">can_call_bitwise_xor_assignment</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="identifier">dont_care</span> <span class="special">&gt;</span></code></code></a>
                   </p>
                 </td>
+</tr>
+<tr>
 <td>
                   <p>
-                    &#248;
+                    <code class="computeroutput"><span class="special">&lt;&lt;</span></code>
                   </p>
                 </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/can_call_left_shift.html" title="can_call_left_shift"><code class="computeroutput"><span class="identifier">can_call_left_shift</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="identifier">dont_care</span> <span class="special">&gt;</span></code></code></a>
                   </p>
                 </td>
 </tr>
 <tr>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="special">&lt;&lt;=</span></code>
+                    <code class="computeroutput"><span class="special">&gt;&gt;</span></code>
                   </p>
                 </td>
 <td>
                   <p>
-                    &#248;
+                    <a class="link" href="../../reference/can_call_right_shift.html" title="can_call_right_shift"><code class="computeroutput"><span class="identifier">can_call_right_shift</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="identifier">dont_care</span> <span class="special">&gt;</span></code></code></a>
                   </p>
                 </td>
+</tr>
+<tr>
 <td>
                   <p>
-                    &#248;
+                    <code class="computeroutput"><span class="special">&lt;&lt;=</span></code>
                   </p>
                 </td>
 <td>
                   <p>
-                    <a class="link" href="../../reference/has_operator_left_shift_equal.html" title="has_operator_left_shift_equal"><code class="computeroutput"><span class="identifier">has_operator_left_shift_equal</span></code></a>
+                    <a class="link" href="../../reference/can_call_left_shift_assignment.html" title="can_call_left_shift_assignment"><code class="computeroutput"><span class="identifier">can_call_left_shift_assignment</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="identifier">dont_care</span> <span class="special">&gt;</span></code></code></a>
                   </p>
                 </td>
 </tr>
@@ -1409,118 +423,162 @@
                 </td>
 <td>
                   <p>
-                    &#248;
-                  </p>
-                </td>
-<td>
-                  <p>
-                    &#248;
+                    <a class="link" href="../../reference/can_call_right_shift_assignment.html" title="can_call_right_shift_assignment"><code class="computeroutput"><span class="identifier">can_call_right_shift_assignment</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="identifier">dont_care</span> <span class="special">&gt;</span></code></code></a>
                   </p>
                 </td>
+</tr>
+<tr>
 <td>
                   <p>
-                    <a class="link" href="../../reference/has_operator_right_shift_equal.html" title="has_operator_right_shift_equal"><code class="computeroutput"><span class="identifier">has_operator_right_shift_equal</span></code></a>
+                    <code class="computeroutput"><span class="special">==</span></code>
                   </p>
                 </td>
-</tr>
-<tr>
 <td>
                   <p>
-                    prefix
+                    <a class="link" href="../../reference/can_call_equal.html" title="can_call_equal"><code class="computeroutput"><span class="identifier">can_call_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="identifier">dont_care</span>
+                    <span class="special">&gt;</span></code></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>
                   <p>
-                    <code class="computeroutput"><span class="special">++</span></code>
+                    <code class="computeroutput"><span class="special">!=</span></code>
                   </p>
                 </td>
 <td>
                   <p>
-                    &#248;
+                    <a class="link" href="../../reference/can_call_not_equal.html" title="can_call_not_equal"><code class="computeroutput"><span class="identifier">can_call_not_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="identifier">dont_care</span>
+                    <span class="special">&gt;</span></code></code></a>
                   </p>
                 </td>
+</tr>
+<tr>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="identifier">advance</span></code>
+                    <code class="computeroutput"><span class="special">&lt;</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></a>
+                    <a class="link" href="../../reference/can_call_less.html" title="can_call_less"><code class="computeroutput"><span class="identifier">can_call_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="identifier">dont_care</span>
+                    <span class="special">&gt;</span></code></code></a>
                   </p>
                 </td>
 </tr>
 <tr>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="special">--</span></code>
+                    <code class="computeroutput"><span class="special">&lt;=</span></code>
                   </p>
                 </td>
 <td>
                   <p>
-                    &#248;
+                    <a class="link" href="../../reference/can_call_less_equal.html" title="can_call_less_equal"><code class="computeroutput"><span class="identifier">can_call_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="identifier">dont_care</span> <span class="special">&gt;</span></code></code></a>
                   </p>
                 </td>
+</tr>
+<tr>
 <td>
                   <p>
-                    &#248;
+                    <code class="computeroutput"><span class="special">&gt;</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></a>
+                    <a class="link" href="../../reference/can_call_greater.html" title="can_call_greater"><code class="computeroutput"><span class="identifier">can_call_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="identifier">dont_care</span>
+                    <span class="special">&gt;</span></code></code></a>
                   </p>
                 </td>
 </tr>
 <tr>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="special">+</span></code>
+                    <code class="computeroutput"><span class="special">&gt;=</span></code>
                   </p>
                 </td>
 <td>
                   <p>
-                    &#248;
+                    <a class="link" href="../../reference/can_call_greater_equal.html" title="can_call_greater_equal"><code class="computeroutput"><span class="identifier">can_call_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="identifier">dont_care</span> <span class="special">&gt;</span></code></code></a>
                   </p>
                 </td>
+</tr>
+<tr>
 <td>
                   <p>
-                    &#248;
+                    <code class="computeroutput"><span class="special">&amp;&amp;</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></a>
+                    <a class="link" href="../../reference/can_call_and.html" title="can_call_and"><code class="computeroutput"><span class="identifier">can_call_and</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="identifier">dont_care</span>
+                    <span class="special">&gt;</span></code></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>
                   <p>
-                    &#248;
+                    <a class="link" href="../../reference/can_call_or.html" title="can_call_or"><code class="computeroutput"><span class="identifier">can_call_or</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="identifier">dont_care</span>
+                    <span class="special">&gt;</span></code></code></a>
                   </p>
                 </td>
-<td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<br class="table-break"><div class="table">
+<a name="id3312536"></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>
+<col>
+</colgroup>
+<thead><tr>
+<th>
                   <p>
-                    <code class="computeroutput"><span class="identifier">negate</span></code>
+                    operator
                   </p>
-                </td>
-<td>
+                </th>
+<th>
                   <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></a>
+                    trait name
                   </p>
-                </td>
-</tr>
+                </th>
+</tr></thead>
+<tbody>
 <tr>
 <td>
                   <p>
@@ -1529,39 +587,54 @@
                 </td>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="keyword">not</span></code>
+                    <a class="link" href="../../reference/can_call_not.html" title="can_call_not"><code class="computeroutput"><span class="identifier">can_call_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="identifier">dont_care</span> <span class="special">&gt;</span></code></code></a>
                   </p>
                 </td>
+</tr>
+<tr>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="identifier">logical_not</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></a>
+                    <a class="link" href="../../reference/can_call_unary_plus.html" title="can_call_unary_plus"><code class="computeroutput"><span class="identifier">can_call_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="identifier">dont_care</span>
+                    <span class="special">&gt;</span></code></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>
                   <p>
-                    <code class="computeroutput"><span class="keyword">compl</span></code>
+                    <a class="link" href="../../reference/can_call_unary_minus.html" title="can_call_unary_minus"><code class="computeroutput"><span class="identifier">can_call_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="identifier">dont_care</span>
+                    <span class="special">&gt;</span></code></code></a>
                   </p>
                 </td>
+</tr>
+<tr>
 <td>
                   <p>
-                    &#248;
+                    <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></a>
+                    <a class="link" href="../../reference/can_call_complement.html" title="can_call_complement"><code class="computeroutput"><span class="identifier">can_call_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="identifier">dont_care</span>
+                    <span class="special">&gt;</span></code></code></a>
                   </p>
                 </td>
 </tr>
@@ -1573,71 +646,93 @@
                 </td>
 <td>
                   <p>
-                    &#248;
-                  </p>
-                </td>
-<td>
-                  <p>
-                    &#248;
+                    <a class="link" href="../../reference/can_call_dereference.html" title="can_call_dereference"><code class="computeroutput"><span class="identifier">can_call_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="identifier">dont_care</span>
+                    <span class="special">&gt;</span></code></code></a>
                   </p>
                 </td>
+</tr>
+<tr>
 <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></a>
+                    <code class="computeroutput"><span class="special">++</span></code>
                   </p>
                 </td>
-</tr>
-<tr>
 <td>
                   <p>
-                    postfix
+                    <a class="link" href="../../reference/can_call_pre_increment.html" title="can_call_pre_increment"><code class="computeroutput"><span class="identifier">can_call_pre_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="identifier">dont_care</span>
+                    <span class="special">&gt;</span></code></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>
                   <p>
-                    <code class="computeroutput"><span class="special">++</span></code>
+                    <code class="computeroutput"><span class="special">--</span></code>
                   </p>
                 </td>
 <td>
                   <p>
-                    &#248;
+                    <a class="link" href="../../reference/can_call_pre_decrement.html" title="can_call_pre_decrement"><code class="computeroutput"><span class="identifier">can_call_pre_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="identifier">dont_care</span>
+                    <span class="special">&gt;</span></code></code></a>
                   </p>
                 </td>
-<td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<br class="table-break"><div class="table">
+<a name="id3313172"></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>
+<col>
+</colgroup>
+<thead><tr>
+<th>
                   <p>
-                    <code class="computeroutput"><span class="identifier">advance</span></code>
+                    operator
                   </p>
-                </td>
-<td>
+                </th>
+<th>
                   <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></a>
+                    trait name
                   </p>
-                </td>
-</tr>
+                </th>
+</tr></thead>
+<tbody>
 <tr>
 <td>
                   <p>
-                    <code class="computeroutput"><span class="special">--</span></code>
+                    <code class="computeroutput"><span class="special">++</span></code>
                   </p>
                 </td>
 <td>
                   <p>
-                    &#248;
+                    <a class="link" href="../../reference/can_call_post_increment.html" title="can_call_post_increment"><code class="computeroutput"><span class="identifier">can_call_post_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="identifier">dont_care</span>
+                    <span class="special">&gt;</span></code></code></a>
                   </p>
                 </td>
+</tr>
+<tr>
 <td>
                   <p>
-                    &#248;
+                    <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></a>
+                    <a class="link" href="../../reference/can_call_post_decrement.html" title="can_call_post_decrement"><code class="computeroutput"><span class="identifier">can_call_post_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="identifier">dont_care</span>
+                    <span class="special">&gt;</span></code></code></a>
                   </p>
                 </td>
 </tr>
@@ -1645,18 +740,18 @@
 </table></div>
 </div>
 <br class="table-break"><a name="boost_typetraits.category.value_traits.operators.implementation"></a><h6>
-<a name="id3414084"></a>
+<a name="id3313387"></a>
           <a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.implementation">Implementation</a>
         </h6>
 <p>
           The implementation consists in only header files. The following headers
           should included first: 
 </p>
-<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">operators</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
+<pre class="programlisting"><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">can_call</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
 <p>
           or 
 </p>
-<pre class="programlisting"><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_name</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
+<pre class="programlisting"><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">can_call_name</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
 <p>
           where <code class="literal">name</code> is the textual name chosen for the wanted
           operator. The first method includes all operator traits.
@@ -1664,8 +759,8 @@
 <p>
           All traits are implemented the same way using preprocessor macros to avoid
           code duplication. The main files are in <code class="literal">boost/type_traits/detail</code>:
-          <code class="literal">has_binary_operator.hpp</code>, <code class="literal">has_prefix_operator.hpp</code>
-          and <code class="literal">has_postfix_operator.hpp</code>. The example of prefix
+          <code class="literal">can_call_binary_operator.hpp</code>, <code class="literal">can_call_prefix_operator.hpp</code>
+          and <code class="literal">can_call_postfix_operator.hpp</code>. The example of prefix
           <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code>
           is presented below:
         </p>
@@ -1674,34 +769,22 @@
 </p>
 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
 <span class="keyword">namespace</span> <span class="identifier">detail</span> <span class="special">{</span>
-<span class="keyword">namespace</span> <span class="identifier">has_operator_unary_minus_impl</span> <span class="special">{</span>
+
+<span class="comment">// This namespace ensures that ADL does not mess things up.
+</span><span class="keyword">namespace</span> <span class="identifier">can_call_unary_minus_impl</span> <span class="special">{</span>
 
 <span class="comment">// 1. a function to have an instance of type T without requiring T to be default
 </span><span class="comment">// constructible
-</span><span class="keyword">namespace</span> <span class="special">{</span>
-   <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">T</span> <span class="special">&amp;</span><span class="identifier">make</span><span class="special">();</span>
-<span class="special">}</span>
-
-<span class="comment">// 2. we provide operator- for types that do not have one already
-</span>
-<span class="comment">// a type returned from operator- when no such operator is found in the type's
-</span><span class="comment">// own namespace so that we have a means to know that our operator was used
-</span><span class="keyword">struct</span> <span class="identifier">tag</span> <span class="special">{</span> <span class="special">};</span>
-
-<span class="comment">// this class allows implicit conversions and makes the following operator
-</span><span class="comment">// definition less-preferred than any other such operators that might be found
-</span><span class="comment">// via argument-dependent name lookup
-</span><span class="keyword">struct</span> <span class="identifier">any</span> <span class="special">{</span> <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">any</span><span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;);</span> <span class="special">};</span>
+</span><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">T</span> <span class="special">&amp;</span><span class="identifier">make</span><span class="special">();</span>
 
-<span class="comment">// when operator- is not available, this one is used
-</span><span class="identifier">tag</span> <span class="keyword">operator</span><span class="special">-(</span><span class="keyword">const</span> <span class="identifier">any</span><span class="special">&amp;);</span>
 
-<span class="comment">// 3. if the return type has to be checked, we need to determine if operator-
-</span><span class="comment">// returns void or not
+<span class="comment">// 2. checks if operator- returns void or not
+</span><span class="comment">// conditions: Rhs!=void
 </span>
 <span class="comment">// we first redefine "operator," so that we have no compilation error if
 </span><span class="comment">// operator- returns void and we can use the return type of
-</span><span class="comment">// (-rhs, returns_void_t()) to deduce if operator- returns void or not:
+</span><span class="comment">// (-rhs, returns_void_t()) to deduce if
+</span><span class="comment">// operator- returns void or not:
 </span><span class="comment">// - operator- returns void   -&gt; (-rhs, returns_void_t()) returns returns_void_t
 </span><span class="comment">// - operator- returns !=void -&gt; (-rhs, returns_void_t()) returns int
 </span><span class="keyword">struct</span> <span class="identifier">returns_void_t</span> <span class="special">{};</span>
@@ -1710,109 +793,146 @@
 <span class="comment">// this intermediate trait has member value of type bool:
 </span><span class="comment">// - value==true -&gt; operator- returns void
 </span><span class="comment">// - value==false -&gt; operator- does not return void
-</span><span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">RHS</span> <span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">operator_unary_minus_returns_void</span> <span class="special">{</span>
+</span><span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">Rhs</span> <span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">operator_returns_void</span> <span class="special">{</span>
    <span class="comment">// overloads of function returns_void make the difference
 </span>   <span class="comment">// yes_type and no_type have different size by construction
 </span>   <span class="keyword">static</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">type_traits</span><span class="special">::</span><span class="identifier">yes_type</span> <span class="identifier">returns_void</span><span class="special">(</span><span class="identifier">returns_void_t</span><span class="special">);</span>
    <span class="keyword">static</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">type_traits</span><span class="special">::</span><span class="identifier">no_type</span> <span class="identifier">returns_void</span><span class="special">(</span><span class="keyword">int</span><span class="special">);</span>
-   <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span><span class="special">=(</span><span class="keyword">sizeof</span><span class="special">(::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">type_traits</span><span class="special">::</span><span class="identifier">yes_type</span><span class="special">)==</span><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">returns_void</span><span class="special">((-</span><span class="identifier">make</span><span class="special">&lt;</span><span class="identifier">RHS</span><span class="special">&gt;(),</span><span class="identifier">returns_void_t</span><span class="special">()))));</span>
+   <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span> <span class="special">=</span> <span class="special">(</span><span class="keyword">sizeof</span><span class="special">(::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">type_traits</span><span class="special">::</span><span class="identifier">yes_type</span><span class="special">)==</span><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">returns_void</span><span class="special">((-</span> <span class="identifier">make</span><span class="special">&lt;</span><span class="identifier">Rhs</span><span class="special">&gt;(),</span><span class="identifier">returns_void_t</span><span class="special">()))));</span>
 <span class="special">};</span>
 
-<span class="comment">// 4. check for return type when RET is non void
+
+<span class="comment">// 3. check for return type if Ret!=dont_care
+</span><span class="comment">// conditions: Rhs!=void
 </span>
-<span class="comment">// this class is used only when RET is non void, therefore it is specialized to
-</span><span class="comment">// have its value==false when the operator returns void
-</span><span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">RET</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">RETURNS_VOID</span> <span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">has_operator_unary_minus_impl2</span><span class="special">;</span>
-
-<span class="comment">// operator- does not return void, checks if it is convertible to RET using the
-</span><span class="comment">// sizeof trick based on overload resolution
-</span><span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">RET</span> <span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">has_operator_unary_minus_impl2</span><span class="special">&lt;</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</span><span class="special">,</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">false_type</span> <span class="special">&gt;</span> <span class="special">{</span>
-   <span class="keyword">static</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">type_traits</span><span class="special">::</span><span class="identifier">yes_type</span> <span class="identifier">is_convertible_to_RET</span><span class="special">(</span><span class="identifier">RET</span><span class="special">);</span>
-   <span class="keyword">static</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">type_traits</span><span class="special">::</span><span class="identifier">no_type</span> <span class="identifier">is_convertible_to_RET</span><span class="special">(...);</span>
-   <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span><span class="special">=(</span><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">is_convertible_to_RET</span><span class="special">(-</span> <span class="identifier">make</span><span class="special">&lt;</span><span class="identifier">RHS</span><span class="special">&gt;()))==</span><span class="keyword">sizeof</span><span class="special">(::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">type_traits</span><span class="special">::</span><span class="identifier">yes_type</span><span class="special">));</span>
+<span class="keyword">struct</span> <span class="identifier">dont_care</span> <span class="special">{</span> <span class="special">};</span>
+
+<span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Ret</span><span class="special">,</span> <span class="keyword">bool</span> <span class="identifier">Returns_void</span> <span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">operator_returns_Ret</span><span class="special">;</span>
+
+<span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">Rhs</span> <span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">operator_returns_Ret</span> <span class="special">&lt;</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">dont_care</span><span class="special">,</span> <span class="keyword">true</span> <span class="special">&gt;</span> <span class="special">{</span>
+   <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span> <span class="special">=</span> <span class="keyword">true</span><span class="special">;</span>
 <span class="special">};</span>
 
-<span class="comment">// operator- returns void!=RET -&gt; specialization to return value==false
-</span><span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">RET</span> <span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">has_operator_unary_minus_impl2</span><span class="special">&lt;</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</span><span class="special">,</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">true_type</span> <span class="special">&gt;</span> <span class="special">{</span>
-   <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span><span class="special">=</span><span class="keyword">false</span><span class="special">;</span>
+<span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">Rhs</span> <span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">operator_returns_Ret</span> <span class="special">&lt;</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">dont_care</span><span class="special">,</span> <span class="keyword">false</span> <span class="special">&gt;</span> <span class="special">{</span>
+   <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span> <span class="special">=</span> <span class="keyword">true</span><span class="special">;</span>
 <span class="special">};</span>
 
-<span class="comment">// 5. main struct: to avoid any compilation error, this struct behaves
-</span><span class="comment">// differently when:
-</span><span class="comment">// - RET is void or non void
-</span><span class="comment">// - operator-(RHS) is forbidden by the standard
-</span><span class="comment">// forbidden_if is a bool that is:
-</span><span class="comment">// - true when the operator-(RHS) is forbidden by the standard (would yield
-</span><span class="comment">//   compilation error if used)
-</span><span class="comment">// - false otherwise
-</span><span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">RET</span><span class="special">,</span> <span class="keyword">bool</span> <span class="identifier">forbidden_if</span> <span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">has_operator_unary_minus_impl1</span><span class="special">;</span>
+<span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">Rhs</span> <span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">operator_returns_Ret</span> <span class="special">&lt;</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="keyword">void</span><span class="special">,</span> <span class="keyword">true</span> <span class="special">&gt;</span> <span class="special">{</span>
+   <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span> <span class="special">=</span> <span class="keyword">true</span><span class="special">;</span>
+<span class="special">};</span>
+
+<span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">Rhs</span> <span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">operator_returns_Ret</span> <span class="special">&lt;</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="keyword">void</span><span class="special">,</span> <span class="keyword">false</span> <span class="special">&gt;</span> <span class="special">{</span>
+   <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span> <span class="special">=</span> <span class="keyword">false</span><span class="special">;</span>
+<span class="special">};</span>
 
-<span class="comment">// specialization to avoid compilation error when forbidden by the standard
-</span><span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">RET</span> <span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">has_operator_unary_minus_impl1</span> <span class="special">&lt;</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</span><span class="special">,</span> <span class="keyword">true</span> <span class="special">&gt;</span> <span class="special">{</span>
-   <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span><span class="special">=</span><span class="keyword">false</span><span class="special">;</span>
+<span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Ret</span> <span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">operator_returns_Ret</span> <span class="special">&lt;</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">,</span> <span class="keyword">true</span> <span class="special">&gt;</span> <span class="special">{</span>
+   <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span> <span class="special">=</span> <span class="keyword">false</span><span class="special">;</span>
 <span class="special">};</span>
 
-<span class="comment">// checks for return type if template parameter RET is non void: use previously
-</span><span class="comment">// defined struct
-</span><span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">RET</span> <span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">has_operator_unary_minus_impl1</span> <span class="special">&lt;</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</span><span class="special">,</span> <span class="keyword">false</span> <span class="special">&gt;</span> <span class="special">{</span>
-   <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span><span class="special">=(</span><span class="identifier">has_operator_unary_minus_impl2</span><span class="special">&lt;</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</span><span class="special">,</span> <span class="keyword">typename</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">integral_constant</span><span class="special">&lt;</span> <span class="keyword">bool</span><span class="special">,</span> <span class="identifier">operator_unary_minus_returns_void</span><span class="special">&lt;</span> <span class="identifier">RHS</span> <span class="special">&gt;::</span><span class="identifier">value</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special
">);</span>
+<span class="comment">// when Ret!=void, checks if it is convertible to Ret using the sizeof trick
+</span><span class="comment">// based on overload resolution
+</span><span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Ret</span> <span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">operator_returns_Ret</span> <span class="special">&lt;</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">,</span> <span class="keyword">false</span> <span class="special">&gt;</span> <span class="special">{</span>
+   <span class="keyword">static</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">type_traits</span><span class="special">::</span><span class="identifier">yes_type</span> <span class="identifier">is_convertible_to_Ret</span><span class="special">(</span><span class="identifier">Ret</span><span class="special">);</span> <span class="comment">// this version is preferred for types convertible to Ret
+</span>   <span class="keyword">static</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">type_traits</span><span class="special">::</span><span class="identifier">no_type</span> <span class="identifier">is_convertible_to_Ret</span><span class="special">(...);</span> <span class="comment">// this version is used otherwise
+</span>
+   <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span> <span class="special">=</span> <span class="special">(</span><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">is_convertible_to_Ret</span><span class="special">(-</span> <span class="identifier">make</span><span class="special">&lt;</span><span class="identifier">Rhs</span><span class="special">&gt;()))==</span><span class="keyword">sizeof</span><span class="special">(::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">type_traits</span><span class="special">::</span><span class="identifier">yes_type</span><span class="special">));</span>
 <span class="special">};</span>
 
-<span class="comment">// in case we do not want to check for return type, we still need to know if our
-</span><span class="comment">// definition of operator BOOST_TT_TRAIT_OP is used or an other existing one;
+
+<span class="comment">// 4. we provide our operator definition for types that do not have one already
+</span>
+<span class="comment">// a type returned from operator- when no such operator is
+</span><span class="comment">// found in the type's own namespace so that we have a means to know that our
+</span><span class="comment">// operator was used
+</span><span class="keyword">struct</span> <span class="identifier">tag</span> <span class="special">{</span> <span class="special">};</span>
+
+<span class="comment">// this class allows implicit conversions and makes the following operator
+</span><span class="comment">// definition less-preferred than any other such operators that might be found
+</span><span class="comment">// via argument-dependent name lookup
+</span><span class="keyword">struct</span> <span class="identifier">any</span> <span class="special">{</span> <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">any</span><span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;);</span> <span class="special">};</span>
+
+<span class="comment">// when operator- is not available, this one is used
+</span><span class="identifier">tag</span> <span class="keyword">operator</span> <span class="special">-</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">any</span><span class="special">&amp;);</span>
+
+
+<span class="comment">// 5. check for operator existence
+</span><span class="comment">// condition: Rhs!=void
+</span>
+<span class="comment">// check if our definition of operator- is used or an other
+</span><span class="comment">// existing one;
 </span><span class="comment">// this is done with redefinition of "operator," that returns tag or tag2
 </span><span class="keyword">struct</span> <span class="identifier">tag2</span> <span class="special">{</span> <span class="special">};</span>
 <span class="identifier">tag</span> <span class="keyword">operator</span><span class="special">,(</span><span class="identifier">tag</span><span class="special">,</span> <span class="identifier">tag2</span><span class="special">);</span>
 
-<span class="comment">// do not check for return type if 2nd template parameter RET is void
-</span><span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">RHS</span> <span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">has_operator_unary_minus_impl1</span><span class="special">&lt;</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="keyword">void</span><span class="special">,</span> <span class="keyword">false</span> <span class="special">&gt;</span> <span class="special">{</span>
+<span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">Rhs</span> <span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">operator_exists</span> <span class="special">{</span>
    <span class="keyword">static</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">type_traits</span><span class="special">::</span><span class="identifier">yes_type</span> <span class="identifier">check</span><span class="special">(</span><span class="identifier">tag2</span><span class="special">);</span> <span class="comment">// this version is preferred when operator exists
 </span>   <span class="keyword">static</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">type_traits</span><span class="special">::</span><span class="identifier">no_type</span> <span class="identifier">check</span><span class="special">(</span><span class="identifier">tag</span><span class="special">);</span> <span class="comment">// this version is used otherwise
 </span>
-   <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span><span class="special">=(</span><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">check</span><span class="special">(((-</span><span class="identifier">make</span><span class="special">&lt;</span><span class="identifier">RHS</span><span class="special">&gt;()),</span><span class="identifier">make</span><span class="special">&lt;</span><span class="identifier">tag2</span><span class="special">&gt;())))==</span><span class="keyword">sizeof</span><span class="special">(::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">type_traits</span><span class="special">::</span><span class="identifier">yes_type</span><span class="special">));</span>
+   <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span> <span class="special">=</span> <span class="special">(</span><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">check</span><span class="special">(((-</span> <span class="identifier">make</span><span class="special">&lt;</span><span class="identifier">Rhs</span><span class="special">&gt;()),</span><span class="identifier">make</span><span class="special">&lt;</span><span class="identifier">tag2</span><span class="special">&gt;())))==</span><span class="keyword">sizeof</span><span class="special">(::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">type_traits</span><span class="special">::</span><span class="identifier">yes_type</span><span class="special">));</span>
+<span class="special">};</span>
+
+
+<span class="comment">// 5. main trait: to avoid any compilation error, this struct behaves
+</span><span class="comment">// differently when:
+</span><span class="comment">// - operator-(Rhs) is forbidden by the standard
+</span><span class="comment">// Forbidden_if is a bool that is:
+</span><span class="comment">// - true when the operator-(Rhs) is forbidden by the standard
+</span><span class="comment">//   (would yield compilation error if used)
+</span><span class="comment">// - false otherwise
+</span><span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Ret</span><span class="special">,</span> <span class="keyword">bool</span> <span class="identifier">Forbidden_if</span> <span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">trait_impl1</span><span class="special">;</span>
+
+<span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Ret</span> <span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">trait_impl1</span> <span class="special">&lt;</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">,</span> <span class="keyword">true</span> <span class="special">&gt;</span> <span class="special">{</span>
+   <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span> <span class="special">=</span> <span class="keyword">false</span><span class="special">;</span>
 <span class="special">};</span>
 
-<span class="comment">// some specializations needs to be declared for the special void case
-</span><span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">RET</span> <span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">has_operator_unary_minus_impl1</span><span class="special">&lt;</span> <span class="keyword">void</span><span class="special">,</span> <span class="identifier">RET</span><span class="special">,</span> <span class="keyword">false</span> <span class="special">&gt;</span> <span class="special">{</span>
-   <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span><span class="special">=</span><span class="keyword">false</span><span class="special">;</span>
+<span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Ret</span> <span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">trait_impl1</span> <span class="special">&lt;</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">,</span> <span class="keyword">false</span> <span class="special">&gt;</span> <span class="special">{</span>
+   <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span>
+      <span class="identifier">value</span> <span class="special">=</span> <span class="special">(</span>
+         <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">type_traits</span><span class="special">::</span><span class="identifier">ice_and</span><span class="special">&lt;</span>
+            <span class="identifier">operator_exists</span> <span class="special">&lt;</span> <span class="identifier">Rhs</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span>
+            <span class="identifier">operator_returns_Ret</span> <span class="special">&lt;</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">,</span> <span class="identifier">operator_returns_void</span> <span class="special">&lt;</span> <span class="identifier">Rhs</span> <span class="special">&gt;::</span><span class="identifier">value</span> <span class="special">&gt;::</span><span class="identifier">value</span>
+         <span class="special">&gt;::</span><span class="identifier">value</span>
+      <span class="special">);</span>
 <span class="special">};</span>
 
-<span class="keyword">template</span> <span class="special">&lt;&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">has_operator_unary_minus_impl1</span><span class="special">&lt;</span> <span class="keyword">void</span><span class="special">,</span> <span class="keyword">void</span><span class="special">,</span> <span class="keyword">false</span> <span class="special">&gt;</span> <span class="special">{</span>
-   <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span><span class="special">=</span><span class="keyword">false</span><span class="special">;</span>
+<span class="comment">// specialization needs to be declared for the special void case
+</span><span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">Ret</span> <span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">trait_impl1</span> <span class="special">&lt;</span> <span class="keyword">void</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">,</span> <span class="keyword">false</span> <span class="special">&gt;</span> <span class="special">{</span>
+   <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span> <span class="special">=</span> <span class="keyword">false</span><span class="special">;</span>
 <span class="special">};</span>
 
 <span class="comment">// defines some typedef for convenience
-</span><span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">RET</span> <span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">has_operator_unary_minus_impl</span> <span class="special">{</span>
-   <span class="comment">// shortcuts for writing forbidden_if
-</span>   <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">remove_reference</span><span class="special">&lt;</span><span class="identifier">RHS</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">rhs_noref</span><span class="special">;</span>
-   <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">remove_cv</span><span class="special">&lt;</span><span class="identifier">rhs_noref</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">rhs_nocv</span><span class="special">;</span>
-   <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">remove_cv</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">remove_reference</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">remove_pointer</span><span class="special">&lt;</span><span class="identifier">rhs_noref</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="special">&gt;::</span><span class="identifier">type</span> <span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">rhs_noptr</span><span class="special">;</span>
-   <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span><span class="special">=(</span><span class="identifier">has_operator_unary_minus_impl1</span> <span class="special">&lt;</span> <span class="identifier">rhs_noref</span><span class="special">,</span> <span class="identifier">RET</span><span class="special">,</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_pointer</span><span class="special">&lt;</span> <span class="identifier">rhs_noref</span> <span class="special">&gt;::</span><span class="identifier">value</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">);</span>
+</span><span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Ret</span> <span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">trait_impl</span> <span class="special">{</span>
+   <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">remove_reference</span><span class="special">&lt;</span><span class="identifier">Rhs</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">Rhs_noref</span><span class="special">;</span>
+   <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span> <span class="special">=</span> <span class="special">(</span><span class="identifier">trait_impl1</span> <span class="special">&lt;</span> <span class="identifier">Rhs_noref</span><span class="special">,</span> <span class="identifier">Ret</span><span class="special">,</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_pointer</span><span class="special">&lt;</span> <span class="identifier">Rhs_noref</span> <span class="special">&gt;::</span><span class="identifier">value</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">);</span>
 <span class="special">};</span>
-<span class="special">}</span> <span class="comment">// namespace has_operator_unary_minus_impl
+
+<span class="special">}</span> <span class="comment">// namespace can_call_unary_minus_impl
 </span><span class="special">}</span> <span class="comment">// namespace detail
 </span>
 <span class="comment">// this is the accessible definition of the trait to end user
-</span><span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span> <span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">has_operator_unary_minus</span> <span class="special">:</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">integral_constant</span><span class="special">&lt;</span> <span class="keyword">bool</span><span class="special">,</span> <span class="special">(::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">detail</span><span class="special">::</span><span class="identifier">has_operator_unary_minus_impl</span><span class="special">::</span><span class="identifier">has_operator_unary_minus_impl</span><span class="special">&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</span><span class="special">)&gt;</span> <span class="special">{</span>
-<span class="special">};</span>
+</span><span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">Rhs</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Ret</span><span class="special">=::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">detail</span><span class="special">::</span><span class="identifier">can_call_unary_minus_impl</span><span class="special">::</span><span class="identifier">dont_care</span> <span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_unary_minus</span> <span class="special">:</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">integral_constant</span><span class="special">&lt;</span><span class="keyword">bool</span><span class="special">,(::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">detail</span><span class="special">::</span><span class="identifier">can_call_unary_minus_impl</span><span class="special">::</span><span class="identifier">trait_impl</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</span><span class="special">)&gt;</span> <span class="special">{</span> <span class="special">};</span>
+
 <span class="special">}</span> <span class="comment">// namespace boost
 </span></pre>
 <p>
         </p>
 <a name="boost_typetraits.category.value_traits.operators.known_issues"></a><h6>
-<a name="id3417429"></a>
+<a name="id3316872"></a>
           <a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.known_issues">Known
           issues</a>
         </h6>
@@ -1826,7 +946,7 @@
           
 </p>
 <pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="identifier">A</span> <span class="keyword">operator</span><span class="special">-();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_unary_minus</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator-() is private
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_unary_minus</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator-() is private
 </span></pre>
 <p>
         </p>
@@ -1844,8 +964,8 @@
 <pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
 <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">-(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
 <span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_unary_minus</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_unary_minus</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload between
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_unary_minus</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_unary_minus</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload between
 </span>                                           <span class="comment">// operator-(const any&amp;) and
 </span>                                           <span class="comment">// operator-(const A&amp;)
 </span>                                           <span class="comment">// both need type conversion
@@ -1856,8 +976,8 @@
 <pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="special">};</span>
 <span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="identifier">A</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">B</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="special">}</span> <span class="special">};</span>
 <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">-(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_unary_minus</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_unary_minus</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload between
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_unary_minus</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_unary_minus</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload between
 </span>                                           <span class="comment">// operator-(const any&amp;) and
 </span>                                           <span class="comment">// operator-(const A&amp;)
 </span>                                           <span class="comment">// both need type conversion
@@ -1865,7 +985,7 @@
 <p>
         </p>
 <a name="boost_typetraits.category.value_traits.operators.acknowledgments"></a><h6>
-<a name="id3418061"></a>
+<a name="id3317505"></a>
           <a class="link" href="operators.html#boost_typetraits.category.value_traits.operators.acknowledgments">Acknowledgments</a>
         </h6>
 <p>
@@ -1879,7 +999,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/value_traits/primary.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/value_traits/primary.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/value_traits/primary.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -107,7 +107,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/value_traits/properties.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/value_traits/properties.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/value_traits/properties.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -102,7 +102,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/value_traits/relate.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/value_traits/relate.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/category/value_traits/relate.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -40,7 +40,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/credits.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/credits.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/credits.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -29,7 +29,7 @@
     </p>
 <p>
       This version of type traits library is based on contributions by Adobe Systems
-      Inc, David Abrahams, Fr&#233;d&#233;ric Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy,
+      Inc, David Abrahams, Frederic Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy,
       Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Thorsten
       Ottosen, Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven
       Watanabe.
@@ -56,7 +56,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/examples.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/examples.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/examples.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -35,7 +35,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/examples/copy.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/examples/copy.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/examples/copy.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -72,7 +72,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/examples/destruct.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/examples/destruct.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/examples/destruct.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -59,7 +59,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/examples/fill.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/examples/fill.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/examples/fill.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -66,7 +66,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/examples/iter.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/examples/iter.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/examples/iter.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -75,7 +75,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/examples/to_double.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/examples/to_double.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/examples/to_double.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -35,7 +35,7 @@
 <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,
+      Frederic 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>

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-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -92,7 +92,7 @@
       of the following macros:
     </p>
 <div class="table">
-<a name="id3421143"></a><p class="title"><b>Table&#160;1.8.&#160;Macros for Compiler Intrinsics</b></p>
+<a name="id3320588"></a><p class="title"><b>Table&#160;1.7.&#160;Macros for Compiler Intrinsics</b></p>
 <div class="table-contents"><table class="table" summary="Macros for Compiler Intrinsics">
 <colgroup>
 <col>
@@ -333,7 +333,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/intro.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/intro.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/intro.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -42,7 +42,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/mpl.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/mpl.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/mpl.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -39,7 +39,7 @@
 <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,
+      Frederic 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>

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-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -27,6 +27,56 @@
 <dt><span class="section"> add_volatile</span></dt>
 <dt><span class="section"> aligned_storage</span></dt>
 <dt><span class="section"> alignment_of</span></dt>
+<dt><span class="section"> can_call_addition</span></dt>
+<dt><span class="section"><a href="reference/can_call_addition_assignment.html">
+      can_call_addition_assignment</a></span></dt>
+<dt><span class="section"> can_call_and</span></dt>
+<dt><span class="section"> can_call_bitwise_and</span></dt>
+<dt><span class="section"><a href="reference/can_call_bitwise_and_assignment.html">
+      can_call_bitwise_and_assignment</a></span></dt>
+<dt><span class="section"> can_call_bitwise_or</span></dt>
+<dt><span class="section"><a href="reference/can_call_bitwise_or_assignment.html">
+      can_call_bitwise_or_assignment</a></span></dt>
+<dt><span class="section"> can_call_bitwise_xor</span></dt>
+<dt><span class="section"><a href="reference/can_call_bitwise_xor_assignment.html">
+      can_call_bitwise_xor_assignment</a></span></dt>
+<dt><span class="section"> can_call_complement</span></dt>
+<dt><span class="section"> can_call_dereference</span></dt>
+<dt><span class="section"> can_call_division</span></dt>
+<dt><span class="section"><a href="reference/can_call_division_assignment.html">
+      can_call_division_assignment</a></span></dt>
+<dt><span class="section"> can_call_equal</span></dt>
+<dt><span class="section"> can_call_greater</span></dt>
+<dt><span class="section"> can_call_greater_equal</span></dt>
+<dt><span class="section"> can_call_left_shift</span></dt>
+<dt><span class="section"><a href="reference/can_call_left_shift_assignment.html">
+      can_call_left_shift_assignment</a></span></dt>
+<dt><span class="section"> can_call_less</span></dt>
+<dt><span class="section"> can_call_less_equal</span></dt>
+<dt><span class="section"> can_call_modulus</span></dt>
+<dt><span class="section"><a href="reference/can_call_modulus_assignment.html">
+      can_call_modulus_assignment</a></span></dt>
+<dt><span class="section"><a href="reference/can_call_multiplication.html">
+      can_call_multiplication</a></span></dt>
+<dt><span class="section"><a href="reference/can_call_multiplication_assignment.html">
+      can_call_multiplication_assignment</a></span></dt>
+<dt><span class="section"> can_call_not</span></dt>
+<dt><span class="section"> can_call_not_equal</span></dt>
+<dt><span class="section"> can_call_or</span></dt>
+<dt><span class="section"><a href="reference/can_call_post_decrement.html">
+      can_call_post_decrement</a></span></dt>
+<dt><span class="section"><a href="reference/can_call_post_increment.html">
+      can_call_post_increment</a></span></dt>
+<dt><span class="section"> can_call_pre_decrement</span></dt>
+<dt><span class="section"> can_call_pre_increment</span></dt>
+<dt><span class="section"> can_call_right_shift</span></dt>
+<dt><span class="section"><a href="reference/can_call_right_shift_assignment.html">
+      can_call_right_shift_assignment</a></span></dt>
+<dt><span class="section"> can_call_subtraction</span></dt>
+<dt><span class="section"><a href="reference/can_call_subtraction_assignment.html">
+      can_call_subtraction_assignment</a></span></dt>
+<dt><span class="section"> can_call_unary_minus</span></dt>
+<dt><span class="section"> can_call_unary_plus</span></dt>
 <dt><span class="section"> decay</span></dt>
 <dt><span class="section"> extent</span></dt>
 <dt><span class="section"><a href="reference/floating_point_promotion.html">
@@ -38,70 +88,6 @@
 <dt><span class="section"> has_nothrow_copy</span></dt>
 <dt><span class="section"> has_nothrow_copy_constructor</span></dt>
 <dt><span class="section"> has_nothrow_default_constructor</span></dt>
-<dt><span class="section"> has_operator_bit_and</span></dt>
-<dt><span class="section"><a href="reference/has_operator_bit_and_equal.html">
-      has_operator_bit_and_equal</a></span></dt>
-<dt><span class="section"> has_operator_bit_or</span></dt>
-<dt><span class="section"><a href="reference/has_operator_bit_or_equal.html">
-      has_operator_bit_or_equal</a></span></dt>
-<dt><span class="section"> has_operator_bit_xor</span></dt>
-<dt><span class="section"><a href="reference/has_operator_bit_xor_equal.html">
-      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>
-<dt><span class="section"> has_operator_equal_to</span></dt>
-<dt><span class="section"> has_operator_greater</span></dt>
-<dt><span class="section"><a href="reference/has_operator_greater_equal.html">
-      has_operator_greater_equal</a></span></dt>
-<dt><span class="section"><a href="reference/has_operator_left_shift.html">
-      has_operator_left_shift</a></span></dt>
-<dt><span class="section"><a href="reference/has_operator_left_shift_equal.html">
-      has_operator_left_shift_equal</a></span></dt>
-<dt><span class="section"> has_operator_less</span></dt>
-<dt><span class="section"><a href="reference/has_operator_less_equal.html">
-      has_operator_less_equal</a></span></dt>
-<dt><span class="section"><a href="reference/has_operator_logical_and.html">
-      has_operator_logical_and</a></span></dt>
-<dt><span class="section"><a href="reference/has_operator_logical_not.html">
-      has_operator_logical_not</a></span></dt>
-<dt><span class="section"><a href="reference/has_operator_logical_or.html">
-      has_operator_logical_or</a></span></dt>
-<dt><span class="section"> has_operator_minus</span></dt>
-<dt><span class="section"><a href="reference/has_operator_minus_equal.html">
-      has_operator_minus_equal</a></span></dt>
-<dt><span class="section"> has_operator_modulus</span></dt>
-<dt><span class="section"><a href="reference/has_operator_modulus_equal.html">
-      has_operator_modulus_equal</a></span></dt>
-<dt><span class="section"><a href="reference/has_operator_multiplies.html">
-      has_operator_multiplies</a></span></dt>
-<dt><span class="section"><a href="reference/has_operator_multiplies_equal.html">
-      has_operator_multiplies_equal</a></span></dt>
-<dt><span class="section"><a href="reference/has_operator_not_equal_to.html">
-      has_operator_not_equal_to</a></span></dt>
-<dt><span class="section"> has_operator_plus</span></dt>
-<dt><span class="section"><a href="reference/has_operator_plus_equal.html">
-      has_operator_plus_equal</a></span></dt>
-<dt><span class="section"><a href="reference/has_operator_postfix_decrement.html">
-      has_operator_postfix_decrement</a></span></dt>
-<dt><span class="section"><a href="reference/has_operator_postfix_increment.html">
-      has_operator_postfix_increment</a></span></dt>
-<dt><span class="section"><a href="reference/has_operator_prefix_decrement.html">
-      has_operator_prefix_decrement</a></span></dt>
-<dt><span class="section"><a href="reference/has_operator_prefix_increment.html">
-      has_operator_prefix_increment</a></span></dt>
-<dt><span class="section"><a href="reference/has_operator_right_shift.html">
-      has_operator_right_shift</a></span></dt>
-<dt><span class="section"><a href="reference/has_operator_right_shift_equal.html">
-      has_operator_right_shift_equal</a></span></dt>
-<dt><span class="section"><a href="reference/has_operator_unary_minus.html">
-      has_operator_unary_minus</a></span></dt>
-<dt><span class="section"><a href="reference/has_operator_unary_plus.html">
-      has_operator_unary_plus</a></span></dt>
 <dt><span class="section"> has_trivial_assign</span></dt>
 <dt><span class="section"><a href="reference/has_trivial_constructor.html">
       has_trivial_constructor</a></span></dt>
@@ -164,7 +150,7 @@
 <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,
+      Frederic 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>

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-04-19 17:59:57 EDT (Tue, 19 Apr 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="id3425942"></a><p class="title"><b>Table&#160;1.9.&#160;Examples</b></p>
+<a name="id3325386"></a><p class="title"><b>Table&#160;1.8.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>
@@ -122,7 +122,7 @@
 <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,
+      Frederic 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>

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-04-19 17:59:57 EDT (Tue, 19 Apr 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="id3426525"></a><p class="title"><b>Table&#160;1.10.&#160;Examples</b></p>
+<a name="id3325970"></a><p class="title"><b>Table&#160;1.9.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>
@@ -125,7 +125,7 @@
 <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,
+      Frederic 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>

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-04-19 17:59:57 EDT (Tue, 19 Apr 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="id3427178"></a><p class="title"><b>Table&#160;1.11.&#160;Examples</b></p>
+<a name="id3326622"></a><p class="title"><b>Table&#160;1.10.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>
@@ -124,7 +124,7 @@
 <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,
+      Frederic 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>

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-04-19 17:59:57 EDT (Tue, 19 Apr 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="id3427764"></a><p class="title"><b>Table&#160;1.12.&#160;Examples</b></p>
+<a name="id3327208"></a><p class="title"><b>Table&#160;1.11.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>
@@ -121,7 +121,7 @@
 <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,
+      Frederic 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>

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-04-19 17:59:57 EDT (Tue, 19 Apr 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="id3428341"></a><p class="title"><b>Table&#160;1.13.&#160;Examples</b></p>
+<a name="id3327785"></a><p class="title"><b>Table&#160;1.12.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>
@@ -123,7 +123,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/aligned_storage.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/aligned_storage.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/aligned_storage.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -39,7 +39,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/alignment_of.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/alignment_of.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/alignment_of.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 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="aligned_storage.html" title="aligned_storage">
-<link rel="next" href="decay.html" title="decay">
+<link rel="next" href="can_call_addition.html" title="can_call_addition">
 </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="aligned_storage.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="decay.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="aligned_storage.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="can_call_addition.html"><img src="../../images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
@@ -58,7 +58,7 @@
 <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,
+      Frederic 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>
@@ -69,7 +69,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="aligned_storage.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="decay.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="aligned_storage.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="can_call_addition.html"><img src="../../images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_addition.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_addition.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,141 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_addition</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="alignment_of.html" title="alignment_of">
+<link rel="next" href="can_call_addition_assignment.html" title="can_call_addition_assignment">
+</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="alignment_of.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="can_call_addition_assignment.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.can_call_addition"></a><a class="link" href="can_call_addition.html" title="can_call_addition"> can_call_addition</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">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="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_addition</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">lhs</span></code>
+        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><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="identifier">dont_care</span></code> or the result of expression
+        <code class="computeroutput"><span class="identifier">lhs</span><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="identifier">dont_care</span></code>)
+        is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        is different from the default <code class="computeroutput"><span class="identifier">dont_care</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 can_call_addition&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_addition</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">can_call</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">can_call_addition</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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">can_call_addition</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_addition</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_addition</span><span class="special">&lt;</span><span class="keyword">long</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">can_call_addition</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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">can_call_addition</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">&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">can_call_addition</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</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">can_call_addition</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</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">can_call_addition</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">&gt;::</span><span class="identifier">value</span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_addition</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">can_call_addition</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">can_call_addition</span></code>
+        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> or not. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">+(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_addition</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator+(const A&amp;) is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">+(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_addition</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_addition</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="alignment_of.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="can_call_addition_assignment.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_addition_assignment.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_addition_assignment.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,149 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_addition_assignment</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="can_call_addition.html" title="can_call_addition">
+<link rel="next" href="can_call_and.html" title="can_call_and">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="can_call_addition.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="can_call_and.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.reference.can_call_addition_assignment"></a><a class="link" href="can_call_addition_assignment.html" title="can_call_addition_assignment">
+      can_call_addition_assignment</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">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="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_addition_assignment</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">lhs</span></code>
+        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><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="identifier">dont_care</span></code> or the result of expression
+        <code class="computeroutput"><span class="identifier">lhs</span><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="identifier">dont_care</span></code>)
+        is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">+=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        is different from the default <code class="computeroutput"><span class="identifier">dont_care</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 can_call_addition_assignment&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_addition_assignment</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">can_call</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">can_call_addition_assignment</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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">can_call_addition_assignment</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_addition_assignment</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_addition_assignment</span><span class="special">&lt;</span><span class="keyword">long</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">can_call_addition_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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">can_call_addition_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
+          <span class="keyword">long</span><span class="special">&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">can_call_addition_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</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">can_call_addition_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</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">can_call_addition_assignment</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">&gt;::</span><span class="identifier">value</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">can_call_addition_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
+          <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">+=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">+=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">can_call_addition_assignment</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">can_call_addition_assignment</span></code>
+        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">+=</span></code> or not. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">+=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_addition_assignment</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator+=(const A&amp;) is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">+=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_addition_assignment</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_addition_assignment</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="can_call_addition.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="can_call_and.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_and.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_and.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,140 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_and</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="can_call_addition_assignment.html" title="can_call_addition_assignment">
+<link rel="next" href="can_call_bitwise_and.html" title="can_call_bitwise_and">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="can_call_addition_assignment.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="can_call_bitwise_and.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.reference.can_call_and"></a><a class="link" href="can_call_and.html" title="can_call_and"> can_call_and</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">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="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_and</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">lhs</span></code>
+        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><span class="special">&amp;&amp;</span><span class="identifier">rhs</span></code>,
+        and (ii) <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression
+        <code class="computeroutput"><span class="identifier">lhs</span><span class="special">&amp;&amp;</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="identifier">dont_care</span></code>)
+        is 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="identifier">dont_care</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 can_call_and&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_and</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">can_call</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">can_call_and</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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">can_call_and</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_and</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_and</span><span class="special">&lt;</span><span class="keyword">bool</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">can_call_and</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">bool</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">can_call_and</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">&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">can_call_and</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&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">can_call_and</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">&gt;::</span><span class="identifier">value</span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_and</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot 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">can_call_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">can_call_and</span></code> cannot
+        be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;&amp;</span></code> or not. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&amp;&amp;(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_and</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator&amp;&amp;(const A&amp;) is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&amp;&amp;(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_and</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_and</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="can_call_addition_assignment.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="can_call_bitwise_and.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_bitwise_and.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_bitwise_and.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,135 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_bitwise_and</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="can_call_and.html" title="can_call_and">
+<link rel="next" href="can_call_bitwise_and_assignment.html" title="can_call_bitwise_and_assignment">
+</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="can_call_and.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="can_call_bitwise_and_assignment.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.can_call_bitwise_and"></a><a class="link" href="can_call_bitwise_and.html" title="can_call_bitwise_and"> can_call_bitwise_and</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">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="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_bitwise_and</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">lhs</span></code>
+        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><span class="special">&amp;</span><span class="identifier">rhs</span></code>,
+        and (ii) <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression
+        <code class="computeroutput"><span class="identifier">lhs</span><span class="special">&amp;</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="identifier">dont_care</span></code>)
+        is 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="identifier">dont_care</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 can_call_bitwise_and&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_bitwise_and</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">can_call</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">can_call_bitwise_and</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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">can_call_bitwise_and</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_bitwise_and</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_bitwise_and</span><span class="special">&lt;</span><span class="keyword">long</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">can_call_bitwise_and</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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">can_call_bitwise_and</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">&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">can_call_bitwise_and</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&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">can_call_bitwise_and</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot 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">can_call_bitwise_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">can_call_bitwise_and</span></code>
+        cannot 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>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&amp;(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_bitwise_and</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator&amp;(const A&amp;) is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&amp;(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_bitwise_and</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_bitwise_and</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="can_call_and.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="can_call_bitwise_and_assignment.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_bitwise_and_assignment.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_bitwise_and_assignment.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,142 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_bitwise_and_assignment</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="can_call_bitwise_and.html" title="can_call_bitwise_and">
+<link rel="next" href="can_call_bitwise_or.html" title="can_call_bitwise_or">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="can_call_bitwise_and.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="can_call_bitwise_or.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.reference.can_call_bitwise_and_assignment"></a><a class="link" href="can_call_bitwise_and_assignment.html" title="can_call_bitwise_and_assignment">
+      can_call_bitwise_and_assignment</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">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="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_bitwise_and_assignment</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">lhs</span></code>
+        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><span class="special">&amp;=</span><span class="identifier">rhs</span></code>,
+        and (ii) <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression
+        <code class="computeroutput"><span class="identifier">lhs</span><span class="special">&amp;=</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="identifier">dont_care</span></code>)
+        is 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="identifier">dont_care</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 can_call_bitwise_and_assignment&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_bitwise_and_assignment</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">can_call</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">can_call_bitwise_and_assignment</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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">can_call_bitwise_and_assignment</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_bitwise_and_assignment</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_bitwise_and_assignment</span><span class="special">&lt;</span><span class="keyword">long</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">can_call_bitwise_and_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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">can_call_bitwise_and_assignment</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">&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">can_call_bitwise_and_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&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">can_call_bitwise_and_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
+          <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot 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">can_call_bitwise_and_assignment</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">can_call_bitwise_and_assignment</span></code>
+        cannot 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>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&amp;=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_bitwise_and_assignment</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator&amp;=(const A&amp;) is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&amp;=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_bitwise_and_assignment</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_bitwise_and_assignment</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="can_call_bitwise_and.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="can_call_bitwise_or.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_bitwise_or.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_bitwise_or.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,135 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_bitwise_or</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="can_call_bitwise_and_assignment.html" title="can_call_bitwise_and_assignment">
+<link rel="next" href="can_call_bitwise_or_assignment.html" title="can_call_bitwise_or_assignment">
+</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="can_call_bitwise_and_assignment.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="can_call_bitwise_or_assignment.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.can_call_bitwise_or"></a><a class="link" href="can_call_bitwise_or.html" title="can_call_bitwise_or"> can_call_bitwise_or</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">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="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_bitwise_or</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">lhs</span></code>
+        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><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="identifier">dont_care</span></code> or the result of expression
+        <code class="computeroutput"><span class="identifier">lhs</span><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="identifier">dont_care</span></code>)
+        is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">|</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        is different from the default <code class="computeroutput"><span class="identifier">dont_care</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 can_call_bitwise_or&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_bitwise_or</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">can_call</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">can_call_bitwise_or</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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">can_call_bitwise_or</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_bitwise_or</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_bitwise_or</span><span class="special">&lt;</span><span class="keyword">long</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">can_call_bitwise_or</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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">can_call_bitwise_or</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">&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">can_call_bitwise_or</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&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">can_call_bitwise_or</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">|</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">|</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">can_call_bitwise_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">can_call_bitwise_or</span></code>
+        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">|</span></code> or not. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">|(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_bitwise_or</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator|(const A&amp;) is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">|(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_bitwise_or</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_bitwise_or</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="can_call_bitwise_and_assignment.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="can_call_bitwise_or_assignment.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_bitwise_or_assignment.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_bitwise_or_assignment.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,140 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_bitwise_or_assignment</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="can_call_bitwise_or.html" title="can_call_bitwise_or">
+<link rel="next" href="can_call_bitwise_xor.html" title="can_call_bitwise_xor">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="can_call_bitwise_or.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="can_call_bitwise_xor.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.reference.can_call_bitwise_or_assignment"></a><a class="link" href="can_call_bitwise_or_assignment.html" title="can_call_bitwise_or_assignment">
+      can_call_bitwise_or_assignment</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">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="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_bitwise_or_assignment</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">lhs</span></code>
+        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><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="identifier">dont_care</span></code> or the result of expression
+        <code class="computeroutput"><span class="identifier">lhs</span><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="identifier">dont_care</span></code>)
+        is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">|=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        is different from the default <code class="computeroutput"><span class="identifier">dont_care</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 can_call_bitwise_or_assignment&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_bitwise_or_assignment</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">can_call</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">can_call_bitwise_or_assignment</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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">can_call_bitwise_or_assignment</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_bitwise_or_assignment</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_bitwise_or_assignment</span><span class="special">&lt;</span><span class="keyword">long</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">can_call_bitwise_or_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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">can_call_bitwise_or_assignment</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">&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">can_call_bitwise_or_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&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">can_call_bitwise_or_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
+          <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">|=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">|=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">can_call_bitwise_or_assignment</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">can_call_bitwise_or_assignment</span></code>
+        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">|=</span></code> or not. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">|=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_bitwise_or_assignment</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator|=(const A&amp;) is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">|=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_bitwise_or_assignment</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_bitwise_or_assignment</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="can_call_bitwise_or.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="can_call_bitwise_xor.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_bitwise_xor.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_bitwise_xor.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,135 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_bitwise_xor</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="can_call_bitwise_or_assignment.html" title="can_call_bitwise_or_assignment">
+<link rel="next" href="can_call_bitwise_xor_assignment.html" title="can_call_bitwise_xor_assignment">
+</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="can_call_bitwise_or_assignment.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="can_call_bitwise_xor_assignment.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.can_call_bitwise_xor"></a><a class="link" href="can_call_bitwise_xor.html" title="can_call_bitwise_xor"> can_call_bitwise_xor</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">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="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_bitwise_xor</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">lhs</span></code>
+        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><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="identifier">dont_care</span></code> or the result of expression
+        <code class="computeroutput"><span class="identifier">lhs</span><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="identifier">dont_care</span></code>)
+        is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">^</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        is different from the default <code class="computeroutput"><span class="identifier">dont_care</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 can_call_bitwise_xor&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_bitwise_xor</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">can_call</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">can_call_bitwise_xor</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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">can_call_bitwise_xor</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_bitwise_xor</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_bitwise_xor</span><span class="special">&lt;</span><span class="keyword">long</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">can_call_bitwise_xor</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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">can_call_bitwise_xor</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">&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">can_call_bitwise_xor</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&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">can_call_bitwise_xor</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">^</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">^</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">can_call_bitwise_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">can_call_bitwise_xor</span></code>
+        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">^</span></code> or not. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">^(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_bitwise_xor</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator^(const A&amp;) is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">^(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_bitwise_xor</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_bitwise_xor</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="can_call_bitwise_or_assignment.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="can_call_bitwise_xor_assignment.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_bitwise_xor_assignment.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_bitwise_xor_assignment.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,140 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_bitwise_xor_assignment</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="can_call_bitwise_xor.html" title="can_call_bitwise_xor">
+<link rel="next" href="can_call_complement.html" title="can_call_complement">
+</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="can_call_bitwise_xor.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="can_call_complement.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.can_call_bitwise_xor_assignment"></a><a class="link" href="can_call_bitwise_xor_assignment.html" title="can_call_bitwise_xor_assignment">
+      can_call_bitwise_xor_assignment</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">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="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_bitwise_xor_assignment</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">lhs</span></code>
+        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><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="identifier">dont_care</span></code> or the result of expression
+        <code class="computeroutput"><span class="identifier">lhs</span><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="identifier">dont_care</span></code>)
+        is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">^=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        is different from the default <code class="computeroutput"><span class="identifier">dont_care</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 can_call_bitwise_xor_assignment&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_bitwise_xor_assignment</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">can_call</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">can_call_bitwise_xor_assignment</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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">can_call_bitwise_xor_assignment</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_bitwise_xor_assignment</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_bitwise_xor_assignment</span><span class="special">&lt;</span><span class="keyword">long</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">can_call_bitwise_xor_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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">can_call_bitwise_xor_assignment</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">&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">can_call_bitwise_xor_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&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">can_call_bitwise_xor_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
+          <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">^=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">^=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">can_call_bitwise_xor_assignment</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">can_call_bitwise_xor_assignment</span></code>
+        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">^=</span></code> or not. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">^=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_bitwise_xor_assignment</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator^=(const A&amp;) is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">^=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_bitwise_xor_assignment</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_bitwise_xor_assignment</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="can_call_bitwise_xor.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="can_call_complement.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_complement.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_complement.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,144 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_complement</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="can_call_bitwise_xor_assignment.html" title="can_call_bitwise_xor_assignment">
+<link rel="next" href="can_call_dereference.html" title="can_call_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="can_call_bitwise_xor_assignment.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="can_call_dereference.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.can_call_complement"></a><a class="link" href="can_call_complement.html" title="can_call_complement"> can_call_complement</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="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_complement</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="identifier">dont_care</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="identifier">dont_care</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="identifier">dont_care</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 can_call_complement&lt;RHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_complement</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">can_call</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">can_call_complement</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">can_call_complement</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</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code>
+          integral constant expression.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_complement</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_complement</span><span class="special">&lt;</span><span class="keyword">long</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">can_call_complement</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</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">can_call_complement</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</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">can_call_complement</span><span class="special">&lt;</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">can_call_complement</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">can_call_complement</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</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">can_call_complement</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</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">can_call_complement</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">~</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">~</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">can_call_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
+        reason <code class="computeroutput"><span class="identifier">can_call_complement</span></code>
+        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">~</span></code> or not. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">~();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_complement</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator~() is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">~(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_complement</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_complement</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="can_call_bitwise_xor_assignment.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="can_call_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/can_call_dereference.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_dereference.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,153 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_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="can_call_complement.html" title="can_call_complement">
+<link rel="next" href="can_call_division.html" title="can_call_division">
+</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="can_call_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="can_call_division.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.can_call_dereference"></a><a class="link" href="can_call_dereference.html" title="can_call_dereference"> can_call_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="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_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="identifier">dont_care</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="identifier">dont_care</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="identifier">dont_care</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 can_call_dereference&lt;RHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_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">can_call</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">can_call_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">can_call_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</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code>
+          integral constant expression.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_dereference</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_dereference</span><span class="special">&lt;</span><span class="keyword">long</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">can_call_dereference</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*,</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">can_call_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">can_call_dereference</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</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">can_call_dereference</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">*</span> <span class="keyword">const</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">can_call_dereference</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span> <span class="special">*</span> <span class="keyword">const</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">can_call_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">can_call_dereference</span><span class="special">&lt;</span><span class="keyword">double</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">can_call_dereference</span><span class="special">&lt;</span><span class="keyword">void</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">can_call_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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">can_call_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">can_call_dereference</span></code>
+        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> or not. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">*();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_dereference</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator*() is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">*(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_dereference</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_dereference</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="can_call_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="can_call_division.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_division.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_division.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,141 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_division</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="can_call_dereference.html" title="can_call_dereference">
+<link rel="next" href="can_call_division_assignment.html" title="can_call_division_assignment">
+</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="can_call_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="can_call_division_assignment.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.can_call_division"></a><a class="link" href="can_call_division.html" title="can_call_division"> can_call_division</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">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="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_division</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">lhs</span></code>
+        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><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="identifier">dont_care</span></code> or the result of expression
+        <code class="computeroutput"><span class="identifier">lhs</span><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="identifier">dont_care</span></code>)
+        is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">/</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        is different from the default <code class="computeroutput"><span class="identifier">dont_care</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 can_call_division&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_division</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">can_call</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">can_call_division</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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">can_call_division</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_division</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_division</span><span class="special">&lt;</span><span class="keyword">long</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">can_call_division</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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">can_call_division</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">&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">can_call_division</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</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">can_call_division</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</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">can_call_division</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">&gt;::</span><span class="identifier">value</span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_division</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">/</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">/</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">can_call_division</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">can_call_division</span></code>
+        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">/</span></code> or not. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">/(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_division</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator/(const A&amp;) is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">/(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_division</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_division</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="can_call_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="can_call_division_assignment.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_division_assignment.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_division_assignment.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,149 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_division_assignment</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="can_call_division.html" title="can_call_division">
+<link rel="next" href="can_call_equal.html" title="can_call_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="can_call_division.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="can_call_equal.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.reference.can_call_division_assignment"></a><a class="link" href="can_call_division_assignment.html" title="can_call_division_assignment">
+      can_call_division_assignment</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">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="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_division_assignment</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">lhs</span></code>
+        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><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="identifier">dont_care</span></code> or the result of expression
+        <code class="computeroutput"><span class="identifier">lhs</span><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="identifier">dont_care</span></code>)
+        is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">/=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        is different from the default <code class="computeroutput"><span class="identifier">dont_care</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 can_call_division_assignment&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_division_assignment</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">can_call</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">can_call_division_assignment</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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">can_call_division_assignment</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_division_assignment</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_division_assignment</span><span class="special">&lt;</span><span class="keyword">long</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">can_call_division_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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">can_call_division_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
+          <span class="keyword">long</span><span class="special">&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">can_call_division_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</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">can_call_division_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</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">can_call_division_assignment</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">&gt;::</span><span class="identifier">value</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">can_call_division_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
+          <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">/=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">/=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">can_call_division_assignment</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">can_call_division_assignment</span></code>
+        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">/=</span></code> or not. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">/=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_division_assignment</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator/=(const A&amp;) is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">/=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_division_assignment</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_division_assignment</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="can_call_division.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="can_call_equal.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_equal.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_equal.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,140 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_equal</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="can_call_division_assignment.html" title="can_call_division_assignment">
+<link rel="next" href="can_call_greater.html" title="can_call_greater">
+</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="can_call_division_assignment.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="can_call_greater.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.can_call_equal"></a><a class="link" href="can_call_equal.html" title="can_call_equal"> can_call_equal</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">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="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_equal</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">lhs</span></code>
+        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><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="identifier">dont_care</span></code> or the result of expression
+        <code class="computeroutput"><span class="identifier">lhs</span><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="identifier">dont_care</span></code>)
+        is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        is different from the default <code class="computeroutput"><span class="identifier">dont_care</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 can_call_equal&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_equal</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">can_call</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">can_call_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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">can_call_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_equal</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_equal</span><span class="special">&lt;</span><span class="keyword">long</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">can_call_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">bool</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">can_call_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&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">can_call_equal</span><span class="special">&lt;</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">can_call_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*,</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">can_call_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">double</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">can_call_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">can_call_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">can_call_equal</span></code> cannot
+        be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code> or not. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_equal</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator==(const A&amp;) is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_equal</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_equal</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="can_call_division_assignment.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="can_call_greater.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_greater.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_greater.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,140 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_greater</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="can_call_equal.html" title="can_call_equal">
+<link rel="next" href="can_call_greater_equal.html" title="can_call_greater_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="can_call_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="can_call_greater_equal.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.reference.can_call_greater"></a><a class="link" href="can_call_greater.html" title="can_call_greater"> can_call_greater</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">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="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_greater</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">lhs</span></code>
+        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><span class="special">&gt;</span><span class="identifier">rhs</span></code>,
+        and (ii) <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression
+        <code class="computeroutput"><span class="identifier">lhs</span><span class="special">&gt;</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="identifier">dont_care</span></code>)
+        is 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="identifier">dont_care</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 can_call_greater&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_greater</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">can_call</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">can_call_greater</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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">can_call_greater</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_greater</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_greater</span><span class="special">&lt;</span><span class="keyword">long</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">can_call_greater</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">bool</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">can_call_greater</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&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">can_call_greater</span><span class="special">&lt;</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">can_call_greater</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*,</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">can_call_greater</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">double</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">can_call_greater</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot 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">can_call_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">can_call_greater</span></code> cannot
+        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>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&gt;(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_greater</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator&gt;(const A&amp;) is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&gt;(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_greater</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_greater</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="can_call_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="can_call_greater_equal.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_greater_equal.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_greater_equal.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,147 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_greater_equal</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="can_call_greater.html" title="can_call_greater">
+<link rel="next" href="can_call_left_shift.html" title="can_call_left_shift">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="can_call_greater.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="can_call_left_shift.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.reference.can_call_greater_equal"></a><a class="link" href="can_call_greater_equal.html" title="can_call_greater_equal"> can_call_greater_equal</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">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="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_greater_equal</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">lhs</span></code>
+        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><span class="special">&gt;=</span><span class="identifier">rhs</span></code>,
+        and (ii) <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression
+        <code class="computeroutput"><span class="identifier">lhs</span><span class="special">&gt;=</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="identifier">dont_care</span></code>)
+        is 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="identifier">dont_care</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 can_call_greater_equal&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_greater_equal</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">can_call</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">can_call_greater_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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">can_call_greater_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_greater_equal</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_greater_equal</span><span class="special">&lt;</span><span class="keyword">long</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">can_call_greater_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
+          <span class="keyword">bool</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">can_call_greater_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&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">can_call_greater_equal</span><span class="special">&lt;</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">can_call_greater_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*,</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">can_call_greater_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">double</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">can_call_greater_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
+          <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot 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">can_call_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">can_call_greater_equal</span></code>
+        cannot 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>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&gt;=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_greater_equal</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator&gt;=(const A&amp;) is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&gt;=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_greater_equal</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_greater_equal</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="can_call_greater.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="can_call_left_shift.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_left_shift.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_left_shift.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,149 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_left_shift</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="can_call_greater_equal.html" title="can_call_greater_equal">
+<link rel="next" href="can_call_left_shift_assignment.html" title="can_call_left_shift_assignment">
+</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="can_call_greater_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="can_call_left_shift_assignment.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.can_call_left_shift"></a><a class="link" href="can_call_left_shift.html" title="can_call_left_shift"> can_call_left_shift</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">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="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_left_shift</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">lhs</span></code>
+        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><span class="special">&lt;&lt;</span><span class="identifier">rhs</span></code>,
+        and (ii) <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression
+        <code class="computeroutput"><span class="identifier">lhs</span><span class="special">&lt;&lt;</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="identifier">dont_care</span></code>)
+        is 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="identifier">dont_care</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 can_call_left_shift&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_left_shift</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">can_call</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">can_call_left_shift</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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">can_call_left_shift</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_left_shift</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_left_shift</span><span class="special">&lt;</span><span class="keyword">long</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">can_call_left_shift</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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">can_call_left_shift</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">&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">can_call_left_shift</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&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">can_call_left_shift</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">,</span> <span class="keyword">char</span><span class="special">*,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">&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">can_call_left_shift</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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">can_call_left_shift</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&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">can_call_left_shift</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot 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">can_call_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">can_call_left_shift</span></code>
+        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></code> or not. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&lt;&lt;(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_left_shift</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator&lt;&lt;(const A&amp;) is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&lt;&lt;(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_left_shift</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_left_shift</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="can_call_greater_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="can_call_left_shift_assignment.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_left_shift_assignment.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_left_shift_assignment.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,142 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_left_shift_assignment</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="can_call_left_shift.html" title="can_call_left_shift">
+<link rel="next" href="can_call_less.html" title="can_call_less">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="can_call_left_shift.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="can_call_less.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.can_call_left_shift_assignment"></a><a class="link" href="can_call_left_shift_assignment.html" title="can_call_left_shift_assignment">
+      can_call_left_shift_assignment</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">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="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_left_shift_assignment</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">lhs</span></code>
+        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><span class="special">&lt;&lt;=</span><span class="identifier">rhs</span></code>,
+        and (ii) <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression
+        <code class="computeroutput"><span class="identifier">lhs</span><span class="special">&lt;&lt;=</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="identifier">dont_care</span></code>)
+        is 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="identifier">dont_care</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 can_call_left_shift_assignment&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_left_shift_assignment</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">can_call</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">can_call_left_shift_assignment</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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">can_call_left_shift_assignment</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_left_shift_assignment</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_left_shift_assignment</span><span class="special">&lt;</span><span class="keyword">long</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">can_call_left_shift_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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">can_call_left_shift_assignment</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">&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">can_call_left_shift_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&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">can_call_left_shift_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
+          <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot 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">can_call_left_shift_assignment</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">can_call_left_shift_assignment</span></code>
+        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;=</span></code> or not. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&lt;&lt;=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_left_shift_assignment</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator&lt;&lt;=(const A&amp;) is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&lt;&lt;=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_left_shift_assignment</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_left_shift_assignment</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="can_call_left_shift.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="can_call_less.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_less.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_less.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,140 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_less</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="can_call_left_shift_assignment.html" title="can_call_left_shift_assignment">
+<link rel="next" href="can_call_less_equal.html" title="can_call_less_equal">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="can_call_left_shift_assignment.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="can_call_less_equal.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.reference.can_call_less"></a><a class="link" href="can_call_less.html" title="can_call_less"> can_call_less</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">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="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_less</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">lhs</span></code>
+        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><span class="special">&lt;</span><span class="identifier">rhs</span></code>,
+        and (ii) <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression
+        <code class="computeroutput"><span class="identifier">lhs</span><span class="special">&lt;</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="identifier">dont_care</span></code>)
+        is 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="identifier">dont_care</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 can_call_less&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_less</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">can_call</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">can_call_less</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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">can_call_less</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_less</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_less</span><span class="special">&lt;</span><span class="keyword">long</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">can_call_less</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">bool</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">can_call_less</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&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">can_call_less</span><span class="special">&lt;</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">can_call_less</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*,</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">can_call_less</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">double</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">can_call_less</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot 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">can_call_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">can_call_less</span></code> cannot
+        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>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&lt;(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_less</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator&lt;(const A&amp;) is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&lt;(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_less</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_less</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="can_call_left_shift_assignment.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="can_call_less_equal.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_less_equal.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_less_equal.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,140 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_less_equal</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="can_call_less.html" title="can_call_less">
+<link rel="next" href="can_call_modulus.html" title="can_call_modulus">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="can_call_less.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="can_call_modulus.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.reference.can_call_less_equal"></a><a class="link" href="can_call_less_equal.html" title="can_call_less_equal"> can_call_less_equal</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">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="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_less_equal</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">lhs</span></code>
+        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><span class="special">&lt;=</span><span class="identifier">rhs</span></code>,
+        and (ii) <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression
+        <code class="computeroutput"><span class="identifier">lhs</span><span class="special">&lt;=</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="identifier">dont_care</span></code>)
+        is 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="identifier">dont_care</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 can_call_less_equal&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_less_equal</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">can_call</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">can_call_less_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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">can_call_less_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_less_equal</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_less_equal</span><span class="special">&lt;</span><span class="keyword">long</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">can_call_less_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">bool</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">can_call_less_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&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">can_call_less_equal</span><span class="special">&lt;</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">can_call_less_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*,</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">can_call_less_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">double</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">can_call_less_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot 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">can_call_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">can_call_less_equal</span></code>
+        cannot 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>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&lt;=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_less_equal</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator&lt;=(const A&amp;) is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&lt;=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_less_equal</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_less_equal</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="can_call_less.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="can_call_modulus.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_modulus.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_modulus.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,134 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_modulus</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="can_call_less_equal.html" title="can_call_less_equal">
+<link rel="next" href="can_call_modulus_assignment.html" title="can_call_modulus_assignment">
+</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="can_call_less_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="can_call_modulus_assignment.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.can_call_modulus"></a><a class="link" href="can_call_modulus.html" title="can_call_modulus"> can_call_modulus</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">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="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_modulus</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">lhs</span></code>
+        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><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="identifier">dont_care</span></code> or the result of expression
+        <code class="computeroutput"><span class="identifier">lhs</span><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="identifier">dont_care</span></code>)
+        is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">%</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        is different from the default <code class="computeroutput"><span class="identifier">dont_care</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 can_call_modulus&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_modulus</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">can_call</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">can_call_modulus</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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">can_call_modulus</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_modulus</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_modulus</span><span class="special">&lt;</span><span class="keyword">long</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">can_call_modulus</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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">can_call_modulus</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">&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">can_call_modulus</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">&gt;::</span><span class="identifier">value</span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_modulus</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">%</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">%</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">can_call_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">can_call_modulus</span></code> cannot
+        be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">%</span></code> or not. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">%(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_modulus</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator%(const A&amp;) is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">%(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_modulus</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_modulus</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="can_call_less_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="can_call_modulus_assignment.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_modulus_assignment.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_modulus_assignment.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,140 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_modulus_assignment</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="can_call_modulus.html" title="can_call_modulus">
+<link rel="next" href="can_call_multiplication.html" title="can_call_multiplication">
+</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="can_call_modulus.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="can_call_multiplication.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.can_call_modulus_assignment"></a><a class="link" href="can_call_modulus_assignment.html" title="can_call_modulus_assignment">
+      can_call_modulus_assignment</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">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="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_modulus_assignment</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">lhs</span></code>
+        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><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="identifier">dont_care</span></code> or the result of expression
+        <code class="computeroutput"><span class="identifier">lhs</span><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="identifier">dont_care</span></code>)
+        is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">%=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        is different from the default <code class="computeroutput"><span class="identifier">dont_care</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 can_call_modulus_assignment&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_modulus_assignment</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">can_call</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">can_call_modulus_assignment</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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">can_call_modulus_assignment</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_modulus_assignment</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_modulus_assignment</span><span class="special">&lt;</span><span class="keyword">long</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">can_call_modulus_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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">can_call_modulus_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
+          <span class="keyword">long</span><span class="special">&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">can_call_modulus_assignment</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">&gt;::</span><span class="identifier">value</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">can_call_modulus_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">%=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">%=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">can_call_modulus_assignment</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">can_call_modulus_assignment</span></code>
+        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">%=</span></code> or not. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">%=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_modulus_assignment</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator%=(const A&amp;) is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">%=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_modulus_assignment</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_modulus_assignment</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="can_call_modulus.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="can_call_multiplication.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_multiplication.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_multiplication.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,149 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_multiplication</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="can_call_modulus_assignment.html" title="can_call_modulus_assignment">
+<link rel="next" href="can_call_multiplication_assignment.html" title="can_call_multiplication_assignment">
+</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="can_call_modulus_assignment.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="can_call_multiplication_assignment.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.can_call_multiplication"></a><a class="link" href="can_call_multiplication.html" title="can_call_multiplication">
+      can_call_multiplication</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">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="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_multiplication</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">lhs</span></code>
+        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><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="identifier">dont_care</span></code> or the result of expression
+        <code class="computeroutput"><span class="identifier">lhs</span><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="identifier">dont_care</span></code>)
+        is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        is different from the default <code class="computeroutput"><span class="identifier">dont_care</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 can_call_multiplication&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_multiplication</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">can_call</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">can_call_multiplication</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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">can_call_multiplication</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_multiplication</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_multiplication</span><span class="special">&lt;</span><span class="keyword">long</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">can_call_multiplication</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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">can_call_multiplication</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
+          <span class="keyword">long</span><span class="special">&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">can_call_multiplication</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</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">can_call_multiplication</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</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">can_call_multiplication</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">&gt;::</span><span class="identifier">value</span></code>
+          inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_multiplication</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
+          <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">can_call_multiplication</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">can_call_multiplication</span></code>
+        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> or not. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">*(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_multiplication</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator*(const A&amp;) is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">*(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_multiplication</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_multiplication</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="can_call_modulus_assignment.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="can_call_multiplication_assignment.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_multiplication_assignment.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_multiplication_assignment.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,149 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_multiplication_assignment</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="can_call_multiplication.html" title="can_call_multiplication">
+<link rel="next" href="can_call_not.html" title="can_call_not">
+</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="can_call_multiplication.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="can_call_not.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.can_call_multiplication_assignment"></a><a class="link" href="can_call_multiplication_assignment.html" title="can_call_multiplication_assignment">
+      can_call_multiplication_assignment</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">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="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_multiplication_assignment</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">lhs</span></code>
+        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><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="identifier">dont_care</span></code> or the result of expression
+        <code class="computeroutput"><span class="identifier">lhs</span><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="identifier">dont_care</span></code>)
+        is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">*=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        is different from the default <code class="computeroutput"><span class="identifier">dont_care</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 can_call_multiplication_assignment&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_multiplication_assignment</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">can_call</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">can_call_multiplication_assignment</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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">can_call_multiplication_assignment</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_multiplication_assignment</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_multiplication_assignment</span><span class="special">&lt;</span><span class="keyword">long</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">can_call_multiplication_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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">can_call_multiplication_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
+          <span class="keyword">long</span><span class="special">&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">can_call_multiplication_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</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">can_call_multiplication_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</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">can_call_multiplication_assignment</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">&gt;::</span><span class="identifier">value</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">can_call_multiplication_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
+          <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">*=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">*=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">can_call_multiplication_assignment</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">can_call_multiplication_assignment</span></code>
+        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">*=</span></code> or not. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">*=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_multiplication_assignment</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator*=(const A&amp;) is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">*=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_multiplication_assignment</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_multiplication_assignment</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="can_call_multiplication.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="can_call_not.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_not.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_not.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,140 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_not</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="can_call_multiplication_assignment.html" title="can_call_multiplication_assignment">
+<link rel="next" href="can_call_not_equal.html" title="can_call_not_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="can_call_multiplication_assignment.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="can_call_not_equal.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.reference.can_call_not"></a><a class="link" href="can_call_not.html" title="can_call_not"> can_call_not</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="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_not</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="identifier">dont_care</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="identifier">dont_care</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="identifier">dont_care</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 can_call_not&lt;RHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_not</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">can_call</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">can_call_not</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">can_call_not</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</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code>
+          integral constant expression.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_not</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_not</span><span class="special">&lt;</span><span class="keyword">bool</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">can_call_not</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">bool</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">can_call_not</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</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">can_call_not</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</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">can_call_not</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</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">can_call_not</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="keyword">bool</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">can_call_not</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">!</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">!</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">can_call_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">can_call_not</span></code> cannot
+        be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">!</span></code> or not. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">!();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_not</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator!() is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">!(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_not</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_not</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="can_call_multiplication_assignment.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="can_call_not_equal.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_not_equal.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_not_equal.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,140 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_not_equal</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="can_call_not.html" title="can_call_not">
+<link rel="next" href="can_call_or.html" title="can_call_or">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="can_call_not.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="can_call_or.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.reference.can_call_not_equal"></a><a class="link" href="can_call_not_equal.html" title="can_call_not_equal"> can_call_not_equal</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">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="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_not_equal</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">lhs</span></code>
+        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><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="identifier">dont_care</span></code> or the result of expression
+        <code class="computeroutput"><span class="identifier">lhs</span><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="identifier">dont_care</span></code>)
+        is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">!=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        is different from the default <code class="computeroutput"><span class="identifier">dont_care</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 can_call_not_equal&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_not_equal</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">can_call</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">can_call_not_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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">can_call_not_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_not_equal</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_not_equal</span><span class="special">&lt;</span><span class="keyword">long</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">can_call_not_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">bool</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">can_call_not_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&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">can_call_not_equal</span><span class="special">&lt;</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">can_call_not_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*,</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">can_call_not_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">double</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">can_call_not_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">!=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">!=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">can_call_not_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">can_call_not_equal</span></code>
+        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">!=</span></code> or not. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_not_equal</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator!=(const A&amp;) is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_not_equal</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_not_equal</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="can_call_not.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="can_call_or.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_or.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_or.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,138 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_or</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="can_call_not_equal.html" title="can_call_not_equal">
+<link rel="next" href="can_call_post_decrement.html" title="can_call_post_decrement">
+</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="can_call_not_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="can_call_post_decrement.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.can_call_or"></a><a class="link" href="can_call_or.html" title="can_call_or"> can_call_or</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">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="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_or</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">lhs</span></code>
+        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><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="identifier">dont_care</span></code> or the result of expression
+        <code class="computeroutput"><span class="identifier">lhs</span><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="identifier">dont_care</span></code>)
+        is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">||</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        is different from the default <code class="computeroutput"><span class="identifier">dont_care</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 can_call_or&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_or</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">can_call</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">can_call_or</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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">can_call_or</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_or</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_or</span><span class="special">&lt;</span><span class="keyword">bool</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">can_call_or</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">bool</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">can_call_or</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">&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">can_call_or</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&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">can_call_or</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">&gt;::</span><span class="identifier">value</span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_or</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">||</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">||</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">can_call_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">can_call_or</span></code> cannot
+        be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">||</span></code> or not. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">||(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_or</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator||(const A&amp;) is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">||(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_or</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_or</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="can_call_not_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="can_call_post_decrement.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_post_decrement.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_post_decrement.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,151 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_post_decrement</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="can_call_or.html" title="can_call_or">
+<link rel="next" href="can_call_post_increment.html" title="can_call_post_increment">
+</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="can_call_or.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="can_call_post_increment.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.can_call_post_decrement"></a><a class="link" href="can_call_post_decrement.html" title="can_call_post_decrement">
+      can_call_post_decrement</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">LHS</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">RET</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_post_decrement</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">lhs</span></code>
+        of type <code class="computeroutput"><span class="identifier">LHS</span></code> can be used in
+        expression <code class="computeroutput"><span class="identifier">lhs</span><span class="special">--</span></code>,
+        and (ii) <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression
+        <code class="computeroutput"><span class="identifier">lhs</span><span class="special">--</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="identifier">dont_care</span></code>)
+        is to not check for the return value of postfix <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        is different from the default <code class="computeroutput"><span class="identifier">dont_care</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 can_call_post_decrement&lt;LHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_post_decrement</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">can_call</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">can_call_post_decrement</span><span class="special">&lt;</span><span class="identifier">LHS</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">can_call_post_decrement</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RET</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.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_post_decrement</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_post_decrement</span><span class="special">&lt;</span><span class="keyword">long</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">can_call_post_decrement</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</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">can_call_post_decrement</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</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">can_call_post_decrement</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</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">can_call_post_decrement</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</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">can_call_post_decrement</span><span class="special">&lt;</span><span class="keyword">bool</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">can_call_post_decrement</span><span class="special">&lt;</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">false_type</a></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_post_decrement</span><span class="special">&lt;</span><span class="keyword">void</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">can_call_post_decrement</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot detect whether postfix <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">can_call_post_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
+        reason <code class="computeroutput"><span class="identifier">can_call_post_decrement</span></code>
+        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code> or not. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">--(</span><span class="keyword">int</span><span class="special">);</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_post_decrement</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator--(int) is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">--(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">int</span><span class="special">);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_post_decrement</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_post_decrement</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="can_call_or.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="can_call_post_increment.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_post_increment.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_post_increment.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,151 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_post_increment</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="can_call_post_decrement.html" title="can_call_post_decrement">
+<link rel="next" href="can_call_pre_decrement.html" title="can_call_pre_decrement">
+</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="can_call_post_decrement.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="can_call_pre_decrement.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.can_call_post_increment"></a><a class="link" href="can_call_post_increment.html" title="can_call_post_increment">
+      can_call_post_increment</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">LHS</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">RET</span><span class="special">=</span><span class="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_post_increment</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">lhs</span></code>
+        of type <code class="computeroutput"><span class="identifier">LHS</span></code> can be used in
+        expression <code class="computeroutput"><span class="identifier">lhs</span><span class="special">++</span></code>,
+        and (ii) <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression
+        <code class="computeroutput"><span class="identifier">lhs</span><span class="special">++</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="identifier">dont_care</span></code>)
+        is to not check for the return value of postfix <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        is different from the default <code class="computeroutput"><span class="identifier">dont_care</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 can_call_post_increment&lt;LHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_post_increment</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">can_call</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">can_call_post_increment</span><span class="special">&lt;</span><span class="identifier">LHS</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">can_call_post_increment</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RET</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.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_post_increment</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_post_increment</span><span class="special">&lt;</span><span class="keyword">long</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">can_call_post_increment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</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">can_call_post_increment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</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">can_call_post_increment</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</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">can_call_post_increment</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</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">can_call_post_increment</span><span class="special">&lt;</span><span class="keyword">bool</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">can_call_post_increment</span><span class="special">&lt;</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">false_type</a></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_post_increment</span><span class="special">&lt;</span><span class="keyword">void</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">can_call_post_increment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot detect whether postfix <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">can_call_post_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
+        reason <code class="computeroutput"><span class="identifier">can_call_post_increment</span></code>
+        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code> or not. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">++(</span><span class="keyword">int</span><span class="special">);</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_post_increment</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator++(int) is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">++(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">int</span><span class="special">);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_post_increment</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_post_increment</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="can_call_post_decrement.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="can_call_pre_decrement.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_pre_decrement.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_pre_decrement.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,150 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_pre_decrement</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="can_call_post_increment.html" title="can_call_post_increment">
+<link rel="next" href="can_call_pre_increment.html" title="can_call_pre_increment">
+</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="can_call_post_increment.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="can_call_pre_increment.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.can_call_pre_decrement"></a><a class="link" href="can_call_pre_decrement.html" title="can_call_pre_decrement"> can_call_pre_decrement</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="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_pre_decrement</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="identifier">dont_care</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="identifier">dont_care</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="identifier">dont_care</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 can_call_pre_decrement&lt;RHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_pre_decrement</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">can_call</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">can_call_pre_decrement</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">can_call_pre_decrement</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</span></code>
+          is a <code class="computeroutput"><span class="keyword">bool</span></code> integral constant
+          expression.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_pre_decrement</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_pre_decrement</span><span class="special">&lt;</span><span class="keyword">long</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">can_call_pre_decrement</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</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">can_call_pre_decrement</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</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">can_call_pre_decrement</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</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">can_call_pre_decrement</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</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">can_call_pre_decrement</span><span class="special">&lt;</span><span class="keyword">bool</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">can_call_pre_decrement</span><span class="special">&lt;</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">false_type</a></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_pre_decrement</span><span class="special">&lt;</span><span class="keyword">void</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">can_call_pre_decrement</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">can_call_pre_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
+        reason <code class="computeroutput"><span class="identifier">can_call_pre_decrement</span></code>
+        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code> or not. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">--();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_pre_decrement</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator--() is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">--(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_pre_decrement</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_pre_decrement</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="can_call_post_increment.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="can_call_pre_increment.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_pre_increment.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_pre_increment.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,150 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_pre_increment</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="can_call_pre_decrement.html" title="can_call_pre_decrement">
+<link rel="next" href="can_call_right_shift.html" title="can_call_right_shift">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="can_call_pre_decrement.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="can_call_right_shift.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.reference.can_call_pre_increment"></a><a class="link" href="can_call_pre_increment.html" title="can_call_pre_increment"> can_call_pre_increment</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="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_pre_increment</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="identifier">dont_care</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="identifier">dont_care</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="identifier">dont_care</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 can_call_pre_increment&lt;RHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_pre_increment</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">can_call</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">can_call_pre_increment</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">can_call_pre_increment</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</span></code>
+          is a <code class="computeroutput"><span class="keyword">bool</span></code> integral constant
+          expression.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_pre_increment</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_pre_increment</span><span class="special">&lt;</span><span class="keyword">long</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">can_call_pre_increment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</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">can_call_pre_increment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</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">can_call_pre_increment</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</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">can_call_pre_increment</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</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">can_call_pre_increment</span><span class="special">&lt;</span><span class="keyword">bool</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">can_call_pre_increment</span><span class="special">&lt;</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">false_type</a></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_pre_increment</span><span class="special">&lt;</span><span class="keyword">void</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">can_call_pre_increment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">can_call_pre_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
+        reason <code class="computeroutput"><span class="identifier">can_call_pre_increment</span></code>
+        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code> or not. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">++();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_pre_increment</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator++() is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">++(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_pre_increment</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_pre_increment</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="can_call_pre_decrement.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="can_call_right_shift.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_right_shift.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_right_shift.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,149 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_right_shift</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
+<link rel="up" href="../reference.html" title="Alphabetical Reference">
+<link rel="prev" href="can_call_pre_increment.html" title="can_call_pre_increment">
+<link rel="next" href="can_call_right_shift_assignment.html" title="can_call_right_shift_assignment">
+</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="can_call_pre_increment.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="can_call_right_shift_assignment.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.can_call_right_shift"></a><a class="link" href="can_call_right_shift.html" title="can_call_right_shift"> can_call_right_shift</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">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="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_right_shift</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">lhs</span></code>
+        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><span class="special">&gt;&gt;</span><span class="identifier">rhs</span></code>,
+        and (ii) <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression
+        <code class="computeroutput"><span class="identifier">lhs</span><span class="special">&gt;&gt;</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="identifier">dont_care</span></code>)
+        is 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="identifier">dont_care</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 can_call_right_shift&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_right_shift</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">can_call</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">can_call_right_shift</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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">can_call_right_shift</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_right_shift</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_right_shift</span><span class="special">&lt;</span><span class="keyword">long</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">can_call_right_shift</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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">can_call_right_shift</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">&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">can_call_right_shift</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">istream</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&amp;&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">can_call_right_shift</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">istream</span><span class="special">,</span> <span class="keyword">char</span><span class="special">*,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">&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">can_call_right_shift</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">istream</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&amp;&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">can_call_right_shift</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&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">can_call_right_shift</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot 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">can_call_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">can_call_right_shift</span></code>
+        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;&gt;</span></code> or not. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&gt;&gt;(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_right_shift</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator&gt;&gt;(const A&amp;) is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&gt;&gt;(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_right_shift</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_right_shift</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="can_call_pre_increment.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="can_call_right_shift_assignment.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_right_shift_assignment.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_right_shift_assignment.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,142 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_right_shift_assignment</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="can_call_right_shift.html" title="can_call_right_shift">
+<link rel="next" href="can_call_subtraction.html" title="can_call_subtraction">
+</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="can_call_right_shift.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="can_call_subtraction.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.can_call_right_shift_assignment"></a><a class="link" href="can_call_right_shift_assignment.html" title="can_call_right_shift_assignment">
+      can_call_right_shift_assignment</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">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="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_right_shift_assignment</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">lhs</span></code>
+        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><span class="special">&gt;&gt;=</span><span class="identifier">rhs</span></code>,
+        and (ii) <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="identifier">dont_care</span></code> or the result of expression
+        <code class="computeroutput"><span class="identifier">lhs</span><span class="special">&gt;&gt;=</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="identifier">dont_care</span></code>)
+        is 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="identifier">dont_care</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 can_call_right_shift_assignment&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_right_shift_assignment</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">can_call</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">can_call_right_shift_assignment</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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">can_call_right_shift_assignment</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_right_shift_assignment</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_right_shift_assignment</span><span class="special">&lt;</span><span class="keyword">long</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">can_call_right_shift_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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">can_call_right_shift_assignment</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">&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">can_call_right_shift_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&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">can_call_right_shift_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
+          <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot 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">can_call_right_shift_assignment</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">can_call_right_shift_assignment</span></code>
+        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;&gt;=</span></code> or not. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&gt;&gt;=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_right_shift_assignment</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator&gt;&gt;=(const A&amp;) is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&gt;&gt;=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_right_shift_assignment</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_right_shift_assignment</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="can_call_right_shift.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="can_call_subtraction.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_subtraction.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_subtraction.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,141 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_subtraction</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="can_call_right_shift_assignment.html" title="can_call_right_shift_assignment">
+<link rel="next" href="can_call_subtraction_assignment.html" title="can_call_subtraction_assignment">
+</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="can_call_right_shift_assignment.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="can_call_subtraction_assignment.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.can_call_subtraction"></a><a class="link" href="can_call_subtraction.html" title="can_call_subtraction"> can_call_subtraction</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">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="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_subtraction</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">lhs</span></code>
+        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><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="identifier">dont_care</span></code> or the result of expression
+        <code class="computeroutput"><span class="identifier">lhs</span><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="identifier">dont_care</span></code>)
+        is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        is different from the default <code class="computeroutput"><span class="identifier">dont_care</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 can_call_subtraction&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_subtraction</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">can_call</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">can_call_subtraction</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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">can_call_subtraction</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_subtraction</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_subtraction</span><span class="special">&lt;</span><span class="keyword">long</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">can_call_subtraction</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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">can_call_subtraction</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">&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">can_call_subtraction</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</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">can_call_subtraction</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</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">can_call_subtraction</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">&gt;::</span><span class="identifier">value</span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_subtraction</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">can_call_subtraction</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">can_call_subtraction</span></code>
+        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> or not. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">-(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_subtraction</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator-(const A&amp;) is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">-(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_subtraction</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_subtraction</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="can_call_right_shift_assignment.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="can_call_subtraction_assignment.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_subtraction_assignment.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_subtraction_assignment.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,149 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_subtraction_assignment</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="can_call_subtraction.html" title="can_call_subtraction">
+<link rel="next" href="can_call_unary_minus.html" title="can_call_unary_minus">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="can_call_subtraction.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="can_call_unary_minus.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.reference.can_call_subtraction_assignment"></a><a class="link" href="can_call_subtraction_assignment.html" title="can_call_subtraction_assignment">
+      can_call_subtraction_assignment</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">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="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_subtraction_assignment</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">lhs</span></code>
+        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><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="identifier">dont_care</span></code> or the result of expression
+        <code class="computeroutput"><span class="identifier">lhs</span><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="identifier">dont_care</span></code>)
+        is to not check for the return value of binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">-=</span></code>. If <code class="computeroutput"><span class="identifier">RET</span></code>
+        is different from the default <code class="computeroutput"><span class="identifier">dont_care</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 can_call_subtraction_assignment&lt;LHS, RHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_subtraction_assignment</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">can_call</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">can_call_subtraction_assignment</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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">can_call_subtraction_assignment</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_subtraction_assignment</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_subtraction_assignment</span><span class="special">&lt;</span><span class="keyword">long</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">can_call_subtraction_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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">can_call_subtraction_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
+          <span class="keyword">long</span><span class="special">&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">can_call_subtraction_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</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">can_call_subtraction_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</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">can_call_subtraction_assignment</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">&gt;::</span><span class="identifier">value</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">can_call_subtraction_assignment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
+          <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">-=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">-=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">can_call_subtraction_assignment</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">can_call_subtraction_assignment</span></code>
+        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">-=</span></code> or not. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">-=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_subtraction_assignment</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator-=(const A&amp;) is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">-=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_subtraction_assignment</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_subtraction_assignment</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="can_call_subtraction.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="can_call_unary_minus.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_unary_minus.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_unary_minus.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,140 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_unary_minus</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="can_call_subtraction_assignment.html" title="can_call_subtraction_assignment">
+<link rel="next" href="can_call_unary_plus.html" title="can_call_unary_plus">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="can_call_subtraction_assignment.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="can_call_unary_plus.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.reference.can_call_unary_minus"></a><a class="link" href="can_call_unary_minus.html" title="can_call_unary_minus"> can_call_unary_minus</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="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_unary_minus</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="identifier">dont_care</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="identifier">dont_care</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="identifier">dont_care</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 can_call_unary_minus&lt;RHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_unary_minus</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">can_call</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">can_call_unary_minus</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">can_call_unary_minus</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</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code>
+          integral constant expression.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_unary_minus</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_unary_minus</span><span class="special">&lt;</span><span class="keyword">long</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">can_call_unary_minus</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</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">can_call_unary_minus</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</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">can_call_unary_minus</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</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">can_call_unary_minus</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</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">can_call_unary_minus</span><span class="special">&lt;</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">can_call_unary_minus</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">can_call_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">can_call_unary_minus</span></code>
+        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> or not. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">-();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_unary_minus</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator-() is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">-(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_unary_minus</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_unary_minus</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="can_call_subtraction_assignment.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="can_call_unary_plus.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_unary_plus.html
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/can_call_unary_plus.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,140 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>can_call_unary_plus</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="can_call_unary_minus.html" title="can_call_unary_minus">
+<link rel="next" href="decay.html" title="decay">
+</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="can_call_unary_minus.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="decay.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.can_call_unary_plus"></a><a class="link" href="can_call_unary_plus.html" title="can_call_unary_plus"> can_call_unary_plus</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="identifier">dont_care</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">can_call_unary_plus</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="identifier">dont_care</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="identifier">dont_care</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="identifier">dont_care</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 can_call_unary_plus&lt;RHS, RET&gt;::value==true
+</span></pre>
+<p>
+        If <code class="computeroutput"><span class="identifier">RET</span><span class="special">=</span><span class="keyword">void</span></code>, the return type is checked to be exactly
+        <code class="computeroutput"><span class="keyword">void</span></code>.
+      </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">can_call_unary_plus</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">can_call</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">can_call_unary_plus</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">can_call_unary_plus</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</span></code> is a <code class="computeroutput"><span class="keyword">bool</span></code>
+          integral constant expression.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_unary_plus</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
+        </p></blockquote></div>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          <code class="computeroutput"><span class="identifier">can_call_unary_plus</span><span class="special">&lt;</span><span class="keyword">long</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">can_call_unary_plus</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</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">can_call_unary_plus</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</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">can_call_unary_plus</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</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">can_call_unary_plus</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</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">can_call_unary_plus</span><span class="special">&lt;</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">can_call_unary_plus</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
+<p>
+        <span class="bold"><strong>Known issues:</strong></span>
+      </p>
+<p>
+        This trait cannot detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">can_call_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">can_call_unary_plus</span></code>
+        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> or not. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">+();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_unary_plus</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator+() is private
+</span></pre>
+<p>
+      </p>
+<p>
+        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
+        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
+        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
+        will report an ambiguous overload. 
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">+(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
+<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
+<span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_unary_plus</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
+</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">can_call_unary_plus</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload
+</span></pre>
+<p>
+      </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
+      Frederic 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="can_call_unary_minus.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="decay.html"><img src="../../images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

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-04-19 17:59:57 EDT (Tue, 19 Apr 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="alignment_of.html" title="alignment_of">
+<link rel="prev" href="can_call_unary_plus.html" title="can_call_unary_plus">
 <link rel="next" href="extent.html" title="extent">
 </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="alignment_of.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="extent.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="can_call_unary_plus.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="extent.html"><img src="../../images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
@@ -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="id3429839"></a><p class="title"><b>Table&#160;1.14.&#160;Examples</b></p>
+<a name="id3390147"></a><p class="title"><b>Table&#160;1.13.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>
@@ -128,7 +128,7 @@
 <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,
+      Frederic 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>
@@ -139,7 +139,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="alignment_of.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="extent.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="can_call_unary_plus.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="extent.html"><img src="../../images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/extent.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/extent.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/extent.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -72,7 +72,7 @@
 <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,
+      Frederic 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>

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-04-19 17:59:57 EDT (Tue, 19 Apr 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="id3431448"></a><p class="title"><b>Table&#160;1.15.&#160;Examples</b></p>
+<a name="id3391756"></a><p class="title"><b>Table&#160;1.14.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>
@@ -106,7 +106,7 @@
 <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,
+      Frederic 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>

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-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -52,7 +52,7 @@
         </p></td></tr>
 </table></div>
 <div class="table">
-<a name="id3431893"></a><p class="title"><b>Table&#160;1.16.&#160;Function Traits Members</b></p>
+<a name="id3392201"></a><p class="title"><b>Table&#160;1.15.&#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="id3432150"></a><p class="title"><b>Table&#160;1.17.&#160;Examples</b></p>
+<a name="id3392459"></a><p class="title"><b>Table&#160;1.16.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>
@@ -261,7 +261,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_no_throw_def_cons.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_no_throw_def_cons.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_no_throw_def_cons.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 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_nothrow_cp_cons.html" title="has_nothrow_copy_constructor">
-<link rel="next" href="has_operator_bit_and.html" title="has_operator_bit_and">
+<link rel="next" href="has_trivial_assign.html" title="has_trivial_assign">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="has_nothrow_cp_cons.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_bit_and.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="has_nothrow_cp_cons.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_trivial_assign.html"><img src="../../images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
@@ -26,7 +26,7 @@
 <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,
+      Frederic 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>
@@ -37,7 +37,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="has_nothrow_cp_cons.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_bit_and.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="has_nothrow_cp_cons.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_trivial_assign.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_nothrow_assign.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_assign.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_assign.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -50,7 +50,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_constructor.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_constructor.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_constructor.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -57,7 +57,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_copy.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_copy.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_copy.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -56,7 +56,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_cp_cons.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_cp_cons.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_cp_cons.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -26,7 +26,7 @@
 <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,
+      Frederic 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>

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,136 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>has_operator_bit_and</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_no_throw_def_cons.html" title="has_nothrow_default_constructor">
-<link rel="next" href="has_operator_bit_and_equal.html" title="has_operator_bit_and_equal">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="has_no_throw_def_cons.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_bit_and_equal.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_operator_bit_and"></a><a class="link" href="has_operator_bit_and.html" title="has_operator_bit_and"> has_operator_bit_and</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">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>
-<span class="keyword">struct</span> <span class="identifier">has_operator_bit_and</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">lhs</span></code>
-        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><span class="special">&amp;</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="identifier">lhs</span><span class="special">&amp;</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 binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;</span></code>. Be careful that it does not mean that
-        <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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_bit_and</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">operators</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_bit_and</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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_bit_and</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_bit_and</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_bit_and</span><span class="special">&lt;</span><span class="keyword">long</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_bit_and</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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_bit_and</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">&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_bit_and</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&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_bit_and</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot 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>
-        cannot 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>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&amp;(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_bit_and</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator&amp;(const A&amp;) is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&amp;(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_bit_and</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_bit_and</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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_no_throw_def_cons.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_bit_and_equal.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,143 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>has_operator_bit_and_equal</title>
-<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
-<link rel="up" href="../reference.html" title="Alphabetical Reference">
-<link rel="prev" href="has_operator_bit_and.html" title="has_operator_bit_and">
-<link rel="next" href="has_operator_bit_or.html" title="has_operator_bit_or">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="has_operator_bit_and.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_bit_or.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_operator_bit_and_equal"></a><a class="link" href="has_operator_bit_and_equal.html" title="has_operator_bit_and_equal">
-      has_operator_bit_and_equal</a>
-</h3></div></div></div>
-<pre class="programlisting"><span class="keyword">template</span> <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>
-<span class="keyword">struct</span> <span class="identifier">has_operator_bit_and_equal</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">lhs</span></code>
-        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><span class="special">&amp;=</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="identifier">lhs</span><span class="special">&amp;=</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 binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;=</span></code>. Be careful that it does not mean that
-        <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;=</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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_bit_and_equal</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">operators</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_bit_and_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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_bit_and_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_bit_and_equal</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_bit_and_equal</span><span class="special">&lt;</span><span class="keyword">long</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_bit_and_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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_bit_and_equal</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">&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_bit_and_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&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_bit_and_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
-          <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot 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>
-        cannot 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>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&amp;=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_bit_and_equal</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator&amp;=(const A&amp;) is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&amp;=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_bit_and_equal</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_bit_and_equal</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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_bit_and.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_bit_or.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,137 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>has_operator_bit_or</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_bit_and_equal.html" title="has_operator_bit_and_equal">
-<link rel="next" href="has_operator_bit_or_equal.html" title="has_operator_bit_or_equal">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="has_operator_bit_and_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_bit_or_equal.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_operator_bit_or"></a><a class="link" href="has_operator_bit_or.html" title="has_operator_bit_or"> has_operator_bit_or</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">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>
-<span class="keyword">struct</span> <span class="identifier">has_operator_bit_or</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">lhs</span></code>
-        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><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="identifier">lhs</span><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 binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">|</span></code>. Be careful that it does not mean that
-        <code class="computeroutput"><span class="keyword">operator</span><span class="special">|</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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_bit_or</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">operators</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_bit_or</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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_bit_or</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_bit_or</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_bit_or</span><span class="special">&lt;</span><span class="keyword">long</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_bit_or</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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_bit_or</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">&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_bit_or</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&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_bit_or</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">|</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">|</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_bit_or</span><span class="special">&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>
-        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">|</span></code> or not. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">|(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_bit_or</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator|(const A&amp;) is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">|(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_bit_or</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_bit_or</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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_bit_and_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_bit_or_equal.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,142 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>has_operator_bit_or_equal</title>
-<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
-<link rel="up" href="../reference.html" title="Alphabetical Reference">
-<link rel="prev" href="has_operator_bit_or.html" title="has_operator_bit_or">
-<link rel="next" href="has_operator_bit_xor.html" title="has_operator_bit_xor">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="has_operator_bit_or.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_bit_xor.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_operator_bit_or_equal"></a><a class="link" href="has_operator_bit_or_equal.html" title="has_operator_bit_or_equal">
-      has_operator_bit_or_equal</a>
-</h3></div></div></div>
-<pre class="programlisting"><span class="keyword">template</span> <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>
-<span class="keyword">struct</span> <span class="identifier">has_operator_bit_or_equal</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">lhs</span></code>
-        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><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="identifier">lhs</span><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 binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">|=</span></code>. Be careful that it does not mean that
-        <code class="computeroutput"><span class="keyword">operator</span><span class="special">|=</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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_bit_or_equal</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">operators</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_bit_or_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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_bit_or_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_bit_or_equal</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_bit_or_equal</span><span class="special">&lt;</span><span class="keyword">long</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_bit_or_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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_bit_or_equal</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">&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_bit_or_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&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_bit_or_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
-          <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">|=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">|=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_bit_or_equal</span><span class="special">&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>
-        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">|=</span></code> or not. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">|=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_bit_or_equal</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator|=(const A&amp;) is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">|=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_bit_or_equal</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_bit_or_equal</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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_bit_or.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_bit_xor.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,137 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>has_operator_bit_xor</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_bit_or_equal.html" title="has_operator_bit_or_equal">
-<link rel="next" href="has_operator_bit_xor_equal.html" title="has_operator_bit_xor_equal">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="has_operator_bit_or_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_bit_xor_equal.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_operator_bit_xor"></a><a class="link" href="has_operator_bit_xor.html" title="has_operator_bit_xor"> has_operator_bit_xor</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">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>
-<span class="keyword">struct</span> <span class="identifier">has_operator_bit_xor</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">lhs</span></code>
-        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><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="identifier">lhs</span><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 binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">^</span></code>. Be careful that it does not mean that
-        <code class="computeroutput"><span class="keyword">operator</span><span class="special">^</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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_bit_xor</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">operators</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_bit_xor</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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_bit_xor</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_bit_xor</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_bit_xor</span><span class="special">&lt;</span><span class="keyword">long</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_bit_xor</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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_bit_xor</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">&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_bit_xor</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&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_bit_xor</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">^</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">^</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_bit_xor</span><span class="special">&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>
-        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">^</span></code> or not. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">^(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_bit_xor</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator^(const A&amp;) is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">^(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_bit_xor</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_bit_xor</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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_bit_or_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_bit_xor_equal.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,142 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>has_operator_bit_xor_equal</title>
-<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
-<link rel="up" href="../reference.html" title="Alphabetical Reference">
-<link rel="prev" href="has_operator_bit_xor.html" title="has_operator_bit_xor">
-<link rel="next" href="has_operator_complement.html" title="has_operator_complement">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="has_operator_bit_xor.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_complement.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_operator_bit_xor_equal"></a><a class="link" href="has_operator_bit_xor_equal.html" title="has_operator_bit_xor_equal">
-      has_operator_bit_xor_equal</a>
-</h3></div></div></div>
-<pre class="programlisting"><span class="keyword">template</span> <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>
-<span class="keyword">struct</span> <span class="identifier">has_operator_bit_xor_equal</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">lhs</span></code>
-        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><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="identifier">lhs</span><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 binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">^=</span></code>. Be careful that it does not mean that
-        <code class="computeroutput"><span class="keyword">operator</span><span class="special">^=</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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_bit_xor_equal</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">operators</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_bit_xor_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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_bit_xor_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_bit_xor_equal</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_bit_xor_equal</span><span class="special">&lt;</span><span class="keyword">long</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_bit_xor_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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_bit_xor_equal</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">&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_bit_xor_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&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_bit_xor_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
-          <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">^=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">^=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_bit_xor_equal</span><span class="special">&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>
-        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">^=</span></code> or not. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">^=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_bit_xor_equal</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator^=(const A&amp;) is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">^=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_bit_xor_equal</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_bit_xor_equal</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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_bit_xor.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_complement.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,149 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>has_operator_complement</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_bit_xor_equal.html" title="has_operator_bit_xor_equal">
-<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_dereference.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_complement"></a><a class="link" href="has_operator_complement.html" title="has_operator_complement">
-      has_operator_complement</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_complement</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>. Be careful that it does not mean that
-        <code class="computeroutput"><span class="keyword">operator</span><span class="special">~</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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_complement</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">operators</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_complement</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_complement</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</span></code>
-          is a <code class="computeroutput"><span class="keyword">bool</span></code> integral constant
-          expression.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_complement</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_complement</span><span class="special">&lt;</span><span class="keyword">long</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_complement</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</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_complement</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</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_complement</span><span class="special">&lt;</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_complement</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_complement</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</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_complement</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</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_complement</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">~</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">~</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_complement</span><span class="special">&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_complement</span></code>
-        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">~</span></code> or not. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">~();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_complement</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator~() is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">~(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_complement</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_complement</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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_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>

Deleted: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_dereference.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_operator_dereference.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,155 +0,0 @@
-<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>. Be careful that it does not mean that
-        <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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">operators</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="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
-        </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><span class="identifier">value</span></code>
-          is a <code class="computeroutput"><span class="keyword">bool</span></code> integral constant
-          expression that evaluates to <code class="computeroutput"><span class="keyword">true</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">long</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">*,</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">*,</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">int</span> <span class="keyword">const</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">*</span> <span class="keyword">const</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="keyword">const</span> <span class="special">*</span> <span class="keyword">const</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">double</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">void</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">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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_dereference</span><span class="special">&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>
-        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> or not. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">*();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_dereference</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator*() is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">*(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_dereference</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_dereference</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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>

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,143 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>has_operator_divides</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_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_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">
-<a name="boost_typetraits.reference.has_operator_divides"></a><a class="link" href="has_operator_divides.html" title="has_operator_divides"> has_operator_divides</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">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>
-<span class="keyword">struct</span> <span class="identifier">has_operator_divides</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">lhs</span></code>
-        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><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="identifier">lhs</span><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 binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">/</span></code>. Be careful that it does not mean that
-        <code class="computeroutput"><span class="keyword">operator</span><span class="special">/</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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_divides</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">operators</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_divides</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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_divides</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_divides</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_divides</span><span class="special">&lt;</span><span class="keyword">long</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_divides</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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_divides</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">&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_divides</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</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_divides</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</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_divides</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">&gt;::</span><span class="identifier">value</span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_divides</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">/</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">/</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_divides</span><span class="special">&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>
-        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">/</span></code> or not. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">/(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_divides</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator/(const A&amp;) is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">/(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_divides</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_divides</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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_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>

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,151 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>has_operator_divides_equal</title>
-<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
-<link rel="up" href="../reference.html" title="Alphabetical Reference">
-<link rel="prev" href="has_operator_divides.html" title="has_operator_divides">
-<link rel="next" href="has_operator_equal_to.html" title="has_operator_equal_to">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="has_operator_divides.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_equal_to.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_operator_divides_equal"></a><a class="link" href="has_operator_divides_equal.html" title="has_operator_divides_equal">
-      has_operator_divides_equal</a>
-</h3></div></div></div>
-<pre class="programlisting"><span class="keyword">template</span> <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>
-<span class="keyword">struct</span> <span class="identifier">has_operator_divides_equal</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">lhs</span></code>
-        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><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="identifier">lhs</span><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 binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">/=</span></code>. Be careful that it does not mean that
-        <code class="computeroutput"><span class="keyword">operator</span><span class="special">/=</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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_divides_equal</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">operators</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_divides_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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_divides_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_divides_equal</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_divides_equal</span><span class="special">&lt;</span><span class="keyword">long</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_divides_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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_divides_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
-          <span class="keyword">long</span><span class="special">&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_divides_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</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_divides_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</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_divides_equal</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">&gt;::</span><span class="identifier">value</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_divides_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
-          <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">/=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">/=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_divides_equal</span><span class="special">&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>
-        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">/=</span></code> or not. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">/=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_divides_equal</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator/=(const A&amp;) is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">/=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_divides_equal</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_divides_equal</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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_divides.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_equal_to.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,142 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>has_operator_equal_to</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_divides_equal.html" title="has_operator_divides_equal">
-<link rel="next" href="has_operator_greater.html" title="has_operator_greater">
-</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_divides_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_greater.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_equal_to"></a><a class="link" href="has_operator_equal_to.html" title="has_operator_equal_to"> has_operator_equal_to</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">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>
-<span class="keyword">struct</span> <span class="identifier">has_operator_equal_to</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">lhs</span></code>
-        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><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="identifier">lhs</span><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 binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code>. Be careful that it does not mean that
-        <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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_equal_to</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">operators</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_equal_to</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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_equal_to</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_equal_to</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_equal_to</span><span class="special">&lt;</span><span class="keyword">long</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_equal_to</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">bool</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_equal_to</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&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_equal_to</span><span class="special">&lt;</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_equal_to</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*,</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_equal_to</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">double</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_equal_to</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_equal_to</span><span class="special">&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>
-        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code> or not. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_equal_to</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator==(const A&amp;) is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_equal_to</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_equal_to</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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_divides_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_greater.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,141 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>has_operator_greater</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_equal_to.html" title="has_operator_equal_to">
-<link rel="next" href="has_operator_greater_equal.html" title="has_operator_greater_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_equal_to.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_greater_equal.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_operator_greater"></a><a class="link" href="has_operator_greater.html" title="has_operator_greater"> has_operator_greater</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">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>
-<span class="keyword">struct</span> <span class="identifier">has_operator_greater</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">lhs</span></code>
-        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><span class="special">&gt;</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="identifier">lhs</span><span class="special">&gt;</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 binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;</span></code>. Be careful that it does not mean that
-        <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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_greater</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">operators</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_greater</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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_greater</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_greater</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_greater</span><span class="special">&lt;</span><span class="keyword">long</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_greater</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">bool</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_greater</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&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_greater</span><span class="special">&lt;</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_greater</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*,</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_greater</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">double</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_greater</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot 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>
-        cannot 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>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&gt;(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_greater</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator&gt;(const A&amp;) is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&gt;(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_greater</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_greater</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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_equal_to.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_greater_equal.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,149 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>has_operator_greater_equal</title>
-<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
-<link rel="up" href="../reference.html" title="Alphabetical Reference">
-<link rel="prev" href="has_operator_greater.html" title="has_operator_greater">
-<link rel="next" href="has_operator_left_shift.html" title="has_operator_left_shift">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="has_operator_greater.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_left_shift.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_operator_greater_equal"></a><a class="link" href="has_operator_greater_equal.html" title="has_operator_greater_equal">
-      has_operator_greater_equal</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">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>
-<span class="keyword">struct</span> <span class="identifier">has_operator_greater_equal</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">lhs</span></code>
-        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><span class="special">&gt;=</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="identifier">lhs</span><span class="special">&gt;=</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 binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;=</span></code>. Be careful that it does not mean that
-        <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;=</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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_greater_equal</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">operators</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_greater_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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_greater_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_greater_equal</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_greater_equal</span><span class="special">&lt;</span><span class="keyword">long</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_greater_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
-          <span class="keyword">bool</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_greater_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&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_greater_equal</span><span class="special">&lt;</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_greater_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*,</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_greater_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">double</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_greater_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
-          <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot 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>
-        cannot 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>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&gt;=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_greater_equal</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator&gt;=(const A&amp;) is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&gt;=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_greater_equal</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_greater_equal</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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_greater.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_left_shift.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,155 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>has_operator_left_shift</title>
-<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
-<link rel="up" href="../reference.html" title="Alphabetical Reference">
-<link rel="prev" href="has_operator_greater_equal.html" title="has_operator_greater_equal">
-<link rel="next" href="has_operator_left_shift_equal.html" title="has_operator_left_shift_equal">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="has_operator_greater_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_left_shift_equal.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_operator_left_shift"></a><a class="link" href="has_operator_left_shift.html" title="has_operator_left_shift">
-      has_operator_left_shift</a>
-</h3></div></div></div>
-<pre class="programlisting"><span class="keyword">template</span> <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>
-<span class="keyword">struct</span> <span class="identifier">has_operator_left_shift</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">lhs</span></code>
-        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><span class="special">&lt;&lt;</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="identifier">lhs</span><span class="special">&lt;&lt;</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 binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></code>. Be careful that it does not mean
-        that <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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_left_shift</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">operators</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_left_shift</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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_left_shift</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_left_shift</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_left_shift</span><span class="special">&lt;</span><span class="keyword">long</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_left_shift</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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_left_shift</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">&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_left_shift</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&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_left_shift</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">,</span> <span class="keyword">char</span><span class="special">*,</span>
-          <span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">&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_left_shift</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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_left_shift</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&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_left_shift</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
-          <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot 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>
-        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></code> or not. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&lt;&lt;(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_left_shift</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator&lt;&lt;(const A&amp;) is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&lt;&lt;(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_left_shift</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_left_shift</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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_greater_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_left_shift_equal.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,143 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>has_operator_left_shift_equal</title>
-<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
-<link rel="up" href="../reference.html" title="Alphabetical Reference">
-<link rel="prev" href="has_operator_left_shift.html" title="has_operator_left_shift">
-<link rel="next" href="has_operator_less.html" title="has_operator_less">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="has_operator_left_shift.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_less.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_operator_left_shift_equal"></a><a class="link" href="has_operator_left_shift_equal.html" title="has_operator_left_shift_equal">
-      has_operator_left_shift_equal</a>
-</h3></div></div></div>
-<pre class="programlisting"><span class="keyword">template</span> <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>
-<span class="keyword">struct</span> <span class="identifier">has_operator_left_shift_equal</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">lhs</span></code>
-        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><span class="special">&lt;&lt;=</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="identifier">lhs</span><span class="special">&lt;&lt;=</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 binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;=</span></code>. Be careful that it does not mean
-        that <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;=</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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_left_shift_equal</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">operators</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_left_shift_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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_left_shift_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_left_shift_equal</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_left_shift_equal</span><span class="special">&lt;</span><span class="keyword">long</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_left_shift_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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_left_shift_equal</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">&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_left_shift_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&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_left_shift_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
-          <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot 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>
-        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;=</span></code> or not. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&lt;&lt;=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_left_shift_equal</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator&lt;&lt;=(const A&amp;) is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&lt;&lt;=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_left_shift_equal</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_left_shift_equal</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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_left_shift.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_less.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,141 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>has_operator_less</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_left_shift_equal.html" title="has_operator_left_shift_equal">
-<link rel="next" href="has_operator_less_equal.html" title="has_operator_less_equal">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="has_operator_left_shift_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_less_equal.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_operator_less"></a><a class="link" href="has_operator_less.html" title="has_operator_less"> has_operator_less</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">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>
-<span class="keyword">struct</span> <span class="identifier">has_operator_less</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">lhs</span></code>
-        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><span class="special">&lt;</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="identifier">lhs</span><span class="special">&lt;</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 binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;</span></code>. Be careful that it does not mean that
-        <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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_less</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">operators</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_less</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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_less</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_less</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_less</span><span class="special">&lt;</span><span class="keyword">long</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_less</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">bool</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_less</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&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_less</span><span class="special">&lt;</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_less</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*,</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_less</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">double</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_less</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot 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>
-        cannot 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>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&lt;(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_less</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator&lt;(const A&amp;) is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&lt;(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_less</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_less</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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_left_shift_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_less_equal.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,149 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>has_operator_less_equal</title>
-<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
-<link rel="up" href="../reference.html" title="Alphabetical Reference">
-<link rel="prev" href="has_operator_less.html" title="has_operator_less">
-<link rel="next" href="has_operator_logical_and.html" title="has_operator_logical_and">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="has_operator_less.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_logical_and.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_operator_less_equal"></a><a class="link" href="has_operator_less_equal.html" title="has_operator_less_equal">
-      has_operator_less_equal</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">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>
-<span class="keyword">struct</span> <span class="identifier">has_operator_less_equal</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">lhs</span></code>
-        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><span class="special">&lt;=</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="identifier">lhs</span><span class="special">&lt;=</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 binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;=</span></code>. Be careful that it does not mean that
-        <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;=</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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_less_equal</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">operators</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_less_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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_less_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_less_equal</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_less_equal</span><span class="special">&lt;</span><span class="keyword">long</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_less_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
-          <span class="keyword">bool</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_less_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&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_less_equal</span><span class="special">&lt;</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_less_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*,</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_less_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">double</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_less_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
-          <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot 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>
-        cannot 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>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&lt;=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_less_equal</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator&lt;=(const A&amp;) is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&lt;=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_less_equal</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_less_equal</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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_less.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_logical_and.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,149 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>has_operator_logical_and</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_less_equal.html" title="has_operator_less_equal">
-<link rel="next" href="has_operator_logical_not.html" title="has_operator_logical_not">
-</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_less_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_logical_not.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_logical_and"></a><a class="link" href="has_operator_logical_and.html" title="has_operator_logical_and">
-      has_operator_logical_and</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">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>
-<span class="keyword">struct</span> <span class="identifier">has_operator_logical_and</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">lhs</span></code>
-        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><span class="special">&amp;&amp;</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="identifier">lhs</span><span class="special">&amp;&amp;</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 binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;&amp;</span></code>. Be careful that it does not mean
-        that <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;&amp;</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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_logical_and</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">operators</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_logical_and</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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_logical_and</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_logical_and</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_logical_and</span><span class="special">&lt;</span><span class="keyword">bool</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_logical_and</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
-          <span class="keyword">bool</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_logical_and</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
-          <span class="keyword">long</span><span class="special">&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_logical_and</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&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_logical_and</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">&gt;::</span><span class="identifier">value</span></code>
-          inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_logical_and</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
-          <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot 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>
-        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;&amp;</span></code> or not. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&amp;&amp;(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_logical_and</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator&amp;&amp;(const A&amp;) is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&amp;&amp;(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_logical_and</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_logical_and</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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_less_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_logical_not.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,146 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>has_operator_logical_not</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_logical_and.html" title="has_operator_logical_and">
-<link rel="next" href="has_operator_logical_or.html" title="has_operator_logical_or">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="has_operator_logical_and.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_logical_or.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_operator_logical_not"></a><a class="link" href="has_operator_logical_not.html" title="has_operator_logical_not">
-      has_operator_logical_not</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_logical_not</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>. Be careful that it does not mean that
-        <code class="computeroutput"><span class="keyword">operator</span><span class="special">!</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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_logical_not</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">operators</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_logical_not</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_logical_not</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</span></code>
-          is a <code class="computeroutput"><span class="keyword">bool</span></code> integral constant
-          expression.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_logical_not</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_logical_not</span><span class="special">&lt;</span><span class="keyword">bool</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_logical_not</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">bool</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_logical_not</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</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_logical_not</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</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_logical_not</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</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_logical_not</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="keyword">bool</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_logical_not</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">!</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">!</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_logical_not</span><span class="special">&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>
-        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">!</span></code> or not. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">!();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_logical_not</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator!() is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">!(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_logical_not</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_logical_not</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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_logical_and.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_logical_or.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,148 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>has_operator_logical_or</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_logical_not.html" title="has_operator_logical_not">
-<link rel="next" href="has_operator_minus.html" title="has_operator_minus">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="has_operator_logical_not.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_minus.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_operator_logical_or"></a><a class="link" href="has_operator_logical_or.html" title="has_operator_logical_or">
-      has_operator_logical_or</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">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>
-<span class="keyword">struct</span> <span class="identifier">has_operator_logical_or</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">lhs</span></code>
-        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><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="identifier">lhs</span><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 binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">||</span></code>. Be careful that it does not mean that
-        <code class="computeroutput"><span class="keyword">operator</span><span class="special">||</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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_logical_or</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">operators</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_logical_or</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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_logical_or</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_logical_or</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_logical_or</span><span class="special">&lt;</span><span class="keyword">bool</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_logical_or</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
-          <span class="keyword">bool</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_logical_or</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
-          <span class="keyword">long</span><span class="special">&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_logical_or</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&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_logical_or</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">&gt;::</span><span class="identifier">value</span></code>
-          inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_logical_or</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
-          <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">||</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">||</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_logical_or</span><span class="special">&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>
-        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">||</span></code> or not. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">||(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_logical_or</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator||(const A&amp;) is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">||(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_logical_or</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_logical_or</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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_logical_not.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_minus.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,143 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>has_operator_minus</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_logical_or.html" title="has_operator_logical_or">
-<link rel="next" href="has_operator_minus_equal.html" title="has_operator_minus_equal">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="has_operator_logical_or.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_minus_equal.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_operator_minus"></a><a class="link" href="has_operator_minus.html" title="has_operator_minus"> has_operator_minus</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">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>
-<span class="keyword">struct</span> <span class="identifier">has_operator_minus</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">lhs</span></code>
-        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><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="identifier">lhs</span><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 binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code>. Be careful that it does not mean that
-        <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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_minus</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">operators</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_minus</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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_minus</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_minus</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_minus</span><span class="special">&lt;</span><span class="keyword">long</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_minus</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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_minus</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">&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_minus</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</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_minus</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</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_minus</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">&gt;::</span><span class="identifier">value</span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_minus</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_minus</span><span class="special">&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>
-        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> or not. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">-(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_minus</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator-(const A&amp;) is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">-(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_minus</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_minus</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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_logical_or.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_minus_equal.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,151 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>has_operator_minus_equal</title>
-<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
-<link rel="up" href="../reference.html" title="Alphabetical Reference">
-<link rel="prev" href="has_operator_minus.html" title="has_operator_minus">
-<link rel="next" href="has_operator_modulus.html" title="has_operator_modulus">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="has_operator_minus.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_modulus.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_operator_minus_equal"></a><a class="link" href="has_operator_minus_equal.html" title="has_operator_minus_equal">
-      has_operator_minus_equal</a>
-</h3></div></div></div>
-<pre class="programlisting"><span class="keyword">template</span> <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>
-<span class="keyword">struct</span> <span class="identifier">has_operator_minus_equal</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">lhs</span></code>
-        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><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="identifier">lhs</span><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 binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">-=</span></code>. Be careful that it does not mean that
-        <code class="computeroutput"><span class="keyword">operator</span><span class="special">-=</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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_minus_equal</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">operators</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_minus_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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_minus_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_minus_equal</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_minus_equal</span><span class="special">&lt;</span><span class="keyword">long</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_minus_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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_minus_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
-          <span class="keyword">long</span><span class="special">&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_minus_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</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_minus_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</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_minus_equal</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">&gt;::</span><span class="identifier">value</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_minus_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
-          <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">-=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">-=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_minus_equal</span><span class="special">&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>
-        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">-=</span></code> or not. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">-=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_minus_equal</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator-=(const A&amp;) is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">-=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_minus_equal</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_minus_equal</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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_minus.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_modulus.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,136 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>has_operator_modulus</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_minus_equal.html" title="has_operator_minus_equal">
-<link rel="next" href="has_operator_modulus_equal.html" title="has_operator_modulus_equal">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="has_operator_minus_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_modulus_equal.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_operator_modulus"></a><a class="link" href="has_operator_modulus.html" title="has_operator_modulus"> has_operator_modulus</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">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>
-<span class="keyword">struct</span> <span class="identifier">has_operator_modulus</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">lhs</span></code>
-        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><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="identifier">lhs</span><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 binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">%</span></code>. Be careful that it does not mean that
-        <code class="computeroutput"><span class="keyword">operator</span><span class="special">%</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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_modulus</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">operators</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_modulus</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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_modulus</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_modulus</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_modulus</span><span class="special">&lt;</span><span class="keyword">long</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_modulus</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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_modulus</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">&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_modulus</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">&gt;::</span><span class="identifier">value</span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_modulus</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">%</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">%</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_modulus</span><span class="special">&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>
-        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">%</span></code> or not. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">%(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_modulus</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator%(const A&amp;) is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">%(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_modulus</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_modulus</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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_minus_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_modulus_equal.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,142 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>has_operator_modulus_equal</title>
-<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
-<link rel="up" href="../reference.html" title="Alphabetical Reference">
-<link rel="prev" href="has_operator_modulus.html" title="has_operator_modulus">
-<link rel="next" href="has_operator_multiplies.html" title="has_operator_multiplies">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="has_operator_modulus.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_multiplies.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_operator_modulus_equal"></a><a class="link" href="has_operator_modulus_equal.html" title="has_operator_modulus_equal">
-      has_operator_modulus_equal</a>
-</h3></div></div></div>
-<pre class="programlisting"><span class="keyword">template</span> <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>
-<span class="keyword">struct</span> <span class="identifier">has_operator_modulus_equal</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">lhs</span></code>
-        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><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="identifier">lhs</span><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 binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">%=</span></code>. Be careful that it does not mean that
-        <code class="computeroutput"><span class="keyword">operator</span><span class="special">%=</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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_modulus_equal</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">operators</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_modulus_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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_modulus_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_modulus_equal</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_modulus_equal</span><span class="special">&lt;</span><span class="keyword">long</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_modulus_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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_modulus_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
-          <span class="keyword">long</span><span class="special">&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_modulus_equal</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">&gt;::</span><span class="identifier">value</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_modulus_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">%=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">%=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_modulus_equal</span><span class="special">&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>
-        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">%=</span></code> or not. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">%=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_modulus_equal</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator%=(const A&amp;) is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">%=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_modulus_equal</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_modulus_equal</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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_modulus.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_multiplies.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,151 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>has_operator_multiplies</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_modulus_equal.html" title="has_operator_modulus_equal">
-<link rel="next" href="has_operator_multiplies_equal.html" title="has_operator_multiplies_equal">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="has_operator_modulus_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_multiplies_equal.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_operator_multiplies"></a><a class="link" href="has_operator_multiplies.html" title="has_operator_multiplies">
-      has_operator_multiplies</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">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>
-<span class="keyword">struct</span> <span class="identifier">has_operator_multiplies</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">lhs</span></code>
-        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><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="identifier">lhs</span><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 binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code>. Be careful that it does not mean that
-        <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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_multiplies</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">operators</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_multiplies</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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_multiplies</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_multiplies</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_multiplies</span><span class="special">&lt;</span><span class="keyword">long</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_multiplies</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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_multiplies</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
-          <span class="keyword">long</span><span class="special">&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_multiplies</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</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_multiplies</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</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_multiplies</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">&gt;::</span><span class="identifier">value</span></code>
-          inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_multiplies</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
-          <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_multiplies</span><span class="special">&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>
-        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> or not. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">*(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_multiplies</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator*(const A&amp;) is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">*(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_multiplies</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_multiplies</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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_modulus_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_multiplies_equal.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,151 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>has_operator_multiplies_equal</title>
-<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
-<link rel="up" href="../reference.html" title="Alphabetical Reference">
-<link rel="prev" href="has_operator_multiplies.html" title="has_operator_multiplies">
-<link rel="next" href="has_operator_not_equal_to.html" title="has_operator_not_equal_to">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="has_operator_multiplies.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_not_equal_to.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_operator_multiplies_equal"></a><a class="link" href="has_operator_multiplies_equal.html" title="has_operator_multiplies_equal">
-      has_operator_multiplies_equal</a>
-</h3></div></div></div>
-<pre class="programlisting"><span class="keyword">template</span> <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>
-<span class="keyword">struct</span> <span class="identifier">has_operator_multiplies_equal</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">lhs</span></code>
-        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><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="identifier">lhs</span><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 binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">*=</span></code>. Be careful that it does not mean that
-        <code class="computeroutput"><span class="keyword">operator</span><span class="special">*=</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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_multiplies_equal</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">operators</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_multiplies_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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_multiplies_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_multiplies_equal</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_multiplies_equal</span><span class="special">&lt;</span><span class="keyword">long</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_multiplies_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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_multiplies_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
-          <span class="keyword">long</span><span class="special">&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_multiplies_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</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_multiplies_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</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_multiplies_equal</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">&gt;::</span><span class="identifier">value</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_multiplies_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
-          <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">*=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">*=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_multiplies_equal</span><span class="special">&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>
-        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">*=</span></code> or not. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">*=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_multiplies_equal</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator*=(const A&amp;) is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">*=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_multiplies_equal</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_multiplies_equal</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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_multiplies.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_not_equal_to.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,150 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>has_operator_not_equal_to</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_multiplies_equal.html" title="has_operator_multiplies_equal">
-<link rel="next" href="has_operator_plus.html" title="has_operator_plus">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="has_operator_multiplies_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_plus.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_operator_not_equal_to"></a><a class="link" href="has_operator_not_equal_to.html" title="has_operator_not_equal_to">
-      has_operator_not_equal_to</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">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>
-<span class="keyword">struct</span> <span class="identifier">has_operator_not_equal_to</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">lhs</span></code>
-        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><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="identifier">lhs</span><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 binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">!=</span></code>. Be careful that it does not mean that
-        <code class="computeroutput"><span class="keyword">operator</span><span class="special">!=</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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_not_equal_to</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">operators</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_not_equal_to</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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_not_equal_to</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_not_equal_to</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_not_equal_to</span><span class="special">&lt;</span><span class="keyword">long</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_not_equal_to</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
-          <span class="keyword">bool</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_not_equal_to</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&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_not_equal_to</span><span class="special">&lt;</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_not_equal_to</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*,</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_not_equal_to</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*,</span> <span class="keyword">double</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_not_equal_to</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
-          <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">!=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">!=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_not_equal_to</span><span class="special">&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>
-        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">!=</span></code> or not. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_not_equal_to</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator!=(const A&amp;) is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_not_equal_to</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_not_equal_to</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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_multiplies_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_plus.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,143 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>has_operator_plus</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_not_equal_to.html" title="has_operator_not_equal_to">
-<link rel="next" href="has_operator_plus_equal.html" title="has_operator_plus_equal">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="has_operator_not_equal_to.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_plus_equal.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_operator_plus"></a><a class="link" href="has_operator_plus.html" title="has_operator_plus"> has_operator_plus</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">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>
-<span class="keyword">struct</span> <span class="identifier">has_operator_plus</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">lhs</span></code>
-        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><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="identifier">lhs</span><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 binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code>. Be careful that it does not mean that
-        <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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_plus</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">operators</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_plus</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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_plus</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_plus</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_plus</span><span class="special">&lt;</span><span class="keyword">long</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_plus</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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_plus</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</span><span class="special">&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_plus</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</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_plus</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</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_plus</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">&gt;::</span><span class="identifier">value</span></code> inherits from <code class="computeroutput"><a class="link" href="integral_constant.html" title="integral_constant">true_type</a></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_plus</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_plus</span><span class="special">&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>
-        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> or not. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">+(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_plus</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator+(const A&amp;) is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">+(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_plus</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_plus</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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_not_equal_to.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_plus_equal.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,151 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>has_operator_plus_equal</title>
-<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
-<link rel="up" href="../reference.html" title="Alphabetical Reference">
-<link rel="prev" href="has_operator_plus.html" title="has_operator_plus">
-<link rel="next" href="has_operator_postfix_decrement.html" title="has_operator_postfix_decrement">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="has_operator_plus.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_postfix_decrement.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_operator_plus_equal"></a><a class="link" href="has_operator_plus_equal.html" title="has_operator_plus_equal">
-      has_operator_plus_equal</a>
-</h3></div></div></div>
-<pre class="programlisting"><span class="keyword">template</span> <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>
-<span class="keyword">struct</span> <span class="identifier">has_operator_plus_equal</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">lhs</span></code>
-        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><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="identifier">lhs</span><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 binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">+=</span></code>. Be careful that it does not mean that
-        <code class="computeroutput"><span class="keyword">operator</span><span class="special">+=</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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_plus_equal</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">operators</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_plus_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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_plus_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_plus_equal</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_plus_equal</span><span class="special">&lt;</span><span class="keyword">long</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_plus_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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_plus_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
-          <span class="keyword">long</span><span class="special">&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_plus_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</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_plus_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</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_plus_equal</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">&gt;::</span><span class="identifier">value</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_plus_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
-          <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">+=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">+=</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_plus_equal</span><span class="special">&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>
-        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">+=</span></code> or not. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">+=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_plus_equal</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator+=(const A&amp;) is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">+=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_plus_equal</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_plus_equal</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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_plus.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_postfix_decrement.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,152 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>has_operator_postfix_decrement</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_plus_equal.html" title="has_operator_plus_equal">
-<link rel="next" href="has_operator_postfix_increment.html" title="has_operator_postfix_increment">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="has_operator_plus_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_postfix_increment.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_postfix_decrement"></a><a class="link" href="has_operator_postfix_decrement.html" title="has_operator_postfix_decrement">
-      has_operator_postfix_decrement</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">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>
-<span class="keyword">struct</span> <span class="identifier">has_operator_postfix_decrement</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">lhs</span></code>
-        of type <code class="computeroutput"><span class="identifier">LHS</span></code> can be used in
-        expression <code class="computeroutput"><span class="identifier">lhs</span><span class="special">--</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="identifier">lhs</span><span class="special">--</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 postfix <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code>. Be careful that it does not mean that
-        <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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_postfix_decrement</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">operators</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_postfix_decrement</span><span class="special">&lt;</span><span class="identifier">LHS</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_postfix_decrement</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RET</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.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_postfix_decrement</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_postfix_decrement</span><span class="special">&lt;</span><span class="keyword">long</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_postfix_decrement</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</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_postfix_decrement</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</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_postfix_decrement</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</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_postfix_decrement</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</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_postfix_decrement</span><span class="special">&lt;</span><span class="keyword">bool</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_postfix_decrement</span><span class="special">&lt;</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">false_type</a></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_postfix_decrement</span><span class="special">&lt;</span><span class="keyword">void</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_postfix_decrement</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot detect whether postfix <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_postfix_decrement</span><span class="special">&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_postfix_decrement</span></code>
-        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code> or not. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">--(</span><span class="keyword">int</span><span class="special">);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_postfix_decrement</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator--(int) is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">--(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">int</span><span class="special">);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_postfix_decrement</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_postfix_decrement</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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_plus_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_postfix_increment.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,152 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>has_operator_postfix_increment</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_postfix_decrement.html" title="has_operator_postfix_decrement">
-<link rel="next" href="has_operator_prefix_decrement.html" title="has_operator_prefix_decrement">
-</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_postfix_decrement.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_prefix_decrement.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_postfix_increment"></a><a class="link" href="has_operator_postfix_increment.html" title="has_operator_postfix_increment">
-      has_operator_postfix_increment</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">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>
-<span class="keyword">struct</span> <span class="identifier">has_operator_postfix_increment</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">lhs</span></code>
-        of type <code class="computeroutput"><span class="identifier">LHS</span></code> can be used in
-        expression <code class="computeroutput"><span class="identifier">lhs</span><span class="special">++</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="identifier">lhs</span><span class="special">++</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 postfix <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code>. Be careful that it does not mean that
-        <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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_postfix_increment</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">operators</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_postfix_increment</span><span class="special">&lt;</span><span class="identifier">LHS</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_postfix_increment</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RET</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.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_postfix_increment</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_postfix_increment</span><span class="special">&lt;</span><span class="keyword">long</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_postfix_increment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</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_postfix_increment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</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_postfix_increment</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</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_postfix_increment</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</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_postfix_increment</span><span class="special">&lt;</span><span class="keyword">bool</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_postfix_increment</span><span class="special">&lt;</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">false_type</a></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_postfix_increment</span><span class="special">&lt;</span><span class="keyword">void</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_postfix_increment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot detect whether postfix <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">LHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_postfix_increment</span><span class="special">&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_postfix_increment</span></code>
-        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code> or not. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">++(</span><span class="keyword">int</span><span class="special">);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_postfix_increment</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator++(int) is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">++(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">int</span><span class="special">);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_postfix_increment</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_postfix_increment</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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_postfix_decrement.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_prefix_decrement.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,152 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>has_operator_prefix_decrement</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_postfix_increment.html" title="has_operator_postfix_increment">
-<link rel="next" href="has_operator_prefix_increment.html" title="has_operator_prefix_increment">
-</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_postfix_increment.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_prefix_increment.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_prefix_decrement"></a><a class="link" href="has_operator_prefix_decrement.html" title="has_operator_prefix_decrement">
-      has_operator_prefix_decrement</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_prefix_decrement</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>. Be careful that it does not mean that
-        <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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_prefix_decrement</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">operators</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_prefix_decrement</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_prefix_decrement</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</span></code>
-          is a <code class="computeroutput"><span class="keyword">bool</span></code> integral constant
-          expression.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_prefix_decrement</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_prefix_decrement</span><span class="special">&lt;</span><span class="keyword">long</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_prefix_decrement</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</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_prefix_decrement</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</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_prefix_decrement</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</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_prefix_decrement</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</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_prefix_decrement</span><span class="special">&lt;</span><span class="keyword">bool</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_prefix_decrement</span><span class="special">&lt;</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">false_type</a></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_prefix_decrement</span><span class="special">&lt;</span><span class="keyword">void</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_prefix_decrement</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_prefix_decrement</span><span class="special">&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_prefix_decrement</span></code>
-        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">--</span></code> or not. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">--();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_prefix_decrement</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator--() is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">--(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_prefix_decrement</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_prefix_decrement</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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_postfix_increment.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_prefix_increment.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,152 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>has_operator_prefix_increment</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_prefix_decrement.html" title="has_operator_prefix_decrement">
-<link rel="next" href="has_operator_right_shift.html" title="has_operator_right_shift">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="has_operator_prefix_decrement.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_right_shift.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_operator_prefix_increment"></a><a class="link" href="has_operator_prefix_increment.html" title="has_operator_prefix_increment">
-      has_operator_prefix_increment</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_prefix_increment</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>. Be careful that it does not mean that
-        <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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_prefix_increment</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">operators</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_prefix_increment</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_prefix_increment</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</span></code>
-          is a <code class="computeroutput"><span class="keyword">bool</span></code> integral constant
-          expression.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_prefix_increment</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_prefix_increment</span><span class="special">&lt;</span><span class="keyword">long</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_prefix_increment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</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_prefix_increment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</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_prefix_increment</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</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_prefix_increment</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</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_prefix_increment</span><span class="special">&lt;</span><span class="keyword">bool</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_prefix_increment</span><span class="special">&lt;</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">false_type</a></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_prefix_increment</span><span class="special">&lt;</span><span class="keyword">void</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_prefix_increment</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_prefix_increment</span><span class="special">&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_prefix_increment</span></code>
-        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">++</span></code> or not. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">++();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_prefix_increment</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator++() is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">++(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_prefix_increment</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_prefix_increment</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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_prefix_decrement.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_right_shift.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,155 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>has_operator_right_shift</title>
-<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
-<link rel="up" href="../reference.html" title="Alphabetical Reference">
-<link rel="prev" href="has_operator_prefix_increment.html" title="has_operator_prefix_increment">
-<link rel="next" href="has_operator_right_shift_equal.html" title="has_operator_right_shift_equal">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="has_operator_prefix_increment.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_right_shift_equal.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_operator_right_shift"></a><a class="link" href="has_operator_right_shift.html" title="has_operator_right_shift">
-      has_operator_right_shift</a>
-</h3></div></div></div>
-<pre class="programlisting"><span class="keyword">template</span> <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>
-<span class="keyword">struct</span> <span class="identifier">has_operator_right_shift</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">lhs</span></code>
-        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><span class="special">&gt;&gt;</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="identifier">lhs</span><span class="special">&gt;&gt;</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 binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;&gt;</span></code>. Be careful that it does not mean
-        that <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;&gt;</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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_right_shift</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">operators</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_right_shift</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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_right_shift</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_right_shift</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_right_shift</span><span class="special">&lt;</span><span class="keyword">long</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_right_shift</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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_right_shift</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">&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_right_shift</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">istream</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&amp;&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_right_shift</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">istream</span><span class="special">,</span> <span class="keyword">char</span><span class="special">*,</span>
-          <span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">&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_right_shift</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">istream</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&amp;&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_right_shift</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&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_right_shift</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
-          <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot 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>
-        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;&gt;</span></code> or not. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&gt;&gt;(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_right_shift</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator&gt;&gt;(const A&amp;) is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&gt;&gt;(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_right_shift</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_right_shift</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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_prefix_increment.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_right_shift_equal.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,143 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>has_operator_right_shift_equal</title>
-<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
-<link rel="up" href="../reference.html" title="Alphabetical Reference">
-<link rel="prev" href="has_operator_right_shift.html" title="has_operator_right_shift">
-<link rel="next" href="has_operator_unary_minus.html" title="has_operator_unary_minus">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="has_operator_right_shift.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_unary_minus.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_operator_right_shift_equal"></a><a class="link" href="has_operator_right_shift_equal.html" title="has_operator_right_shift_equal">
-      has_operator_right_shift_equal</a>
-</h3></div></div></div>
-<pre class="programlisting"><span class="keyword">template</span> <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>
-<span class="keyword">struct</span> <span class="identifier">has_operator_right_shift_equal</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">lhs</span></code>
-        of type <code class="computeroutput"><span class="identifier">LHS</span></code> and <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="identifier">lhs</span><span class="special">&gt;&gt;=</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="identifier">lhs</span><span class="special">&gt;&gt;=</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 binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;&gt;=</span></code>. Be careful that it does not mean
-        that <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;&gt;=</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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_right_shift_equal</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">operators</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_right_shift_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</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_right_shift_equal</span><span class="special">&lt;</span><span class="identifier">LHS</span><span class="special">,</span> <span class="identifier">RHS</span><span class="special">,</span> <span class="identifier">RET</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.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_right_shift_equal</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_right_shift_equal</span><span class="special">&lt;</span><span class="keyword">long</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_right_shift_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</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_right_shift_equal</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">&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_right_shift_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&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_right_shift_equal</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span>
-          <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot 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>
-        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;&gt;=</span></code> or not. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&gt;&gt;=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_right_shift_equal</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator&gt;&gt;=(const A&amp;) is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&gt;&gt;=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_right_shift_equal</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_right_shift_equal</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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_right_shift.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_unary_minus.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,146 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>has_operator_unary_minus</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_right_shift_equal.html" title="has_operator_right_shift_equal">
-<link rel="next" href="has_operator_unary_plus.html" title="has_operator_unary_plus">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="has_operator_right_shift_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_unary_plus.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_typetraits.reference.has_operator_unary_minus"></a><a class="link" href="has_operator_unary_minus.html" title="has_operator_unary_minus">
-      has_operator_unary_minus</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_unary_minus</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>. Be careful that it does not mean that
-        <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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_unary_minus</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">operators</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_unary_minus</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_unary_minus</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</span></code>
-          is a <code class="computeroutput"><span class="keyword">bool</span></code> integral constant
-          expression.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_unary_minus</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_unary_minus</span><span class="special">&lt;</span><span class="keyword">long</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_unary_minus</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</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_unary_minus</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</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_unary_minus</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</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_unary_minus</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</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_unary_minus</span><span class="special">&lt;</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_unary_minus</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_unary_minus</span><span class="special">&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>
-        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> or not. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">-();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_unary_minus</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator-() is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">-(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_unary_minus</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_unary_minus</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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_right_shift_equal.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_operator_unary_plus.html"><img src="../../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,146 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>has_operator_unary_plus</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_unary_minus.html" title="has_operator_unary_minus">
-<link rel="next" href="has_trivial_assign.html" title="has_trivial_assign">
-</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_unary_minus.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_trivial_assign.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_unary_plus"></a><a class="link" href="has_operator_unary_plus.html" title="has_operator_unary_plus">
-      has_operator_unary_plus</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_unary_plus</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>. Be careful that it does not mean that
-        <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code>
-        must return <code class="computeroutput"><span class="keyword">void</span></code> to have the
-        trait derive from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>.
-        If <code class="computeroutput"><span class="identifier">RET</span></code> is different from
-        the default <code class="computeroutput"><span class="keyword">void</span></code> type, the return
-        value is checked to be convertible to <code class="computeroutput"><span class="identifier">RET</span></code>.
-        Convertible to <code class="computeroutput"><span class="identifier">RET</span></code> means
-        that the return value of the operator can be used as argument to a function
-        expecting <code class="computeroutput"><span class="identifier">RET</span></code>: 
-</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>
-        <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_unary_plus</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">operators</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_unary_plus</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_unary_plus</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</span></code>
-          is a <code class="computeroutput"><span class="keyword">bool</span></code> integral constant
-          expression.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_unary_plus</span><span class="special">&lt;</span><span class="keyword">int</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 <code class="computeroutput"><span class="keyword">true</span></code>.
-        </p></blockquote></div>
-<div class="blockquote"><blockquote class="blockquote"><p>
-          <code class="computeroutput"><span class="identifier">has_operator_unary_plus</span><span class="special">&lt;</span><span class="keyword">long</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_unary_plus</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</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_unary_plus</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">long</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_unary_plus</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</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_unary_plus</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</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_unary_plus</span><span class="special">&lt;</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_unary_plus</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&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>
-<p>
-        <span class="bold"><strong>Known issues:</strong></span>
-      </p>
-<p>
-        This trait cannot detect whether prefix <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">RHS</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_operator_unary_plus</span><span class="special">&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>
-        cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> or not. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">+();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_unary_plus</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator+() is private
-</span></pre>
-<p>
-      </p>
-<p>
-        There is an issue if the operator exists only for type <code class="computeroutput"><span class="identifier">A</span></code>
-        and <code class="computeroutput"><span class="identifier">B</span></code> is convertible to
-        <code class="computeroutput"><span class="identifier">A</span></code>. In this case, the compiler
-        will report an ambigous overload. 
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">+(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_unary_plus</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine
-</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_operator_unary_plus</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambigous overload
-</span></pre>
-<p>
-      </p>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<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_unary_minus.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_trivial_assign.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_trivial_assign.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_assign.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_assign.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 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_unary_plus.html" title="has_operator_unary_plus">
+<link rel="prev" href="has_no_throw_def_cons.html" title="has_nothrow_default_constructor">
 <link rel="next" href="has_trivial_constructor.html" title="has_trivial_constructor">
 </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_unary_plus.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_trivial_constructor.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="has_no_throw_def_cons.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_trivial_constructor.html"><img src="../../images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
@@ -77,7 +77,7 @@
 <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,
+      Frederic 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>
@@ -88,7 +88,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="has_operator_unary_plus.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_trivial_constructor.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="has_no_throw_def_cons.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="has_trivial_constructor.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_trivial_constructor.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_constructor.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_constructor.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -87,7 +87,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_copy.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_copy.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_copy.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -83,7 +83,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_cp_cons.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_cp_cons.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_cp_cons.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -26,7 +26,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_def_cons.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_def_cons.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_def_cons.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -26,7 +26,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_destructor.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_destructor.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_destructor.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -80,7 +80,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_virtual_destructor.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_virtual_destructor.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/has_virtual_destructor.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -49,7 +49,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/integral_constant.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/integral_constant.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/integral_constant.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -41,7 +41,7 @@
 <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,
+      Frederic 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>

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-04-19 17:59:57 EDT (Tue, 19 Apr 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="id3498152"></a><p class="title"><b>Table&#160;1.18.&#160;Examples</b></p>
+<a name="id3397390"></a><p class="title"><b>Table&#160;1.17.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>
@@ -107,7 +107,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_abstract.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_abstract.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_abstract.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -69,7 +69,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_arithmetic.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_arithmetic.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_arithmetic.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -58,7 +58,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_array.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_array.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_array.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -60,7 +60,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_base_of.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_base_of.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_base_of.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -91,7 +91,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_class.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_class.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_class.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -76,7 +76,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_complex.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_complex.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_complex.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -40,7 +40,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_compound.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_compound.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_compound.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -65,7 +65,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_const.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_const.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_const.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -69,7 +69,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_convertible.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_convertible.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_convertible.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -108,7 +108,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_empty.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_empty.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_empty.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -84,7 +84,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_enum.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_enum.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_enum.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -76,7 +76,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_floating_point.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_floating_point.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_floating_point.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -56,7 +56,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_function.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_function.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_function.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -124,7 +124,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_fundamental.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_fundamental.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_fundamental.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -61,7 +61,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_integral.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_integral.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_integral.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -57,7 +57,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_member_function_pointer.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_member_function_pointer.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_member_function_pointer.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -65,7 +65,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_member_object_pointer.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_member_object_pointer.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_member_object_pointer.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -65,7 +65,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_member_pointer.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_member_pointer.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_member_pointer.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -57,7 +57,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_object.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_object.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_object.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -75,7 +75,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_pod.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_pod.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_pod.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -81,7 +81,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_pointer.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_pointer.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_pointer.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -82,7 +82,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_polymorphic.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_polymorphic.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_polymorphic.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -67,7 +67,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_reference.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_reference.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_reference.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -64,7 +64,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_same.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_same.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_same.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -66,7 +66,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_scalar.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_scalar.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_scalar.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -75,7 +75,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_signed.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_signed.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_signed.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -69,7 +69,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_stateless.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_stateless.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_stateless.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -66,7 +66,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_union.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_union.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_union.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -74,7 +74,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_unsigned.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_unsigned.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_unsigned.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -70,7 +70,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_void.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_void.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_void.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -61,7 +61,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_volatile.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_volatile.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/is_volatile.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -61,7 +61,7 @@
 <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,
+      Frederic 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>

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-04-19 17:59:57 EDT (Tue, 19 Apr 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="id3516070"></a><p class="title"><b>Table&#160;1.19.&#160;Examples</b></p>
+<a name="id3415307"></a><p class="title"><b>Table&#160;1.18.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>
@@ -137,7 +137,7 @@
 <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,
+      Frederic 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>

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-04-19 17:59:57 EDT (Tue, 19 Apr 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="id3516650"></a><p class="title"><b>Table&#160;1.20.&#160;Examples</b></p>
+<a name="id3415887"></a><p class="title"><b>Table&#160;1.19.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>
@@ -138,7 +138,7 @@
 <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,
+      Frederic 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>

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-04-19 17:59:57 EDT (Tue, 19 Apr 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="id3517254"></a><p class="title"><b>Table&#160;1.21.&#160;Examples</b></p>
+<a name="id3416492"></a><p class="title"><b>Table&#160;1.20.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>
@@ -143,7 +143,7 @@
 <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,
+      Frederic 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>

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-04-19 17:59:57 EDT (Tue, 19 Apr 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="id3518014"></a><p class="title"><b>Table&#160;1.22.&#160;Examples</b></p>
+<a name="id3417251"></a><p class="title"><b>Table&#160;1.21.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>
@@ -107,7 +107,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/rank.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/rank.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/rank.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -66,7 +66,7 @@
 <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,
+      Frederic 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>

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-04-19 17:59:57 EDT (Tue, 19 Apr 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="id3519301"></a><p class="title"><b>Table&#160;1.23.&#160;Examples</b></p>
+<a name="id3418538"></a><p class="title"><b>Table&#160;1.22.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>
@@ -136,7 +136,7 @@
 <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,
+      Frederic 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>

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-04-19 17:59:57 EDT (Tue, 19 Apr 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="id3519963"></a><p class="title"><b>Table&#160;1.24.&#160;Examples</b></p>
+<a name="id3419200"></a><p class="title"><b>Table&#160;1.23.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>
@@ -134,7 +134,7 @@
 <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,
+      Frederic 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>

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-04-19 17:59:57 EDT (Tue, 19 Apr 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="id3520608"></a><p class="title"><b>Table&#160;1.25.&#160;Examples</b></p>
+<a name="id3419845"></a><p class="title"><b>Table&#160;1.24.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>
@@ -134,7 +134,7 @@
 <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,
+      Frederic 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>

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-04-19 17:59:57 EDT (Tue, 19 Apr 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="id3521255"></a><p class="title"><b>Table&#160;1.26.&#160;Examples</b></p>
+<a name="id3420491"></a><p class="title"><b>Table&#160;1.25.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>
@@ -134,7 +134,7 @@
 <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,
+      Frederic 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>

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-04-19 17:59:57 EDT (Tue, 19 Apr 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="id3522523"></a><p class="title"><b>Table&#160;1.28.&#160;Examples</b></p>
+<a name="id3421760"></a><p class="title"><b>Table&#160;1.27.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>
@@ -146,7 +146,7 @@
 <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,
+      Frederic 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>

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-04-19 17:59:57 EDT (Tue, 19 Apr 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="id3521930"></a><p class="title"><b>Table&#160;1.27.&#160;Examples</b></p>
+<a name="id3421167"></a><p class="title"><b>Table&#160;1.26.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>
@@ -135,7 +135,7 @@
 <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,
+      Frederic 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>

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-04-19 17:59:57 EDT (Tue, 19 Apr 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="id3523312"></a><p class="title"><b>Table&#160;1.29.&#160;Examples</b></p>
+<a name="id3422549"></a><p class="title"><b>Table&#160;1.28.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>
@@ -122,7 +122,7 @@
 <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,
+      Frederic 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>

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-04-19 17:59:57 EDT (Tue, 19 Apr 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="id3523868"></a><p class="title"><b>Table&#160;1.30.&#160;Examples</b></p>
+<a name="id3423104"></a><p class="title"><b>Table&#160;1.29.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>
@@ -137,7 +137,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/type_with_alignment.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/type_with_alignment.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/reference/type_with_alignment.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -38,7 +38,7 @@
 <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,
+      Frederic 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>

Modified: sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/user_defined.html
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/user_defined.html	(original)
+++ sandbox/type_traits/libs/type_traits/doc/html/boost_typetraits/user_defined.html	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -57,7 +57,7 @@
 <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,
+      Frederic 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>

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-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -19,12 +19,12 @@
 <span class="firstname">various</span> <span class="surname">authors</span>
 </h3></div></div>
 <div><p class="copyright">Copyright &#169; 2000, 2011 Adobe Systems Inc, David Abrahams,
-      Fr&#233;d&#233;ric Bron, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant,
+      Frederic 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></div>
 <div><div class="legalnotice">
-<a name="id3392365"></a><p>
+<a name="id3294202"></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>
@@ -81,6 +81,56 @@
 <dt><span class="section"> add_volatile</span></dt>
 <dt><span class="section"> aligned_storage</span></dt>
 <dt><span class="section"> alignment_of</span></dt>
+<dt><span class="section"> can_call_addition</span></dt>
+<dt><span class="section"><a href="boost_typetraits/reference/can_call_addition_assignment.html">
+      can_call_addition_assignment</a></span></dt>
+<dt><span class="section"> can_call_and</span></dt>
+<dt><span class="section"> can_call_bitwise_and</span></dt>
+<dt><span class="section"><a href="boost_typetraits/reference/can_call_bitwise_and_assignment.html">
+      can_call_bitwise_and_assignment</a></span></dt>
+<dt><span class="section"> can_call_bitwise_or</span></dt>
+<dt><span class="section"><a href="boost_typetraits/reference/can_call_bitwise_or_assignment.html">
+      can_call_bitwise_or_assignment</a></span></dt>
+<dt><span class="section"> can_call_bitwise_xor</span></dt>
+<dt><span class="section"><a href="boost_typetraits/reference/can_call_bitwise_xor_assignment.html">
+      can_call_bitwise_xor_assignment</a></span></dt>
+<dt><span class="section"> can_call_complement</span></dt>
+<dt><span class="section"> can_call_dereference</span></dt>
+<dt><span class="section"> can_call_division</span></dt>
+<dt><span class="section"><a href="boost_typetraits/reference/can_call_division_assignment.html">
+      can_call_division_assignment</a></span></dt>
+<dt><span class="section"> can_call_equal</span></dt>
+<dt><span class="section"> can_call_greater</span></dt>
+<dt><span class="section"> can_call_greater_equal</span></dt>
+<dt><span class="section"> can_call_left_shift</span></dt>
+<dt><span class="section"><a href="boost_typetraits/reference/can_call_left_shift_assignment.html">
+      can_call_left_shift_assignment</a></span></dt>
+<dt><span class="section"> can_call_less</span></dt>
+<dt><span class="section"> can_call_less_equal</span></dt>
+<dt><span class="section"> can_call_modulus</span></dt>
+<dt><span class="section"><a href="boost_typetraits/reference/can_call_modulus_assignment.html">
+      can_call_modulus_assignment</a></span></dt>
+<dt><span class="section"><a href="boost_typetraits/reference/can_call_multiplication.html">
+      can_call_multiplication</a></span></dt>
+<dt><span class="section"><a href="boost_typetraits/reference/can_call_multiplication_assignment.html">
+      can_call_multiplication_assignment</a></span></dt>
+<dt><span class="section"> can_call_not</span></dt>
+<dt><span class="section"> can_call_not_equal</span></dt>
+<dt><span class="section"> can_call_or</span></dt>
+<dt><span class="section"><a href="boost_typetraits/reference/can_call_post_decrement.html">
+      can_call_post_decrement</a></span></dt>
+<dt><span class="section"><a href="boost_typetraits/reference/can_call_post_increment.html">
+      can_call_post_increment</a></span></dt>
+<dt><span class="section"> can_call_pre_decrement</span></dt>
+<dt><span class="section"> can_call_pre_increment</span></dt>
+<dt><span class="section"> can_call_right_shift</span></dt>
+<dt><span class="section"><a href="boost_typetraits/reference/can_call_right_shift_assignment.html">
+      can_call_right_shift_assignment</a></span></dt>
+<dt><span class="section"> can_call_subtraction</span></dt>
+<dt><span class="section"><a href="boost_typetraits/reference/can_call_subtraction_assignment.html">
+      can_call_subtraction_assignment</a></span></dt>
+<dt><span class="section"> can_call_unary_minus</span></dt>
+<dt><span class="section"> can_call_unary_plus</span></dt>
 <dt><span class="section"> decay</span></dt>
 <dt><span class="section"> extent</span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/floating_point_promotion.html">
@@ -92,70 +142,6 @@
 <dt><span class="section"> has_nothrow_copy</span></dt>
 <dt><span class="section"> has_nothrow_copy_constructor</span></dt>
 <dt><span class="section"> has_nothrow_default_constructor</span></dt>
-<dt><span class="section"> has_operator_bit_and</span></dt>
-<dt><span class="section"><a href="boost_typetraits/reference/has_operator_bit_and_equal.html">
-      has_operator_bit_and_equal</a></span></dt>
-<dt><span class="section"> has_operator_bit_or</span></dt>
-<dt><span class="section"><a href="boost_typetraits/reference/has_operator_bit_or_equal.html">
-      has_operator_bit_or_equal</a></span></dt>
-<dt><span class="section"> has_operator_bit_xor</span></dt>
-<dt><span class="section"><a href="boost_typetraits/reference/has_operator_bit_xor_equal.html">
-      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>
-<dt><span class="section"> has_operator_equal_to</span></dt>
-<dt><span class="section"> has_operator_greater</span></dt>
-<dt><span class="section"><a href="boost_typetraits/reference/has_operator_greater_equal.html">
-      has_operator_greater_equal</a></span></dt>
-<dt><span class="section"><a href="boost_typetraits/reference/has_operator_left_shift.html">
-      has_operator_left_shift</a></span></dt>
-<dt><span class="section"><a href="boost_typetraits/reference/has_operator_left_shift_equal.html">
-      has_operator_left_shift_equal</a></span></dt>
-<dt><span class="section"> has_operator_less</span></dt>
-<dt><span class="section"><a href="boost_typetraits/reference/has_operator_less_equal.html">
-      has_operator_less_equal</a></span></dt>
-<dt><span class="section"><a href="boost_typetraits/reference/has_operator_logical_and.html">
-      has_operator_logical_and</a></span></dt>
-<dt><span class="section"><a href="boost_typetraits/reference/has_operator_logical_not.html">
-      has_operator_logical_not</a></span></dt>
-<dt><span class="section"><a href="boost_typetraits/reference/has_operator_logical_or.html">
-      has_operator_logical_or</a></span></dt>
-<dt><span class="section"> has_operator_minus</span></dt>
-<dt><span class="section"><a href="boost_typetraits/reference/has_operator_minus_equal.html">
-      has_operator_minus_equal</a></span></dt>
-<dt><span class="section"> has_operator_modulus</span></dt>
-<dt><span class="section"><a href="boost_typetraits/reference/has_operator_modulus_equal.html">
-      has_operator_modulus_equal</a></span></dt>
-<dt><span class="section"><a href="boost_typetraits/reference/has_operator_multiplies.html">
-      has_operator_multiplies</a></span></dt>
-<dt><span class="section"><a href="boost_typetraits/reference/has_operator_multiplies_equal.html">
-      has_operator_multiplies_equal</a></span></dt>
-<dt><span class="section"><a href="boost_typetraits/reference/has_operator_not_equal_to.html">
-      has_operator_not_equal_to</a></span></dt>
-<dt><span class="section"> has_operator_plus</span></dt>
-<dt><span class="section"><a href="boost_typetraits/reference/has_operator_plus_equal.html">
-      has_operator_plus_equal</a></span></dt>
-<dt><span class="section"><a href="boost_typetraits/reference/has_operator_postfix_decrement.html">
-      has_operator_postfix_decrement</a></span></dt>
-<dt><span class="section"><a href="boost_typetraits/reference/has_operator_postfix_increment.html">
-      has_operator_postfix_increment</a></span></dt>
-<dt><span class="section"><a href="boost_typetraits/reference/has_operator_prefix_decrement.html">
-      has_operator_prefix_decrement</a></span></dt>
-<dt><span class="section"><a href="boost_typetraits/reference/has_operator_prefix_increment.html">
-      has_operator_prefix_increment</a></span></dt>
-<dt><span class="section"><a href="boost_typetraits/reference/has_operator_right_shift.html">
-      has_operator_right_shift</a></span></dt>
-<dt><span class="section"><a href="boost_typetraits/reference/has_operator_right_shift_equal.html">
-      has_operator_right_shift_equal</a></span></dt>
-<dt><span class="section"><a href="boost_typetraits/reference/has_operator_unary_minus.html">
-      has_operator_unary_minus</a></span></dt>
-<dt><span class="section"><a href="boost_typetraits/reference/has_operator_unary_plus.html">
-      has_operator_unary_plus</a></span></dt>
 <dt><span class="section"> has_trivial_assign</span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/has_trivial_constructor.html">
       has_trivial_constructor</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-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -1,13 +1,13 @@
 [/
-  Copyright 2011 Frédéric Bron
+  (C) Copyright 2011 Frederic 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).
 ]
 [c++]
-[def __binary_temp `< class LHS, class RHS=LHS, class RET=void >`]
-[def __prefix_temp `< class RHS, class RET=void >`]
-[def __postfix_temp `< class LHS, class RET=void >`]
+[def __binary_temp `< class Lhs, class Rhs=Lhs, class Ret=dont_care >`]
+[def __prefix_temp `< class Rhs, class Ret=dont_care >`]
+[def __postfix_temp `< class Lhs, class Ret=dont_care >`]
 
 [section:operators Operator Type Traits]
 
@@ -17,7 +17,7 @@
 and providing a simple `true` or `false` boolean value which reflects the fact
 that given types can or not be used with given operators.
 
-For example, `has_operator_plus<int, double>::value` is a `bool`
+For example, `can_call_addition<int, double>::value` is a `bool`
 which value is `true` because it is possible to add a `double` to an `int` like
 in the following code:
 ``
@@ -28,195 +28,128 @@
 It is also possible to know if the result of the operator is convertible or not
 to a given type:
 ``
-has_operator_plus<int, double, double>::value; // true: int+double is convertible to double
-has_operator_plus<int, double, char*>::value; // false: int+double is not convertible to char*
-has_operator_less<int, double, bool>::value; // true: int<double is convertible to bool
+can_call_addition<int, double, double>::value; // true: int+double is convertible to double
+can_call_addition<int, double, char*>::value; // false: int+double is not convertible to char*
+can_call_subtraction<int, double, bool>::value; // true: int<double is convertible to bool
 ``
 
 The syntax for binary operators is the following:
 ``
-template __binary_temp has_operator_op;
+template __binary_temp can_call_op;
 ``
 where:
 
-* `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
+* `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.
 
-The default behaviour (`RET=void`) is to not check for the return value of the
-operator. Be careful that it does not mean that the operator must return `void`
-to have the trait value to be `true`.
-If `RET` is different from the default `void`, the return value is checked to be
-convertible to `RET`. Convertible to `RET` means that the return value can be
-used as argument to a function expecting `RET`:
-``
-void f(RET);
-LHS lhs;
-RHS rhs;
-f(lhs+rhs); // is valid if has_operator_plus<LHS, RHS, RET>::value==true
+The default behaviour (`Ret=dont_care`) is to not check for the return value of the
+operator.
+If `Ret` is different from the default `dont_care`, 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 can_call_addition<Lhs, Rhs, Ret>::value==true
 ``
+If `Ret=void`, the return type is checked to be exactly `void`.
 
 Similarly, the syntax for postfix and prefix operators is the following:
 ``
-template __prefix_temp has_operator_prefixop;
-template __postfix_temp has_operator_postfixop;
+template __prefix_temp can_call_prefixop;
+template __postfix_temp can_call_postfixop;
 ``
 
 The following tables give the list of supported binary, prefix and postfix
 operators.
 
 [table Supported binary operators
-   [[operator]                   [trait name]]
-
-   [[`==`]    [[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_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`]]]
-   [[`*`]     [[link boost_typetraits.reference.has_operator_multiplies `has_operator_multiplies __binary_temp`]]]
-   [[`/`]     [[link boost_typetraits.reference.has_operator_divides `has_operator_divides __binary_temp`]]]
-   [[`%`]     [[link boost_typetraits.reference.has_operator_modulus `has_operator_modulus __binary_temp`]]]
-   [[`+=`]    [[link boost_typetraits.reference.has_operator_plus_equal `has_operator_plus_equal __binary_temp`]]]
-   [[`-=`]    [[link boost_typetraits.reference.has_operator_minus_equal `has_operator_minus_equal __binary_temp`]]]
-   [[`*=`]    [[link boost_typetraits.reference.has_operator_multiplies_equal `has_operator_multiplies_equal __binary_temp`]]]
-   [[`/=`]    [[link boost_typetraits.reference.has_operator_divides_equal `has_operator_divides_equal __binary_temp`]]]
-   [[`%=`]    [[link boost_typetraits.reference.has_operator_modulus_equal `has_operator_modulus_equal __binary_temp`]]]
-
-   [[`&&`]    [[link boost_typetraits.reference.has_operator_logical_and `has_operator_logical_and __binary_temp`]]]
-   [[`||`]    [[link boost_typetraits.reference.has_operator_logical_or `has_operator_logical_or __binary_temp`]]]
-
-   [[`&`]     [[link boost_typetraits.reference.has_operator_bit_and `has_operator_bit_and __binary_temp`]]]
-   [[`|`]     [[link boost_typetraits.reference.has_operator_bit_or `has_operator_bit_or __binary_temp`]]]
-   [[`^`]     [[link boost_typetraits.reference.has_operator_bit_xor `has_operator_bit_xor __binary_temp`]]]
-   [[`<<`]    [[link boost_typetraits.reference.has_operator_left_shift `has_operator_left_shift __binary_temp`]]]
-   [[`>>`]    [[link boost_typetraits.reference.has_operator_right_shift `has_operator_right_shift __binary_temp`]]]
-   [[`&=`]    [[link boost_typetraits.reference.has_operator_bit_and_equal `has_operator_bit_and_equal __binary_temp`]]]
-   [[`|=`]    [[link boost_typetraits.reference.has_operator_bit_or_equal `has_operator_bit_or_equal __binary_temp`]]]
-   [[`^=`]    [[link boost_typetraits.reference.has_operator_bit_xor_equal `has_operator_bit_xor_equal __binary_temp`]]]
-   [[`<<=`]   [[link boost_typetraits.reference.has_operator_left_shift_equal `has_operator_left_shift_equal __binary_temp`]]]
-   [[`>>=`]   [[link boost_typetraits.reference.has_operator_right_shift_equal `has_operator_right_shift_equal __binary_temp`]]]
+   [[operator] [trait name]]
+   [[`+`]      [[link boost_typetraits.reference.can_call_addition `can_call_addition __binary_temp`]]]
+   [[`-`]      [[link boost_typetraits.reference.can_call_subtraction `can_call_subtraction __binary_temp`]]]
+   [[`*`]      [[link boost_typetraits.reference.can_call_multiplication `can_call_multiplication __binary_temp`]]]
+   [[`/`]      [[link boost_typetraits.reference.can_call_division `can_call_division __binary_temp`]]]
+   [[`%`]      [[link boost_typetraits.reference.can_call_modulus `can_call_modulus __binary_temp`]]]
+   [[`+=`]     [[link boost_typetraits.reference.can_call_addition_assignment `can_call_addition_assignment __binary_temp`]]]
+   [[`-=`]     [[link boost_typetraits.reference.can_call_subtraction_assignment `can_call_subtraction_assignment __binary_temp`]]]
+   [[`*=`]     [[link boost_typetraits.reference.can_call_multiplication_assignment `can_call_multiplication_assignment __binary_temp`]]]
+   [[`/=`]     [[link boost_typetraits.reference.can_call_division_assignment `can_call_division_assignment __binary_temp`]]]
+   [[`%=`]     [[link boost_typetraits.reference.can_call_modulus_assignment `can_call_modulus_assignment __binary_temp`]]]
+   [[`&`]      [[link boost_typetraits.reference.can_call_bitwise_and `can_call_bitwise_and __binary_temp`]]]
+   [[`|`]      [[link boost_typetraits.reference.can_call_bitwise_or `can_call_bitwise_or __binary_temp`]]]
+   [[`^`]      [[link boost_typetraits.reference.can_call_bitwise_xor `can_call_bitwise_xor __binary_temp`]]]
+   [[`&=`]     [[link boost_typetraits.reference.can_call_bitwise_and_assignment `can_call_bitwise_and_assignment __binary_temp`]]]
+   [[`|=`]     [[link boost_typetraits.reference.can_call_bitwise_or_assignment `can_call_bitwise_or_assignment __binary_temp`]]]
+   [[`^=`]     [[link boost_typetraits.reference.can_call_bitwise_xor_assignment `can_call_bitwise_xor_assignment __binary_temp`]]]
+   [[`<<`]     [[link boost_typetraits.reference.can_call_left_shift `can_call_left_shift __binary_temp`]]]
+   [[`>>`]     [[link boost_typetraits.reference.can_call_right_shift `can_call_right_shift __binary_temp`]]]
+   [[`<<=`]    [[link boost_typetraits.reference.can_call_left_shift_assignment `can_call_left_shift_assignment __binary_temp`]]]
+   [[`>>=`]    [[link boost_typetraits.reference.can_call_right_shift_assignment `can_call_right_shift_assignment __binary_temp`]]]
+   [[`==`]     [[link boost_typetraits.reference.can_call_equal `can_call_equal __binary_temp`]]]
+   [[`!=`]     [[link boost_typetraits.reference.can_call_not_equal `can_call_not_equal __binary_temp`]]]
+   [[`<`]      [[link boost_typetraits.reference.can_call_less `can_call_less __binary_temp`]]]
+   [[`<=`]     [[link boost_typetraits.reference.can_call_less_equal `can_call_less_equal __binary_temp`]]]
+   [[`>`]      [[link boost_typetraits.reference.can_call_greater `can_call_greater __binary_temp`]]]
+   [[`>=`]     [[link boost_typetraits.reference.can_call_greater_equal `can_call_greater_equal __binary_temp`]]]
+   [[`&&`]     [[link boost_typetraits.reference.can_call_and `can_call_and __binary_temp`]]]
+   [[`||`]     [[link boost_typetraits.reference.can_call_or `can_call_or __binary_temp`]]]
 ]
 
 [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_dereference `has_operator_dereference __prefix_temp`]]]
+   [[operator] [trait name]]
+   [[`!`]      [[link boost_typetraits.reference.can_call_not `can_call_not __prefix_temp`]]]
+   [[`+`]      [[link boost_typetraits.reference.can_call_unary_plus `can_call_unary_plus __prefix_temp`]]]
+   [[`-`]      [[link boost_typetraits.reference.can_call_unary_minus `can_call_unary_minus __prefix_temp`]]]
+   [[`~`]      [[link boost_typetraits.reference.can_call_complement `can_call_complement __prefix_temp`]]]
+   [[`*`]      [[link boost_typetraits.reference.can_call_dereference `can_call_dereference __prefix_temp`]]]
+   [[`++`]     [[link boost_typetraits.reference.can_call_pre_increment `can_call_pre_increment __prefix_temp`]]]
+   [[`--`]     [[link boost_typetraits.reference.can_call_pre_decrement `can_call_pre_decrement __prefix_temp`]]]
 ]
 
 [table Supported postfix operators
-   [[operator]                   [trait name]]
-   [[`++`]   [[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`]]]
-]
-
-
-The choice of trait names may seem unconsistent but it has not been possible to propose a more consistent naming convention because the standard is itself inconsistent.
-The following table shows the names found in the standard for each operator and the corresponding trait name.
-
-[table Operator names in the standard
-[[operator] [alternative token (__std_ref 2.5)] [name in `<functionnal>` or `<iterator>` (__std_ref 20.3 and 24.2)] [trait name]]
-[[binary]]
-[[`==`]     [\u00F8]                      [`equal_to`]                                 [[link boost_typetraits.reference.has_operator_equal_to          `has_operator_equal_to`]]]
-[[`!=`]     [`not_eq`]                    [`not_equal_to`]                             [[link boost_typetraits.reference.has_operator_not_equal_to      `has_operator_not_equal_to`]]]
-[[`<`]      [\u00F8]                      [`less`]                                     [[link boost_typetraits.reference.has_operator_less              `has_operator_less`]]]
-[[`<=`]     [\u00F8]                      [`less_equal`]                               [[link boost_typetraits.reference.has_operator_less_equal        `has_operator_less_equal`]]]
-[[`>`]      [\u00F8]                      [`greater`]                                  [[link boost_typetraits.reference.has_operator_greater           `has_operator_greater`]]]
-[[`>=`]     [\u00F8]                      [`greater_equal`]                            [[link boost_typetraits.reference.has_operator_greater_equal     `has_operator_greater_equal`]]]
-[[ ]]
-[[`+`]      [\u00F8]                      [`plus`]                                     [[link boost_typetraits.reference.has_operator_plus              `has_operator_plus`]]]
-[[`-`]      [\u00F8]                      [`minus`]                                    [[link boost_typetraits.reference.has_operator_minus             `has_operator_minus`]]]
-[[`*`]      [\u00F8]                      [`multiplies`]                               [[link boost_typetraits.reference.has_operator_multiplies        `has_operator_multiplies`]]]
-[[`/`]      [\u00F8]                      [`divides`]                                  [[link boost_typetraits.reference.has_operator_divides           `has_operator_divides`]]]
-[[`%`]      [\u00F8]                      [`modulus`]                                  [[link boost_typetraits.reference.has_operator_modulus           `has_operator_modulus`]]]
-[[`+=`]     [\u00F8]                      [\u00F8]                                     [[link boost_typetraits.reference.has_operator_plus_equal        `has_operator_plus_equal`]]]
-[[`-=`]     [\u00F8]                      [\u00F8]                                     [[link boost_typetraits.reference.has_operator_minus_equal       `has_operator_minus_equal`]]]
-[[`*=`]     [\u00F8]                      [\u00F8]                                     [[link boost_typetraits.reference.has_operator_multiplies_equal  `has_operator_multiplies_equal`]]]
-[[`/=`]     [\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_equal  `has_operator_left_shift_equal`]]]
-[[`>>=`]    [\u00F8]                      [\u00F8]                                     [[link boost_typetraits.reference.has_operator_right_shift_equal `has_operator_right_shift_equal`]]]
-[[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`]]]
-[[`!`]      [`not`]                       [`logical_not`]                              [[link boost_typetraits.reference.has_operator_logical_not       `has_operator_logical_not`]]]
-[[`~`]      [`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`]]]
+   [[operator] [trait name]]
+   [[`++`]     [[link boost_typetraits.reference.can_call_post_increment `can_call_post_increment __postfix_temp`]]]
+   [[`--`]     [[link boost_typetraits.reference.can_call_post_decrement `can_call_post_decrement __postfix_temp`]]]
 ]
 
 [heading Implementation]
 
 The implementation consists in only header files. The following headers should
 included first:
-``#include <boost/type_traits/operators.hpp>``
+``#include <boost/type_traits/can_call.hpp>``
 or
-``#include <boost/type_traits/has_operator_name.hpp>``
+``#include <boost/type_traits/can_call_name.hpp>``
 where [^name] is the textual name chosen for the wanted operator. The first
 method includes all operator traits.
 
 All traits are implemented the same way using preprocessor macros to avoid code
 duplication.
-The main files are in [^boost/type_traits/detail]: [^has_binary_operator.hpp],
-[^has_prefix_operator.hpp] and [^has_postfix_operator.hpp].
+The main files are in [^boost/type_traits/detail]: [^can_call_binary_operator.hpp],
+[^can_call_prefix_operator.hpp] and [^can_call_postfix_operator.hpp].
 The example of prefix `operator-` is presented below:
 
 ``
 namespace boost {
 namespace detail {
-namespace has_operator_unary_minus_impl {
+
+// This namespace ensures that ADL does not mess things up.
+namespace can_call_unary_minus_impl {
 
 // 1. a function to have an instance of type T without requiring T to be default
 // constructible
-namespace {
-   template <typename T> T &make();
-}
+template <typename T> T &make();
 
-// 2. we provide operator- for types that do not have one already
 
-// a type returned from operator- when no such operator is found in the type's
-// own namespace so that we have a means to know that our operator was used
-struct tag { };
-
-// this class allows implicit conversions and makes the following operator
-// definition less-preferred than any other such operators that might be found
-// via argument-dependent name lookup
-struct any { template <class T> any(T const&); };
-
-// when operator- is not available, this one is used
-tag operator-(const any&);
-
-// 3. if the return type has to be checked, we need to determine if operator-
-// returns void or not
+// 2. checks if operator- returns void or not
+// conditions: Rhs!=void
 
 // we first redefine "operator," so that we have no compilation error if
 // operator- returns void and we can use the return type of
-// (-rhs, returns_void_t()) to deduce if operator- returns void or not:
+// (-rhs, returns_void_t()) to deduce if
+// operator- returns void or not:
 // - operator- returns void   -> (-rhs, returns_void_t()) returns returns_void_t
 // - operator- returns !=void -> (-rhs, returns_void_t()) returns int
 struct returns_void_t {};
@@ -225,103 +158,140 @@
 // this intermediate trait has member value of type bool:
 // - value==true -> operator- returns void
 // - value==false -> operator- does not return void
-template < typename RHS >
-struct operator_unary_minus_returns_void {
+template < typename Rhs >
+struct operator_returns_void {
    // overloads of function returns_void make the difference
    // yes_type and no_type have different size by construction
    static ::boost::type_traits::yes_type returns_void(returns_void_t);
    static ::boost::type_traits::no_type returns_void(int);
-   static const bool value=(sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((-make<RHS>(),returns_void_t()))));
+   static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((- make<Rhs>(),returns_void_t()))));
 };
 
-// 4. check for return type when RET is non void
 
-// this class is used only when RET is non void, therefore it is specialized to
-// have its value==false when the operator returns void
-template < typename RHS, typename RET, typename RETURNS_VOID >
-struct has_operator_unary_minus_impl2;
+// 3. check for return type if Ret!=dont_care
+// conditions: Rhs!=void
 
-// operator- does not return void, checks if it is convertible to RET using the
-// sizeof trick based on overload resolution
-template < typename RHS, typename RET >
-struct has_operator_unary_minus_impl2< RHS, RET, ::boost::false_type > {
-   static ::boost::type_traits::yes_type is_convertible_to_RET(RET);
-   static ::boost::type_traits::no_type is_convertible_to_RET(...);
-   static const bool value=(sizeof(is_convertible_to_RET(- make<RHS>()))==sizeof(::boost::type_traits::yes_type));
+struct dont_care { };
+
+template < typename Rhs, typename Ret, bool Returns_void >
+struct operator_returns_Ret;
+
+template < typename Rhs >
+struct operator_returns_Ret < Rhs, dont_care, true > {
+   static const bool value = true;
 };
 
-// operator- returns void!=RET -> specialization to return value==false
-template < typename RHS, typename RET >
-struct has_operator_unary_minus_impl2< RHS, RET, ::boost::true_type > {
-   static const bool value=false;
+template < typename Rhs >
+struct operator_returns_Ret < Rhs, dont_care, false > {
+   static const bool value = true;
 };
 
-// 5. main struct: to avoid any compilation error, this struct behaves
-// differently when:
-// - RET is void or non void
-// - operator-(RHS) is forbidden by the standard
-// forbidden_if is a bool that is:
-// - true when the operator-(RHS) is forbidden by the standard (would yield
-//   compilation error if used)
-// - false otherwise
-template < typename RHS, typename RET, bool forbidden_if >
-struct has_operator_unary_minus_impl1;
+template < typename Rhs >
+struct operator_returns_Ret < Rhs, void, true > {
+   static const bool value = true;
+};
 
-// specialization to avoid compilation error when forbidden by the standard
-template < typename RHS, typename RET >
-struct has_operator_unary_minus_impl1 < RHS, RET, true > {
-   static const bool value=false;
+template < typename Rhs >
+struct operator_returns_Ret < Rhs, void, false > {
+   static const bool value = false;
 };
 
-// checks for return type if template parameter RET is non void: use previously
-// defined struct
-template < typename RHS, typename RET >
-struct has_operator_unary_minus_impl1 < RHS, RET, false > {
-   static const bool value=(has_operator_unary_minus_impl2< RHS, RET, typename ::boost::integral_constant< bool, operator_unary_minus_returns_void< RHS >::value > >::value);
+template < typename Rhs, typename Ret >
+struct operator_returns_Ret < Rhs, Ret, true > {
+   static const bool value = false;
+};
+
+// when Ret!=void, checks if it is convertible to Ret using the sizeof trick
+// based on overload resolution
+template < typename Rhs, typename Ret >
+struct operator_returns_Ret < Rhs, Ret, false > {
+   static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret); // this version is preferred for types convertible to Ret
+   static ::boost::type_traits::no_type is_convertible_to_Ret(...); // this version is used otherwise
+
+   static const bool value = (sizeof(is_convertible_to_Ret(- make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
 };
 
-// in case we do not want to check for return type, we still need to know if our
-// definition of operator BOOST_TT_TRAIT_OP is used or an other existing one;
+
+// 4. we provide our operator definition for types that do not have one already
+
+// a type returned from operator- when no such operator is
+// found in the type's own namespace so that we have a means to know that our
+// operator was used
+struct tag { };
+
+// this class allows implicit conversions and makes the following operator
+// definition less-preferred than any other such operators that might be found
+// via argument-dependent name lookup
+struct any { template <class T> any(T const&); };
+
+// when operator- is not available, this one is used
+tag operator - (const any&);
+
+
+// 5. check for operator existence
+// condition: Rhs!=void
+
+// check if our definition of operator- is used or an other
+// existing one;
 // this is done with redefinition of "operator," that returns tag or tag2
 struct tag2 { };
 tag operator,(tag, tag2);
 
-// do not check for return type if 2nd template parameter RET is void
-template < typename RHS >
-struct has_operator_unary_minus_impl1< RHS, void, false > {
+template < typename Rhs >
+struct operator_exists {
    static ::boost::type_traits::yes_type check(tag2); // this version is preferred when operator exists
    static ::boost::type_traits::no_type check(tag); // this version is used otherwise
 
-   static const bool value=(sizeof(check(((-make<RHS>()),make<tag2>())))==sizeof(::boost::type_traits::yes_type));
+   static const bool value = (sizeof(check(((- make<Rhs>()),make<tag2>())))==sizeof(::boost::type_traits::yes_type));
 };
 
-// some specializations needs to be declared for the special void case
-template < typename RET >
-struct has_operator_unary_minus_impl1< void, RET, false > {
-   static const bool value=false;
+
+// 5. main trait: to avoid any compilation error, this struct behaves
+// differently when:
+// - operator-(Rhs) is forbidden by the standard
+// Forbidden_if is a bool that is:
+// - true when the operator-(Rhs) is forbidden by the standard
+//   (would yield compilation error if used)
+// - false otherwise
+template < typename Rhs, typename Ret, bool Forbidden_if >
+struct trait_impl1;
+
+template < typename Rhs, typename Ret >
+struct trait_impl1 < Rhs, Ret, true > {
+   static const bool value = false;
 };
 
-template <>
-struct has_operator_unary_minus_impl1< void, void, false > {
-   static const bool value=false;
+template < typename Rhs, typename Ret >
+struct trait_impl1 < Rhs, Ret, false > {
+   static const bool
+      value = (
+         ::boost::type_traits::ice_and<
+            operator_exists < Rhs >::value,
+            operator_returns_Ret < Rhs, Ret, operator_returns_void < Rhs >::value >::value
+         >::value
+      );
+};
+
+// specialization needs to be declared for the special void case
+template < typename Ret >
+struct trait_impl1 < void, Ret, false > {
+   static const bool value = false;
 };
 
 // defines some typedef for convenience
-template < typename RHS, typename RET >
-struct has_operator_unary_minus_impl {
-   // shortcuts for writing forbidden_if
-   typedef typename ::boost::remove_reference<RHS>::type rhs_noref;
-   typedef typename ::boost::remove_cv<rhs_noref>::type rhs_nocv;
-   typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<rhs_noref>::type >::type >::type rhs_noptr;
-   static const bool value=(has_operator_unary_minus_impl1 < rhs_noref, RET, ::boost::is_pointer< rhs_noref >::value >::value);
+template < typename Rhs, typename Ret >
+struct trait_impl {
+   typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
+   static const bool value = (trait_impl1 < Rhs_noref, Ret, ::boost::is_pointer< Rhs_noref >::value >::value);
 };
-} // namespace has_operator_unary_minus_impl
+
+} // namespace can_call_unary_minus_impl
 } // namespace detail
 
 // this is the accessible definition of the trait to end user
-template < typename RHS, typename RET=void >
-struct has_operator_unary_minus : ::boost::integral_constant< bool, (::boost::detail::has_operator_unary_minus_impl::has_operator_unary_minus_impl< RHS, RET >::value)> {
-};
+template < typename Rhs, typename Ret=::boost::detail::can_call_unary_minus_impl::dont_care >
+struct can_call_unary_minus : ::boost::integral_constant<bool,(::boost::detail::can_call_unary_minus_impl::trait_impl < Rhs, Ret >::value)> { };
+
 } // namespace boost
 ``
 
@@ -335,7 +305,7 @@
 
 ``
 struct A { private: A operator-(); };
-boost::has_operator_unary_minus<A>::value; // error: A::operator-() is private
+boost::can_call_unary_minus<A>::value; // error: A::operator-() is private
 ``
 
 * There is an issue if the operator exists only for type `A` and `B` is
@@ -347,8 +317,8 @@
 struct A { };
 void operator-(const A&);
 struct B { operator A(); };
-boost::has_operator_unary_minus<A>::value; // this is fine
-boost::has_operator_unary_minus<B>::value; // error: ambigous overload between
+boost::can_call_unary_minus<A>::value; // this is fine
+boost::can_call_unary_minus<B>::value; // error: ambigous overload between
                                            // operator-(const any&) and
                                            // operator-(const A&)
                                            // both need type conversion
@@ -357,8 +327,8 @@
 struct B { };
 struct A { A(const B&) { } };
 void operator-(const A&);
-boost::has_operator_unary_minus<A>::value; // this is fine
-boost::has_operator_unary_minus<B>::value; // error: ambigous overload between
+boost::can_call_unary_minus<A>::value; // this is fine
+boost::can_call_unary_minus<B>::value; // error: ambigous overload between
                                            // operator-(const any&) and
                                            // operator-(const A&)
                                            // both need type conversion

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-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -7,7 +7,7 @@
 
 [library Boost.TypeTraits
     [quickbook 1.4]
-    [copyright 2000 2011 Adobe Systems Inc, David Abrahams, Frédéric Bron, 
+    [copyright 2000 2011 Adobe Systems Inc, David Abrahams, Frederic 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]
@@ -165,6 +165,43 @@
 [include add_volatile.qbk]
 [include aligned_storage.qbk]
 [include alignment_of.qbk]
+[include can_call_addition.qbk]
+[include can_call_addition_assignment.qbk]
+[include can_call_and.qbk]
+[include can_call_bitwise_and.qbk]
+[include can_call_bitwise_and_assignment.qbk]
+[include can_call_bitwise_or.qbk]
+[include can_call_bitwise_or_assignment.qbk]
+[include can_call_bitwise_xor.qbk]
+[include can_call_bitwise_xor_assignment.qbk]
+[include can_call_complement.qbk]
+[include can_call_dereference.qbk]
+[include can_call_division.qbk]
+[include can_call_division_assignment.qbk]
+[include can_call_equal.qbk]
+[include can_call_greater.qbk]
+[include can_call_greater_equal.qbk]
+[include can_call_left_shift.qbk]
+[include can_call_left_shift_assignment.qbk]
+[include can_call_less.qbk]
+[include can_call_less_equal.qbk]
+[include can_call_modulus.qbk]
+[include can_call_modulus_assignment.qbk]
+[include can_call_multiplication.qbk]
+[include can_call_multiplication_assignment.qbk]
+[include can_call_not.qbk]
+[include can_call_not_equal.qbk]
+[include can_call_or.qbk]
+[include can_call_post_decrement.qbk]
+[include can_call_post_increment.qbk]
+[include can_call_pre_decrement.qbk]
+[include can_call_pre_increment.qbk]
+[include can_call_right_shift.qbk]
+[include can_call_right_shift_assignment.qbk]
+[include can_call_subtraction.qbk]
+[include can_call_subtraction_assignment.qbk]
+[include can_call_unary_minus.qbk]
+[include can_call_unary_plus.qbk]
 [include decay.qbk]
 [include extent.qbk]
 [include floating_point_promotion.qbk]
@@ -179,43 +216,6 @@
 [section:has_no_throw_def_cons has_nothrow_default_constructor]
 See __has_nothrow_constructor.
 [endsect]
-[include has_operator_bit_and.qbk]
-[include has_operator_bit_and_equal.qbk]
-[include has_operator_bit_or.qbk]
-[include has_operator_bit_or_equal.qbk]
-[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]
-[include has_operator_greater.qbk]
-[include has_operator_greater_equal.qbk]
-[include has_operator_left_shift.qbk]
-[include has_operator_left_shift_equal.qbk]
-[include has_operator_less.qbk]
-[include has_operator_less_equal.qbk]
-[include has_operator_logical_and.qbk]
-[include has_operator_logical_not.qbk]
-[include has_operator_logical_or.qbk]
-[include has_operator_minus.qbk]
-[include has_operator_minus_equal.qbk]
-[include has_operator_modulus.qbk]
-[include has_operator_modulus_equal.qbk]
-[include has_operator_multiplies.qbk]
-[include has_operator_multiplies_equal.qbk]
-[include has_operator_not_equal_to.qbk]
-[include has_operator_plus.qbk]
-[include has_operator_plus_equal.qbk]
-[include has_operator_postfix_decrement.qbk]
-[include has_operator_postfix_increment.qbk]
-[include has_operator_prefix_decrement.qbk]
-[include has_operator_prefix_increment.qbk]
-[include has_operator_right_shift.qbk]
-[include has_operator_right_shift_equal.qbk]
-[include has_operator_unary_minus.qbk]
-[include has_operator_unary_plus.qbk]
 [include has_trivial_assign.qbk]
 [include has_trivial_constructor.qbk]
 [include has_trivial_copy.qbk]

Modified: sandbox/type_traits/libs/type_traits/test/Jamfile.v2
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/Jamfile.v2	(original)
+++ sandbox/type_traits/libs/type_traits/test/Jamfile.v2	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -12,7 +12,7 @@
 
 rule non-operator-tests {
      local result ;
-     for local source in [ glob *_test.cpp : has_operator_*_test.cpp ] udt_specialisations.cpp
+     for local source in [ glob *_test.cpp : can_call_*_test.cpp ] udt_specialisations.cpp
      {
          result += [ run $(source) ] ;
      }
@@ -21,7 +21,7 @@
 
 rule operator-tests {
      local result ;
-     for local source in [ glob has_operator_*_test.cpp ]
+     for local source in [ glob can_call_*_test.cpp ]
      {
          result += [ run $(source) ] ;
      }

Added: sandbox/type_traits/libs/type_traits/test/can_call_addition_assignment_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_addition_assignment_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,33 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_addition_assignment.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_addition_assignment
+#define BOOST_TT_TRAIT_OP +=
+
+#include "can_call_binary_operators.hpp"
+#include "can_call_addition_assignment_test.hpp"
+
+namespace {
+void specific() {
+   /* nothing specific */
+}
+}
+
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_addition_assignment_test.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_addition_assignment_test.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,1250 @@
+//  (C) Copyright Frederic Bron 2009-2011.
+//  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)
+
+namespace {
+
+void run2() {
+   // test with only one template parameter
+   TEST_T(void, false);
+   TEST_T(bool, true);
+   TEST_T(char, true);
+   TEST_T(signed char, true);
+   TEST_T(short int, true);
+   TEST_T(int, true);
+   TEST_T(long int, true);
+   TEST_T(unsigned char, true);
+   TEST_T(unsigned short int, true);
+   TEST_T(unsigned int, true);
+   TEST_T(unsigned long int, true);
+   TEST_T(wchar_t, true);
+   TEST_T(float, true);
+   TEST_T(double, true);
+   TEST_T(long double, true);
+   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), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	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), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	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 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);
+   TEST_TT(bool, short int, true);
+   TEST_TT(bool, int, true);
+   TEST_TT(bool, long int, true);
+   TEST_TT(bool, unsigned char, true);
+   TEST_TT(bool, unsigned short int, true);
+   TEST_TT(bool, unsigned int, true);
+   TEST_TT(bool, unsigned long int, true);
+   TEST_TT(bool, wchar_t, true);
+   TEST_TT(bool, float, true);
+   TEST_TT(bool, double, true);
+   TEST_TT(bool, long double, true);
+   TEST_TT(char, bool, true);
+   TEST_TT(char, char, true);
+   TEST_TT(char, signed char, true);
+   TEST_TT(char, short int, true);
+   TEST_TT(char, int, true);
+   TEST_TT(char, long int, true);
+   TEST_TT(char, unsigned char, true);
+   TEST_TT(char, unsigned short int, true);
+   TEST_TT(char, unsigned int, true);
+   TEST_TT(char, unsigned long int, true);
+   TEST_TT(char, wchar_t, true);
+   TEST_TT(char, float, true);
+   TEST_TT(char, double, true);
+   TEST_TT(char, long double, true);
+   TEST_TT(signed char, bool, true);
+   TEST_TT(signed char, char, true);
+   TEST_TT(signed char, signed char, true);
+   TEST_TT(signed char, short int, true);
+   TEST_TT(signed char, int, true);
+   TEST_TT(signed char, long int, true);
+   TEST_TT(signed char, unsigned char, true);
+   TEST_TT(signed char, unsigned short int, true);
+   TEST_TT(signed char, unsigned int, true);
+   TEST_TT(signed char, unsigned long int, true);
+   TEST_TT(signed char, wchar_t, true);
+   TEST_TT(signed char, float, true);
+   TEST_TT(signed char, double, true);
+   TEST_TT(signed char, long double, true);
+   TEST_TT(short int, bool, true);
+   TEST_TT(short int, char, true);
+   TEST_TT(short int, signed char, true);
+   TEST_TT(short int, short int, true);
+   TEST_TT(short int, int, true);
+   TEST_TT(short int, long int, true);
+   TEST_TT(short int, unsigned char, true);
+   TEST_TT(short int, unsigned short int, true);
+   TEST_TT(short int, unsigned int, true);
+   TEST_TT(short int, unsigned long int, true);
+   TEST_TT(short int, wchar_t, true);
+   TEST_TT(short int, float, true);
+   TEST_TT(short int, double, true);
+   TEST_TT(short int, long double, true);
+   TEST_TT(int, bool, true);
+   TEST_TT(int, char, true);
+   TEST_TT(int, signed char, true);
+   TEST_TT(int, short int, true);
+   TEST_TT(int, int, true);
+   TEST_TT(int, long int, true);
+   TEST_TT(int, unsigned char, true);
+   TEST_TT(int, unsigned short int, true);
+   TEST_TT(int, unsigned int, true);
+   TEST_TT(int, unsigned long int, true);
+   TEST_TT(int, wchar_t, true);
+   TEST_TT(int, float, true);
+   TEST_TT(int, double, true);
+   TEST_TT(int, long double, true);
+   TEST_TT(long int, bool, true);
+   TEST_TT(long int, char, true);
+   TEST_TT(long int, signed char, true);
+   TEST_TT(long int, short int, true);
+   TEST_TT(long int, int, true);
+   TEST_TT(long int, long int, true);
+   TEST_TT(long int, unsigned char, true);
+   TEST_TT(long int, unsigned short int, true);
+   TEST_TT(long int, unsigned int, true);
+   TEST_TT(long int, unsigned long int, true);
+   TEST_TT(long int, wchar_t, true);
+   TEST_TT(long int, float, true);
+   TEST_TT(long int, double, true);
+   TEST_TT(long int, long double, true);
+   TEST_TT(unsigned char, bool, true);
+   TEST_TT(unsigned char, char, true);
+   TEST_TT(unsigned char, signed char, true);
+   TEST_TT(unsigned char, short int, true);
+   TEST_TT(unsigned char, int, true);
+   TEST_TT(unsigned char, long int, true);
+   TEST_TT(unsigned char, unsigned char, true);
+   TEST_TT(unsigned char, unsigned short int, true);
+   TEST_TT(unsigned char, unsigned int, true);
+   TEST_TT(unsigned char, unsigned long int, true);
+   TEST_TT(unsigned char, wchar_t, true);
+   TEST_TT(unsigned char, float, true);
+   TEST_TT(unsigned char, double, true);
+   TEST_TT(unsigned char, long double, true);
+   TEST_TT(unsigned short int, bool, true);
+   TEST_TT(unsigned short int, char, true);
+   TEST_TT(unsigned short int, signed char, true);
+   TEST_TT(unsigned short int, short int, true);
+   TEST_TT(unsigned short int, int, true);
+   TEST_TT(unsigned short int, long int, true);
+   TEST_TT(unsigned short int, unsigned char, true);
+   TEST_TT(unsigned short int, unsigned short int, true);
+   TEST_TT(unsigned short int, unsigned int, true);
+   TEST_TT(unsigned short int, unsigned long int, true);
+   TEST_TT(unsigned short int, wchar_t, true);
+   TEST_TT(unsigned short int, float, true);
+   TEST_TT(unsigned short int, double, true);
+   TEST_TT(unsigned short int, long double, true);
+   TEST_TT(unsigned int, bool, true);
+   TEST_TT(unsigned int, char, true);
+   TEST_TT(unsigned int, signed char, true);
+   TEST_TT(unsigned int, short int, true);
+   TEST_TT(unsigned int, int, true);
+   TEST_TT(unsigned int, long int, true);
+   TEST_TT(unsigned int, unsigned char, true);
+   TEST_TT(unsigned int, unsigned short int, true);
+   TEST_TT(unsigned int, unsigned int, true);
+   TEST_TT(unsigned int, unsigned long int, true);
+   TEST_TT(unsigned int, wchar_t, true);
+   TEST_TT(unsigned int, float, true);
+   TEST_TT(unsigned int, double, true);
+   TEST_TT(unsigned int, long double, true);
+   TEST_TT(unsigned long int, bool, true);
+   TEST_TT(unsigned long int, char, true);
+   TEST_TT(unsigned long int, signed char, true);
+   TEST_TT(unsigned long int, short int, true);
+   TEST_TT(unsigned long int, int, true);
+   TEST_TT(unsigned long int, long int, true);
+   TEST_TT(unsigned long int, unsigned char, true);
+   TEST_TT(unsigned long int, unsigned short int, true);
+   TEST_TT(unsigned long int, unsigned int, true);
+   TEST_TT(unsigned long int, unsigned long int, true);
+   TEST_TT(unsigned long int, wchar_t, true);
+   TEST_TT(unsigned long int, float, true);
+   TEST_TT(unsigned long int, double, true);
+   TEST_TT(unsigned long int, long double, true);
+   TEST_TT(wchar_t, bool, true);
+   TEST_TT(wchar_t, char, true);
+   TEST_TT(wchar_t, signed char, true);
+   TEST_TT(wchar_t, short int, true);
+   TEST_TT(wchar_t, int, true);
+   TEST_TT(wchar_t, long int, true);
+   TEST_TT(wchar_t, unsigned char, true);
+   TEST_TT(wchar_t, unsigned short int, true);
+   TEST_TT(wchar_t, unsigned int, true);
+   TEST_TT(wchar_t, unsigned long int, true);
+   TEST_TT(wchar_t, wchar_t, true);
+   TEST_TT(wchar_t, float, true);
+   TEST_TT(wchar_t, double, true);
+   TEST_TT(wchar_t, long double, true);
+   TEST_TT(float, bool, true);
+   TEST_TT(float, char, true);
+   TEST_TT(float, signed char, true);
+   TEST_TT(float, short int, true);
+   TEST_TT(float, int, true);
+   TEST_TT(float, long int, true);
+   TEST_TT(float, unsigned char, true);
+   TEST_TT(float, unsigned short int, true);
+   TEST_TT(float, unsigned int, true);
+   TEST_TT(float, unsigned long int, true);
+   TEST_TT(float, wchar_t, true);
+   TEST_TT(float, float, true);
+   TEST_TT(float, double, true);
+   TEST_TT(float, long double, true);
+   TEST_TT(double, bool, true);
+   TEST_TT(double, char, true);
+   TEST_TT(double, signed char, true);
+   TEST_TT(double, short int, true);
+   TEST_TT(double, int, true);
+   TEST_TT(double, long int, true);
+   TEST_TT(double, unsigned char, true);
+   TEST_TT(double, unsigned short int, true);
+   TEST_TT(double, unsigned int, true);
+   TEST_TT(double, unsigned long int, true);
+   TEST_TT(double, wchar_t, true);
+   TEST_TT(double, float, true);
+   TEST_TT(double, double, true);
+   TEST_TT(double, long double, true);
+   TEST_TT(long double, bool, true);
+   TEST_TT(long double, char, true);
+   TEST_TT(long double, signed char, true);
+   TEST_TT(long double, short int, true);
+   TEST_TT(long double, int, true);
+   TEST_TT(long double, long int, true);
+   TEST_TT(long double, unsigned char, true);
+   TEST_TT(long double, unsigned short int, true);
+   TEST_TT(long double, unsigned int, true);
+   TEST_TT(long double, unsigned long int, true);
+   TEST_TT(long double, wchar_t, true);
+   TEST_TT(long double, float, true);
+   TEST_TT(long double, double, true);
+   TEST_TT(long double, long double, true);
+   TEST_TT(bool, void, false);
+   TEST_TT(void, bool, false);
+   TEST_TT(char, void, false);
+   TEST_TT(void, char, false);
+   TEST_TT(signed char, void, false);
+   TEST_TT(void, signed char, false);
+   TEST_TT(short int, void, false);
+   TEST_TT(void, short int, false);
+   TEST_TT(int, void, false);
+   TEST_TT(void, int, false);
+   TEST_TT(long int, void, false);
+   TEST_TT(void, long int, false);
+   TEST_TT(unsigned char, void, false);
+   TEST_TT(void, unsigned char, false);
+   TEST_TT(unsigned short int, void, false);
+   TEST_TT(void, unsigned short int, false);
+   TEST_TT(unsigned int, void, false);
+   TEST_TT(void, unsigned int, false);
+   TEST_TT(unsigned long int, void, false);
+   TEST_TT(void, unsigned long int, false);
+   TEST_TT(wchar_t, void, false);
+   TEST_TT(void, wchar_t, false);
+   TEST_TT(float, void, false);
+   TEST_TT(void, float, false);
+   TEST_TT(double, void, false);
+   TEST_TT(void, double, false);
+   TEST_TT(long double, void, false);
+   TEST_TT(void, long double, false);
+
+// test with three template parameters
+   TEST_TTR(bool, bool, bool, true);
+   TEST_TTR(bool, char, bool, true);
+   TEST_TTR(bool, signed char, bool, true);
+   TEST_TTR(bool, short int, bool, true);
+   TEST_TTR(bool, int, bool, true);
+   TEST_TTR(bool, long int, bool, true);
+   TEST_TTR(bool, unsigned char, bool, true);
+   TEST_TTR(bool, unsigned short int, bool, true);
+   TEST_TTR(bool, unsigned int, bool, true);
+   TEST_TTR(bool, unsigned long int, bool, true);
+   TEST_TTR(bool, wchar_t, bool, true);
+   TEST_TTR(bool, float, bool, true);
+   TEST_TTR(bool, double, bool, true);
+   TEST_TTR(bool, long double, bool, true);
+   TEST_TTR(char, bool, bool, true);
+   TEST_TTR(char, char, bool, true);
+   TEST_TTR(char, signed char, bool, true);
+   TEST_TTR(char, short int, bool, true);
+   TEST_TTR(char, int, bool, true);
+   TEST_TTR(char, long int, bool, true);
+   TEST_TTR(char, unsigned char, bool, true);
+   TEST_TTR(char, unsigned short int, bool, true);
+   TEST_TTR(char, unsigned int, bool, true);
+   TEST_TTR(char, unsigned long int, bool, true);
+   TEST_TTR(char, wchar_t, bool, true);
+   TEST_TTR(char, float, bool, true);
+   TEST_TTR(char, double, bool, true);
+   TEST_TTR(char, long double, bool, true);
+   TEST_TTR(signed char, bool, bool, true);
+   TEST_TTR(signed char, char, bool, true);
+   TEST_TTR(signed char, signed char, bool, true);
+   TEST_TTR(signed char, short int, bool, true);
+   TEST_TTR(signed char, int, bool, true);
+   TEST_TTR(signed char, long int, bool, true);
+   TEST_TTR(signed char, unsigned char, bool, true);
+   TEST_TTR(signed char, unsigned short int, bool, true);
+   TEST_TTR(signed char, unsigned int, bool, true);
+   TEST_TTR(signed char, unsigned long int, bool, true);
+   TEST_TTR(signed char, wchar_t, bool, true);
+   TEST_TTR(signed char, float, bool, true);
+   TEST_TTR(signed char, double, bool, true);
+   TEST_TTR(signed char, long double, bool, true);
+   TEST_TTR(short int, bool, bool, true);
+   TEST_TTR(short int, char, bool, true);
+   TEST_TTR(short int, signed char, bool, true);
+   TEST_TTR(short int, short int, bool, true);
+   TEST_TTR(short int, int, bool, true);
+   TEST_TTR(short int, long int, bool, true);
+   TEST_TTR(short int, unsigned char, bool, true);
+   TEST_TTR(short int, unsigned short int, bool, true);
+   TEST_TTR(short int, unsigned int, bool, true);
+   TEST_TTR(short int, unsigned long int, bool, true);
+   TEST_TTR(short int, wchar_t, bool, true);
+   TEST_TTR(short int, float, bool, true);
+   TEST_TTR(short int, double, bool, true);
+   TEST_TTR(short int, long double, bool, true);
+   TEST_TTR(int, bool, bool, true);
+   TEST_TTR(int, char, bool, true);
+   TEST_TTR(int, signed char, bool, true);
+   TEST_TTR(int, short int, bool, true);
+   TEST_TTR(int, int, bool, true);
+   TEST_TTR(int, long int, bool, true);
+   TEST_TTR(int, unsigned char, bool, true);
+   TEST_TTR(int, unsigned short int, bool, true);
+   TEST_TTR(int, unsigned int, bool, true);
+   TEST_TTR(int, unsigned long int, bool, true);
+   TEST_TTR(int, wchar_t, bool, true);
+   TEST_TTR(int, float, bool, true);
+   TEST_TTR(int, double, bool, true);
+   TEST_TTR(int, long double, bool, true);
+   TEST_TTR(long int, bool, bool, true);
+   TEST_TTR(long int, char, bool, true);
+   TEST_TTR(long int, signed char, bool, true);
+   TEST_TTR(long int, short int, bool, true);
+   TEST_TTR(long int, int, bool, true);
+   TEST_TTR(long int, long int, bool, true);
+   TEST_TTR(long int, unsigned char, bool, true);
+   TEST_TTR(long int, unsigned short int, bool, true);
+   TEST_TTR(long int, unsigned int, bool, true);
+   TEST_TTR(long int, unsigned long int, bool, true);
+   TEST_TTR(long int, wchar_t, bool, true);
+   TEST_TTR(long int, float, bool, true);
+   TEST_TTR(long int, double, bool, true);
+   TEST_TTR(long int, long double, bool, true);
+   TEST_TTR(unsigned char, bool, bool, true);
+   TEST_TTR(unsigned char, char, bool, true);
+   TEST_TTR(unsigned char, signed char, bool, true);
+   TEST_TTR(unsigned char, short int, bool, true);
+   TEST_TTR(unsigned char, int, bool, true);
+   TEST_TTR(unsigned char, long int, bool, true);
+   TEST_TTR(unsigned char, unsigned char, bool, true);
+   TEST_TTR(unsigned char, unsigned short int, bool, true);
+   TEST_TTR(unsigned char, unsigned int, bool, true);
+   TEST_TTR(unsigned char, unsigned long int, bool, true);
+   TEST_TTR(unsigned char, wchar_t, bool, true);
+   TEST_TTR(unsigned char, float, bool, true);
+   TEST_TTR(unsigned char, double, bool, true);
+   TEST_TTR(unsigned char, long double, bool, true);
+   TEST_TTR(unsigned short int, bool, bool, true);
+   TEST_TTR(unsigned short int, char, bool, true);
+   TEST_TTR(unsigned short int, signed char, bool, true);
+   TEST_TTR(unsigned short int, short int, bool, true);
+   TEST_TTR(unsigned short int, int, bool, true);
+   TEST_TTR(unsigned short int, long int, bool, true);
+   TEST_TTR(unsigned short int, unsigned char, bool, true);
+   TEST_TTR(unsigned short int, unsigned short int, bool, true);
+   TEST_TTR(unsigned short int, unsigned int, bool, true);
+   TEST_TTR(unsigned short int, unsigned long int, bool, true);
+   TEST_TTR(unsigned short int, wchar_t, bool, true);
+   TEST_TTR(unsigned short int, float, bool, true);
+   TEST_TTR(unsigned short int, double, bool, true);
+   TEST_TTR(unsigned short int, long double, bool, true);
+   TEST_TTR(unsigned int, bool, bool, true);
+   TEST_TTR(unsigned int, char, bool, true);
+   TEST_TTR(unsigned int, signed char, bool, true);
+   TEST_TTR(unsigned int, short int, bool, true);
+   TEST_TTR(unsigned int, int, bool, true);
+   TEST_TTR(unsigned int, long int, bool, true);
+   TEST_TTR(unsigned int, unsigned char, bool, true);
+   TEST_TTR(unsigned int, unsigned short int, bool, true);
+   TEST_TTR(unsigned int, unsigned int, bool, true);
+   TEST_TTR(unsigned int, unsigned long int, bool, true);
+   TEST_TTR(unsigned int, wchar_t, bool, true);
+   TEST_TTR(unsigned int, float, bool, true);
+   TEST_TTR(unsigned int, double, bool, true);
+   TEST_TTR(unsigned int, long double, bool, true);
+   TEST_TTR(unsigned long int, bool, bool, true);
+   TEST_TTR(unsigned long int, char, bool, true);
+   TEST_TTR(unsigned long int, signed char, bool, true);
+   TEST_TTR(unsigned long int, short int, bool, true);
+   TEST_TTR(unsigned long int, int, bool, true);
+   TEST_TTR(unsigned long int, long int, bool, true);
+   TEST_TTR(unsigned long int, unsigned char, bool, true);
+   TEST_TTR(unsigned long int, unsigned short int, bool, true);
+   TEST_TTR(unsigned long int, unsigned int, bool, true);
+   TEST_TTR(unsigned long int, unsigned long int, bool, true);
+   TEST_TTR(unsigned long int, wchar_t, bool, true);
+   TEST_TTR(unsigned long int, float, bool, true);
+   TEST_TTR(unsigned long int, double, bool, true);
+   TEST_TTR(unsigned long int, long double, bool, true);
+   TEST_TTR(wchar_t, bool, bool, true);
+   TEST_TTR(wchar_t, char, bool, true);
+   TEST_TTR(wchar_t, signed char, bool, true);
+   TEST_TTR(wchar_t, short int, bool, true);
+   TEST_TTR(wchar_t, int, bool, true);
+   TEST_TTR(wchar_t, long int, bool, true);
+   TEST_TTR(wchar_t, unsigned char, bool, true);
+   TEST_TTR(wchar_t, unsigned short int, bool, true);
+   TEST_TTR(wchar_t, unsigned int, bool, true);
+   TEST_TTR(wchar_t, unsigned long int, bool, true);
+   TEST_TTR(wchar_t, wchar_t, bool, true);
+   TEST_TTR(wchar_t, float, bool, true);
+   TEST_TTR(wchar_t, double, bool, true);
+   TEST_TTR(wchar_t, long double, bool, true);
+   TEST_TTR(float, bool, bool, true);
+   TEST_TTR(float, char, bool, true);
+   TEST_TTR(float, signed char, bool, true);
+   TEST_TTR(float, short int, bool, true);
+   TEST_TTR(float, int, bool, true);
+   TEST_TTR(float, long int, bool, true);
+   TEST_TTR(float, unsigned char, bool, true);
+   TEST_TTR(float, unsigned short int, bool, true);
+   TEST_TTR(float, unsigned int, bool, true);
+   TEST_TTR(float, unsigned long int, bool, true);
+   TEST_TTR(float, wchar_t, bool, true);
+   TEST_TTR(float, float, bool, true);
+   TEST_TTR(float, double, bool, true);
+   TEST_TTR(float, long double, bool, true);
+   TEST_TTR(double, bool, bool, true);
+   TEST_TTR(double, char, bool, true);
+   TEST_TTR(double, signed char, bool, true);
+   TEST_TTR(double, short int, bool, true);
+   TEST_TTR(double, int, bool, true);
+   TEST_TTR(double, long int, bool, true);
+   TEST_TTR(double, unsigned char, bool, true);
+   TEST_TTR(double, unsigned short int, bool, true);
+   TEST_TTR(double, unsigned int, bool, true);
+   TEST_TTR(double, unsigned long int, bool, true);
+   TEST_TTR(double, wchar_t, bool, true);
+   TEST_TTR(double, float, bool, true);
+   TEST_TTR(double, double, bool, true);
+   TEST_TTR(double, long double, bool, true);
+   TEST_TTR(long double, bool, bool, true);
+   TEST_TTR(long double, char, bool, true);
+   TEST_TTR(long double, signed char, bool, true);
+   TEST_TTR(long double, short int, bool, true);
+   TEST_TTR(long double, int, bool, true);
+   TEST_TTR(long double, long int, bool, true);
+   TEST_TTR(long double, unsigned char, bool, true);
+   TEST_TTR(long double, unsigned short int, bool, true);
+   TEST_TTR(long double, unsigned int, bool, true);
+   TEST_TTR(long double, unsigned long int, bool, true);
+   TEST_TTR(long double, wchar_t, bool, true);
+   TEST_TTR(long double, float, bool, true);
+   TEST_TTR(long double, double, bool, true);
+   TEST_TTR(long double, long double, bool, true);
+   TEST_TTR(bool, bool, tag, false);
+   TEST_TTR(bool, char, tag, false);
+   TEST_TTR(bool, signed char, tag, false);
+   TEST_TTR(bool, short int, tag, false);
+   TEST_TTR(bool, int, tag, false);
+   TEST_TTR(bool, long int, tag, false);
+   TEST_TTR(bool, unsigned char, tag, false);
+   TEST_TTR(bool, unsigned short int, tag, false);
+   TEST_TTR(bool, unsigned int, tag, false);
+   TEST_TTR(bool, unsigned long int, tag, false);
+   TEST_TTR(bool, wchar_t, tag, false);
+   TEST_TTR(bool, float, tag, false);
+   TEST_TTR(bool, double, tag, false);
+   TEST_TTR(bool, long double, tag, false);
+   TEST_TTR(char, bool, tag, false);
+   TEST_TTR(char, char, tag, false);
+   TEST_TTR(char, signed char, tag, false);
+   TEST_TTR(char, short int, tag, false);
+   TEST_TTR(char, int, tag, false);
+   TEST_TTR(char, long int, tag, false);
+   TEST_TTR(char, unsigned char, tag, false);
+   TEST_TTR(char, unsigned short int, tag, false);
+   TEST_TTR(char, unsigned int, tag, false);
+   TEST_TTR(char, unsigned long int, tag, false);
+   TEST_TTR(char, wchar_t, tag, false);
+   TEST_TTR(char, float, tag, false);
+   TEST_TTR(char, double, tag, false);
+   TEST_TTR(char, long double, tag, false);
+   TEST_TTR(signed char, bool, tag, false);
+   TEST_TTR(signed char, char, tag, false);
+   TEST_TTR(signed char, signed char, tag, false);
+   TEST_TTR(signed char, short int, tag, false);
+   TEST_TTR(signed char, int, tag, false);
+   TEST_TTR(signed char, long int, tag, false);
+   TEST_TTR(signed char, unsigned char, tag, false);
+   TEST_TTR(signed char, unsigned short int, tag, false);
+   TEST_TTR(signed char, unsigned int, tag, false);
+   TEST_TTR(signed char, unsigned long int, tag, false);
+   TEST_TTR(signed char, wchar_t, tag, false);
+   TEST_TTR(signed char, float, tag, false);
+   TEST_TTR(signed char, double, tag, false);
+   TEST_TTR(signed char, long double, tag, false);
+   TEST_TTR(short int, bool, tag, false);
+   TEST_TTR(short int, char, tag, false);
+   TEST_TTR(short int, signed char, tag, false);
+   TEST_TTR(short int, short int, tag, false);
+   TEST_TTR(short int, int, tag, false);
+   TEST_TTR(short int, long int, tag, false);
+   TEST_TTR(short int, unsigned char, tag, false);
+   TEST_TTR(short int, unsigned short int, tag, false);
+   TEST_TTR(short int, unsigned int, tag, false);
+   TEST_TTR(short int, unsigned long int, tag, false);
+   TEST_TTR(short int, wchar_t, tag, false);
+   TEST_TTR(short int, float, tag, false);
+   TEST_TTR(short int, double, tag, false);
+   TEST_TTR(short int, long double, tag, false);
+   TEST_TTR(int, bool, tag, false);
+   TEST_TTR(int, char, tag, false);
+   TEST_TTR(int, signed char, tag, false);
+   TEST_TTR(int, short int, tag, false);
+   TEST_TTR(int, int, tag, false);
+   TEST_TTR(int, long int, tag, false);
+   TEST_TTR(int, unsigned char, tag, false);
+   TEST_TTR(int, unsigned short int, tag, false);
+   TEST_TTR(int, unsigned int, tag, false);
+   TEST_TTR(int, unsigned long int, tag, false);
+   TEST_TTR(int, wchar_t, tag, false);
+   TEST_TTR(int, float, tag, false);
+   TEST_TTR(int, double, tag, false);
+   TEST_TTR(int, long double, tag, false);
+   TEST_TTR(long int, bool, tag, false);
+   TEST_TTR(long int, char, tag, false);
+   TEST_TTR(long int, signed char, tag, false);
+   TEST_TTR(long int, short int, tag, false);
+   TEST_TTR(long int, int, tag, false);
+   TEST_TTR(long int, long int, tag, false);
+   TEST_TTR(long int, unsigned char, tag, false);
+   TEST_TTR(long int, unsigned short int, tag, false);
+   TEST_TTR(long int, unsigned int, tag, false);
+   TEST_TTR(long int, unsigned long int, tag, false);
+   TEST_TTR(long int, wchar_t, tag, false);
+   TEST_TTR(long int, float, tag, false);
+   TEST_TTR(long int, double, tag, false);
+   TEST_TTR(long int, long double, tag, false);
+   TEST_TTR(unsigned char, bool, tag, false);
+   TEST_TTR(unsigned char, char, tag, false);
+   TEST_TTR(unsigned char, signed char, tag, false);
+   TEST_TTR(unsigned char, short int, tag, false);
+   TEST_TTR(unsigned char, int, tag, false);
+   TEST_TTR(unsigned char, long int, tag, false);
+   TEST_TTR(unsigned char, unsigned char, tag, false);
+   TEST_TTR(unsigned char, unsigned short int, tag, false);
+   TEST_TTR(unsigned char, unsigned int, tag, false);
+   TEST_TTR(unsigned char, unsigned long int, tag, false);
+   TEST_TTR(unsigned char, wchar_t, tag, false);
+   TEST_TTR(unsigned char, float, tag, false);
+   TEST_TTR(unsigned char, double, tag, false);
+   TEST_TTR(unsigned char, long double, tag, false);
+   TEST_TTR(unsigned short int, bool, tag, false);
+   TEST_TTR(unsigned short int, char, tag, false);
+   TEST_TTR(unsigned short int, signed char, tag, false);
+   TEST_TTR(unsigned short int, short int, tag, false);
+   TEST_TTR(unsigned short int, int, tag, false);
+   TEST_TTR(unsigned short int, long int, tag, false);
+   TEST_TTR(unsigned short int, unsigned char, tag, false);
+   TEST_TTR(unsigned short int, unsigned short int, tag, false);
+   TEST_TTR(unsigned short int, unsigned int, tag, false);
+   TEST_TTR(unsigned short int, unsigned long int, tag, false);
+   TEST_TTR(unsigned short int, wchar_t, tag, false);
+   TEST_TTR(unsigned short int, float, tag, false);
+   TEST_TTR(unsigned short int, double, tag, false);
+   TEST_TTR(unsigned short int, long double, tag, false);
+   TEST_TTR(unsigned int, bool, tag, false);
+   TEST_TTR(unsigned int, char, tag, false);
+   TEST_TTR(unsigned int, signed char, tag, false);
+   TEST_TTR(unsigned int, short int, tag, false);
+   TEST_TTR(unsigned int, int, tag, false);
+   TEST_TTR(unsigned int, long int, tag, false);
+   TEST_TTR(unsigned int, unsigned char, tag, false);
+   TEST_TTR(unsigned int, unsigned short int, tag, false);
+   TEST_TTR(unsigned int, unsigned int, tag, false);
+   TEST_TTR(unsigned int, unsigned long int, tag, false);
+   TEST_TTR(unsigned int, wchar_t, tag, false);
+   TEST_TTR(unsigned int, float, tag, false);
+   TEST_TTR(unsigned int, double, tag, false);
+   TEST_TTR(unsigned int, long double, tag, false);
+   TEST_TTR(unsigned long int, bool, tag, false);
+   TEST_TTR(unsigned long int, char, tag, false);
+   TEST_TTR(unsigned long int, signed char, tag, false);
+   TEST_TTR(unsigned long int, short int, tag, false);
+   TEST_TTR(unsigned long int, int, tag, false);
+   TEST_TTR(unsigned long int, long int, tag, false);
+   TEST_TTR(unsigned long int, unsigned char, tag, false);
+   TEST_TTR(unsigned long int, unsigned short int, tag, false);
+   TEST_TTR(unsigned long int, unsigned int, tag, false);
+   TEST_TTR(unsigned long int, unsigned long int, tag, false);
+   TEST_TTR(unsigned long int, wchar_t, tag, false);
+   TEST_TTR(unsigned long int, float, tag, false);
+   TEST_TTR(unsigned long int, double, tag, false);
+   TEST_TTR(unsigned long int, long double, tag, false);
+   TEST_TTR(wchar_t, bool, tag, false);
+   TEST_TTR(wchar_t, char, tag, false);
+   TEST_TTR(wchar_t, signed char, tag, false);
+   TEST_TTR(wchar_t, short int, tag, false);
+   TEST_TTR(wchar_t, int, tag, false);
+   TEST_TTR(wchar_t, long int, tag, false);
+   TEST_TTR(wchar_t, unsigned char, tag, false);
+   TEST_TTR(wchar_t, unsigned short int, tag, false);
+   TEST_TTR(wchar_t, unsigned int, tag, false);
+   TEST_TTR(wchar_t, unsigned long int, tag, false);
+   TEST_TTR(wchar_t, wchar_t, tag, false);
+   TEST_TTR(wchar_t, float, tag, false);
+   TEST_TTR(wchar_t, double, tag, false);
+   TEST_TTR(wchar_t, long double, tag, false);
+   TEST_TTR(float, bool, tag, false);
+   TEST_TTR(float, char, tag, false);
+   TEST_TTR(float, signed char, tag, false);
+   TEST_TTR(float, short int, tag, false);
+   TEST_TTR(float, int, tag, false);
+   TEST_TTR(float, long int, tag, false);
+   TEST_TTR(float, unsigned char, tag, false);
+   TEST_TTR(float, unsigned short int, tag, false);
+   TEST_TTR(float, unsigned int, tag, false);
+   TEST_TTR(float, unsigned long int, tag, false);
+   TEST_TTR(float, wchar_t, tag, false);
+   TEST_TTR(float, float, tag, false);
+   TEST_TTR(float, double, tag, false);
+   TEST_TTR(float, long double, tag, false);
+   TEST_TTR(double, bool, tag, false);
+   TEST_TTR(double, char, tag, false);
+   TEST_TTR(double, signed char, tag, false);
+   TEST_TTR(double, short int, tag, false);
+   TEST_TTR(double, int, tag, false);
+   TEST_TTR(double, long int, tag, false);
+   TEST_TTR(double, unsigned char, tag, false);
+   TEST_TTR(double, unsigned short int, tag, false);
+   TEST_TTR(double, unsigned int, tag, false);
+   TEST_TTR(double, unsigned long int, tag, false);
+   TEST_TTR(double, wchar_t, tag, false);
+   TEST_TTR(double, float, tag, false);
+   TEST_TTR(double, double, tag, false);
+   TEST_TTR(double, long double, tag, false);
+   TEST_TTR(long double, bool, tag, false);
+   TEST_TTR(long double, char, tag, false);
+   TEST_TTR(long double, signed char, tag, false);
+   TEST_TTR(long double, short int, tag, false);
+   TEST_TTR(long double, int, tag, false);
+   TEST_TTR(long double, long int, tag, false);
+   TEST_TTR(long double, unsigned char, tag, false);
+   TEST_TTR(long double, unsigned short int, tag, false);
+   TEST_TTR(long double, unsigned int, tag, false);
+   TEST_TTR(long double, unsigned long int, tag, false);
+   TEST_TTR(long double, wchar_t, tag, false);
+   TEST_TTR(long double, float, tag, false);
+   TEST_TTR(long double, double, tag, false);
+   TEST_TTR(long double, long double, tag, false);
+#	undef CV1
+#	define CV1(T) const T
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), false);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), false);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, false);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), false);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), false);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, false);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const T&
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), false);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), false);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, false);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T&
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T&
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), false);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), false);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, false);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const T
+#	undef CV2
+#	define CV2(T) const T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), false);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), false);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, false);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const T&
+#	undef CV2
+#	define CV2(T) const T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), false);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), false);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, false);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T
+#	undef CV2
+#	define CV2(T) volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T&
+#	undef CV2
+#	define CV2(T) volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T
+#	undef CV2
+#	define CV2(T) const volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), false);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), false);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, false);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T&
+#	undef CV2
+#	define CV2(T) const volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), false);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), false);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, false);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+   // pointers
+   TEST_TT(void*, bool, false);
+   TEST_TT(void*, int, false);
+   TEST_TT(void*, double, false);
+   TEST_TT(void*, A, false);
+   TEST_TT(void*, B, false);
+   TEST_TT(bool*, bool, true);
+   TEST_TT(bool*, int, true);
+   TEST_TT(bool*, double, false);
+   TEST_TT(bool*, A, false);
+   TEST_TT(bool*, B, false);
+   TEST_TT(int*, bool, true);
+   TEST_TT(int*, int, true);
+   TEST_TT(int*, double, false);
+   TEST_TT(int*, A, false);
+   TEST_TT(int*, B, false);
+   TEST_TT(double*, bool, true);
+   TEST_TT(double*, int, true);
+   TEST_TT(double*, double, false);
+   TEST_TT(double*, A, false);
+   TEST_TT(double*, B, false);
+   TEST_TT(A*, bool, true);
+   TEST_TT(A*, int, true);
+   TEST_TT(A*, double, false);
+   TEST_TT(A*, A, false);
+   TEST_TT(A*, B, false);
+   TEST_TT(B*, bool, true);
+   TEST_TT(B*, int, true);
+   TEST_TT(B*, double, false);
+   TEST_TT(B*, A, false);
+   TEST_TT(B*, B, false);
+   TEST_TT(bool, void*, false);
+   TEST_TT(bool, bool*, true);
+   TEST_TT(bool, int*, true);
+   TEST_TT(bool, double*, true);
+   TEST_TT(bool, A*, true);
+   TEST_TT(bool, B*, true);
+   TEST_TT(int, void*, false);
+   TEST_TT(int, bool*, false);
+   TEST_TT(int, int*, false);
+   TEST_TT(int, double*, false);
+   TEST_TT(int, A*, false);
+   TEST_TT(int, B*, false);
+   TEST_TT(double, void*, false);
+   TEST_TT(double, bool*, false);
+   TEST_TT(double, int*, false);
+   TEST_TT(double, double*, false);
+   TEST_TT(double, A*, false);
+   TEST_TT(double, B*, false);
+   TEST_TT(A, void*, false);
+   TEST_TT(A, bool*, false);
+   TEST_TT(A, int*, false);
+   TEST_TT(A, double*, false);
+   TEST_TT(A, A*, false);
+   TEST_TT(A, B*, false);
+   TEST_TT(B, void*, false);
+   TEST_TT(B, bool*, false);
+   TEST_TT(B, int*, false);
+   TEST_TT(B, double*, false);
+   TEST_TT(B, A*, false);
+   TEST_TT(B, B*, false);
+   TEST_TT(void*, void*, false);
+   TEST_TT(void*, bool*, false);
+   TEST_TT(void*, int*, false);
+   TEST_TT(void*, double*, false);
+   TEST_TT(void*, A*, false);
+   TEST_TT(void*, B*, false);
+   TEST_TT(bool*, void*, false);
+   TEST_TT(bool*, bool*, false);
+   TEST_TT(bool*, int*, false);
+   TEST_TT(bool*, double*, false);
+   TEST_TT(bool*, A*, false);
+   TEST_TT(bool*, B*, false);
+   TEST_TT(int*, void*, false);
+   TEST_TT(int*, bool*, false);
+   TEST_TT(int*, int*, false);
+   TEST_TT(int*, double*, false);
+   TEST_TT(int*, A*, false);
+   TEST_TT(int*, B*, false);
+   TEST_TT(double*, void*, false);
+   TEST_TT(double*, bool*, false);
+   TEST_TT(double*, int*, false);
+   TEST_TT(double*, double*, false);
+   TEST_TT(double*, A*, false);
+   TEST_TT(double*, B*, false);
+   TEST_TT(A*, void*, false);
+   TEST_TT(A*, bool*, false);
+   TEST_TT(A*, int*, false);
+   TEST_TT(A*, double*, false);
+   TEST_TT(A*, A*, false);
+   TEST_TT(A*, B*, false);
+   TEST_TT(B*, void*, false);
+   TEST_TT(B*, bool*, false);
+   TEST_TT(B*, int*, false);
+   TEST_TT(B*, double*, false);
+   TEST_TT(B*, A*, false);
+   TEST_TT(B*, B*, false);
+   TEST_TT(C, void*, true);
+   TEST_TT(D, void*, false);
+   TEST_TT(void*, C, false);
+   TEST_TT(void*, D, true);
+   TEST_TT(C, D, true);
+}
+}

Added: sandbox/type_traits/libs/type_traits/test/can_call_addition_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_addition_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,33 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_addition.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_addition
+#define BOOST_TT_TRAIT_OP +
+
+#include "can_call_binary_operators.hpp"
+#include "can_call_addition_test.hpp"
+
+namespace {
+void specific() {
+   /* nothing specific */
+}
+}
+
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_addition_test.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_addition_test.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,1250 @@
+//  (C) Copyright Frederic Bron 2009-2011.
+//  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)
+
+namespace {
+
+void run2() {
+   // test with only one template parameter
+   TEST_T(void, false);
+   TEST_T(bool, true);
+   TEST_T(char, true);
+   TEST_T(signed char, true);
+   TEST_T(short int, true);
+   TEST_T(int, true);
+   TEST_T(long int, true);
+   TEST_T(unsigned char, true);
+   TEST_T(unsigned short int, true);
+   TEST_T(unsigned int, true);
+   TEST_T(unsigned long int, true);
+   TEST_T(wchar_t, true);
+   TEST_T(float, true);
+   TEST_T(double, true);
+   TEST_T(long double, true);
+   TEST_T(void, false);
+#	undef CV
+#	define CV(T) const T
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	undef CV
+#	define CV(T) volatile T
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	undef CV
+#	define CV(T) const volatile T
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	undef CV
+#	define CV(T) const T&
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	undef CV
+#	define CV(T) volatile T&
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	undef CV
+#	define CV(T) const volatile T&
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   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);
+   TEST_TT(bool, short int, true);
+   TEST_TT(bool, int, true);
+   TEST_TT(bool, long int, true);
+   TEST_TT(bool, unsigned char, true);
+   TEST_TT(bool, unsigned short int, true);
+   TEST_TT(bool, unsigned int, true);
+   TEST_TT(bool, unsigned long int, true);
+   TEST_TT(bool, wchar_t, true);
+   TEST_TT(bool, float, true);
+   TEST_TT(bool, double, true);
+   TEST_TT(bool, long double, true);
+   TEST_TT(char, bool, true);
+   TEST_TT(char, char, true);
+   TEST_TT(char, signed char, true);
+   TEST_TT(char, short int, true);
+   TEST_TT(char, int, true);
+   TEST_TT(char, long int, true);
+   TEST_TT(char, unsigned char, true);
+   TEST_TT(char, unsigned short int, true);
+   TEST_TT(char, unsigned int, true);
+   TEST_TT(char, unsigned long int, true);
+   TEST_TT(char, wchar_t, true);
+   TEST_TT(char, float, true);
+   TEST_TT(char, double, true);
+   TEST_TT(char, long double, true);
+   TEST_TT(signed char, bool, true);
+   TEST_TT(signed char, char, true);
+   TEST_TT(signed char, signed char, true);
+   TEST_TT(signed char, short int, true);
+   TEST_TT(signed char, int, true);
+   TEST_TT(signed char, long int, true);
+   TEST_TT(signed char, unsigned char, true);
+   TEST_TT(signed char, unsigned short int, true);
+   TEST_TT(signed char, unsigned int, true);
+   TEST_TT(signed char, unsigned long int, true);
+   TEST_TT(signed char, wchar_t, true);
+   TEST_TT(signed char, float, true);
+   TEST_TT(signed char, double, true);
+   TEST_TT(signed char, long double, true);
+   TEST_TT(short int, bool, true);
+   TEST_TT(short int, char, true);
+   TEST_TT(short int, signed char, true);
+   TEST_TT(short int, short int, true);
+   TEST_TT(short int, int, true);
+   TEST_TT(short int, long int, true);
+   TEST_TT(short int, unsigned char, true);
+   TEST_TT(short int, unsigned short int, true);
+   TEST_TT(short int, unsigned int, true);
+   TEST_TT(short int, unsigned long int, true);
+   TEST_TT(short int, wchar_t, true);
+   TEST_TT(short int, float, true);
+   TEST_TT(short int, double, true);
+   TEST_TT(short int, long double, true);
+   TEST_TT(int, bool, true);
+   TEST_TT(int, char, true);
+   TEST_TT(int, signed char, true);
+   TEST_TT(int, short int, true);
+   TEST_TT(int, int, true);
+   TEST_TT(int, long int, true);
+   TEST_TT(int, unsigned char, true);
+   TEST_TT(int, unsigned short int, true);
+   TEST_TT(int, unsigned int, true);
+   TEST_TT(int, unsigned long int, true);
+   TEST_TT(int, wchar_t, true);
+   TEST_TT(int, float, true);
+   TEST_TT(int, double, true);
+   TEST_TT(int, long double, true);
+   TEST_TT(long int, bool, true);
+   TEST_TT(long int, char, true);
+   TEST_TT(long int, signed char, true);
+   TEST_TT(long int, short int, true);
+   TEST_TT(long int, int, true);
+   TEST_TT(long int, long int, true);
+   TEST_TT(long int, unsigned char, true);
+   TEST_TT(long int, unsigned short int, true);
+   TEST_TT(long int, unsigned int, true);
+   TEST_TT(long int, unsigned long int, true);
+   TEST_TT(long int, wchar_t, true);
+   TEST_TT(long int, float, true);
+   TEST_TT(long int, double, true);
+   TEST_TT(long int, long double, true);
+   TEST_TT(unsigned char, bool, true);
+   TEST_TT(unsigned char, char, true);
+   TEST_TT(unsigned char, signed char, true);
+   TEST_TT(unsigned char, short int, true);
+   TEST_TT(unsigned char, int, true);
+   TEST_TT(unsigned char, long int, true);
+   TEST_TT(unsigned char, unsigned char, true);
+   TEST_TT(unsigned char, unsigned short int, true);
+   TEST_TT(unsigned char, unsigned int, true);
+   TEST_TT(unsigned char, unsigned long int, true);
+   TEST_TT(unsigned char, wchar_t, true);
+   TEST_TT(unsigned char, float, true);
+   TEST_TT(unsigned char, double, true);
+   TEST_TT(unsigned char, long double, true);
+   TEST_TT(unsigned short int, bool, true);
+   TEST_TT(unsigned short int, char, true);
+   TEST_TT(unsigned short int, signed char, true);
+   TEST_TT(unsigned short int, short int, true);
+   TEST_TT(unsigned short int, int, true);
+   TEST_TT(unsigned short int, long int, true);
+   TEST_TT(unsigned short int, unsigned char, true);
+   TEST_TT(unsigned short int, unsigned short int, true);
+   TEST_TT(unsigned short int, unsigned int, true);
+   TEST_TT(unsigned short int, unsigned long int, true);
+   TEST_TT(unsigned short int, wchar_t, true);
+   TEST_TT(unsigned short int, float, true);
+   TEST_TT(unsigned short int, double, true);
+   TEST_TT(unsigned short int, long double, true);
+   TEST_TT(unsigned int, bool, true);
+   TEST_TT(unsigned int, char, true);
+   TEST_TT(unsigned int, signed char, true);
+   TEST_TT(unsigned int, short int, true);
+   TEST_TT(unsigned int, int, true);
+   TEST_TT(unsigned int, long int, true);
+   TEST_TT(unsigned int, unsigned char, true);
+   TEST_TT(unsigned int, unsigned short int, true);
+   TEST_TT(unsigned int, unsigned int, true);
+   TEST_TT(unsigned int, unsigned long int, true);
+   TEST_TT(unsigned int, wchar_t, true);
+   TEST_TT(unsigned int, float, true);
+   TEST_TT(unsigned int, double, true);
+   TEST_TT(unsigned int, long double, true);
+   TEST_TT(unsigned long int, bool, true);
+   TEST_TT(unsigned long int, char, true);
+   TEST_TT(unsigned long int, signed char, true);
+   TEST_TT(unsigned long int, short int, true);
+   TEST_TT(unsigned long int, int, true);
+   TEST_TT(unsigned long int, long int, true);
+   TEST_TT(unsigned long int, unsigned char, true);
+   TEST_TT(unsigned long int, unsigned short int, true);
+   TEST_TT(unsigned long int, unsigned int, true);
+   TEST_TT(unsigned long int, unsigned long int, true);
+   TEST_TT(unsigned long int, wchar_t, true);
+   TEST_TT(unsigned long int, float, true);
+   TEST_TT(unsigned long int, double, true);
+   TEST_TT(unsigned long int, long double, true);
+   TEST_TT(wchar_t, bool, true);
+   TEST_TT(wchar_t, char, true);
+   TEST_TT(wchar_t, signed char, true);
+   TEST_TT(wchar_t, short int, true);
+   TEST_TT(wchar_t, int, true);
+   TEST_TT(wchar_t, long int, true);
+   TEST_TT(wchar_t, unsigned char, true);
+   TEST_TT(wchar_t, unsigned short int, true);
+   TEST_TT(wchar_t, unsigned int, true);
+   TEST_TT(wchar_t, unsigned long int, true);
+   TEST_TT(wchar_t, wchar_t, true);
+   TEST_TT(wchar_t, float, true);
+   TEST_TT(wchar_t, double, true);
+   TEST_TT(wchar_t, long double, true);
+   TEST_TT(float, bool, true);
+   TEST_TT(float, char, true);
+   TEST_TT(float, signed char, true);
+   TEST_TT(float, short int, true);
+   TEST_TT(float, int, true);
+   TEST_TT(float, long int, true);
+   TEST_TT(float, unsigned char, true);
+   TEST_TT(float, unsigned short int, true);
+   TEST_TT(float, unsigned int, true);
+   TEST_TT(float, unsigned long int, true);
+   TEST_TT(float, wchar_t, true);
+   TEST_TT(float, float, true);
+   TEST_TT(float, double, true);
+   TEST_TT(float, long double, true);
+   TEST_TT(double, bool, true);
+   TEST_TT(double, char, true);
+   TEST_TT(double, signed char, true);
+   TEST_TT(double, short int, true);
+   TEST_TT(double, int, true);
+   TEST_TT(double, long int, true);
+   TEST_TT(double, unsigned char, true);
+   TEST_TT(double, unsigned short int, true);
+   TEST_TT(double, unsigned int, true);
+   TEST_TT(double, unsigned long int, true);
+   TEST_TT(double, wchar_t, true);
+   TEST_TT(double, float, true);
+   TEST_TT(double, double, true);
+   TEST_TT(double, long double, true);
+   TEST_TT(long double, bool, true);
+   TEST_TT(long double, char, true);
+   TEST_TT(long double, signed char, true);
+   TEST_TT(long double, short int, true);
+   TEST_TT(long double, int, true);
+   TEST_TT(long double, long int, true);
+   TEST_TT(long double, unsigned char, true);
+   TEST_TT(long double, unsigned short int, true);
+   TEST_TT(long double, unsigned int, true);
+   TEST_TT(long double, unsigned long int, true);
+   TEST_TT(long double, wchar_t, true);
+   TEST_TT(long double, float, true);
+   TEST_TT(long double, double, true);
+   TEST_TT(long double, long double, true);
+   TEST_TT(bool, void, false);
+   TEST_TT(void, bool, false);
+   TEST_TT(char, void, false);
+   TEST_TT(void, char, false);
+   TEST_TT(signed char, void, false);
+   TEST_TT(void, signed char, false);
+   TEST_TT(short int, void, false);
+   TEST_TT(void, short int, false);
+   TEST_TT(int, void, false);
+   TEST_TT(void, int, false);
+   TEST_TT(long int, void, false);
+   TEST_TT(void, long int, false);
+   TEST_TT(unsigned char, void, false);
+   TEST_TT(void, unsigned char, false);
+   TEST_TT(unsigned short int, void, false);
+   TEST_TT(void, unsigned short int, false);
+   TEST_TT(unsigned int, void, false);
+   TEST_TT(void, unsigned int, false);
+   TEST_TT(unsigned long int, void, false);
+   TEST_TT(void, unsigned long int, false);
+   TEST_TT(wchar_t, void, false);
+   TEST_TT(void, wchar_t, false);
+   TEST_TT(float, void, false);
+   TEST_TT(void, float, false);
+   TEST_TT(double, void, false);
+   TEST_TT(void, double, false);
+   TEST_TT(long double, void, false);
+   TEST_TT(void, long double, false);
+
+// test with three template parameters
+   TEST_TTR(bool, bool, bool, true);
+   TEST_TTR(bool, char, bool, true);
+   TEST_TTR(bool, signed char, bool, true);
+   TEST_TTR(bool, short int, bool, true);
+   TEST_TTR(bool, int, bool, true);
+   TEST_TTR(bool, long int, bool, true);
+   TEST_TTR(bool, unsigned char, bool, true);
+   TEST_TTR(bool, unsigned short int, bool, true);
+   TEST_TTR(bool, unsigned int, bool, true);
+   TEST_TTR(bool, unsigned long int, bool, true);
+   TEST_TTR(bool, wchar_t, bool, true);
+   TEST_TTR(bool, float, bool, true);
+   TEST_TTR(bool, double, bool, true);
+   TEST_TTR(bool, long double, bool, true);
+   TEST_TTR(char, bool, bool, true);
+   TEST_TTR(char, char, bool, true);
+   TEST_TTR(char, signed char, bool, true);
+   TEST_TTR(char, short int, bool, true);
+   TEST_TTR(char, int, bool, true);
+   TEST_TTR(char, long int, bool, true);
+   TEST_TTR(char, unsigned char, bool, true);
+   TEST_TTR(char, unsigned short int, bool, true);
+   TEST_TTR(char, unsigned int, bool, true);
+   TEST_TTR(char, unsigned long int, bool, true);
+   TEST_TTR(char, wchar_t, bool, true);
+   TEST_TTR(char, float, bool, true);
+   TEST_TTR(char, double, bool, true);
+   TEST_TTR(char, long double, bool, true);
+   TEST_TTR(signed char, bool, bool, true);
+   TEST_TTR(signed char, char, bool, true);
+   TEST_TTR(signed char, signed char, bool, true);
+   TEST_TTR(signed char, short int, bool, true);
+   TEST_TTR(signed char, int, bool, true);
+   TEST_TTR(signed char, long int, bool, true);
+   TEST_TTR(signed char, unsigned char, bool, true);
+   TEST_TTR(signed char, unsigned short int, bool, true);
+   TEST_TTR(signed char, unsigned int, bool, true);
+   TEST_TTR(signed char, unsigned long int, bool, true);
+   TEST_TTR(signed char, wchar_t, bool, true);
+   TEST_TTR(signed char, float, bool, true);
+   TEST_TTR(signed char, double, bool, true);
+   TEST_TTR(signed char, long double, bool, true);
+   TEST_TTR(short int, bool, bool, true);
+   TEST_TTR(short int, char, bool, true);
+   TEST_TTR(short int, signed char, bool, true);
+   TEST_TTR(short int, short int, bool, true);
+   TEST_TTR(short int, int, bool, true);
+   TEST_TTR(short int, long int, bool, true);
+   TEST_TTR(short int, unsigned char, bool, true);
+   TEST_TTR(short int, unsigned short int, bool, true);
+   TEST_TTR(short int, unsigned int, bool, true);
+   TEST_TTR(short int, unsigned long int, bool, true);
+   TEST_TTR(short int, wchar_t, bool, true);
+   TEST_TTR(short int, float, bool, true);
+   TEST_TTR(short int, double, bool, true);
+   TEST_TTR(short int, long double, bool, true);
+   TEST_TTR(int, bool, bool, true);
+   TEST_TTR(int, char, bool, true);
+   TEST_TTR(int, signed char, bool, true);
+   TEST_TTR(int, short int, bool, true);
+   TEST_TTR(int, int, bool, true);
+   TEST_TTR(int, long int, bool, true);
+   TEST_TTR(int, unsigned char, bool, true);
+   TEST_TTR(int, unsigned short int, bool, true);
+   TEST_TTR(int, unsigned int, bool, true);
+   TEST_TTR(int, unsigned long int, bool, true);
+   TEST_TTR(int, wchar_t, bool, true);
+   TEST_TTR(int, float, bool, true);
+   TEST_TTR(int, double, bool, true);
+   TEST_TTR(int, long double, bool, true);
+   TEST_TTR(long int, bool, bool, true);
+   TEST_TTR(long int, char, bool, true);
+   TEST_TTR(long int, signed char, bool, true);
+   TEST_TTR(long int, short int, bool, true);
+   TEST_TTR(long int, int, bool, true);
+   TEST_TTR(long int, long int, bool, true);
+   TEST_TTR(long int, unsigned char, bool, true);
+   TEST_TTR(long int, unsigned short int, bool, true);
+   TEST_TTR(long int, unsigned int, bool, true);
+   TEST_TTR(long int, unsigned long int, bool, true);
+   TEST_TTR(long int, wchar_t, bool, true);
+   TEST_TTR(long int, float, bool, true);
+   TEST_TTR(long int, double, bool, true);
+   TEST_TTR(long int, long double, bool, true);
+   TEST_TTR(unsigned char, bool, bool, true);
+   TEST_TTR(unsigned char, char, bool, true);
+   TEST_TTR(unsigned char, signed char, bool, true);
+   TEST_TTR(unsigned char, short int, bool, true);
+   TEST_TTR(unsigned char, int, bool, true);
+   TEST_TTR(unsigned char, long int, bool, true);
+   TEST_TTR(unsigned char, unsigned char, bool, true);
+   TEST_TTR(unsigned char, unsigned short int, bool, true);
+   TEST_TTR(unsigned char, unsigned int, bool, true);
+   TEST_TTR(unsigned char, unsigned long int, bool, true);
+   TEST_TTR(unsigned char, wchar_t, bool, true);
+   TEST_TTR(unsigned char, float, bool, true);
+   TEST_TTR(unsigned char, double, bool, true);
+   TEST_TTR(unsigned char, long double, bool, true);
+   TEST_TTR(unsigned short int, bool, bool, true);
+   TEST_TTR(unsigned short int, char, bool, true);
+   TEST_TTR(unsigned short int, signed char, bool, true);
+   TEST_TTR(unsigned short int, short int, bool, true);
+   TEST_TTR(unsigned short int, int, bool, true);
+   TEST_TTR(unsigned short int, long int, bool, true);
+   TEST_TTR(unsigned short int, unsigned char, bool, true);
+   TEST_TTR(unsigned short int, unsigned short int, bool, true);
+   TEST_TTR(unsigned short int, unsigned int, bool, true);
+   TEST_TTR(unsigned short int, unsigned long int, bool, true);
+   TEST_TTR(unsigned short int, wchar_t, bool, true);
+   TEST_TTR(unsigned short int, float, bool, true);
+   TEST_TTR(unsigned short int, double, bool, true);
+   TEST_TTR(unsigned short int, long double, bool, true);
+   TEST_TTR(unsigned int, bool, bool, true);
+   TEST_TTR(unsigned int, char, bool, true);
+   TEST_TTR(unsigned int, signed char, bool, true);
+   TEST_TTR(unsigned int, short int, bool, true);
+   TEST_TTR(unsigned int, int, bool, true);
+   TEST_TTR(unsigned int, long int, bool, true);
+   TEST_TTR(unsigned int, unsigned char, bool, true);
+   TEST_TTR(unsigned int, unsigned short int, bool, true);
+   TEST_TTR(unsigned int, unsigned int, bool, true);
+   TEST_TTR(unsigned int, unsigned long int, bool, true);
+   TEST_TTR(unsigned int, wchar_t, bool, true);
+   TEST_TTR(unsigned int, float, bool, true);
+   TEST_TTR(unsigned int, double, bool, true);
+   TEST_TTR(unsigned int, long double, bool, true);
+   TEST_TTR(unsigned long int, bool, bool, true);
+   TEST_TTR(unsigned long int, char, bool, true);
+   TEST_TTR(unsigned long int, signed char, bool, true);
+   TEST_TTR(unsigned long int, short int, bool, true);
+   TEST_TTR(unsigned long int, int, bool, true);
+   TEST_TTR(unsigned long int, long int, bool, true);
+   TEST_TTR(unsigned long int, unsigned char, bool, true);
+   TEST_TTR(unsigned long int, unsigned short int, bool, true);
+   TEST_TTR(unsigned long int, unsigned int, bool, true);
+   TEST_TTR(unsigned long int, unsigned long int, bool, true);
+   TEST_TTR(unsigned long int, wchar_t, bool, true);
+   TEST_TTR(unsigned long int, float, bool, true);
+   TEST_TTR(unsigned long int, double, bool, true);
+   TEST_TTR(unsigned long int, long double, bool, true);
+   TEST_TTR(wchar_t, bool, bool, true);
+   TEST_TTR(wchar_t, char, bool, true);
+   TEST_TTR(wchar_t, signed char, bool, true);
+   TEST_TTR(wchar_t, short int, bool, true);
+   TEST_TTR(wchar_t, int, bool, true);
+   TEST_TTR(wchar_t, long int, bool, true);
+   TEST_TTR(wchar_t, unsigned char, bool, true);
+   TEST_TTR(wchar_t, unsigned short int, bool, true);
+   TEST_TTR(wchar_t, unsigned int, bool, true);
+   TEST_TTR(wchar_t, unsigned long int, bool, true);
+   TEST_TTR(wchar_t, wchar_t, bool, true);
+   TEST_TTR(wchar_t, float, bool, true);
+   TEST_TTR(wchar_t, double, bool, true);
+   TEST_TTR(wchar_t, long double, bool, true);
+   TEST_TTR(float, bool, bool, true);
+   TEST_TTR(float, char, bool, true);
+   TEST_TTR(float, signed char, bool, true);
+   TEST_TTR(float, short int, bool, true);
+   TEST_TTR(float, int, bool, true);
+   TEST_TTR(float, long int, bool, true);
+   TEST_TTR(float, unsigned char, bool, true);
+   TEST_TTR(float, unsigned short int, bool, true);
+   TEST_TTR(float, unsigned int, bool, true);
+   TEST_TTR(float, unsigned long int, bool, true);
+   TEST_TTR(float, wchar_t, bool, true);
+   TEST_TTR(float, float, bool, true);
+   TEST_TTR(float, double, bool, true);
+   TEST_TTR(float, long double, bool, true);
+   TEST_TTR(double, bool, bool, true);
+   TEST_TTR(double, char, bool, true);
+   TEST_TTR(double, signed char, bool, true);
+   TEST_TTR(double, short int, bool, true);
+   TEST_TTR(double, int, bool, true);
+   TEST_TTR(double, long int, bool, true);
+   TEST_TTR(double, unsigned char, bool, true);
+   TEST_TTR(double, unsigned short int, bool, true);
+   TEST_TTR(double, unsigned int, bool, true);
+   TEST_TTR(double, unsigned long int, bool, true);
+   TEST_TTR(double, wchar_t, bool, true);
+   TEST_TTR(double, float, bool, true);
+   TEST_TTR(double, double, bool, true);
+   TEST_TTR(double, long double, bool, true);
+   TEST_TTR(long double, bool, bool, true);
+   TEST_TTR(long double, char, bool, true);
+   TEST_TTR(long double, signed char, bool, true);
+   TEST_TTR(long double, short int, bool, true);
+   TEST_TTR(long double, int, bool, true);
+   TEST_TTR(long double, long int, bool, true);
+   TEST_TTR(long double, unsigned char, bool, true);
+   TEST_TTR(long double, unsigned short int, bool, true);
+   TEST_TTR(long double, unsigned int, bool, true);
+   TEST_TTR(long double, unsigned long int, bool, true);
+   TEST_TTR(long double, wchar_t, bool, true);
+   TEST_TTR(long double, float, bool, true);
+   TEST_TTR(long double, double, bool, true);
+   TEST_TTR(long double, long double, bool, true);
+   TEST_TTR(bool, bool, tag, false);
+   TEST_TTR(bool, char, tag, false);
+   TEST_TTR(bool, signed char, tag, false);
+   TEST_TTR(bool, short int, tag, false);
+   TEST_TTR(bool, int, tag, false);
+   TEST_TTR(bool, long int, tag, false);
+   TEST_TTR(bool, unsigned char, tag, false);
+   TEST_TTR(bool, unsigned short int, tag, false);
+   TEST_TTR(bool, unsigned int, tag, false);
+   TEST_TTR(bool, unsigned long int, tag, false);
+   TEST_TTR(bool, wchar_t, tag, false);
+   TEST_TTR(bool, float, tag, false);
+   TEST_TTR(bool, double, tag, false);
+   TEST_TTR(bool, long double, tag, false);
+   TEST_TTR(char, bool, tag, false);
+   TEST_TTR(char, char, tag, false);
+   TEST_TTR(char, signed char, tag, false);
+   TEST_TTR(char, short int, tag, false);
+   TEST_TTR(char, int, tag, false);
+   TEST_TTR(char, long int, tag, false);
+   TEST_TTR(char, unsigned char, tag, false);
+   TEST_TTR(char, unsigned short int, tag, false);
+   TEST_TTR(char, unsigned int, tag, false);
+   TEST_TTR(char, unsigned long int, tag, false);
+   TEST_TTR(char, wchar_t, tag, false);
+   TEST_TTR(char, float, tag, false);
+   TEST_TTR(char, double, tag, false);
+   TEST_TTR(char, long double, tag, false);
+   TEST_TTR(signed char, bool, tag, false);
+   TEST_TTR(signed char, char, tag, false);
+   TEST_TTR(signed char, signed char, tag, false);
+   TEST_TTR(signed char, short int, tag, false);
+   TEST_TTR(signed char, int, tag, false);
+   TEST_TTR(signed char, long int, tag, false);
+   TEST_TTR(signed char, unsigned char, tag, false);
+   TEST_TTR(signed char, unsigned short int, tag, false);
+   TEST_TTR(signed char, unsigned int, tag, false);
+   TEST_TTR(signed char, unsigned long int, tag, false);
+   TEST_TTR(signed char, wchar_t, tag, false);
+   TEST_TTR(signed char, float, tag, false);
+   TEST_TTR(signed char, double, tag, false);
+   TEST_TTR(signed char, long double, tag, false);
+   TEST_TTR(short int, bool, tag, false);
+   TEST_TTR(short int, char, tag, false);
+   TEST_TTR(short int, signed char, tag, false);
+   TEST_TTR(short int, short int, tag, false);
+   TEST_TTR(short int, int, tag, false);
+   TEST_TTR(short int, long int, tag, false);
+   TEST_TTR(short int, unsigned char, tag, false);
+   TEST_TTR(short int, unsigned short int, tag, false);
+   TEST_TTR(short int, unsigned int, tag, false);
+   TEST_TTR(short int, unsigned long int, tag, false);
+   TEST_TTR(short int, wchar_t, tag, false);
+   TEST_TTR(short int, float, tag, false);
+   TEST_TTR(short int, double, tag, false);
+   TEST_TTR(short int, long double, tag, false);
+   TEST_TTR(int, bool, tag, false);
+   TEST_TTR(int, char, tag, false);
+   TEST_TTR(int, signed char, tag, false);
+   TEST_TTR(int, short int, tag, false);
+   TEST_TTR(int, int, tag, false);
+   TEST_TTR(int, long int, tag, false);
+   TEST_TTR(int, unsigned char, tag, false);
+   TEST_TTR(int, unsigned short int, tag, false);
+   TEST_TTR(int, unsigned int, tag, false);
+   TEST_TTR(int, unsigned long int, tag, false);
+   TEST_TTR(int, wchar_t, tag, false);
+   TEST_TTR(int, float, tag, false);
+   TEST_TTR(int, double, tag, false);
+   TEST_TTR(int, long double, tag, false);
+   TEST_TTR(long int, bool, tag, false);
+   TEST_TTR(long int, char, tag, false);
+   TEST_TTR(long int, signed char, tag, false);
+   TEST_TTR(long int, short int, tag, false);
+   TEST_TTR(long int, int, tag, false);
+   TEST_TTR(long int, long int, tag, false);
+   TEST_TTR(long int, unsigned char, tag, false);
+   TEST_TTR(long int, unsigned short int, tag, false);
+   TEST_TTR(long int, unsigned int, tag, false);
+   TEST_TTR(long int, unsigned long int, tag, false);
+   TEST_TTR(long int, wchar_t, tag, false);
+   TEST_TTR(long int, float, tag, false);
+   TEST_TTR(long int, double, tag, false);
+   TEST_TTR(long int, long double, tag, false);
+   TEST_TTR(unsigned char, bool, tag, false);
+   TEST_TTR(unsigned char, char, tag, false);
+   TEST_TTR(unsigned char, signed char, tag, false);
+   TEST_TTR(unsigned char, short int, tag, false);
+   TEST_TTR(unsigned char, int, tag, false);
+   TEST_TTR(unsigned char, long int, tag, false);
+   TEST_TTR(unsigned char, unsigned char, tag, false);
+   TEST_TTR(unsigned char, unsigned short int, tag, false);
+   TEST_TTR(unsigned char, unsigned int, tag, false);
+   TEST_TTR(unsigned char, unsigned long int, tag, false);
+   TEST_TTR(unsigned char, wchar_t, tag, false);
+   TEST_TTR(unsigned char, float, tag, false);
+   TEST_TTR(unsigned char, double, tag, false);
+   TEST_TTR(unsigned char, long double, tag, false);
+   TEST_TTR(unsigned short int, bool, tag, false);
+   TEST_TTR(unsigned short int, char, tag, false);
+   TEST_TTR(unsigned short int, signed char, tag, false);
+   TEST_TTR(unsigned short int, short int, tag, false);
+   TEST_TTR(unsigned short int, int, tag, false);
+   TEST_TTR(unsigned short int, long int, tag, false);
+   TEST_TTR(unsigned short int, unsigned char, tag, false);
+   TEST_TTR(unsigned short int, unsigned short int, tag, false);
+   TEST_TTR(unsigned short int, unsigned int, tag, false);
+   TEST_TTR(unsigned short int, unsigned long int, tag, false);
+   TEST_TTR(unsigned short int, wchar_t, tag, false);
+   TEST_TTR(unsigned short int, float, tag, false);
+   TEST_TTR(unsigned short int, double, tag, false);
+   TEST_TTR(unsigned short int, long double, tag, false);
+   TEST_TTR(unsigned int, bool, tag, false);
+   TEST_TTR(unsigned int, char, tag, false);
+   TEST_TTR(unsigned int, signed char, tag, false);
+   TEST_TTR(unsigned int, short int, tag, false);
+   TEST_TTR(unsigned int, int, tag, false);
+   TEST_TTR(unsigned int, long int, tag, false);
+   TEST_TTR(unsigned int, unsigned char, tag, false);
+   TEST_TTR(unsigned int, unsigned short int, tag, false);
+   TEST_TTR(unsigned int, unsigned int, tag, false);
+   TEST_TTR(unsigned int, unsigned long int, tag, false);
+   TEST_TTR(unsigned int, wchar_t, tag, false);
+   TEST_TTR(unsigned int, float, tag, false);
+   TEST_TTR(unsigned int, double, tag, false);
+   TEST_TTR(unsigned int, long double, tag, false);
+   TEST_TTR(unsigned long int, bool, tag, false);
+   TEST_TTR(unsigned long int, char, tag, false);
+   TEST_TTR(unsigned long int, signed char, tag, false);
+   TEST_TTR(unsigned long int, short int, tag, false);
+   TEST_TTR(unsigned long int, int, tag, false);
+   TEST_TTR(unsigned long int, long int, tag, false);
+   TEST_TTR(unsigned long int, unsigned char, tag, false);
+   TEST_TTR(unsigned long int, unsigned short int, tag, false);
+   TEST_TTR(unsigned long int, unsigned int, tag, false);
+   TEST_TTR(unsigned long int, unsigned long int, tag, false);
+   TEST_TTR(unsigned long int, wchar_t, tag, false);
+   TEST_TTR(unsigned long int, float, tag, false);
+   TEST_TTR(unsigned long int, double, tag, false);
+   TEST_TTR(unsigned long int, long double, tag, false);
+   TEST_TTR(wchar_t, bool, tag, false);
+   TEST_TTR(wchar_t, char, tag, false);
+   TEST_TTR(wchar_t, signed char, tag, false);
+   TEST_TTR(wchar_t, short int, tag, false);
+   TEST_TTR(wchar_t, int, tag, false);
+   TEST_TTR(wchar_t, long int, tag, false);
+   TEST_TTR(wchar_t, unsigned char, tag, false);
+   TEST_TTR(wchar_t, unsigned short int, tag, false);
+   TEST_TTR(wchar_t, unsigned int, tag, false);
+   TEST_TTR(wchar_t, unsigned long int, tag, false);
+   TEST_TTR(wchar_t, wchar_t, tag, false);
+   TEST_TTR(wchar_t, float, tag, false);
+   TEST_TTR(wchar_t, double, tag, false);
+   TEST_TTR(wchar_t, long double, tag, false);
+   TEST_TTR(float, bool, tag, false);
+   TEST_TTR(float, char, tag, false);
+   TEST_TTR(float, signed char, tag, false);
+   TEST_TTR(float, short int, tag, false);
+   TEST_TTR(float, int, tag, false);
+   TEST_TTR(float, long int, tag, false);
+   TEST_TTR(float, unsigned char, tag, false);
+   TEST_TTR(float, unsigned short int, tag, false);
+   TEST_TTR(float, unsigned int, tag, false);
+   TEST_TTR(float, unsigned long int, tag, false);
+   TEST_TTR(float, wchar_t, tag, false);
+   TEST_TTR(float, float, tag, false);
+   TEST_TTR(float, double, tag, false);
+   TEST_TTR(float, long double, tag, false);
+   TEST_TTR(double, bool, tag, false);
+   TEST_TTR(double, char, tag, false);
+   TEST_TTR(double, signed char, tag, false);
+   TEST_TTR(double, short int, tag, false);
+   TEST_TTR(double, int, tag, false);
+   TEST_TTR(double, long int, tag, false);
+   TEST_TTR(double, unsigned char, tag, false);
+   TEST_TTR(double, unsigned short int, tag, false);
+   TEST_TTR(double, unsigned int, tag, false);
+   TEST_TTR(double, unsigned long int, tag, false);
+   TEST_TTR(double, wchar_t, tag, false);
+   TEST_TTR(double, float, tag, false);
+   TEST_TTR(double, double, tag, false);
+   TEST_TTR(double, long double, tag, false);
+   TEST_TTR(long double, bool, tag, false);
+   TEST_TTR(long double, char, tag, false);
+   TEST_TTR(long double, signed char, tag, false);
+   TEST_TTR(long double, short int, tag, false);
+   TEST_TTR(long double, int, tag, false);
+   TEST_TTR(long double, long int, tag, false);
+   TEST_TTR(long double, unsigned char, tag, false);
+   TEST_TTR(long double, unsigned short int, tag, false);
+   TEST_TTR(long double, unsigned int, tag, false);
+   TEST_TTR(long double, unsigned long int, tag, false);
+   TEST_TTR(long double, wchar_t, tag, false);
+   TEST_TTR(long double, float, tag, false);
+   TEST_TTR(long double, double, tag, false);
+   TEST_TTR(long double, long double, tag, false);
+#	undef CV1
+#	define CV1(T) const T
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const T&
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T&
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T&
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const T
+#	undef CV2
+#	define CV2(T) const T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const T&
+#	undef CV2
+#	define CV2(T) const T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T
+#	undef CV2
+#	define CV2(T) volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T&
+#	undef CV2
+#	define CV2(T) volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T
+#	undef CV2
+#	define CV2(T) const volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T&
+#	undef CV2
+#	define CV2(T) const volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+   // pointers
+   TEST_TT(void*, bool, false);
+   TEST_TT(void*, int, false);
+   TEST_TT(void*, double, false);
+   TEST_TT(void*, A, false);
+   TEST_TT(void*, B, false);
+   TEST_TT(bool*, bool, true);
+   TEST_TT(bool*, int, true);
+   TEST_TT(bool*, double, false);
+   TEST_TT(bool*, A, false);
+   TEST_TT(bool*, B, false);
+   TEST_TT(int*, bool, true);
+   TEST_TT(int*, int, true);
+   TEST_TT(int*, double, false);
+   TEST_TT(int*, A, false);
+   TEST_TT(int*, B, false);
+   TEST_TT(double*, bool, true);
+   TEST_TT(double*, int, true);
+   TEST_TT(double*, double, false);
+   TEST_TT(double*, A, false);
+   TEST_TT(double*, B, false);
+   TEST_TT(A*, bool, true);
+   TEST_TT(A*, int, true);
+   TEST_TT(A*, double, false);
+   TEST_TT(A*, A, false);
+   TEST_TT(A*, B, false);
+   TEST_TT(B*, bool, true);
+   TEST_TT(B*, int, true);
+   TEST_TT(B*, double, false);
+   TEST_TT(B*, A, false);
+   TEST_TT(B*, B, false);
+   TEST_TT(bool, void*, false);
+   TEST_TT(bool, bool*, true);
+   TEST_TT(bool, int*, true);
+   TEST_TT(bool, double*, true);
+   TEST_TT(bool, A*, true);
+   TEST_TT(bool, B*, true);
+   TEST_TT(int, void*, false);
+   TEST_TT(int, bool*, true);
+   TEST_TT(int, int*, true);
+   TEST_TT(int, double*, true);
+   TEST_TT(int, A*, true);
+   TEST_TT(int, B*, true);
+   TEST_TT(double, void*, false);
+   TEST_TT(double, bool*, false);
+   TEST_TT(double, int*, false);
+   TEST_TT(double, double*, false);
+   TEST_TT(double, A*, false);
+   TEST_TT(double, B*, false);
+   TEST_TT(A, void*, false);
+   TEST_TT(A, bool*, false);
+   TEST_TT(A, int*, false);
+   TEST_TT(A, double*, false);
+   TEST_TT(A, A*, false);
+   TEST_TT(A, B*, false);
+   TEST_TT(B, void*, false);
+   TEST_TT(B, bool*, false);
+   TEST_TT(B, int*, false);
+   TEST_TT(B, double*, false);
+   TEST_TT(B, A*, false);
+   TEST_TT(B, B*, false);
+   TEST_TT(void*, void*, false);
+   TEST_TT(void*, bool*, false);
+   TEST_TT(void*, int*, false);
+   TEST_TT(void*, double*, false);
+   TEST_TT(void*, A*, false);
+   TEST_TT(void*, B*, false);
+   TEST_TT(bool*, void*, false);
+   TEST_TT(bool*, bool*, false);
+   TEST_TT(bool*, int*, false);
+   TEST_TT(bool*, double*, false);
+   TEST_TT(bool*, A*, false);
+   TEST_TT(bool*, B*, false);
+   TEST_TT(int*, void*, false);
+   TEST_TT(int*, bool*, false);
+   TEST_TT(int*, int*, false);
+   TEST_TT(int*, double*, false);
+   TEST_TT(int*, A*, false);
+   TEST_TT(int*, B*, false);
+   TEST_TT(double*, void*, false);
+   TEST_TT(double*, bool*, false);
+   TEST_TT(double*, int*, false);
+   TEST_TT(double*, double*, false);
+   TEST_TT(double*, A*, false);
+   TEST_TT(double*, B*, false);
+   TEST_TT(A*, void*, false);
+   TEST_TT(A*, bool*, false);
+   TEST_TT(A*, int*, false);
+   TEST_TT(A*, double*, false);
+   TEST_TT(A*, A*, false);
+   TEST_TT(A*, B*, false);
+   TEST_TT(B*, void*, false);
+   TEST_TT(B*, bool*, false);
+   TEST_TT(B*, int*, false);
+   TEST_TT(B*, double*, false);
+   TEST_TT(B*, A*, false);
+   TEST_TT(B*, B*, false);
+   TEST_TT(C, void*, true);
+   TEST_TT(D, void*, false);
+   TEST_TT(void*, C, false);
+   TEST_TT(void*, D, true);
+   TEST_TT(C, D, true);
+}
+}

Added: sandbox/type_traits/libs/type_traits/test/can_call_and_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_and_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,33 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_and.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_and
+#define BOOST_TT_TRAIT_OP &&
+
+#include "can_call_binary_operators.hpp"
+#include "can_call_binary_logical_test.hpp"
+
+namespace {
+void specific() {
+   /* nothing specific */
+}
+}
+
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_binary_logical_test.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_binary_logical_test.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,1250 @@
+//  (C) Copyright Frederic Bron 2009-2011.
+//  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)
+
+namespace {
+
+void run2() {
+   // test with only one template parameter
+   TEST_T(void, false);
+   TEST_T(bool, true);
+   TEST_T(char, true);
+   TEST_T(signed char, true);
+   TEST_T(short int, true);
+   TEST_T(int, true);
+   TEST_T(long int, true);
+   TEST_T(unsigned char, true);
+   TEST_T(unsigned short int, true);
+   TEST_T(unsigned int, true);
+   TEST_T(unsigned long int, true);
+   TEST_T(wchar_t, true);
+   TEST_T(float, true);
+   TEST_T(double, true);
+   TEST_T(long double, true);
+   TEST_T(void, false);
+#	undef CV
+#	define CV(T) const T
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	undef CV
+#	define CV(T) volatile T
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	undef CV
+#	define CV(T) const volatile T
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	undef CV
+#	define CV(T) const T&
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	undef CV
+#	define CV(T) volatile T&
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	undef CV
+#	define CV(T) const volatile T&
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   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);
+   TEST_TT(bool, short int, true);
+   TEST_TT(bool, int, true);
+   TEST_TT(bool, long int, true);
+   TEST_TT(bool, unsigned char, true);
+   TEST_TT(bool, unsigned short int, true);
+   TEST_TT(bool, unsigned int, true);
+   TEST_TT(bool, unsigned long int, true);
+   TEST_TT(bool, wchar_t, true);
+   TEST_TT(bool, float, true);
+   TEST_TT(bool, double, true);
+   TEST_TT(bool, long double, true);
+   TEST_TT(char, bool, true);
+   TEST_TT(char, char, true);
+   TEST_TT(char, signed char, true);
+   TEST_TT(char, short int, true);
+   TEST_TT(char, int, true);
+   TEST_TT(char, long int, true);
+   TEST_TT(char, unsigned char, true);
+   TEST_TT(char, unsigned short int, true);
+   TEST_TT(char, unsigned int, true);
+   TEST_TT(char, unsigned long int, true);
+   TEST_TT(char, wchar_t, true);
+   TEST_TT(char, float, true);
+   TEST_TT(char, double, true);
+   TEST_TT(char, long double, true);
+   TEST_TT(signed char, bool, true);
+   TEST_TT(signed char, char, true);
+   TEST_TT(signed char, signed char, true);
+   TEST_TT(signed char, short int, true);
+   TEST_TT(signed char, int, true);
+   TEST_TT(signed char, long int, true);
+   TEST_TT(signed char, unsigned char, true);
+   TEST_TT(signed char, unsigned short int, true);
+   TEST_TT(signed char, unsigned int, true);
+   TEST_TT(signed char, unsigned long int, true);
+   TEST_TT(signed char, wchar_t, true);
+   TEST_TT(signed char, float, true);
+   TEST_TT(signed char, double, true);
+   TEST_TT(signed char, long double, true);
+   TEST_TT(short int, bool, true);
+   TEST_TT(short int, char, true);
+   TEST_TT(short int, signed char, true);
+   TEST_TT(short int, short int, true);
+   TEST_TT(short int, int, true);
+   TEST_TT(short int, long int, true);
+   TEST_TT(short int, unsigned char, true);
+   TEST_TT(short int, unsigned short int, true);
+   TEST_TT(short int, unsigned int, true);
+   TEST_TT(short int, unsigned long int, true);
+   TEST_TT(short int, wchar_t, true);
+   TEST_TT(short int, float, true);
+   TEST_TT(short int, double, true);
+   TEST_TT(short int, long double, true);
+   TEST_TT(int, bool, true);
+   TEST_TT(int, char, true);
+   TEST_TT(int, signed char, true);
+   TEST_TT(int, short int, true);
+   TEST_TT(int, int, true);
+   TEST_TT(int, long int, true);
+   TEST_TT(int, unsigned char, true);
+   TEST_TT(int, unsigned short int, true);
+   TEST_TT(int, unsigned int, true);
+   TEST_TT(int, unsigned long int, true);
+   TEST_TT(int, wchar_t, true);
+   TEST_TT(int, float, true);
+   TEST_TT(int, double, true);
+   TEST_TT(int, long double, true);
+   TEST_TT(long int, bool, true);
+   TEST_TT(long int, char, true);
+   TEST_TT(long int, signed char, true);
+   TEST_TT(long int, short int, true);
+   TEST_TT(long int, int, true);
+   TEST_TT(long int, long int, true);
+   TEST_TT(long int, unsigned char, true);
+   TEST_TT(long int, unsigned short int, true);
+   TEST_TT(long int, unsigned int, true);
+   TEST_TT(long int, unsigned long int, true);
+   TEST_TT(long int, wchar_t, true);
+   TEST_TT(long int, float, true);
+   TEST_TT(long int, double, true);
+   TEST_TT(long int, long double, true);
+   TEST_TT(unsigned char, bool, true);
+   TEST_TT(unsigned char, char, true);
+   TEST_TT(unsigned char, signed char, true);
+   TEST_TT(unsigned char, short int, true);
+   TEST_TT(unsigned char, int, true);
+   TEST_TT(unsigned char, long int, true);
+   TEST_TT(unsigned char, unsigned char, true);
+   TEST_TT(unsigned char, unsigned short int, true);
+   TEST_TT(unsigned char, unsigned int, true);
+   TEST_TT(unsigned char, unsigned long int, true);
+   TEST_TT(unsigned char, wchar_t, true);
+   TEST_TT(unsigned char, float, true);
+   TEST_TT(unsigned char, double, true);
+   TEST_TT(unsigned char, long double, true);
+   TEST_TT(unsigned short int, bool, true);
+   TEST_TT(unsigned short int, char, true);
+   TEST_TT(unsigned short int, signed char, true);
+   TEST_TT(unsigned short int, short int, true);
+   TEST_TT(unsigned short int, int, true);
+   TEST_TT(unsigned short int, long int, true);
+   TEST_TT(unsigned short int, unsigned char, true);
+   TEST_TT(unsigned short int, unsigned short int, true);
+   TEST_TT(unsigned short int, unsigned int, true);
+   TEST_TT(unsigned short int, unsigned long int, true);
+   TEST_TT(unsigned short int, wchar_t, true);
+   TEST_TT(unsigned short int, float, true);
+   TEST_TT(unsigned short int, double, true);
+   TEST_TT(unsigned short int, long double, true);
+   TEST_TT(unsigned int, bool, true);
+   TEST_TT(unsigned int, char, true);
+   TEST_TT(unsigned int, signed char, true);
+   TEST_TT(unsigned int, short int, true);
+   TEST_TT(unsigned int, int, true);
+   TEST_TT(unsigned int, long int, true);
+   TEST_TT(unsigned int, unsigned char, true);
+   TEST_TT(unsigned int, unsigned short int, true);
+   TEST_TT(unsigned int, unsigned int, true);
+   TEST_TT(unsigned int, unsigned long int, true);
+   TEST_TT(unsigned int, wchar_t, true);
+   TEST_TT(unsigned int, float, true);
+   TEST_TT(unsigned int, double, true);
+   TEST_TT(unsigned int, long double, true);
+   TEST_TT(unsigned long int, bool, true);
+   TEST_TT(unsigned long int, char, true);
+   TEST_TT(unsigned long int, signed char, true);
+   TEST_TT(unsigned long int, short int, true);
+   TEST_TT(unsigned long int, int, true);
+   TEST_TT(unsigned long int, long int, true);
+   TEST_TT(unsigned long int, unsigned char, true);
+   TEST_TT(unsigned long int, unsigned short int, true);
+   TEST_TT(unsigned long int, unsigned int, true);
+   TEST_TT(unsigned long int, unsigned long int, true);
+   TEST_TT(unsigned long int, wchar_t, true);
+   TEST_TT(unsigned long int, float, true);
+   TEST_TT(unsigned long int, double, true);
+   TEST_TT(unsigned long int, long double, true);
+   TEST_TT(wchar_t, bool, true);
+   TEST_TT(wchar_t, char, true);
+   TEST_TT(wchar_t, signed char, true);
+   TEST_TT(wchar_t, short int, true);
+   TEST_TT(wchar_t, int, true);
+   TEST_TT(wchar_t, long int, true);
+   TEST_TT(wchar_t, unsigned char, true);
+   TEST_TT(wchar_t, unsigned short int, true);
+   TEST_TT(wchar_t, unsigned int, true);
+   TEST_TT(wchar_t, unsigned long int, true);
+   TEST_TT(wchar_t, wchar_t, true);
+   TEST_TT(wchar_t, float, true);
+   TEST_TT(wchar_t, double, true);
+   TEST_TT(wchar_t, long double, true);
+   TEST_TT(float, bool, true);
+   TEST_TT(float, char, true);
+   TEST_TT(float, signed char, true);
+   TEST_TT(float, short int, true);
+   TEST_TT(float, int, true);
+   TEST_TT(float, long int, true);
+   TEST_TT(float, unsigned char, true);
+   TEST_TT(float, unsigned short int, true);
+   TEST_TT(float, unsigned int, true);
+   TEST_TT(float, unsigned long int, true);
+   TEST_TT(float, wchar_t, true);
+   TEST_TT(float, float, true);
+   TEST_TT(float, double, true);
+   TEST_TT(float, long double, true);
+   TEST_TT(double, bool, true);
+   TEST_TT(double, char, true);
+   TEST_TT(double, signed char, true);
+   TEST_TT(double, short int, true);
+   TEST_TT(double, int, true);
+   TEST_TT(double, long int, true);
+   TEST_TT(double, unsigned char, true);
+   TEST_TT(double, unsigned short int, true);
+   TEST_TT(double, unsigned int, true);
+   TEST_TT(double, unsigned long int, true);
+   TEST_TT(double, wchar_t, true);
+   TEST_TT(double, float, true);
+   TEST_TT(double, double, true);
+   TEST_TT(double, long double, true);
+   TEST_TT(long double, bool, true);
+   TEST_TT(long double, char, true);
+   TEST_TT(long double, signed char, true);
+   TEST_TT(long double, short int, true);
+   TEST_TT(long double, int, true);
+   TEST_TT(long double, long int, true);
+   TEST_TT(long double, unsigned char, true);
+   TEST_TT(long double, unsigned short int, true);
+   TEST_TT(long double, unsigned int, true);
+   TEST_TT(long double, unsigned long int, true);
+   TEST_TT(long double, wchar_t, true);
+   TEST_TT(long double, float, true);
+   TEST_TT(long double, double, true);
+   TEST_TT(long double, long double, true);
+   TEST_TT(bool, void, false);
+   TEST_TT(void, bool, false);
+   TEST_TT(char, void, false);
+   TEST_TT(void, char, false);
+   TEST_TT(signed char, void, false);
+   TEST_TT(void, signed char, false);
+   TEST_TT(short int, void, false);
+   TEST_TT(void, short int, false);
+   TEST_TT(int, void, false);
+   TEST_TT(void, int, false);
+   TEST_TT(long int, void, false);
+   TEST_TT(void, long int, false);
+   TEST_TT(unsigned char, void, false);
+   TEST_TT(void, unsigned char, false);
+   TEST_TT(unsigned short int, void, false);
+   TEST_TT(void, unsigned short int, false);
+   TEST_TT(unsigned int, void, false);
+   TEST_TT(void, unsigned int, false);
+   TEST_TT(unsigned long int, void, false);
+   TEST_TT(void, unsigned long int, false);
+   TEST_TT(wchar_t, void, false);
+   TEST_TT(void, wchar_t, false);
+   TEST_TT(float, void, false);
+   TEST_TT(void, float, false);
+   TEST_TT(double, void, false);
+   TEST_TT(void, double, false);
+   TEST_TT(long double, void, false);
+   TEST_TT(void, long double, false);
+
+// test with three template parameters
+   TEST_TTR(bool, bool, bool, true);
+   TEST_TTR(bool, char, bool, true);
+   TEST_TTR(bool, signed char, bool, true);
+   TEST_TTR(bool, short int, bool, true);
+   TEST_TTR(bool, int, bool, true);
+   TEST_TTR(bool, long int, bool, true);
+   TEST_TTR(bool, unsigned char, bool, true);
+   TEST_TTR(bool, unsigned short int, bool, true);
+   TEST_TTR(bool, unsigned int, bool, true);
+   TEST_TTR(bool, unsigned long int, bool, true);
+   TEST_TTR(bool, wchar_t, bool, true);
+   TEST_TTR(bool, float, bool, true);
+   TEST_TTR(bool, double, bool, true);
+   TEST_TTR(bool, long double, bool, true);
+   TEST_TTR(char, bool, bool, true);
+   TEST_TTR(char, char, bool, true);
+   TEST_TTR(char, signed char, bool, true);
+   TEST_TTR(char, short int, bool, true);
+   TEST_TTR(char, int, bool, true);
+   TEST_TTR(char, long int, bool, true);
+   TEST_TTR(char, unsigned char, bool, true);
+   TEST_TTR(char, unsigned short int, bool, true);
+   TEST_TTR(char, unsigned int, bool, true);
+   TEST_TTR(char, unsigned long int, bool, true);
+   TEST_TTR(char, wchar_t, bool, true);
+   TEST_TTR(char, float, bool, true);
+   TEST_TTR(char, double, bool, true);
+   TEST_TTR(char, long double, bool, true);
+   TEST_TTR(signed char, bool, bool, true);
+   TEST_TTR(signed char, char, bool, true);
+   TEST_TTR(signed char, signed char, bool, true);
+   TEST_TTR(signed char, short int, bool, true);
+   TEST_TTR(signed char, int, bool, true);
+   TEST_TTR(signed char, long int, bool, true);
+   TEST_TTR(signed char, unsigned char, bool, true);
+   TEST_TTR(signed char, unsigned short int, bool, true);
+   TEST_TTR(signed char, unsigned int, bool, true);
+   TEST_TTR(signed char, unsigned long int, bool, true);
+   TEST_TTR(signed char, wchar_t, bool, true);
+   TEST_TTR(signed char, float, bool, true);
+   TEST_TTR(signed char, double, bool, true);
+   TEST_TTR(signed char, long double, bool, true);
+   TEST_TTR(short int, bool, bool, true);
+   TEST_TTR(short int, char, bool, true);
+   TEST_TTR(short int, signed char, bool, true);
+   TEST_TTR(short int, short int, bool, true);
+   TEST_TTR(short int, int, bool, true);
+   TEST_TTR(short int, long int, bool, true);
+   TEST_TTR(short int, unsigned char, bool, true);
+   TEST_TTR(short int, unsigned short int, bool, true);
+   TEST_TTR(short int, unsigned int, bool, true);
+   TEST_TTR(short int, unsigned long int, bool, true);
+   TEST_TTR(short int, wchar_t, bool, true);
+   TEST_TTR(short int, float, bool, true);
+   TEST_TTR(short int, double, bool, true);
+   TEST_TTR(short int, long double, bool, true);
+   TEST_TTR(int, bool, bool, true);
+   TEST_TTR(int, char, bool, true);
+   TEST_TTR(int, signed char, bool, true);
+   TEST_TTR(int, short int, bool, true);
+   TEST_TTR(int, int, bool, true);
+   TEST_TTR(int, long int, bool, true);
+   TEST_TTR(int, unsigned char, bool, true);
+   TEST_TTR(int, unsigned short int, bool, true);
+   TEST_TTR(int, unsigned int, bool, true);
+   TEST_TTR(int, unsigned long int, bool, true);
+   TEST_TTR(int, wchar_t, bool, true);
+   TEST_TTR(int, float, bool, true);
+   TEST_TTR(int, double, bool, true);
+   TEST_TTR(int, long double, bool, true);
+   TEST_TTR(long int, bool, bool, true);
+   TEST_TTR(long int, char, bool, true);
+   TEST_TTR(long int, signed char, bool, true);
+   TEST_TTR(long int, short int, bool, true);
+   TEST_TTR(long int, int, bool, true);
+   TEST_TTR(long int, long int, bool, true);
+   TEST_TTR(long int, unsigned char, bool, true);
+   TEST_TTR(long int, unsigned short int, bool, true);
+   TEST_TTR(long int, unsigned int, bool, true);
+   TEST_TTR(long int, unsigned long int, bool, true);
+   TEST_TTR(long int, wchar_t, bool, true);
+   TEST_TTR(long int, float, bool, true);
+   TEST_TTR(long int, double, bool, true);
+   TEST_TTR(long int, long double, bool, true);
+   TEST_TTR(unsigned char, bool, bool, true);
+   TEST_TTR(unsigned char, char, bool, true);
+   TEST_TTR(unsigned char, signed char, bool, true);
+   TEST_TTR(unsigned char, short int, bool, true);
+   TEST_TTR(unsigned char, int, bool, true);
+   TEST_TTR(unsigned char, long int, bool, true);
+   TEST_TTR(unsigned char, unsigned char, bool, true);
+   TEST_TTR(unsigned char, unsigned short int, bool, true);
+   TEST_TTR(unsigned char, unsigned int, bool, true);
+   TEST_TTR(unsigned char, unsigned long int, bool, true);
+   TEST_TTR(unsigned char, wchar_t, bool, true);
+   TEST_TTR(unsigned char, float, bool, true);
+   TEST_TTR(unsigned char, double, bool, true);
+   TEST_TTR(unsigned char, long double, bool, true);
+   TEST_TTR(unsigned short int, bool, bool, true);
+   TEST_TTR(unsigned short int, char, bool, true);
+   TEST_TTR(unsigned short int, signed char, bool, true);
+   TEST_TTR(unsigned short int, short int, bool, true);
+   TEST_TTR(unsigned short int, int, bool, true);
+   TEST_TTR(unsigned short int, long int, bool, true);
+   TEST_TTR(unsigned short int, unsigned char, bool, true);
+   TEST_TTR(unsigned short int, unsigned short int, bool, true);
+   TEST_TTR(unsigned short int, unsigned int, bool, true);
+   TEST_TTR(unsigned short int, unsigned long int, bool, true);
+   TEST_TTR(unsigned short int, wchar_t, bool, true);
+   TEST_TTR(unsigned short int, float, bool, true);
+   TEST_TTR(unsigned short int, double, bool, true);
+   TEST_TTR(unsigned short int, long double, bool, true);
+   TEST_TTR(unsigned int, bool, bool, true);
+   TEST_TTR(unsigned int, char, bool, true);
+   TEST_TTR(unsigned int, signed char, bool, true);
+   TEST_TTR(unsigned int, short int, bool, true);
+   TEST_TTR(unsigned int, int, bool, true);
+   TEST_TTR(unsigned int, long int, bool, true);
+   TEST_TTR(unsigned int, unsigned char, bool, true);
+   TEST_TTR(unsigned int, unsigned short int, bool, true);
+   TEST_TTR(unsigned int, unsigned int, bool, true);
+   TEST_TTR(unsigned int, unsigned long int, bool, true);
+   TEST_TTR(unsigned int, wchar_t, bool, true);
+   TEST_TTR(unsigned int, float, bool, true);
+   TEST_TTR(unsigned int, double, bool, true);
+   TEST_TTR(unsigned int, long double, bool, true);
+   TEST_TTR(unsigned long int, bool, bool, true);
+   TEST_TTR(unsigned long int, char, bool, true);
+   TEST_TTR(unsigned long int, signed char, bool, true);
+   TEST_TTR(unsigned long int, short int, bool, true);
+   TEST_TTR(unsigned long int, int, bool, true);
+   TEST_TTR(unsigned long int, long int, bool, true);
+   TEST_TTR(unsigned long int, unsigned char, bool, true);
+   TEST_TTR(unsigned long int, unsigned short int, bool, true);
+   TEST_TTR(unsigned long int, unsigned int, bool, true);
+   TEST_TTR(unsigned long int, unsigned long int, bool, true);
+   TEST_TTR(unsigned long int, wchar_t, bool, true);
+   TEST_TTR(unsigned long int, float, bool, true);
+   TEST_TTR(unsigned long int, double, bool, true);
+   TEST_TTR(unsigned long int, long double, bool, true);
+   TEST_TTR(wchar_t, bool, bool, true);
+   TEST_TTR(wchar_t, char, bool, true);
+   TEST_TTR(wchar_t, signed char, bool, true);
+   TEST_TTR(wchar_t, short int, bool, true);
+   TEST_TTR(wchar_t, int, bool, true);
+   TEST_TTR(wchar_t, long int, bool, true);
+   TEST_TTR(wchar_t, unsigned char, bool, true);
+   TEST_TTR(wchar_t, unsigned short int, bool, true);
+   TEST_TTR(wchar_t, unsigned int, bool, true);
+   TEST_TTR(wchar_t, unsigned long int, bool, true);
+   TEST_TTR(wchar_t, wchar_t, bool, true);
+   TEST_TTR(wchar_t, float, bool, true);
+   TEST_TTR(wchar_t, double, bool, true);
+   TEST_TTR(wchar_t, long double, bool, true);
+   TEST_TTR(float, bool, bool, true);
+   TEST_TTR(float, char, bool, true);
+   TEST_TTR(float, signed char, bool, true);
+   TEST_TTR(float, short int, bool, true);
+   TEST_TTR(float, int, bool, true);
+   TEST_TTR(float, long int, bool, true);
+   TEST_TTR(float, unsigned char, bool, true);
+   TEST_TTR(float, unsigned short int, bool, true);
+   TEST_TTR(float, unsigned int, bool, true);
+   TEST_TTR(float, unsigned long int, bool, true);
+   TEST_TTR(float, wchar_t, bool, true);
+   TEST_TTR(float, float, bool, true);
+   TEST_TTR(float, double, bool, true);
+   TEST_TTR(float, long double, bool, true);
+   TEST_TTR(double, bool, bool, true);
+   TEST_TTR(double, char, bool, true);
+   TEST_TTR(double, signed char, bool, true);
+   TEST_TTR(double, short int, bool, true);
+   TEST_TTR(double, int, bool, true);
+   TEST_TTR(double, long int, bool, true);
+   TEST_TTR(double, unsigned char, bool, true);
+   TEST_TTR(double, unsigned short int, bool, true);
+   TEST_TTR(double, unsigned int, bool, true);
+   TEST_TTR(double, unsigned long int, bool, true);
+   TEST_TTR(double, wchar_t, bool, true);
+   TEST_TTR(double, float, bool, true);
+   TEST_TTR(double, double, bool, true);
+   TEST_TTR(double, long double, bool, true);
+   TEST_TTR(long double, bool, bool, true);
+   TEST_TTR(long double, char, bool, true);
+   TEST_TTR(long double, signed char, bool, true);
+   TEST_TTR(long double, short int, bool, true);
+   TEST_TTR(long double, int, bool, true);
+   TEST_TTR(long double, long int, bool, true);
+   TEST_TTR(long double, unsigned char, bool, true);
+   TEST_TTR(long double, unsigned short int, bool, true);
+   TEST_TTR(long double, unsigned int, bool, true);
+   TEST_TTR(long double, unsigned long int, bool, true);
+   TEST_TTR(long double, wchar_t, bool, true);
+   TEST_TTR(long double, float, bool, true);
+   TEST_TTR(long double, double, bool, true);
+   TEST_TTR(long double, long double, bool, true);
+   TEST_TTR(bool, bool, tag, false);
+   TEST_TTR(bool, char, tag, false);
+   TEST_TTR(bool, signed char, tag, false);
+   TEST_TTR(bool, short int, tag, false);
+   TEST_TTR(bool, int, tag, false);
+   TEST_TTR(bool, long int, tag, false);
+   TEST_TTR(bool, unsigned char, tag, false);
+   TEST_TTR(bool, unsigned short int, tag, false);
+   TEST_TTR(bool, unsigned int, tag, false);
+   TEST_TTR(bool, unsigned long int, tag, false);
+   TEST_TTR(bool, wchar_t, tag, false);
+   TEST_TTR(bool, float, tag, false);
+   TEST_TTR(bool, double, tag, false);
+   TEST_TTR(bool, long double, tag, false);
+   TEST_TTR(char, bool, tag, false);
+   TEST_TTR(char, char, tag, false);
+   TEST_TTR(char, signed char, tag, false);
+   TEST_TTR(char, short int, tag, false);
+   TEST_TTR(char, int, tag, false);
+   TEST_TTR(char, long int, tag, false);
+   TEST_TTR(char, unsigned char, tag, false);
+   TEST_TTR(char, unsigned short int, tag, false);
+   TEST_TTR(char, unsigned int, tag, false);
+   TEST_TTR(char, unsigned long int, tag, false);
+   TEST_TTR(char, wchar_t, tag, false);
+   TEST_TTR(char, float, tag, false);
+   TEST_TTR(char, double, tag, false);
+   TEST_TTR(char, long double, tag, false);
+   TEST_TTR(signed char, bool, tag, false);
+   TEST_TTR(signed char, char, tag, false);
+   TEST_TTR(signed char, signed char, tag, false);
+   TEST_TTR(signed char, short int, tag, false);
+   TEST_TTR(signed char, int, tag, false);
+   TEST_TTR(signed char, long int, tag, false);
+   TEST_TTR(signed char, unsigned char, tag, false);
+   TEST_TTR(signed char, unsigned short int, tag, false);
+   TEST_TTR(signed char, unsigned int, tag, false);
+   TEST_TTR(signed char, unsigned long int, tag, false);
+   TEST_TTR(signed char, wchar_t, tag, false);
+   TEST_TTR(signed char, float, tag, false);
+   TEST_TTR(signed char, double, tag, false);
+   TEST_TTR(signed char, long double, tag, false);
+   TEST_TTR(short int, bool, tag, false);
+   TEST_TTR(short int, char, tag, false);
+   TEST_TTR(short int, signed char, tag, false);
+   TEST_TTR(short int, short int, tag, false);
+   TEST_TTR(short int, int, tag, false);
+   TEST_TTR(short int, long int, tag, false);
+   TEST_TTR(short int, unsigned char, tag, false);
+   TEST_TTR(short int, unsigned short int, tag, false);
+   TEST_TTR(short int, unsigned int, tag, false);
+   TEST_TTR(short int, unsigned long int, tag, false);
+   TEST_TTR(short int, wchar_t, tag, false);
+   TEST_TTR(short int, float, tag, false);
+   TEST_TTR(short int, double, tag, false);
+   TEST_TTR(short int, long double, tag, false);
+   TEST_TTR(int, bool, tag, false);
+   TEST_TTR(int, char, tag, false);
+   TEST_TTR(int, signed char, tag, false);
+   TEST_TTR(int, short int, tag, false);
+   TEST_TTR(int, int, tag, false);
+   TEST_TTR(int, long int, tag, false);
+   TEST_TTR(int, unsigned char, tag, false);
+   TEST_TTR(int, unsigned short int, tag, false);
+   TEST_TTR(int, unsigned int, tag, false);
+   TEST_TTR(int, unsigned long int, tag, false);
+   TEST_TTR(int, wchar_t, tag, false);
+   TEST_TTR(int, float, tag, false);
+   TEST_TTR(int, double, tag, false);
+   TEST_TTR(int, long double, tag, false);
+   TEST_TTR(long int, bool, tag, false);
+   TEST_TTR(long int, char, tag, false);
+   TEST_TTR(long int, signed char, tag, false);
+   TEST_TTR(long int, short int, tag, false);
+   TEST_TTR(long int, int, tag, false);
+   TEST_TTR(long int, long int, tag, false);
+   TEST_TTR(long int, unsigned char, tag, false);
+   TEST_TTR(long int, unsigned short int, tag, false);
+   TEST_TTR(long int, unsigned int, tag, false);
+   TEST_TTR(long int, unsigned long int, tag, false);
+   TEST_TTR(long int, wchar_t, tag, false);
+   TEST_TTR(long int, float, tag, false);
+   TEST_TTR(long int, double, tag, false);
+   TEST_TTR(long int, long double, tag, false);
+   TEST_TTR(unsigned char, bool, tag, false);
+   TEST_TTR(unsigned char, char, tag, false);
+   TEST_TTR(unsigned char, signed char, tag, false);
+   TEST_TTR(unsigned char, short int, tag, false);
+   TEST_TTR(unsigned char, int, tag, false);
+   TEST_TTR(unsigned char, long int, tag, false);
+   TEST_TTR(unsigned char, unsigned char, tag, false);
+   TEST_TTR(unsigned char, unsigned short int, tag, false);
+   TEST_TTR(unsigned char, unsigned int, tag, false);
+   TEST_TTR(unsigned char, unsigned long int, tag, false);
+   TEST_TTR(unsigned char, wchar_t, tag, false);
+   TEST_TTR(unsigned char, float, tag, false);
+   TEST_TTR(unsigned char, double, tag, false);
+   TEST_TTR(unsigned char, long double, tag, false);
+   TEST_TTR(unsigned short int, bool, tag, false);
+   TEST_TTR(unsigned short int, char, tag, false);
+   TEST_TTR(unsigned short int, signed char, tag, false);
+   TEST_TTR(unsigned short int, short int, tag, false);
+   TEST_TTR(unsigned short int, int, tag, false);
+   TEST_TTR(unsigned short int, long int, tag, false);
+   TEST_TTR(unsigned short int, unsigned char, tag, false);
+   TEST_TTR(unsigned short int, unsigned short int, tag, false);
+   TEST_TTR(unsigned short int, unsigned int, tag, false);
+   TEST_TTR(unsigned short int, unsigned long int, tag, false);
+   TEST_TTR(unsigned short int, wchar_t, tag, false);
+   TEST_TTR(unsigned short int, float, tag, false);
+   TEST_TTR(unsigned short int, double, tag, false);
+   TEST_TTR(unsigned short int, long double, tag, false);
+   TEST_TTR(unsigned int, bool, tag, false);
+   TEST_TTR(unsigned int, char, tag, false);
+   TEST_TTR(unsigned int, signed char, tag, false);
+   TEST_TTR(unsigned int, short int, tag, false);
+   TEST_TTR(unsigned int, int, tag, false);
+   TEST_TTR(unsigned int, long int, tag, false);
+   TEST_TTR(unsigned int, unsigned char, tag, false);
+   TEST_TTR(unsigned int, unsigned short int, tag, false);
+   TEST_TTR(unsigned int, unsigned int, tag, false);
+   TEST_TTR(unsigned int, unsigned long int, tag, false);
+   TEST_TTR(unsigned int, wchar_t, tag, false);
+   TEST_TTR(unsigned int, float, tag, false);
+   TEST_TTR(unsigned int, double, tag, false);
+   TEST_TTR(unsigned int, long double, tag, false);
+   TEST_TTR(unsigned long int, bool, tag, false);
+   TEST_TTR(unsigned long int, char, tag, false);
+   TEST_TTR(unsigned long int, signed char, tag, false);
+   TEST_TTR(unsigned long int, short int, tag, false);
+   TEST_TTR(unsigned long int, int, tag, false);
+   TEST_TTR(unsigned long int, long int, tag, false);
+   TEST_TTR(unsigned long int, unsigned char, tag, false);
+   TEST_TTR(unsigned long int, unsigned short int, tag, false);
+   TEST_TTR(unsigned long int, unsigned int, tag, false);
+   TEST_TTR(unsigned long int, unsigned long int, tag, false);
+   TEST_TTR(unsigned long int, wchar_t, tag, false);
+   TEST_TTR(unsigned long int, float, tag, false);
+   TEST_TTR(unsigned long int, double, tag, false);
+   TEST_TTR(unsigned long int, long double, tag, false);
+   TEST_TTR(wchar_t, bool, tag, false);
+   TEST_TTR(wchar_t, char, tag, false);
+   TEST_TTR(wchar_t, signed char, tag, false);
+   TEST_TTR(wchar_t, short int, tag, false);
+   TEST_TTR(wchar_t, int, tag, false);
+   TEST_TTR(wchar_t, long int, tag, false);
+   TEST_TTR(wchar_t, unsigned char, tag, false);
+   TEST_TTR(wchar_t, unsigned short int, tag, false);
+   TEST_TTR(wchar_t, unsigned int, tag, false);
+   TEST_TTR(wchar_t, unsigned long int, tag, false);
+   TEST_TTR(wchar_t, wchar_t, tag, false);
+   TEST_TTR(wchar_t, float, tag, false);
+   TEST_TTR(wchar_t, double, tag, false);
+   TEST_TTR(wchar_t, long double, tag, false);
+   TEST_TTR(float, bool, tag, false);
+   TEST_TTR(float, char, tag, false);
+   TEST_TTR(float, signed char, tag, false);
+   TEST_TTR(float, short int, tag, false);
+   TEST_TTR(float, int, tag, false);
+   TEST_TTR(float, long int, tag, false);
+   TEST_TTR(float, unsigned char, tag, false);
+   TEST_TTR(float, unsigned short int, tag, false);
+   TEST_TTR(float, unsigned int, tag, false);
+   TEST_TTR(float, unsigned long int, tag, false);
+   TEST_TTR(float, wchar_t, tag, false);
+   TEST_TTR(float, float, tag, false);
+   TEST_TTR(float, double, tag, false);
+   TEST_TTR(float, long double, tag, false);
+   TEST_TTR(double, bool, tag, false);
+   TEST_TTR(double, char, tag, false);
+   TEST_TTR(double, signed char, tag, false);
+   TEST_TTR(double, short int, tag, false);
+   TEST_TTR(double, int, tag, false);
+   TEST_TTR(double, long int, tag, false);
+   TEST_TTR(double, unsigned char, tag, false);
+   TEST_TTR(double, unsigned short int, tag, false);
+   TEST_TTR(double, unsigned int, tag, false);
+   TEST_TTR(double, unsigned long int, tag, false);
+   TEST_TTR(double, wchar_t, tag, false);
+   TEST_TTR(double, float, tag, false);
+   TEST_TTR(double, double, tag, false);
+   TEST_TTR(double, long double, tag, false);
+   TEST_TTR(long double, bool, tag, false);
+   TEST_TTR(long double, char, tag, false);
+   TEST_TTR(long double, signed char, tag, false);
+   TEST_TTR(long double, short int, tag, false);
+   TEST_TTR(long double, int, tag, false);
+   TEST_TTR(long double, long int, tag, false);
+   TEST_TTR(long double, unsigned char, tag, false);
+   TEST_TTR(long double, unsigned short int, tag, false);
+   TEST_TTR(long double, unsigned int, tag, false);
+   TEST_TTR(long double, unsigned long int, tag, false);
+   TEST_TTR(long double, wchar_t, tag, false);
+   TEST_TTR(long double, float, tag, false);
+   TEST_TTR(long double, double, tag, false);
+   TEST_TTR(long double, long double, tag, false);
+#	undef CV1
+#	define CV1(T) const T
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const T&
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T&
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T&
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const T
+#	undef CV2
+#	define CV2(T) const T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const T&
+#	undef CV2
+#	define CV2(T) const T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T
+#	undef CV2
+#	define CV2(T) volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T&
+#	undef CV2
+#	define CV2(T) volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T
+#	undef CV2
+#	define CV2(T) const volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T&
+#	undef CV2
+#	define CV2(T) const volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+   // pointers
+   TEST_TT(void*, bool, true);
+   TEST_TT(void*, int, true);
+   TEST_TT(void*, double, true);
+   TEST_TT(void*, A, false);
+   TEST_TT(void*, B, false);
+   TEST_TT(bool*, bool, true);
+   TEST_TT(bool*, int, true);
+   TEST_TT(bool*, double, true);
+   TEST_TT(bool*, A, false);
+   TEST_TT(bool*, B, false);
+   TEST_TT(int*, bool, true);
+   TEST_TT(int*, int, true);
+   TEST_TT(int*, double, true);
+   TEST_TT(int*, A, false);
+   TEST_TT(int*, B, false);
+   TEST_TT(double*, bool, true);
+   TEST_TT(double*, int, true);
+   TEST_TT(double*, double, true);
+   TEST_TT(double*, A, false);
+   TEST_TT(double*, B, false);
+   TEST_TT(A*, bool, true);
+   TEST_TT(A*, int, true);
+   TEST_TT(A*, double, true);
+   TEST_TT(A*, A, false);
+   TEST_TT(A*, B, false);
+   TEST_TT(B*, bool, true);
+   TEST_TT(B*, int, true);
+   TEST_TT(B*, double, true);
+   TEST_TT(B*, A, false);
+   TEST_TT(B*, B, false);
+   TEST_TT(bool, void*, true);
+   TEST_TT(bool, bool*, true);
+   TEST_TT(bool, int*, true);
+   TEST_TT(bool, double*, true);
+   TEST_TT(bool, A*, true);
+   TEST_TT(bool, B*, true);
+   TEST_TT(int, void*, true);
+   TEST_TT(int, bool*, true);
+   TEST_TT(int, int*, true);
+   TEST_TT(int, double*, true);
+   TEST_TT(int, A*, true);
+   TEST_TT(int, B*, true);
+   TEST_TT(double, void*, true);
+   TEST_TT(double, bool*, true);
+   TEST_TT(double, int*, true);
+   TEST_TT(double, double*, true);
+   TEST_TT(double, A*, true);
+   TEST_TT(double, B*, true);
+   TEST_TT(A, void*, false);
+   TEST_TT(A, bool*, false);
+   TEST_TT(A, int*, false);
+   TEST_TT(A, double*, false);
+   TEST_TT(A, A*, false);
+   TEST_TT(A, B*, false);
+   TEST_TT(B, void*, false);
+   TEST_TT(B, bool*, false);
+   TEST_TT(B, int*, false);
+   TEST_TT(B, double*, false);
+   TEST_TT(B, A*, false);
+   TEST_TT(B, B*, false);
+   TEST_TT(void*, void*, true);
+   TEST_TT(void*, bool*, true);
+   TEST_TT(void*, int*, true);
+   TEST_TT(void*, double*, true);
+   TEST_TT(void*, A*, true);
+   TEST_TT(void*, B*, true);
+   TEST_TT(bool*, void*, true);
+   TEST_TT(bool*, bool*, true);
+   TEST_TT(bool*, int*, true);
+   TEST_TT(bool*, double*, true);
+   TEST_TT(bool*, A*, true);
+   TEST_TT(bool*, B*, true);
+   TEST_TT(int*, void*, true);
+   TEST_TT(int*, bool*, true);
+   TEST_TT(int*, int*, true);
+   TEST_TT(int*, double*, true);
+   TEST_TT(int*, A*, true);
+   TEST_TT(int*, B*, true);
+   TEST_TT(double*, void*, true);
+   TEST_TT(double*, bool*, true);
+   TEST_TT(double*, int*, true);
+   TEST_TT(double*, double*, true);
+   TEST_TT(double*, A*, true);
+   TEST_TT(double*, B*, true);
+   TEST_TT(A*, void*, true);
+   TEST_TT(A*, bool*, true);
+   TEST_TT(A*, int*, true);
+   TEST_TT(A*, double*, true);
+   TEST_TT(A*, A*, true);
+   TEST_TT(A*, B*, true);
+   TEST_TT(B*, void*, true);
+   TEST_TT(B*, bool*, true);
+   TEST_TT(B*, int*, true);
+   TEST_TT(B*, double*, true);
+   TEST_TT(B*, A*, true);
+   TEST_TT(B*, B*, true);
+   TEST_TT(C, void*, true);
+   TEST_TT(D, void*, false);
+   TEST_TT(void*, C, false);
+   TEST_TT(void*, D, true);
+   TEST_TT(C, D, true);
+}
+}

Added: sandbox/type_traits/libs/type_traits/test/can_call_binary_operators.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_binary_operators.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,140 @@
+//  (C) Copyright Frederic Bron 2009-2011.
+//  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)
+
+// 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,TYPE,RET>::value), RESULT)
+// test with two template parameters
+#define TEST_TT(TYPE1,TYPE2,RESULT) BOOST_CHECK_INTEGRAL_CONSTANT((::tt::BOOST_TT_TRAIT_NAME<TYPE1,TYPE2>::value), RESULT)
+// test with two template parameters plus return value
+#define TEST_TTR(TYPE1,TYPE2,RET,RESULT) BOOST_CHECK_INTEGRAL_CONSTANT((::tt::BOOST_TT_TRAIT_NAME<TYPE1,TYPE2,RET>::value), RESULT)
+
+namespace {
+
+struct without { };
+
+struct ret { };
+
+struct internal { ret operator BOOST_TT_TRAIT_OP (const internal&) const; };
+
+struct external { };
+ret operator BOOST_TT_TRAIT_OP (const external&, const external&);
+
+struct comma1_ret { };
+struct ret_with_comma1 { comma1_ret operator,(int); };
+
+struct internal_comma1 { ret_with_comma1 operator BOOST_TT_TRAIT_OP (const internal_comma1&) const; };
+
+struct external_comma1 { };
+ret_with_comma1 operator BOOST_TT_TRAIT_OP (const external_comma1&, const external_comma1&);
+
+struct ret_with_comma2 { void operator,(int); };
+
+struct internal_comma2 { ret_with_comma2 operator BOOST_TT_TRAIT_OP (const internal_comma2&) const; };
+
+struct external_comma2 { };
+ret_with_comma2 operator BOOST_TT_TRAIT_OP (const external_comma2&, const external_comma2&);
+
+struct returns_int { int operator BOOST_TT_TRAIT_OP (const returns_int&); };
+
+struct returns_void { void operator BOOST_TT_TRAIT_OP (const returns_void&); };
+
+struct returns_void_star { void *operator BOOST_TT_TRAIT_OP (const returns_void_star&); };
+
+struct returns_double { double operator BOOST_TT_TRAIT_OP (const returns_double&); };
+
+struct ret1 { };
+struct convertible_to_ret1 { operator ret1 () const; };
+struct returns_convertible_to_ret1 { convertible_to_ret1 operator BOOST_TT_TRAIT_OP (const returns_convertible_to_ret1&); };
+
+struct convertible_to_ret2 { };
+struct ret2 { ret2(const convertible_to_ret2); };
+struct returns_convertible_to_ret2 { convertible_to_ret2 operator BOOST_TT_TRAIT_OP (const returns_convertible_to_ret2&); };
+
+class Base1 { };
+class Derived1 : public Base1 { };
+
+bool operator BOOST_TT_TRAIT_OP (const Base1&, 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&, const Derived2&) { return true; }
+
+struct tag { };
+
+struct A { };
+struct B : public A { };
+
+struct C { };
+struct D { };
+bool operator BOOST_TT_TRAIT_OP (const C&, void*) { return true; }
+bool operator BOOST_TT_TRAIT_OP (void*, const D&) { return true; }
+bool operator BOOST_TT_TRAIT_OP (const C&, const D&) { return true; }
+
+//class internal_private { ret operator BOOST_TT_TRAIT_OP (const internal_private&) const; };
+
+void run1() {
+   TEST_T(void, false);
+   TEST_TT(void, void, false);
+   TEST_TTR(void, void, void, false);
+   TEST_TTR(void, void, int, false);
+
+   TEST_T(without, false);
+   TEST_T(internal, true);
+   TEST_T(external, true);
+   TEST_T(internal_comma1, true);
+   TEST_T(external_comma1, true);
+   TEST_T(internal_comma2, true);
+   TEST_T(external_comma2, true);
+   TEST_T(returns_int, true);
+   TEST_T(returns_void, true);
+   TEST_T(returns_void_star, true);
+   TEST_T(returns_double, true);
+   TEST_T(returns_convertible_to_ret1, true);
+   TEST_T(returns_convertible_to_ret2, true);
+   TEST_T(Base1, true);
+   TEST_T(Derived1, true);
+   TEST_T(Base2, false);
+   TEST_T(Derived2, true);
+
+   TEST_TR(without, void, false);
+   TEST_TR(without, bool, false);
+   TEST_TR(internal, void, false);
+   TEST_TR(internal, bool, false);
+   TEST_TR(internal, ret, true);
+   TEST_TR(internal_comma1, void, false);
+   TEST_TR(internal_comma1, bool, false);
+   TEST_TR(internal_comma1, ret_with_comma1, true);
+   TEST_TR(internal_comma2, void, false);
+   TEST_TR(internal_comma2, bool, false);
+   TEST_TR(internal_comma2, ret_with_comma2, true);
+   TEST_TR(external, void, false);
+   TEST_TR(external, bool, false);
+   TEST_TR(external, ret, true);
+   TEST_TR(returns_int, void, false);
+   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, void, false);
+   TEST_TR(returns_double, bool, true);
+   TEST_TR(returns_double, double, true);
+   TEST_TR(returns_convertible_to_ret1, void, false);
+   TEST_TR(returns_convertible_to_ret1, ret1, true);
+   TEST_TR(returns_convertible_to_ret2, ret2, true);
+   TEST_TR(Base1, bool, true);
+   TEST_TR(Derived1, bool, true);
+   TEST_TR(Base2, bool, false);
+   TEST_TR(Derived2, bool, true);
+// compile time error
+// TEST_T(internal_private, false);
+}
+
+}

Added: sandbox/type_traits/libs/type_traits/test/can_call_bitwise_and_assignment_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_bitwise_and_assignment_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,33 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_bitwise_and_assignment.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_bitwise_and_assignment
+#define BOOST_TT_TRAIT_OP &=
+
+#include "can_call_binary_operators.hpp"
+#include "can_call_integral_no_constlhs_test.hpp"
+
+namespace {
+void specific() {
+   /* nothing specific */
+}
+}
+
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_bitwise_and_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_bitwise_and_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,33 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_bitwise_and.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_bitwise_and
+#define BOOST_TT_TRAIT_OP &
+
+#include "can_call_binary_operators.hpp"
+#include "can_call_integral_test.hpp"
+
+namespace {
+void specific() {
+   /* nothing specific */
+}
+}
+
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_bitwise_or_assignment_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_bitwise_or_assignment_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,33 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_bitwise_or_assignment.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_bitwise_or_assignment
+#define BOOST_TT_TRAIT_OP |=
+
+#include "can_call_binary_operators.hpp"
+#include "can_call_integral_no_constlhs_test.hpp"
+
+namespace {
+void specific() {
+   /* nothing specific */
+}
+}
+
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_bitwise_or_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_bitwise_or_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,33 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_bitwise_or.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_bitwise_or
+#define BOOST_TT_TRAIT_OP |
+
+#include "can_call_binary_operators.hpp"
+#include "can_call_integral_test.hpp"
+
+namespace {
+void specific() {
+   /* nothing specific */
+}
+}
+
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_bitwise_xor_assignment_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_bitwise_xor_assignment_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,33 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_bitwise_xor_assignment.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_bitwise_xor_assignment
+#define BOOST_TT_TRAIT_OP ^=
+
+#include "can_call_binary_operators.hpp"
+#include "can_call_integral_no_constlhs_test.hpp"
+
+namespace {
+void specific() {
+   /* nothing specific */
+}
+}
+
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_bitwise_xor_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_bitwise_xor_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,33 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_bitwise_xor.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_bitwise_xor
+#define BOOST_TT_TRAIT_OP ^
+
+#include "can_call_binary_operators.hpp"
+#include "can_call_integral_test.hpp"
+
+namespace {
+void specific() {
+   /* nothing specific */
+}
+}
+
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_comparison_test.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_comparison_test.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,1250 @@
+//  (C) Copyright Frederic Bron 2009-2011.
+//  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)
+
+namespace {
+
+void run2() {
+   // test with only one template parameter
+   TEST_T(void, false);
+   TEST_T(bool, true);
+   TEST_T(char, true);
+   TEST_T(signed char, true);
+   TEST_T(short int, true);
+   TEST_T(int, true);
+   TEST_T(long int, true);
+   TEST_T(unsigned char, true);
+   TEST_T(unsigned short int, true);
+   TEST_T(unsigned int, true);
+   TEST_T(unsigned long int, true);
+   TEST_T(wchar_t, true);
+   TEST_T(float, true);
+   TEST_T(double, true);
+   TEST_T(long double, true);
+   TEST_T(void, false);
+#	undef CV
+#	define CV(T) const T
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	undef CV
+#	define CV(T) volatile T
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	undef CV
+#	define CV(T) const volatile T
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	undef CV
+#	define CV(T) const T&
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	undef CV
+#	define CV(T) volatile T&
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	undef CV
+#	define CV(T) const volatile T&
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   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);
+   TEST_TT(bool, short int, true);
+   TEST_TT(bool, int, true);
+   TEST_TT(bool, long int, true);
+   TEST_TT(bool, unsigned char, true);
+   TEST_TT(bool, unsigned short int, true);
+   TEST_TT(bool, unsigned int, true);
+   TEST_TT(bool, unsigned long int, true);
+   TEST_TT(bool, wchar_t, true);
+   TEST_TT(bool, float, true);
+   TEST_TT(bool, double, true);
+   TEST_TT(bool, long double, true);
+   TEST_TT(char, bool, true);
+   TEST_TT(char, char, true);
+   TEST_TT(char, signed char, true);
+   TEST_TT(char, short int, true);
+   TEST_TT(char, int, true);
+   TEST_TT(char, long int, true);
+   TEST_TT(char, unsigned char, true);
+   TEST_TT(char, unsigned short int, true);
+   TEST_TT(char, unsigned int, true);
+   TEST_TT(char, unsigned long int, true);
+   TEST_TT(char, wchar_t, true);
+   TEST_TT(char, float, true);
+   TEST_TT(char, double, true);
+   TEST_TT(char, long double, true);
+   TEST_TT(signed char, bool, true);
+   TEST_TT(signed char, char, true);
+   TEST_TT(signed char, signed char, true);
+   TEST_TT(signed char, short int, true);
+   TEST_TT(signed char, int, true);
+   TEST_TT(signed char, long int, true);
+   TEST_TT(signed char, unsigned char, true);
+   TEST_TT(signed char, unsigned short int, true);
+   TEST_TT(signed char, unsigned int, true);
+   TEST_TT(signed char, unsigned long int, true);
+   TEST_TT(signed char, wchar_t, true);
+   TEST_TT(signed char, float, true);
+   TEST_TT(signed char, double, true);
+   TEST_TT(signed char, long double, true);
+   TEST_TT(short int, bool, true);
+   TEST_TT(short int, char, true);
+   TEST_TT(short int, signed char, true);
+   TEST_TT(short int, short int, true);
+   TEST_TT(short int, int, true);
+   TEST_TT(short int, long int, true);
+   TEST_TT(short int, unsigned char, true);
+   TEST_TT(short int, unsigned short int, true);
+   TEST_TT(short int, unsigned int, true);
+   TEST_TT(short int, unsigned long int, true);
+   TEST_TT(short int, wchar_t, true);
+   TEST_TT(short int, float, true);
+   TEST_TT(short int, double, true);
+   TEST_TT(short int, long double, true);
+   TEST_TT(int, bool, true);
+   TEST_TT(int, char, true);
+   TEST_TT(int, signed char, true);
+   TEST_TT(int, short int, true);
+   TEST_TT(int, int, true);
+   TEST_TT(int, long int, true);
+   TEST_TT(int, unsigned char, true);
+   TEST_TT(int, unsigned short int, true);
+   TEST_TT(int, unsigned int, true);
+   TEST_TT(int, unsigned long int, true);
+   TEST_TT(int, wchar_t, true);
+   TEST_TT(int, float, true);
+   TEST_TT(int, double, true);
+   TEST_TT(int, long double, true);
+   TEST_TT(long int, bool, true);
+   TEST_TT(long int, char, true);
+   TEST_TT(long int, signed char, true);
+   TEST_TT(long int, short int, true);
+   TEST_TT(long int, int, true);
+   TEST_TT(long int, long int, true);
+   TEST_TT(long int, unsigned char, true);
+   TEST_TT(long int, unsigned short int, true);
+   TEST_TT(long int, unsigned int, true);
+   TEST_TT(long int, unsigned long int, true);
+   TEST_TT(long int, wchar_t, true);
+   TEST_TT(long int, float, true);
+   TEST_TT(long int, double, true);
+   TEST_TT(long int, long double, true);
+   TEST_TT(unsigned char, bool, true);
+   TEST_TT(unsigned char, char, true);
+   TEST_TT(unsigned char, signed char, true);
+   TEST_TT(unsigned char, short int, true);
+   TEST_TT(unsigned char, int, true);
+   TEST_TT(unsigned char, long int, true);
+   TEST_TT(unsigned char, unsigned char, true);
+   TEST_TT(unsigned char, unsigned short int, true);
+   TEST_TT(unsigned char, unsigned int, true);
+   TEST_TT(unsigned char, unsigned long int, true);
+   TEST_TT(unsigned char, wchar_t, true);
+   TEST_TT(unsigned char, float, true);
+   TEST_TT(unsigned char, double, true);
+   TEST_TT(unsigned char, long double, true);
+   TEST_TT(unsigned short int, bool, true);
+   TEST_TT(unsigned short int, char, true);
+   TEST_TT(unsigned short int, signed char, true);
+   TEST_TT(unsigned short int, short int, true);
+   TEST_TT(unsigned short int, int, true);
+   TEST_TT(unsigned short int, long int, true);
+   TEST_TT(unsigned short int, unsigned char, true);
+   TEST_TT(unsigned short int, unsigned short int, true);
+   TEST_TT(unsigned short int, unsigned int, true);
+   TEST_TT(unsigned short int, unsigned long int, true);
+   TEST_TT(unsigned short int, wchar_t, true);
+   TEST_TT(unsigned short int, float, true);
+   TEST_TT(unsigned short int, double, true);
+   TEST_TT(unsigned short int, long double, true);
+   TEST_TT(unsigned int, bool, true);
+   TEST_TT(unsigned int, char, true);
+   TEST_TT(unsigned int, signed char, true);
+   TEST_TT(unsigned int, short int, true);
+   TEST_TT(unsigned int, int, true);
+   TEST_TT(unsigned int, long int, true);
+   TEST_TT(unsigned int, unsigned char, true);
+   TEST_TT(unsigned int, unsigned short int, true);
+   TEST_TT(unsigned int, unsigned int, true);
+   TEST_TT(unsigned int, unsigned long int, true);
+   TEST_TT(unsigned int, wchar_t, true);
+   TEST_TT(unsigned int, float, true);
+   TEST_TT(unsigned int, double, true);
+   TEST_TT(unsigned int, long double, true);
+   TEST_TT(unsigned long int, bool, true);
+   TEST_TT(unsigned long int, char, true);
+   TEST_TT(unsigned long int, signed char, true);
+   TEST_TT(unsigned long int, short int, true);
+   TEST_TT(unsigned long int, int, true);
+   TEST_TT(unsigned long int, long int, true);
+   TEST_TT(unsigned long int, unsigned char, true);
+   TEST_TT(unsigned long int, unsigned short int, true);
+   TEST_TT(unsigned long int, unsigned int, true);
+   TEST_TT(unsigned long int, unsigned long int, true);
+   TEST_TT(unsigned long int, wchar_t, true);
+   TEST_TT(unsigned long int, float, true);
+   TEST_TT(unsigned long int, double, true);
+   TEST_TT(unsigned long int, long double, true);
+   TEST_TT(wchar_t, bool, true);
+   TEST_TT(wchar_t, char, true);
+   TEST_TT(wchar_t, signed char, true);
+   TEST_TT(wchar_t, short int, true);
+   TEST_TT(wchar_t, int, true);
+   TEST_TT(wchar_t, long int, true);
+   TEST_TT(wchar_t, unsigned char, true);
+   TEST_TT(wchar_t, unsigned short int, true);
+   TEST_TT(wchar_t, unsigned int, true);
+   TEST_TT(wchar_t, unsigned long int, true);
+   TEST_TT(wchar_t, wchar_t, true);
+   TEST_TT(wchar_t, float, true);
+   TEST_TT(wchar_t, double, true);
+   TEST_TT(wchar_t, long double, true);
+   TEST_TT(float, bool, true);
+   TEST_TT(float, char, true);
+   TEST_TT(float, signed char, true);
+   TEST_TT(float, short int, true);
+   TEST_TT(float, int, true);
+   TEST_TT(float, long int, true);
+   TEST_TT(float, unsigned char, true);
+   TEST_TT(float, unsigned short int, true);
+   TEST_TT(float, unsigned int, true);
+   TEST_TT(float, unsigned long int, true);
+   TEST_TT(float, wchar_t, true);
+   TEST_TT(float, float, true);
+   TEST_TT(float, double, true);
+   TEST_TT(float, long double, true);
+   TEST_TT(double, bool, true);
+   TEST_TT(double, char, true);
+   TEST_TT(double, signed char, true);
+   TEST_TT(double, short int, true);
+   TEST_TT(double, int, true);
+   TEST_TT(double, long int, true);
+   TEST_TT(double, unsigned char, true);
+   TEST_TT(double, unsigned short int, true);
+   TEST_TT(double, unsigned int, true);
+   TEST_TT(double, unsigned long int, true);
+   TEST_TT(double, wchar_t, true);
+   TEST_TT(double, float, true);
+   TEST_TT(double, double, true);
+   TEST_TT(double, long double, true);
+   TEST_TT(long double, bool, true);
+   TEST_TT(long double, char, true);
+   TEST_TT(long double, signed char, true);
+   TEST_TT(long double, short int, true);
+   TEST_TT(long double, int, true);
+   TEST_TT(long double, long int, true);
+   TEST_TT(long double, unsigned char, true);
+   TEST_TT(long double, unsigned short int, true);
+   TEST_TT(long double, unsigned int, true);
+   TEST_TT(long double, unsigned long int, true);
+   TEST_TT(long double, wchar_t, true);
+   TEST_TT(long double, float, true);
+   TEST_TT(long double, double, true);
+   TEST_TT(long double, long double, true);
+   TEST_TT(bool, void, false);
+   TEST_TT(void, bool, false);
+   TEST_TT(char, void, false);
+   TEST_TT(void, char, false);
+   TEST_TT(signed char, void, false);
+   TEST_TT(void, signed char, false);
+   TEST_TT(short int, void, false);
+   TEST_TT(void, short int, false);
+   TEST_TT(int, void, false);
+   TEST_TT(void, int, false);
+   TEST_TT(long int, void, false);
+   TEST_TT(void, long int, false);
+   TEST_TT(unsigned char, void, false);
+   TEST_TT(void, unsigned char, false);
+   TEST_TT(unsigned short int, void, false);
+   TEST_TT(void, unsigned short int, false);
+   TEST_TT(unsigned int, void, false);
+   TEST_TT(void, unsigned int, false);
+   TEST_TT(unsigned long int, void, false);
+   TEST_TT(void, unsigned long int, false);
+   TEST_TT(wchar_t, void, false);
+   TEST_TT(void, wchar_t, false);
+   TEST_TT(float, void, false);
+   TEST_TT(void, float, false);
+   TEST_TT(double, void, false);
+   TEST_TT(void, double, false);
+   TEST_TT(long double, void, false);
+   TEST_TT(void, long double, false);
+
+// test with three template parameters
+   TEST_TTR(bool, bool, bool, true);
+   TEST_TTR(bool, char, bool, true);
+   TEST_TTR(bool, signed char, bool, true);
+   TEST_TTR(bool, short int, bool, true);
+   TEST_TTR(bool, int, bool, true);
+   TEST_TTR(bool, long int, bool, true);
+   TEST_TTR(bool, unsigned char, bool, true);
+   TEST_TTR(bool, unsigned short int, bool, true);
+   TEST_TTR(bool, unsigned int, bool, true);
+   TEST_TTR(bool, unsigned long int, bool, true);
+   TEST_TTR(bool, wchar_t, bool, true);
+   TEST_TTR(bool, float, bool, true);
+   TEST_TTR(bool, double, bool, true);
+   TEST_TTR(bool, long double, bool, true);
+   TEST_TTR(char, bool, bool, true);
+   TEST_TTR(char, char, bool, true);
+   TEST_TTR(char, signed char, bool, true);
+   TEST_TTR(char, short int, bool, true);
+   TEST_TTR(char, int, bool, true);
+   TEST_TTR(char, long int, bool, true);
+   TEST_TTR(char, unsigned char, bool, true);
+   TEST_TTR(char, unsigned short int, bool, true);
+   TEST_TTR(char, unsigned int, bool, true);
+   TEST_TTR(char, unsigned long int, bool, true);
+   TEST_TTR(char, wchar_t, bool, true);
+   TEST_TTR(char, float, bool, true);
+   TEST_TTR(char, double, bool, true);
+   TEST_TTR(char, long double, bool, true);
+   TEST_TTR(signed char, bool, bool, true);
+   TEST_TTR(signed char, char, bool, true);
+   TEST_TTR(signed char, signed char, bool, true);
+   TEST_TTR(signed char, short int, bool, true);
+   TEST_TTR(signed char, int, bool, true);
+   TEST_TTR(signed char, long int, bool, true);
+   TEST_TTR(signed char, unsigned char, bool, true);
+   TEST_TTR(signed char, unsigned short int, bool, true);
+   TEST_TTR(signed char, unsigned int, bool, true);
+   TEST_TTR(signed char, unsigned long int, bool, true);
+   TEST_TTR(signed char, wchar_t, bool, true);
+   TEST_TTR(signed char, float, bool, true);
+   TEST_TTR(signed char, double, bool, true);
+   TEST_TTR(signed char, long double, bool, true);
+   TEST_TTR(short int, bool, bool, true);
+   TEST_TTR(short int, char, bool, true);
+   TEST_TTR(short int, signed char, bool, true);
+   TEST_TTR(short int, short int, bool, true);
+   TEST_TTR(short int, int, bool, true);
+   TEST_TTR(short int, long int, bool, true);
+   TEST_TTR(short int, unsigned char, bool, true);
+   TEST_TTR(short int, unsigned short int, bool, true);
+   TEST_TTR(short int, unsigned int, bool, true);
+   TEST_TTR(short int, unsigned long int, bool, true);
+   TEST_TTR(short int, wchar_t, bool, true);
+   TEST_TTR(short int, float, bool, true);
+   TEST_TTR(short int, double, bool, true);
+   TEST_TTR(short int, long double, bool, true);
+   TEST_TTR(int, bool, bool, true);
+   TEST_TTR(int, char, bool, true);
+   TEST_TTR(int, signed char, bool, true);
+   TEST_TTR(int, short int, bool, true);
+   TEST_TTR(int, int, bool, true);
+   TEST_TTR(int, long int, bool, true);
+   TEST_TTR(int, unsigned char, bool, true);
+   TEST_TTR(int, unsigned short int, bool, true);
+   TEST_TTR(int, unsigned int, bool, true);
+   TEST_TTR(int, unsigned long int, bool, true);
+   TEST_TTR(int, wchar_t, bool, true);
+   TEST_TTR(int, float, bool, true);
+   TEST_TTR(int, double, bool, true);
+   TEST_TTR(int, long double, bool, true);
+   TEST_TTR(long int, bool, bool, true);
+   TEST_TTR(long int, char, bool, true);
+   TEST_TTR(long int, signed char, bool, true);
+   TEST_TTR(long int, short int, bool, true);
+   TEST_TTR(long int, int, bool, true);
+   TEST_TTR(long int, long int, bool, true);
+   TEST_TTR(long int, unsigned char, bool, true);
+   TEST_TTR(long int, unsigned short int, bool, true);
+   TEST_TTR(long int, unsigned int, bool, true);
+   TEST_TTR(long int, unsigned long int, bool, true);
+   TEST_TTR(long int, wchar_t, bool, true);
+   TEST_TTR(long int, float, bool, true);
+   TEST_TTR(long int, double, bool, true);
+   TEST_TTR(long int, long double, bool, true);
+   TEST_TTR(unsigned char, bool, bool, true);
+   TEST_TTR(unsigned char, char, bool, true);
+   TEST_TTR(unsigned char, signed char, bool, true);
+   TEST_TTR(unsigned char, short int, bool, true);
+   TEST_TTR(unsigned char, int, bool, true);
+   TEST_TTR(unsigned char, long int, bool, true);
+   TEST_TTR(unsigned char, unsigned char, bool, true);
+   TEST_TTR(unsigned char, unsigned short int, bool, true);
+   TEST_TTR(unsigned char, unsigned int, bool, true);
+   TEST_TTR(unsigned char, unsigned long int, bool, true);
+   TEST_TTR(unsigned char, wchar_t, bool, true);
+   TEST_TTR(unsigned char, float, bool, true);
+   TEST_TTR(unsigned char, double, bool, true);
+   TEST_TTR(unsigned char, long double, bool, true);
+   TEST_TTR(unsigned short int, bool, bool, true);
+   TEST_TTR(unsigned short int, char, bool, true);
+   TEST_TTR(unsigned short int, signed char, bool, true);
+   TEST_TTR(unsigned short int, short int, bool, true);
+   TEST_TTR(unsigned short int, int, bool, true);
+   TEST_TTR(unsigned short int, long int, bool, true);
+   TEST_TTR(unsigned short int, unsigned char, bool, true);
+   TEST_TTR(unsigned short int, unsigned short int, bool, true);
+   TEST_TTR(unsigned short int, unsigned int, bool, true);
+   TEST_TTR(unsigned short int, unsigned long int, bool, true);
+   TEST_TTR(unsigned short int, wchar_t, bool, true);
+   TEST_TTR(unsigned short int, float, bool, true);
+   TEST_TTR(unsigned short int, double, bool, true);
+   TEST_TTR(unsigned short int, long double, bool, true);
+   TEST_TTR(unsigned int, bool, bool, true);
+   TEST_TTR(unsigned int, char, bool, true);
+   TEST_TTR(unsigned int, signed char, bool, true);
+   TEST_TTR(unsigned int, short int, bool, true);
+   TEST_TTR(unsigned int, int, bool, true);
+   TEST_TTR(unsigned int, long int, bool, true);
+   TEST_TTR(unsigned int, unsigned char, bool, true);
+   TEST_TTR(unsigned int, unsigned short int, bool, true);
+   TEST_TTR(unsigned int, unsigned int, bool, true);
+   TEST_TTR(unsigned int, unsigned long int, bool, true);
+   TEST_TTR(unsigned int, wchar_t, bool, true);
+   TEST_TTR(unsigned int, float, bool, true);
+   TEST_TTR(unsigned int, double, bool, true);
+   TEST_TTR(unsigned int, long double, bool, true);
+   TEST_TTR(unsigned long int, bool, bool, true);
+   TEST_TTR(unsigned long int, char, bool, true);
+   TEST_TTR(unsigned long int, signed char, bool, true);
+   TEST_TTR(unsigned long int, short int, bool, true);
+   TEST_TTR(unsigned long int, int, bool, true);
+   TEST_TTR(unsigned long int, long int, bool, true);
+   TEST_TTR(unsigned long int, unsigned char, bool, true);
+   TEST_TTR(unsigned long int, unsigned short int, bool, true);
+   TEST_TTR(unsigned long int, unsigned int, bool, true);
+   TEST_TTR(unsigned long int, unsigned long int, bool, true);
+   TEST_TTR(unsigned long int, wchar_t, bool, true);
+   TEST_TTR(unsigned long int, float, bool, true);
+   TEST_TTR(unsigned long int, double, bool, true);
+   TEST_TTR(unsigned long int, long double, bool, true);
+   TEST_TTR(wchar_t, bool, bool, true);
+   TEST_TTR(wchar_t, char, bool, true);
+   TEST_TTR(wchar_t, signed char, bool, true);
+   TEST_TTR(wchar_t, short int, bool, true);
+   TEST_TTR(wchar_t, int, bool, true);
+   TEST_TTR(wchar_t, long int, bool, true);
+   TEST_TTR(wchar_t, unsigned char, bool, true);
+   TEST_TTR(wchar_t, unsigned short int, bool, true);
+   TEST_TTR(wchar_t, unsigned int, bool, true);
+   TEST_TTR(wchar_t, unsigned long int, bool, true);
+   TEST_TTR(wchar_t, wchar_t, bool, true);
+   TEST_TTR(wchar_t, float, bool, true);
+   TEST_TTR(wchar_t, double, bool, true);
+   TEST_TTR(wchar_t, long double, bool, true);
+   TEST_TTR(float, bool, bool, true);
+   TEST_TTR(float, char, bool, true);
+   TEST_TTR(float, signed char, bool, true);
+   TEST_TTR(float, short int, bool, true);
+   TEST_TTR(float, int, bool, true);
+   TEST_TTR(float, long int, bool, true);
+   TEST_TTR(float, unsigned char, bool, true);
+   TEST_TTR(float, unsigned short int, bool, true);
+   TEST_TTR(float, unsigned int, bool, true);
+   TEST_TTR(float, unsigned long int, bool, true);
+   TEST_TTR(float, wchar_t, bool, true);
+   TEST_TTR(float, float, bool, true);
+   TEST_TTR(float, double, bool, true);
+   TEST_TTR(float, long double, bool, true);
+   TEST_TTR(double, bool, bool, true);
+   TEST_TTR(double, char, bool, true);
+   TEST_TTR(double, signed char, bool, true);
+   TEST_TTR(double, short int, bool, true);
+   TEST_TTR(double, int, bool, true);
+   TEST_TTR(double, long int, bool, true);
+   TEST_TTR(double, unsigned char, bool, true);
+   TEST_TTR(double, unsigned short int, bool, true);
+   TEST_TTR(double, unsigned int, bool, true);
+   TEST_TTR(double, unsigned long int, bool, true);
+   TEST_TTR(double, wchar_t, bool, true);
+   TEST_TTR(double, float, bool, true);
+   TEST_TTR(double, double, bool, true);
+   TEST_TTR(double, long double, bool, true);
+   TEST_TTR(long double, bool, bool, true);
+   TEST_TTR(long double, char, bool, true);
+   TEST_TTR(long double, signed char, bool, true);
+   TEST_TTR(long double, short int, bool, true);
+   TEST_TTR(long double, int, bool, true);
+   TEST_TTR(long double, long int, bool, true);
+   TEST_TTR(long double, unsigned char, bool, true);
+   TEST_TTR(long double, unsigned short int, bool, true);
+   TEST_TTR(long double, unsigned int, bool, true);
+   TEST_TTR(long double, unsigned long int, bool, true);
+   TEST_TTR(long double, wchar_t, bool, true);
+   TEST_TTR(long double, float, bool, true);
+   TEST_TTR(long double, double, bool, true);
+   TEST_TTR(long double, long double, bool, true);
+   TEST_TTR(bool, bool, tag, false);
+   TEST_TTR(bool, char, tag, false);
+   TEST_TTR(bool, signed char, tag, false);
+   TEST_TTR(bool, short int, tag, false);
+   TEST_TTR(bool, int, tag, false);
+   TEST_TTR(bool, long int, tag, false);
+   TEST_TTR(bool, unsigned char, tag, false);
+   TEST_TTR(bool, unsigned short int, tag, false);
+   TEST_TTR(bool, unsigned int, tag, false);
+   TEST_TTR(bool, unsigned long int, tag, false);
+   TEST_TTR(bool, wchar_t, tag, false);
+   TEST_TTR(bool, float, tag, false);
+   TEST_TTR(bool, double, tag, false);
+   TEST_TTR(bool, long double, tag, false);
+   TEST_TTR(char, bool, tag, false);
+   TEST_TTR(char, char, tag, false);
+   TEST_TTR(char, signed char, tag, false);
+   TEST_TTR(char, short int, tag, false);
+   TEST_TTR(char, int, tag, false);
+   TEST_TTR(char, long int, tag, false);
+   TEST_TTR(char, unsigned char, tag, false);
+   TEST_TTR(char, unsigned short int, tag, false);
+   TEST_TTR(char, unsigned int, tag, false);
+   TEST_TTR(char, unsigned long int, tag, false);
+   TEST_TTR(char, wchar_t, tag, false);
+   TEST_TTR(char, float, tag, false);
+   TEST_TTR(char, double, tag, false);
+   TEST_TTR(char, long double, tag, false);
+   TEST_TTR(signed char, bool, tag, false);
+   TEST_TTR(signed char, char, tag, false);
+   TEST_TTR(signed char, signed char, tag, false);
+   TEST_TTR(signed char, short int, tag, false);
+   TEST_TTR(signed char, int, tag, false);
+   TEST_TTR(signed char, long int, tag, false);
+   TEST_TTR(signed char, unsigned char, tag, false);
+   TEST_TTR(signed char, unsigned short int, tag, false);
+   TEST_TTR(signed char, unsigned int, tag, false);
+   TEST_TTR(signed char, unsigned long int, tag, false);
+   TEST_TTR(signed char, wchar_t, tag, false);
+   TEST_TTR(signed char, float, tag, false);
+   TEST_TTR(signed char, double, tag, false);
+   TEST_TTR(signed char, long double, tag, false);
+   TEST_TTR(short int, bool, tag, false);
+   TEST_TTR(short int, char, tag, false);
+   TEST_TTR(short int, signed char, tag, false);
+   TEST_TTR(short int, short int, tag, false);
+   TEST_TTR(short int, int, tag, false);
+   TEST_TTR(short int, long int, tag, false);
+   TEST_TTR(short int, unsigned char, tag, false);
+   TEST_TTR(short int, unsigned short int, tag, false);
+   TEST_TTR(short int, unsigned int, tag, false);
+   TEST_TTR(short int, unsigned long int, tag, false);
+   TEST_TTR(short int, wchar_t, tag, false);
+   TEST_TTR(short int, float, tag, false);
+   TEST_TTR(short int, double, tag, false);
+   TEST_TTR(short int, long double, tag, false);
+   TEST_TTR(int, bool, tag, false);
+   TEST_TTR(int, char, tag, false);
+   TEST_TTR(int, signed char, tag, false);
+   TEST_TTR(int, short int, tag, false);
+   TEST_TTR(int, int, tag, false);
+   TEST_TTR(int, long int, tag, false);
+   TEST_TTR(int, unsigned char, tag, false);
+   TEST_TTR(int, unsigned short int, tag, false);
+   TEST_TTR(int, unsigned int, tag, false);
+   TEST_TTR(int, unsigned long int, tag, false);
+   TEST_TTR(int, wchar_t, tag, false);
+   TEST_TTR(int, float, tag, false);
+   TEST_TTR(int, double, tag, false);
+   TEST_TTR(int, long double, tag, false);
+   TEST_TTR(long int, bool, tag, false);
+   TEST_TTR(long int, char, tag, false);
+   TEST_TTR(long int, signed char, tag, false);
+   TEST_TTR(long int, short int, tag, false);
+   TEST_TTR(long int, int, tag, false);
+   TEST_TTR(long int, long int, tag, false);
+   TEST_TTR(long int, unsigned char, tag, false);
+   TEST_TTR(long int, unsigned short int, tag, false);
+   TEST_TTR(long int, unsigned int, tag, false);
+   TEST_TTR(long int, unsigned long int, tag, false);
+   TEST_TTR(long int, wchar_t, tag, false);
+   TEST_TTR(long int, float, tag, false);
+   TEST_TTR(long int, double, tag, false);
+   TEST_TTR(long int, long double, tag, false);
+   TEST_TTR(unsigned char, bool, tag, false);
+   TEST_TTR(unsigned char, char, tag, false);
+   TEST_TTR(unsigned char, signed char, tag, false);
+   TEST_TTR(unsigned char, short int, tag, false);
+   TEST_TTR(unsigned char, int, tag, false);
+   TEST_TTR(unsigned char, long int, tag, false);
+   TEST_TTR(unsigned char, unsigned char, tag, false);
+   TEST_TTR(unsigned char, unsigned short int, tag, false);
+   TEST_TTR(unsigned char, unsigned int, tag, false);
+   TEST_TTR(unsigned char, unsigned long int, tag, false);
+   TEST_TTR(unsigned char, wchar_t, tag, false);
+   TEST_TTR(unsigned char, float, tag, false);
+   TEST_TTR(unsigned char, double, tag, false);
+   TEST_TTR(unsigned char, long double, tag, false);
+   TEST_TTR(unsigned short int, bool, tag, false);
+   TEST_TTR(unsigned short int, char, tag, false);
+   TEST_TTR(unsigned short int, signed char, tag, false);
+   TEST_TTR(unsigned short int, short int, tag, false);
+   TEST_TTR(unsigned short int, int, tag, false);
+   TEST_TTR(unsigned short int, long int, tag, false);
+   TEST_TTR(unsigned short int, unsigned char, tag, false);
+   TEST_TTR(unsigned short int, unsigned short int, tag, false);
+   TEST_TTR(unsigned short int, unsigned int, tag, false);
+   TEST_TTR(unsigned short int, unsigned long int, tag, false);
+   TEST_TTR(unsigned short int, wchar_t, tag, false);
+   TEST_TTR(unsigned short int, float, tag, false);
+   TEST_TTR(unsigned short int, double, tag, false);
+   TEST_TTR(unsigned short int, long double, tag, false);
+   TEST_TTR(unsigned int, bool, tag, false);
+   TEST_TTR(unsigned int, char, tag, false);
+   TEST_TTR(unsigned int, signed char, tag, false);
+   TEST_TTR(unsigned int, short int, tag, false);
+   TEST_TTR(unsigned int, int, tag, false);
+   TEST_TTR(unsigned int, long int, tag, false);
+   TEST_TTR(unsigned int, unsigned char, tag, false);
+   TEST_TTR(unsigned int, unsigned short int, tag, false);
+   TEST_TTR(unsigned int, unsigned int, tag, false);
+   TEST_TTR(unsigned int, unsigned long int, tag, false);
+   TEST_TTR(unsigned int, wchar_t, tag, false);
+   TEST_TTR(unsigned int, float, tag, false);
+   TEST_TTR(unsigned int, double, tag, false);
+   TEST_TTR(unsigned int, long double, tag, false);
+   TEST_TTR(unsigned long int, bool, tag, false);
+   TEST_TTR(unsigned long int, char, tag, false);
+   TEST_TTR(unsigned long int, signed char, tag, false);
+   TEST_TTR(unsigned long int, short int, tag, false);
+   TEST_TTR(unsigned long int, int, tag, false);
+   TEST_TTR(unsigned long int, long int, tag, false);
+   TEST_TTR(unsigned long int, unsigned char, tag, false);
+   TEST_TTR(unsigned long int, unsigned short int, tag, false);
+   TEST_TTR(unsigned long int, unsigned int, tag, false);
+   TEST_TTR(unsigned long int, unsigned long int, tag, false);
+   TEST_TTR(unsigned long int, wchar_t, tag, false);
+   TEST_TTR(unsigned long int, float, tag, false);
+   TEST_TTR(unsigned long int, double, tag, false);
+   TEST_TTR(unsigned long int, long double, tag, false);
+   TEST_TTR(wchar_t, bool, tag, false);
+   TEST_TTR(wchar_t, char, tag, false);
+   TEST_TTR(wchar_t, signed char, tag, false);
+   TEST_TTR(wchar_t, short int, tag, false);
+   TEST_TTR(wchar_t, int, tag, false);
+   TEST_TTR(wchar_t, long int, tag, false);
+   TEST_TTR(wchar_t, unsigned char, tag, false);
+   TEST_TTR(wchar_t, unsigned short int, tag, false);
+   TEST_TTR(wchar_t, unsigned int, tag, false);
+   TEST_TTR(wchar_t, unsigned long int, tag, false);
+   TEST_TTR(wchar_t, wchar_t, tag, false);
+   TEST_TTR(wchar_t, float, tag, false);
+   TEST_TTR(wchar_t, double, tag, false);
+   TEST_TTR(wchar_t, long double, tag, false);
+   TEST_TTR(float, bool, tag, false);
+   TEST_TTR(float, char, tag, false);
+   TEST_TTR(float, signed char, tag, false);
+   TEST_TTR(float, short int, tag, false);
+   TEST_TTR(float, int, tag, false);
+   TEST_TTR(float, long int, tag, false);
+   TEST_TTR(float, unsigned char, tag, false);
+   TEST_TTR(float, unsigned short int, tag, false);
+   TEST_TTR(float, unsigned int, tag, false);
+   TEST_TTR(float, unsigned long int, tag, false);
+   TEST_TTR(float, wchar_t, tag, false);
+   TEST_TTR(float, float, tag, false);
+   TEST_TTR(float, double, tag, false);
+   TEST_TTR(float, long double, tag, false);
+   TEST_TTR(double, bool, tag, false);
+   TEST_TTR(double, char, tag, false);
+   TEST_TTR(double, signed char, tag, false);
+   TEST_TTR(double, short int, tag, false);
+   TEST_TTR(double, int, tag, false);
+   TEST_TTR(double, long int, tag, false);
+   TEST_TTR(double, unsigned char, tag, false);
+   TEST_TTR(double, unsigned short int, tag, false);
+   TEST_TTR(double, unsigned int, tag, false);
+   TEST_TTR(double, unsigned long int, tag, false);
+   TEST_TTR(double, wchar_t, tag, false);
+   TEST_TTR(double, float, tag, false);
+   TEST_TTR(double, double, tag, false);
+   TEST_TTR(double, long double, tag, false);
+   TEST_TTR(long double, bool, tag, false);
+   TEST_TTR(long double, char, tag, false);
+   TEST_TTR(long double, signed char, tag, false);
+   TEST_TTR(long double, short int, tag, false);
+   TEST_TTR(long double, int, tag, false);
+   TEST_TTR(long double, long int, tag, false);
+   TEST_TTR(long double, unsigned char, tag, false);
+   TEST_TTR(long double, unsigned short int, tag, false);
+   TEST_TTR(long double, unsigned int, tag, false);
+   TEST_TTR(long double, unsigned long int, tag, false);
+   TEST_TTR(long double, wchar_t, tag, false);
+   TEST_TTR(long double, float, tag, false);
+   TEST_TTR(long double, double, tag, false);
+   TEST_TTR(long double, long double, tag, false);
+#	undef CV1
+#	define CV1(T) const T
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const T&
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T&
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T&
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const T
+#	undef CV2
+#	define CV2(T) const T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const T&
+#	undef CV2
+#	define CV2(T) const T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T
+#	undef CV2
+#	define CV2(T) volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T&
+#	undef CV2
+#	define CV2(T) volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T
+#	undef CV2
+#	define CV2(T) const volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T&
+#	undef CV2
+#	define CV2(T) const volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+   // pointers
+   TEST_TT(void*, bool, false);
+   TEST_TT(void*, int, false);
+   TEST_TT(void*, double, false);
+   TEST_TT(void*, A, false);
+   TEST_TT(void*, B, false);
+   TEST_TT(bool*, bool, false);
+   TEST_TT(bool*, int, false);
+   TEST_TT(bool*, double, false);
+   TEST_TT(bool*, A, false);
+   TEST_TT(bool*, B, false);
+   TEST_TT(int*, bool, false);
+   TEST_TT(int*, int, false);
+   TEST_TT(int*, double, false);
+   TEST_TT(int*, A, false);
+   TEST_TT(int*, B, false);
+   TEST_TT(double*, bool, false);
+   TEST_TT(double*, int, false);
+   TEST_TT(double*, double, false);
+   TEST_TT(double*, A, false);
+   TEST_TT(double*, B, false);
+   TEST_TT(A*, bool, false);
+   TEST_TT(A*, int, false);
+   TEST_TT(A*, double, false);
+   TEST_TT(A*, A, false);
+   TEST_TT(A*, B, false);
+   TEST_TT(B*, bool, false);
+   TEST_TT(B*, int, false);
+   TEST_TT(B*, double, false);
+   TEST_TT(B*, A, false);
+   TEST_TT(B*, B, false);
+   TEST_TT(bool, void*, false);
+   TEST_TT(bool, bool*, false);
+   TEST_TT(bool, int*, false);
+   TEST_TT(bool, double*, false);
+   TEST_TT(bool, A*, false);
+   TEST_TT(bool, B*, false);
+   TEST_TT(int, void*, false);
+   TEST_TT(int, bool*, false);
+   TEST_TT(int, int*, false);
+   TEST_TT(int, double*, false);
+   TEST_TT(int, A*, false);
+   TEST_TT(int, B*, false);
+   TEST_TT(double, void*, false);
+   TEST_TT(double, bool*, false);
+   TEST_TT(double, int*, false);
+   TEST_TT(double, double*, false);
+   TEST_TT(double, A*, false);
+   TEST_TT(double, B*, false);
+   TEST_TT(A, void*, false);
+   TEST_TT(A, bool*, false);
+   TEST_TT(A, int*, false);
+   TEST_TT(A, double*, false);
+   TEST_TT(A, A*, false);
+   TEST_TT(A, B*, false);
+   TEST_TT(B, void*, false);
+   TEST_TT(B, bool*, false);
+   TEST_TT(B, int*, false);
+   TEST_TT(B, double*, false);
+   TEST_TT(B, A*, false);
+   TEST_TT(B, B*, false);
+   TEST_TT(void*, void*, true);
+   TEST_TT(void*, bool*, true);
+   TEST_TT(void*, int*, true);
+   TEST_TT(void*, double*, true);
+   TEST_TT(void*, A*, true);
+   TEST_TT(void*, B*, true);
+   TEST_TT(bool*, void*, true);
+   TEST_TT(bool*, bool*, true);
+   TEST_TT(bool*, int*, false);
+   TEST_TT(bool*, double*, false);
+   TEST_TT(bool*, A*, false);
+   TEST_TT(bool*, B*, false);
+   TEST_TT(int*, void*, true);
+   TEST_TT(int*, bool*, false);
+   TEST_TT(int*, int*, true);
+   TEST_TT(int*, double*, false);
+   TEST_TT(int*, A*, false);
+   TEST_TT(int*, B*, false);
+   TEST_TT(double*, void*, true);
+   TEST_TT(double*, bool*, false);
+   TEST_TT(double*, int*, false);
+   TEST_TT(double*, double*, true);
+   TEST_TT(double*, A*, false);
+   TEST_TT(double*, B*, false);
+   TEST_TT(A*, void*, true);
+   TEST_TT(A*, bool*, false);
+   TEST_TT(A*, int*, false);
+   TEST_TT(A*, double*, false);
+   TEST_TT(A*, A*, true);
+   TEST_TT(A*, B*, true);
+   TEST_TT(B*, void*, true);
+   TEST_TT(B*, bool*, false);
+   TEST_TT(B*, int*, false);
+   TEST_TT(B*, double*, false);
+   TEST_TT(B*, A*, true);
+   TEST_TT(B*, B*, true);
+   TEST_TT(C, void*, true);
+   TEST_TT(D, void*, false);
+   TEST_TT(void*, C, false);
+   TEST_TT(void*, D, true);
+   TEST_TT(C, D, true);
+}
+}

Added: sandbox/type_traits/libs/type_traits/test/can_call_complement_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_complement_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,33 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_complement.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_complement
+#define BOOST_TT_TRAIT_OP ~
+
+#include "can_call_prefix_operators.hpp"
+#include "can_call_complement_test.hpp"
+
+namespace {
+void specific() {
+   /* nothing specific */
+}
+}
+
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_complement_test.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_complement_test.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,97 @@
+//  (C) Copyright Frederic Bron 2009-2011.
+//  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)
+
+namespace {
+
+void run2() {
+   // test with only one template parameter
+   TEST_T(void, false);
+   TEST_T(bool, true);
+   TEST_T(char, true);
+   TEST_T(signed char, true);
+   TEST_T(short int, true);
+   TEST_T(int, true);
+   TEST_T(long int, true);
+   TEST_T(unsigned char, true);
+   TEST_T(unsigned short int, true);
+   TEST_T(unsigned int, true);
+   TEST_T(unsigned long int, true);
+   TEST_T(wchar_t, true);
+   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), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), false);
+#	undef CV
+#	define CV(T) volatile T
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), false);
+#	undef CV
+#	define CV(T) const volatile T
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), false);
+#	undef CV
+#	define CV(T) const T&
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), false);
+#	undef CV
+#	define CV(T) volatile T&
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), false);
+#	undef CV
+#	define CV(T) const volatile T&
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), false);
+
+   // test with three template parameters
+   TEST_TR(bool, bool, true);
+   TEST_TR(char, bool, true);
+   TEST_TR(signed char, bool, true);
+   TEST_TR(short int, bool, true);
+   TEST_TR(int, bool, true);
+   TEST_TR(long int, bool, true);
+   TEST_TR(unsigned char, bool, true);
+   TEST_TR(unsigned short int, bool, true);
+   TEST_TR(unsigned int, bool, true);
+   TEST_TR(unsigned long int, bool, true);
+   TEST_TR(wchar_t, bool, true);
+   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);
+
+   // pointers
+   TEST_T(void*, false);
+   TEST_T(bool*, false);
+   TEST_T(char*, false);
+   TEST_T(int*, false);
+   TEST_T(long*, false);
+   TEST_T(wchar_t*, false);
+   TEST_T(double*, false);
+   TEST_T(without*, false);
+}
+}

Added: sandbox/type_traits/libs/type_traits/test/can_call_dereference_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_dereference_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,33 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_dereference.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_dereference
+#define BOOST_TT_TRAIT_OP *
+
+#include "can_call_prefix_operators.hpp"
+#include "can_call_dereference_test.hpp"
+
+namespace {
+void specific() {
+   /* nothing specific */
+}
+}
+
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_dereference_test.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_dereference_test.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,101 @@
+//  (C) Copyright Frederic Bron 2009-2011.
+//  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)
+
+namespace {
+
+void run2() {
+   // 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);
+
+   // 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);
+}
+}

Added: sandbox/type_traits/libs/type_traits/test/can_call_division_assignment_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_division_assignment_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,33 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_division_assignment.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_division_assignment
+#define BOOST_TT_TRAIT_OP /=
+
+#include "can_call_binary_operators.hpp"
+#include "can_call_no_pointer_no_constlhs_test.hpp"
+
+namespace {
+void specific() {
+   /* nothing specific */
+}
+}
+
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_division_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_division_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,33 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_division.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_division
+#define BOOST_TT_TRAIT_OP /
+
+#include "can_call_binary_operators.hpp"
+#include "can_call_no_pointer_test.hpp"
+
+namespace {
+void specific() {
+   /* nothing specific */
+}
+}
+
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_equal_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_equal_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,33 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_equal.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_equal
+#define BOOST_TT_TRAIT_OP ==
+
+#include "can_call_binary_operators.hpp"
+#include "can_call_comparison_test.hpp"
+
+namespace {
+void specific() {
+   /* nothing specific */
+}
+}
+
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_greater_equal_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_greater_equal_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,33 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_greater_equal.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_greater_equal
+#define BOOST_TT_TRAIT_OP >=
+
+#include "can_call_binary_operators.hpp"
+#include "can_call_comparison_test.hpp"
+
+namespace {
+void specific() {
+   /* nothing specific */
+}
+}
+
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_greater_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_greater_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,33 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_greater.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_greater
+#define BOOST_TT_TRAIT_OP >
+
+#include "can_call_binary_operators.hpp"
+#include "can_call_comparison_test.hpp"
+
+namespace {
+void specific() {
+   /* nothing specific */
+}
+}
+
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_integral_no_constlhs_test.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_integral_no_constlhs_test.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,1250 @@
+//  (C) Copyright Frederic Bron 2009-2011.
+//  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)
+
+namespace {
+
+void run2() {
+   // test with only one template parameter
+   TEST_T(void, false);
+   TEST_T(bool, true);
+   TEST_T(char, true);
+   TEST_T(signed char, true);
+   TEST_T(short int, true);
+   TEST_T(int, true);
+   TEST_T(long int, true);
+   TEST_T(unsigned char, true);
+   TEST_T(unsigned short int, true);
+   TEST_T(unsigned int, true);
+   TEST_T(unsigned long int, true);
+   TEST_T(wchar_t, true);
+   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), true);
+   TEST_T(CV(int), true);
+   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), true);
+   TEST_T(CV(int), true);
+   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 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);
+   TEST_TT(bool, short int, true);
+   TEST_TT(bool, int, true);
+   TEST_TT(bool, long int, true);
+   TEST_TT(bool, unsigned char, true);
+   TEST_TT(bool, unsigned short int, true);
+   TEST_TT(bool, unsigned int, true);
+   TEST_TT(bool, unsigned long int, true);
+   TEST_TT(bool, wchar_t, true);
+   TEST_TT(bool, float, false);
+   TEST_TT(bool, double, false);
+   TEST_TT(bool, long double, false);
+   TEST_TT(char, bool, true);
+   TEST_TT(char, char, true);
+   TEST_TT(char, signed char, true);
+   TEST_TT(char, short int, true);
+   TEST_TT(char, int, true);
+   TEST_TT(char, long int, true);
+   TEST_TT(char, unsigned char, true);
+   TEST_TT(char, unsigned short int, true);
+   TEST_TT(char, unsigned int, true);
+   TEST_TT(char, unsigned long int, true);
+   TEST_TT(char, wchar_t, true);
+   TEST_TT(char, float, false);
+   TEST_TT(char, double, false);
+   TEST_TT(char, long double, false);
+   TEST_TT(signed char, bool, true);
+   TEST_TT(signed char, char, true);
+   TEST_TT(signed char, signed char, true);
+   TEST_TT(signed char, short int, true);
+   TEST_TT(signed char, int, true);
+   TEST_TT(signed char, long int, true);
+   TEST_TT(signed char, unsigned char, true);
+   TEST_TT(signed char, unsigned short int, true);
+   TEST_TT(signed char, unsigned int, true);
+   TEST_TT(signed char, unsigned long int, true);
+   TEST_TT(signed char, wchar_t, true);
+   TEST_TT(signed char, float, false);
+   TEST_TT(signed char, double, false);
+   TEST_TT(signed char, long double, false);
+   TEST_TT(short int, bool, true);
+   TEST_TT(short int, char, true);
+   TEST_TT(short int, signed char, true);
+   TEST_TT(short int, short int, true);
+   TEST_TT(short int, int, true);
+   TEST_TT(short int, long int, true);
+   TEST_TT(short int, unsigned char, true);
+   TEST_TT(short int, unsigned short int, true);
+   TEST_TT(short int, unsigned int, true);
+   TEST_TT(short int, unsigned long int, true);
+   TEST_TT(short int, wchar_t, true);
+   TEST_TT(short int, float, false);
+   TEST_TT(short int, double, false);
+   TEST_TT(short int, long double, false);
+   TEST_TT(int, bool, true);
+   TEST_TT(int, char, true);
+   TEST_TT(int, signed char, true);
+   TEST_TT(int, short int, true);
+   TEST_TT(int, int, true);
+   TEST_TT(int, long int, true);
+   TEST_TT(int, unsigned char, true);
+   TEST_TT(int, unsigned short int, true);
+   TEST_TT(int, unsigned int, true);
+   TEST_TT(int, unsigned long int, true);
+   TEST_TT(int, wchar_t, true);
+   TEST_TT(int, float, false);
+   TEST_TT(int, double, false);
+   TEST_TT(int, long double, false);
+   TEST_TT(long int, bool, true);
+   TEST_TT(long int, char, true);
+   TEST_TT(long int, signed char, true);
+   TEST_TT(long int, short int, true);
+   TEST_TT(long int, int, true);
+   TEST_TT(long int, long int, true);
+   TEST_TT(long int, unsigned char, true);
+   TEST_TT(long int, unsigned short int, true);
+   TEST_TT(long int, unsigned int, true);
+   TEST_TT(long int, unsigned long int, true);
+   TEST_TT(long int, wchar_t, true);
+   TEST_TT(long int, float, false);
+   TEST_TT(long int, double, false);
+   TEST_TT(long int, long double, false);
+   TEST_TT(unsigned char, bool, true);
+   TEST_TT(unsigned char, char, true);
+   TEST_TT(unsigned char, signed char, true);
+   TEST_TT(unsigned char, short int, true);
+   TEST_TT(unsigned char, int, true);
+   TEST_TT(unsigned char, long int, true);
+   TEST_TT(unsigned char, unsigned char, true);
+   TEST_TT(unsigned char, unsigned short int, true);
+   TEST_TT(unsigned char, unsigned int, true);
+   TEST_TT(unsigned char, unsigned long int, true);
+   TEST_TT(unsigned char, wchar_t, true);
+   TEST_TT(unsigned char, float, false);
+   TEST_TT(unsigned char, double, false);
+   TEST_TT(unsigned char, long double, false);
+   TEST_TT(unsigned short int, bool, true);
+   TEST_TT(unsigned short int, char, true);
+   TEST_TT(unsigned short int, signed char, true);
+   TEST_TT(unsigned short int, short int, true);
+   TEST_TT(unsigned short int, int, true);
+   TEST_TT(unsigned short int, long int, true);
+   TEST_TT(unsigned short int, unsigned char, true);
+   TEST_TT(unsigned short int, unsigned short int, true);
+   TEST_TT(unsigned short int, unsigned int, true);
+   TEST_TT(unsigned short int, unsigned long int, true);
+   TEST_TT(unsigned short int, wchar_t, true);
+   TEST_TT(unsigned short int, float, false);
+   TEST_TT(unsigned short int, double, false);
+   TEST_TT(unsigned short int, long double, false);
+   TEST_TT(unsigned int, bool, true);
+   TEST_TT(unsigned int, char, true);
+   TEST_TT(unsigned int, signed char, true);
+   TEST_TT(unsigned int, short int, true);
+   TEST_TT(unsigned int, int, true);
+   TEST_TT(unsigned int, long int, true);
+   TEST_TT(unsigned int, unsigned char, true);
+   TEST_TT(unsigned int, unsigned short int, true);
+   TEST_TT(unsigned int, unsigned int, true);
+   TEST_TT(unsigned int, unsigned long int, true);
+   TEST_TT(unsigned int, wchar_t, true);
+   TEST_TT(unsigned int, float, false);
+   TEST_TT(unsigned int, double, false);
+   TEST_TT(unsigned int, long double, false);
+   TEST_TT(unsigned long int, bool, true);
+   TEST_TT(unsigned long int, char, true);
+   TEST_TT(unsigned long int, signed char, true);
+   TEST_TT(unsigned long int, short int, true);
+   TEST_TT(unsigned long int, int, true);
+   TEST_TT(unsigned long int, long int, true);
+   TEST_TT(unsigned long int, unsigned char, true);
+   TEST_TT(unsigned long int, unsigned short int, true);
+   TEST_TT(unsigned long int, unsigned int, true);
+   TEST_TT(unsigned long int, unsigned long int, true);
+   TEST_TT(unsigned long int, wchar_t, true);
+   TEST_TT(unsigned long int, float, false);
+   TEST_TT(unsigned long int, double, false);
+   TEST_TT(unsigned long int, long double, false);
+   TEST_TT(wchar_t, bool, true);
+   TEST_TT(wchar_t, char, true);
+   TEST_TT(wchar_t, signed char, true);
+   TEST_TT(wchar_t, short int, true);
+   TEST_TT(wchar_t, int, true);
+   TEST_TT(wchar_t, long int, true);
+   TEST_TT(wchar_t, unsigned char, true);
+   TEST_TT(wchar_t, unsigned short int, true);
+   TEST_TT(wchar_t, unsigned int, true);
+   TEST_TT(wchar_t, unsigned long int, true);
+   TEST_TT(wchar_t, wchar_t, true);
+   TEST_TT(wchar_t, float, false);
+   TEST_TT(wchar_t, double, false);
+   TEST_TT(wchar_t, long double, false);
+   TEST_TT(float, bool, false);
+   TEST_TT(float, char, false);
+   TEST_TT(float, signed char, false);
+   TEST_TT(float, short int, false);
+   TEST_TT(float, int, false);
+   TEST_TT(float, long int, false);
+   TEST_TT(float, unsigned char, false);
+   TEST_TT(float, unsigned short int, false);
+   TEST_TT(float, unsigned int, false);
+   TEST_TT(float, unsigned long int, false);
+   TEST_TT(float, wchar_t, false);
+   TEST_TT(float, float, false);
+   TEST_TT(float, double, false);
+   TEST_TT(float, long double, false);
+   TEST_TT(double, bool, false);
+   TEST_TT(double, char, false);
+   TEST_TT(double, signed char, false);
+   TEST_TT(double, short int, false);
+   TEST_TT(double, int, false);
+   TEST_TT(double, long int, false);
+   TEST_TT(double, unsigned char, false);
+   TEST_TT(double, unsigned short int, false);
+   TEST_TT(double, unsigned int, false);
+   TEST_TT(double, unsigned long int, false);
+   TEST_TT(double, wchar_t, false);
+   TEST_TT(double, float, false);
+   TEST_TT(double, double, false);
+   TEST_TT(double, long double, false);
+   TEST_TT(long double, bool, false);
+   TEST_TT(long double, char, false);
+   TEST_TT(long double, signed char, false);
+   TEST_TT(long double, short int, false);
+   TEST_TT(long double, int, false);
+   TEST_TT(long double, long int, false);
+   TEST_TT(long double, unsigned char, false);
+   TEST_TT(long double, unsigned short int, false);
+   TEST_TT(long double, unsigned int, false);
+   TEST_TT(long double, unsigned long int, false);
+   TEST_TT(long double, wchar_t, false);
+   TEST_TT(long double, float, false);
+   TEST_TT(long double, double, false);
+   TEST_TT(long double, long double, false);
+   TEST_TT(bool, void, false);
+   TEST_TT(void, bool, false);
+   TEST_TT(char, void, false);
+   TEST_TT(void, char, false);
+   TEST_TT(signed char, void, false);
+   TEST_TT(void, signed char, false);
+   TEST_TT(short int, void, false);
+   TEST_TT(void, short int, false);
+   TEST_TT(int, void, false);
+   TEST_TT(void, int, false);
+   TEST_TT(long int, void, false);
+   TEST_TT(void, long int, false);
+   TEST_TT(unsigned char, void, false);
+   TEST_TT(void, unsigned char, false);
+   TEST_TT(unsigned short int, void, false);
+   TEST_TT(void, unsigned short int, false);
+   TEST_TT(unsigned int, void, false);
+   TEST_TT(void, unsigned int, false);
+   TEST_TT(unsigned long int, void, false);
+   TEST_TT(void, unsigned long int, false);
+   TEST_TT(wchar_t, void, false);
+   TEST_TT(void, wchar_t, false);
+   TEST_TT(float, void, false);
+   TEST_TT(void, float, false);
+   TEST_TT(double, void, false);
+   TEST_TT(void, double, false);
+   TEST_TT(long double, void, false);
+   TEST_TT(void, long double, false);
+
+// test with three template parameters
+   TEST_TTR(bool, bool, bool, true);
+   TEST_TTR(bool, char, bool, true);
+   TEST_TTR(bool, signed char, bool, true);
+   TEST_TTR(bool, short int, bool, true);
+   TEST_TTR(bool, int, bool, true);
+   TEST_TTR(bool, long int, bool, true);
+   TEST_TTR(bool, unsigned char, bool, true);
+   TEST_TTR(bool, unsigned short int, bool, true);
+   TEST_TTR(bool, unsigned int, bool, true);
+   TEST_TTR(bool, unsigned long int, bool, true);
+   TEST_TTR(bool, wchar_t, bool, true);
+   TEST_TTR(bool, float, bool, false);
+   TEST_TTR(bool, double, bool, false);
+   TEST_TTR(bool, long double, bool, false);
+   TEST_TTR(char, bool, bool, true);
+   TEST_TTR(char, char, bool, true);
+   TEST_TTR(char, signed char, bool, true);
+   TEST_TTR(char, short int, bool, true);
+   TEST_TTR(char, int, bool, true);
+   TEST_TTR(char, long int, bool, true);
+   TEST_TTR(char, unsigned char, bool, true);
+   TEST_TTR(char, unsigned short int, bool, true);
+   TEST_TTR(char, unsigned int, bool, true);
+   TEST_TTR(char, unsigned long int, bool, true);
+   TEST_TTR(char, wchar_t, bool, true);
+   TEST_TTR(char, float, bool, false);
+   TEST_TTR(char, double, bool, false);
+   TEST_TTR(char, long double, bool, false);
+   TEST_TTR(signed char, bool, bool, true);
+   TEST_TTR(signed char, char, bool, true);
+   TEST_TTR(signed char, signed char, bool, true);
+   TEST_TTR(signed char, short int, bool, true);
+   TEST_TTR(signed char, int, bool, true);
+   TEST_TTR(signed char, long int, bool, true);
+   TEST_TTR(signed char, unsigned char, bool, true);
+   TEST_TTR(signed char, unsigned short int, bool, true);
+   TEST_TTR(signed char, unsigned int, bool, true);
+   TEST_TTR(signed char, unsigned long int, bool, true);
+   TEST_TTR(signed char, wchar_t, bool, true);
+   TEST_TTR(signed char, float, bool, false);
+   TEST_TTR(signed char, double, bool, false);
+   TEST_TTR(signed char, long double, bool, false);
+   TEST_TTR(short int, bool, bool, true);
+   TEST_TTR(short int, char, bool, true);
+   TEST_TTR(short int, signed char, bool, true);
+   TEST_TTR(short int, short int, bool, true);
+   TEST_TTR(short int, int, bool, true);
+   TEST_TTR(short int, long int, bool, true);
+   TEST_TTR(short int, unsigned char, bool, true);
+   TEST_TTR(short int, unsigned short int, bool, true);
+   TEST_TTR(short int, unsigned int, bool, true);
+   TEST_TTR(short int, unsigned long int, bool, true);
+   TEST_TTR(short int, wchar_t, bool, true);
+   TEST_TTR(short int, float, bool, false);
+   TEST_TTR(short int, double, bool, false);
+   TEST_TTR(short int, long double, bool, false);
+   TEST_TTR(int, bool, bool, true);
+   TEST_TTR(int, char, bool, true);
+   TEST_TTR(int, signed char, bool, true);
+   TEST_TTR(int, short int, bool, true);
+   TEST_TTR(int, int, bool, true);
+   TEST_TTR(int, long int, bool, true);
+   TEST_TTR(int, unsigned char, bool, true);
+   TEST_TTR(int, unsigned short int, bool, true);
+   TEST_TTR(int, unsigned int, bool, true);
+   TEST_TTR(int, unsigned long int, bool, true);
+   TEST_TTR(int, wchar_t, bool, true);
+   TEST_TTR(int, float, bool, false);
+   TEST_TTR(int, double, bool, false);
+   TEST_TTR(int, long double, bool, false);
+   TEST_TTR(long int, bool, bool, true);
+   TEST_TTR(long int, char, bool, true);
+   TEST_TTR(long int, signed char, bool, true);
+   TEST_TTR(long int, short int, bool, true);
+   TEST_TTR(long int, int, bool, true);
+   TEST_TTR(long int, long int, bool, true);
+   TEST_TTR(long int, unsigned char, bool, true);
+   TEST_TTR(long int, unsigned short int, bool, true);
+   TEST_TTR(long int, unsigned int, bool, true);
+   TEST_TTR(long int, unsigned long int, bool, true);
+   TEST_TTR(long int, wchar_t, bool, true);
+   TEST_TTR(long int, float, bool, false);
+   TEST_TTR(long int, double, bool, false);
+   TEST_TTR(long int, long double, bool, false);
+   TEST_TTR(unsigned char, bool, bool, true);
+   TEST_TTR(unsigned char, char, bool, true);
+   TEST_TTR(unsigned char, signed char, bool, true);
+   TEST_TTR(unsigned char, short int, bool, true);
+   TEST_TTR(unsigned char, int, bool, true);
+   TEST_TTR(unsigned char, long int, bool, true);
+   TEST_TTR(unsigned char, unsigned char, bool, true);
+   TEST_TTR(unsigned char, unsigned short int, bool, true);
+   TEST_TTR(unsigned char, unsigned int, bool, true);
+   TEST_TTR(unsigned char, unsigned long int, bool, true);
+   TEST_TTR(unsigned char, wchar_t, bool, true);
+   TEST_TTR(unsigned char, float, bool, false);
+   TEST_TTR(unsigned char, double, bool, false);
+   TEST_TTR(unsigned char, long double, bool, false);
+   TEST_TTR(unsigned short int, bool, bool, true);
+   TEST_TTR(unsigned short int, char, bool, true);
+   TEST_TTR(unsigned short int, signed char, bool, true);
+   TEST_TTR(unsigned short int, short int, bool, true);
+   TEST_TTR(unsigned short int, int, bool, true);
+   TEST_TTR(unsigned short int, long int, bool, true);
+   TEST_TTR(unsigned short int, unsigned char, bool, true);
+   TEST_TTR(unsigned short int, unsigned short int, bool, true);
+   TEST_TTR(unsigned short int, unsigned int, bool, true);
+   TEST_TTR(unsigned short int, unsigned long int, bool, true);
+   TEST_TTR(unsigned short int, wchar_t, bool, true);
+   TEST_TTR(unsigned short int, float, bool, false);
+   TEST_TTR(unsigned short int, double, bool, false);
+   TEST_TTR(unsigned short int, long double, bool, false);
+   TEST_TTR(unsigned int, bool, bool, true);
+   TEST_TTR(unsigned int, char, bool, true);
+   TEST_TTR(unsigned int, signed char, bool, true);
+   TEST_TTR(unsigned int, short int, bool, true);
+   TEST_TTR(unsigned int, int, bool, true);
+   TEST_TTR(unsigned int, long int, bool, true);
+   TEST_TTR(unsigned int, unsigned char, bool, true);
+   TEST_TTR(unsigned int, unsigned short int, bool, true);
+   TEST_TTR(unsigned int, unsigned int, bool, true);
+   TEST_TTR(unsigned int, unsigned long int, bool, true);
+   TEST_TTR(unsigned int, wchar_t, bool, true);
+   TEST_TTR(unsigned int, float, bool, false);
+   TEST_TTR(unsigned int, double, bool, false);
+   TEST_TTR(unsigned int, long double, bool, false);
+   TEST_TTR(unsigned long int, bool, bool, true);
+   TEST_TTR(unsigned long int, char, bool, true);
+   TEST_TTR(unsigned long int, signed char, bool, true);
+   TEST_TTR(unsigned long int, short int, bool, true);
+   TEST_TTR(unsigned long int, int, bool, true);
+   TEST_TTR(unsigned long int, long int, bool, true);
+   TEST_TTR(unsigned long int, unsigned char, bool, true);
+   TEST_TTR(unsigned long int, unsigned short int, bool, true);
+   TEST_TTR(unsigned long int, unsigned int, bool, true);
+   TEST_TTR(unsigned long int, unsigned long int, bool, true);
+   TEST_TTR(unsigned long int, wchar_t, bool, true);
+   TEST_TTR(unsigned long int, float, bool, false);
+   TEST_TTR(unsigned long int, double, bool, false);
+   TEST_TTR(unsigned long int, long double, bool, false);
+   TEST_TTR(wchar_t, bool, bool, true);
+   TEST_TTR(wchar_t, char, bool, true);
+   TEST_TTR(wchar_t, signed char, bool, true);
+   TEST_TTR(wchar_t, short int, bool, true);
+   TEST_TTR(wchar_t, int, bool, true);
+   TEST_TTR(wchar_t, long int, bool, true);
+   TEST_TTR(wchar_t, unsigned char, bool, true);
+   TEST_TTR(wchar_t, unsigned short int, bool, true);
+   TEST_TTR(wchar_t, unsigned int, bool, true);
+   TEST_TTR(wchar_t, unsigned long int, bool, true);
+   TEST_TTR(wchar_t, wchar_t, bool, true);
+   TEST_TTR(wchar_t, float, bool, false);
+   TEST_TTR(wchar_t, double, bool, false);
+   TEST_TTR(wchar_t, long double, bool, false);
+   TEST_TTR(float, bool, bool, false);
+   TEST_TTR(float, char, bool, false);
+   TEST_TTR(float, signed char, bool, false);
+   TEST_TTR(float, short int, bool, false);
+   TEST_TTR(float, int, bool, false);
+   TEST_TTR(float, long int, bool, false);
+   TEST_TTR(float, unsigned char, bool, false);
+   TEST_TTR(float, unsigned short int, bool, false);
+   TEST_TTR(float, unsigned int, bool, false);
+   TEST_TTR(float, unsigned long int, bool, false);
+   TEST_TTR(float, wchar_t, bool, false);
+   TEST_TTR(float, float, bool, false);
+   TEST_TTR(float, double, bool, false);
+   TEST_TTR(float, long double, bool, false);
+   TEST_TTR(double, bool, bool, false);
+   TEST_TTR(double, char, bool, false);
+   TEST_TTR(double, signed char, bool, false);
+   TEST_TTR(double, short int, bool, false);
+   TEST_TTR(double, int, bool, false);
+   TEST_TTR(double, long int, bool, false);
+   TEST_TTR(double, unsigned char, bool, false);
+   TEST_TTR(double, unsigned short int, bool, false);
+   TEST_TTR(double, unsigned int, bool, false);
+   TEST_TTR(double, unsigned long int, bool, false);
+   TEST_TTR(double, wchar_t, bool, false);
+   TEST_TTR(double, float, bool, false);
+   TEST_TTR(double, double, bool, false);
+   TEST_TTR(double, long double, bool, false);
+   TEST_TTR(long double, bool, bool, false);
+   TEST_TTR(long double, char, bool, false);
+   TEST_TTR(long double, signed char, bool, false);
+   TEST_TTR(long double, short int, bool, false);
+   TEST_TTR(long double, int, bool, false);
+   TEST_TTR(long double, long int, bool, false);
+   TEST_TTR(long double, unsigned char, bool, false);
+   TEST_TTR(long double, unsigned short int, bool, false);
+   TEST_TTR(long double, unsigned int, bool, false);
+   TEST_TTR(long double, unsigned long int, bool, false);
+   TEST_TTR(long double, wchar_t, bool, false);
+   TEST_TTR(long double, float, bool, false);
+   TEST_TTR(long double, double, bool, false);
+   TEST_TTR(long double, long double, bool, false);
+   TEST_TTR(bool, bool, tag, false);
+   TEST_TTR(bool, char, tag, false);
+   TEST_TTR(bool, signed char, tag, false);
+   TEST_TTR(bool, short int, tag, false);
+   TEST_TTR(bool, int, tag, false);
+   TEST_TTR(bool, long int, tag, false);
+   TEST_TTR(bool, unsigned char, tag, false);
+   TEST_TTR(bool, unsigned short int, tag, false);
+   TEST_TTR(bool, unsigned int, tag, false);
+   TEST_TTR(bool, unsigned long int, tag, false);
+   TEST_TTR(bool, wchar_t, tag, false);
+   TEST_TTR(bool, float, tag, false);
+   TEST_TTR(bool, double, tag, false);
+   TEST_TTR(bool, long double, tag, false);
+   TEST_TTR(char, bool, tag, false);
+   TEST_TTR(char, char, tag, false);
+   TEST_TTR(char, signed char, tag, false);
+   TEST_TTR(char, short int, tag, false);
+   TEST_TTR(char, int, tag, false);
+   TEST_TTR(char, long int, tag, false);
+   TEST_TTR(char, unsigned char, tag, false);
+   TEST_TTR(char, unsigned short int, tag, false);
+   TEST_TTR(char, unsigned int, tag, false);
+   TEST_TTR(char, unsigned long int, tag, false);
+   TEST_TTR(char, wchar_t, tag, false);
+   TEST_TTR(char, float, tag, false);
+   TEST_TTR(char, double, tag, false);
+   TEST_TTR(char, long double, tag, false);
+   TEST_TTR(signed char, bool, tag, false);
+   TEST_TTR(signed char, char, tag, false);
+   TEST_TTR(signed char, signed char, tag, false);
+   TEST_TTR(signed char, short int, tag, false);
+   TEST_TTR(signed char, int, tag, false);
+   TEST_TTR(signed char, long int, tag, false);
+   TEST_TTR(signed char, unsigned char, tag, false);
+   TEST_TTR(signed char, unsigned short int, tag, false);
+   TEST_TTR(signed char, unsigned int, tag, false);
+   TEST_TTR(signed char, unsigned long int, tag, false);
+   TEST_TTR(signed char, wchar_t, tag, false);
+   TEST_TTR(signed char, float, tag, false);
+   TEST_TTR(signed char, double, tag, false);
+   TEST_TTR(signed char, long double, tag, false);
+   TEST_TTR(short int, bool, tag, false);
+   TEST_TTR(short int, char, tag, false);
+   TEST_TTR(short int, signed char, tag, false);
+   TEST_TTR(short int, short int, tag, false);
+   TEST_TTR(short int, int, tag, false);
+   TEST_TTR(short int, long int, tag, false);
+   TEST_TTR(short int, unsigned char, tag, false);
+   TEST_TTR(short int, unsigned short int, tag, false);
+   TEST_TTR(short int, unsigned int, tag, false);
+   TEST_TTR(short int, unsigned long int, tag, false);
+   TEST_TTR(short int, wchar_t, tag, false);
+   TEST_TTR(short int, float, tag, false);
+   TEST_TTR(short int, double, tag, false);
+   TEST_TTR(short int, long double, tag, false);
+   TEST_TTR(int, bool, tag, false);
+   TEST_TTR(int, char, tag, false);
+   TEST_TTR(int, signed char, tag, false);
+   TEST_TTR(int, short int, tag, false);
+   TEST_TTR(int, int, tag, false);
+   TEST_TTR(int, long int, tag, false);
+   TEST_TTR(int, unsigned char, tag, false);
+   TEST_TTR(int, unsigned short int, tag, false);
+   TEST_TTR(int, unsigned int, tag, false);
+   TEST_TTR(int, unsigned long int, tag, false);
+   TEST_TTR(int, wchar_t, tag, false);
+   TEST_TTR(int, float, tag, false);
+   TEST_TTR(int, double, tag, false);
+   TEST_TTR(int, long double, tag, false);
+   TEST_TTR(long int, bool, tag, false);
+   TEST_TTR(long int, char, tag, false);
+   TEST_TTR(long int, signed char, tag, false);
+   TEST_TTR(long int, short int, tag, false);
+   TEST_TTR(long int, int, tag, false);
+   TEST_TTR(long int, long int, tag, false);
+   TEST_TTR(long int, unsigned char, tag, false);
+   TEST_TTR(long int, unsigned short int, tag, false);
+   TEST_TTR(long int, unsigned int, tag, false);
+   TEST_TTR(long int, unsigned long int, tag, false);
+   TEST_TTR(long int, wchar_t, tag, false);
+   TEST_TTR(long int, float, tag, false);
+   TEST_TTR(long int, double, tag, false);
+   TEST_TTR(long int, long double, tag, false);
+   TEST_TTR(unsigned char, bool, tag, false);
+   TEST_TTR(unsigned char, char, tag, false);
+   TEST_TTR(unsigned char, signed char, tag, false);
+   TEST_TTR(unsigned char, short int, tag, false);
+   TEST_TTR(unsigned char, int, tag, false);
+   TEST_TTR(unsigned char, long int, tag, false);
+   TEST_TTR(unsigned char, unsigned char, tag, false);
+   TEST_TTR(unsigned char, unsigned short int, tag, false);
+   TEST_TTR(unsigned char, unsigned int, tag, false);
+   TEST_TTR(unsigned char, unsigned long int, tag, false);
+   TEST_TTR(unsigned char, wchar_t, tag, false);
+   TEST_TTR(unsigned char, float, tag, false);
+   TEST_TTR(unsigned char, double, tag, false);
+   TEST_TTR(unsigned char, long double, tag, false);
+   TEST_TTR(unsigned short int, bool, tag, false);
+   TEST_TTR(unsigned short int, char, tag, false);
+   TEST_TTR(unsigned short int, signed char, tag, false);
+   TEST_TTR(unsigned short int, short int, tag, false);
+   TEST_TTR(unsigned short int, int, tag, false);
+   TEST_TTR(unsigned short int, long int, tag, false);
+   TEST_TTR(unsigned short int, unsigned char, tag, false);
+   TEST_TTR(unsigned short int, unsigned short int, tag, false);
+   TEST_TTR(unsigned short int, unsigned int, tag, false);
+   TEST_TTR(unsigned short int, unsigned long int, tag, false);
+   TEST_TTR(unsigned short int, wchar_t, tag, false);
+   TEST_TTR(unsigned short int, float, tag, false);
+   TEST_TTR(unsigned short int, double, tag, false);
+   TEST_TTR(unsigned short int, long double, tag, false);
+   TEST_TTR(unsigned int, bool, tag, false);
+   TEST_TTR(unsigned int, char, tag, false);
+   TEST_TTR(unsigned int, signed char, tag, false);
+   TEST_TTR(unsigned int, short int, tag, false);
+   TEST_TTR(unsigned int, int, tag, false);
+   TEST_TTR(unsigned int, long int, tag, false);
+   TEST_TTR(unsigned int, unsigned char, tag, false);
+   TEST_TTR(unsigned int, unsigned short int, tag, false);
+   TEST_TTR(unsigned int, unsigned int, tag, false);
+   TEST_TTR(unsigned int, unsigned long int, tag, false);
+   TEST_TTR(unsigned int, wchar_t, tag, false);
+   TEST_TTR(unsigned int, float, tag, false);
+   TEST_TTR(unsigned int, double, tag, false);
+   TEST_TTR(unsigned int, long double, tag, false);
+   TEST_TTR(unsigned long int, bool, tag, false);
+   TEST_TTR(unsigned long int, char, tag, false);
+   TEST_TTR(unsigned long int, signed char, tag, false);
+   TEST_TTR(unsigned long int, short int, tag, false);
+   TEST_TTR(unsigned long int, int, tag, false);
+   TEST_TTR(unsigned long int, long int, tag, false);
+   TEST_TTR(unsigned long int, unsigned char, tag, false);
+   TEST_TTR(unsigned long int, unsigned short int, tag, false);
+   TEST_TTR(unsigned long int, unsigned int, tag, false);
+   TEST_TTR(unsigned long int, unsigned long int, tag, false);
+   TEST_TTR(unsigned long int, wchar_t, tag, false);
+   TEST_TTR(unsigned long int, float, tag, false);
+   TEST_TTR(unsigned long int, double, tag, false);
+   TEST_TTR(unsigned long int, long double, tag, false);
+   TEST_TTR(wchar_t, bool, tag, false);
+   TEST_TTR(wchar_t, char, tag, false);
+   TEST_TTR(wchar_t, signed char, tag, false);
+   TEST_TTR(wchar_t, short int, tag, false);
+   TEST_TTR(wchar_t, int, tag, false);
+   TEST_TTR(wchar_t, long int, tag, false);
+   TEST_TTR(wchar_t, unsigned char, tag, false);
+   TEST_TTR(wchar_t, unsigned short int, tag, false);
+   TEST_TTR(wchar_t, unsigned int, tag, false);
+   TEST_TTR(wchar_t, unsigned long int, tag, false);
+   TEST_TTR(wchar_t, wchar_t, tag, false);
+   TEST_TTR(wchar_t, float, tag, false);
+   TEST_TTR(wchar_t, double, tag, false);
+   TEST_TTR(wchar_t, long double, tag, false);
+   TEST_TTR(float, bool, tag, false);
+   TEST_TTR(float, char, tag, false);
+   TEST_TTR(float, signed char, tag, false);
+   TEST_TTR(float, short int, tag, false);
+   TEST_TTR(float, int, tag, false);
+   TEST_TTR(float, long int, tag, false);
+   TEST_TTR(float, unsigned char, tag, false);
+   TEST_TTR(float, unsigned short int, tag, false);
+   TEST_TTR(float, unsigned int, tag, false);
+   TEST_TTR(float, unsigned long int, tag, false);
+   TEST_TTR(float, wchar_t, tag, false);
+   TEST_TTR(float, float, tag, false);
+   TEST_TTR(float, double, tag, false);
+   TEST_TTR(float, long double, tag, false);
+   TEST_TTR(double, bool, tag, false);
+   TEST_TTR(double, char, tag, false);
+   TEST_TTR(double, signed char, tag, false);
+   TEST_TTR(double, short int, tag, false);
+   TEST_TTR(double, int, tag, false);
+   TEST_TTR(double, long int, tag, false);
+   TEST_TTR(double, unsigned char, tag, false);
+   TEST_TTR(double, unsigned short int, tag, false);
+   TEST_TTR(double, unsigned int, tag, false);
+   TEST_TTR(double, unsigned long int, tag, false);
+   TEST_TTR(double, wchar_t, tag, false);
+   TEST_TTR(double, float, tag, false);
+   TEST_TTR(double, double, tag, false);
+   TEST_TTR(double, long double, tag, false);
+   TEST_TTR(long double, bool, tag, false);
+   TEST_TTR(long double, char, tag, false);
+   TEST_TTR(long double, signed char, tag, false);
+   TEST_TTR(long double, short int, tag, false);
+   TEST_TTR(long double, int, tag, false);
+   TEST_TTR(long double, long int, tag, false);
+   TEST_TTR(long double, unsigned char, tag, false);
+   TEST_TTR(long double, unsigned short int, tag, false);
+   TEST_TTR(long double, unsigned int, tag, false);
+   TEST_TTR(long double, unsigned long int, tag, false);
+   TEST_TTR(long double, wchar_t, tag, false);
+   TEST_TTR(long double, float, tag, false);
+   TEST_TTR(long double, double, tag, false);
+   TEST_TTR(long double, long double, tag, false);
+#	undef CV1
+#	define CV1(T) const T
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), false);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), false);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, false);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), false);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), false);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, false);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const T&
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), false);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), false);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, false);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T&
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T&
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), false);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), false);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, false);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const T
+#	undef CV2
+#	define CV2(T) const T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), false);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), false);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, false);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const T&
+#	undef CV2
+#	define CV2(T) const T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), false);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), false);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, false);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T
+#	undef CV2
+#	define CV2(T) volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T&
+#	undef CV2
+#	define CV2(T) volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T
+#	undef CV2
+#	define CV2(T) const volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), false);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), false);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, false);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T&
+#	undef CV2
+#	define CV2(T) const volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), false);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), false);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, false);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+   // pointers
+   TEST_TT(void*, bool, false);
+   TEST_TT(void*, int, false);
+   TEST_TT(void*, double, false);
+   TEST_TT(void*, A, false);
+   TEST_TT(void*, B, false);
+   TEST_TT(bool*, bool, false);
+   TEST_TT(bool*, int, false);
+   TEST_TT(bool*, double, false);
+   TEST_TT(bool*, A, false);
+   TEST_TT(bool*, B, false);
+   TEST_TT(int*, bool, false);
+   TEST_TT(int*, int, false);
+   TEST_TT(int*, double, false);
+   TEST_TT(int*, A, false);
+   TEST_TT(int*, B, false);
+   TEST_TT(double*, bool, false);
+   TEST_TT(double*, int, false);
+   TEST_TT(double*, double, false);
+   TEST_TT(double*, A, false);
+   TEST_TT(double*, B, false);
+   TEST_TT(A*, bool, false);
+   TEST_TT(A*, int, false);
+   TEST_TT(A*, double, false);
+   TEST_TT(A*, A, false);
+   TEST_TT(A*, B, false);
+   TEST_TT(B*, bool, false);
+   TEST_TT(B*, int, false);
+   TEST_TT(B*, double, false);
+   TEST_TT(B*, A, false);
+   TEST_TT(B*, B, false);
+   TEST_TT(bool, void*, false);
+   TEST_TT(bool, bool*, false);
+   TEST_TT(bool, int*, false);
+   TEST_TT(bool, double*, false);
+   TEST_TT(bool, A*, false);
+   TEST_TT(bool, B*, false);
+   TEST_TT(int, void*, false);
+   TEST_TT(int, bool*, false);
+   TEST_TT(int, int*, false);
+   TEST_TT(int, double*, false);
+   TEST_TT(int, A*, false);
+   TEST_TT(int, B*, false);
+   TEST_TT(double, void*, false);
+   TEST_TT(double, bool*, false);
+   TEST_TT(double, int*, false);
+   TEST_TT(double, double*, false);
+   TEST_TT(double, A*, false);
+   TEST_TT(double, B*, false);
+   TEST_TT(A, void*, false);
+   TEST_TT(A, bool*, false);
+   TEST_TT(A, int*, false);
+   TEST_TT(A, double*, false);
+   TEST_TT(A, A*, false);
+   TEST_TT(A, B*, false);
+   TEST_TT(B, void*, false);
+   TEST_TT(B, bool*, false);
+   TEST_TT(B, int*, false);
+   TEST_TT(B, double*, false);
+   TEST_TT(B, A*, false);
+   TEST_TT(B, B*, false);
+   TEST_TT(void*, void*, false);
+   TEST_TT(void*, bool*, false);
+   TEST_TT(void*, int*, false);
+   TEST_TT(void*, double*, false);
+   TEST_TT(void*, A*, false);
+   TEST_TT(void*, B*, false);
+   TEST_TT(bool*, void*, false);
+   TEST_TT(bool*, bool*, false);
+   TEST_TT(bool*, int*, false);
+   TEST_TT(bool*, double*, false);
+   TEST_TT(bool*, A*, false);
+   TEST_TT(bool*, B*, false);
+   TEST_TT(int*, void*, false);
+   TEST_TT(int*, bool*, false);
+   TEST_TT(int*, int*, false);
+   TEST_TT(int*, double*, false);
+   TEST_TT(int*, A*, false);
+   TEST_TT(int*, B*, false);
+   TEST_TT(double*, void*, false);
+   TEST_TT(double*, bool*, false);
+   TEST_TT(double*, int*, false);
+   TEST_TT(double*, double*, false);
+   TEST_TT(double*, A*, false);
+   TEST_TT(double*, B*, false);
+   TEST_TT(A*, void*, false);
+   TEST_TT(A*, bool*, false);
+   TEST_TT(A*, int*, false);
+   TEST_TT(A*, double*, false);
+   TEST_TT(A*, A*, false);
+   TEST_TT(A*, B*, false);
+   TEST_TT(B*, void*, false);
+   TEST_TT(B*, bool*, false);
+   TEST_TT(B*, int*, false);
+   TEST_TT(B*, double*, false);
+   TEST_TT(B*, A*, false);
+   TEST_TT(B*, B*, false);
+   TEST_TT(C, void*, true);
+   TEST_TT(D, void*, false);
+   TEST_TT(void*, C, false);
+   TEST_TT(void*, D, true);
+   TEST_TT(C, D, true);
+}
+}

Added: sandbox/type_traits/libs/type_traits/test/can_call_integral_test.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_integral_test.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,1250 @@
+//  (C) Copyright Frederic Bron 2009-2011.
+//  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)
+
+namespace {
+
+void run2() {
+   // test with only one template parameter
+   TEST_T(void, false);
+   TEST_T(bool, true);
+   TEST_T(char, true);
+   TEST_T(signed char, true);
+   TEST_T(short int, true);
+   TEST_T(int, true);
+   TEST_T(long int, true);
+   TEST_T(unsigned char, true);
+   TEST_T(unsigned short int, true);
+   TEST_T(unsigned int, true);
+   TEST_T(unsigned long int, true);
+   TEST_T(wchar_t, true);
+   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), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), false);
+#	undef CV
+#	define CV(T) volatile T
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), false);
+#	undef CV
+#	define CV(T) const volatile T
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), false);
+#	undef CV
+#	define CV(T) const T&
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), false);
+#	undef CV
+#	define CV(T) volatile T&
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), false);
+#	undef CV
+#	define CV(T) const volatile T&
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   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);
+   TEST_TT(bool, short int, true);
+   TEST_TT(bool, int, true);
+   TEST_TT(bool, long int, true);
+   TEST_TT(bool, unsigned char, true);
+   TEST_TT(bool, unsigned short int, true);
+   TEST_TT(bool, unsigned int, true);
+   TEST_TT(bool, unsigned long int, true);
+   TEST_TT(bool, wchar_t, true);
+   TEST_TT(bool, float, false);
+   TEST_TT(bool, double, false);
+   TEST_TT(bool, long double, false);
+   TEST_TT(char, bool, true);
+   TEST_TT(char, char, true);
+   TEST_TT(char, signed char, true);
+   TEST_TT(char, short int, true);
+   TEST_TT(char, int, true);
+   TEST_TT(char, long int, true);
+   TEST_TT(char, unsigned char, true);
+   TEST_TT(char, unsigned short int, true);
+   TEST_TT(char, unsigned int, true);
+   TEST_TT(char, unsigned long int, true);
+   TEST_TT(char, wchar_t, true);
+   TEST_TT(char, float, false);
+   TEST_TT(char, double, false);
+   TEST_TT(char, long double, false);
+   TEST_TT(signed char, bool, true);
+   TEST_TT(signed char, char, true);
+   TEST_TT(signed char, signed char, true);
+   TEST_TT(signed char, short int, true);
+   TEST_TT(signed char, int, true);
+   TEST_TT(signed char, long int, true);
+   TEST_TT(signed char, unsigned char, true);
+   TEST_TT(signed char, unsigned short int, true);
+   TEST_TT(signed char, unsigned int, true);
+   TEST_TT(signed char, unsigned long int, true);
+   TEST_TT(signed char, wchar_t, true);
+   TEST_TT(signed char, float, false);
+   TEST_TT(signed char, double, false);
+   TEST_TT(signed char, long double, false);
+   TEST_TT(short int, bool, true);
+   TEST_TT(short int, char, true);
+   TEST_TT(short int, signed char, true);
+   TEST_TT(short int, short int, true);
+   TEST_TT(short int, int, true);
+   TEST_TT(short int, long int, true);
+   TEST_TT(short int, unsigned char, true);
+   TEST_TT(short int, unsigned short int, true);
+   TEST_TT(short int, unsigned int, true);
+   TEST_TT(short int, unsigned long int, true);
+   TEST_TT(short int, wchar_t, true);
+   TEST_TT(short int, float, false);
+   TEST_TT(short int, double, false);
+   TEST_TT(short int, long double, false);
+   TEST_TT(int, bool, true);
+   TEST_TT(int, char, true);
+   TEST_TT(int, signed char, true);
+   TEST_TT(int, short int, true);
+   TEST_TT(int, int, true);
+   TEST_TT(int, long int, true);
+   TEST_TT(int, unsigned char, true);
+   TEST_TT(int, unsigned short int, true);
+   TEST_TT(int, unsigned int, true);
+   TEST_TT(int, unsigned long int, true);
+   TEST_TT(int, wchar_t, true);
+   TEST_TT(int, float, false);
+   TEST_TT(int, double, false);
+   TEST_TT(int, long double, false);
+   TEST_TT(long int, bool, true);
+   TEST_TT(long int, char, true);
+   TEST_TT(long int, signed char, true);
+   TEST_TT(long int, short int, true);
+   TEST_TT(long int, int, true);
+   TEST_TT(long int, long int, true);
+   TEST_TT(long int, unsigned char, true);
+   TEST_TT(long int, unsigned short int, true);
+   TEST_TT(long int, unsigned int, true);
+   TEST_TT(long int, unsigned long int, true);
+   TEST_TT(long int, wchar_t, true);
+   TEST_TT(long int, float, false);
+   TEST_TT(long int, double, false);
+   TEST_TT(long int, long double, false);
+   TEST_TT(unsigned char, bool, true);
+   TEST_TT(unsigned char, char, true);
+   TEST_TT(unsigned char, signed char, true);
+   TEST_TT(unsigned char, short int, true);
+   TEST_TT(unsigned char, int, true);
+   TEST_TT(unsigned char, long int, true);
+   TEST_TT(unsigned char, unsigned char, true);
+   TEST_TT(unsigned char, unsigned short int, true);
+   TEST_TT(unsigned char, unsigned int, true);
+   TEST_TT(unsigned char, unsigned long int, true);
+   TEST_TT(unsigned char, wchar_t, true);
+   TEST_TT(unsigned char, float, false);
+   TEST_TT(unsigned char, double, false);
+   TEST_TT(unsigned char, long double, false);
+   TEST_TT(unsigned short int, bool, true);
+   TEST_TT(unsigned short int, char, true);
+   TEST_TT(unsigned short int, signed char, true);
+   TEST_TT(unsigned short int, short int, true);
+   TEST_TT(unsigned short int, int, true);
+   TEST_TT(unsigned short int, long int, true);
+   TEST_TT(unsigned short int, unsigned char, true);
+   TEST_TT(unsigned short int, unsigned short int, true);
+   TEST_TT(unsigned short int, unsigned int, true);
+   TEST_TT(unsigned short int, unsigned long int, true);
+   TEST_TT(unsigned short int, wchar_t, true);
+   TEST_TT(unsigned short int, float, false);
+   TEST_TT(unsigned short int, double, false);
+   TEST_TT(unsigned short int, long double, false);
+   TEST_TT(unsigned int, bool, true);
+   TEST_TT(unsigned int, char, true);
+   TEST_TT(unsigned int, signed char, true);
+   TEST_TT(unsigned int, short int, true);
+   TEST_TT(unsigned int, int, true);
+   TEST_TT(unsigned int, long int, true);
+   TEST_TT(unsigned int, unsigned char, true);
+   TEST_TT(unsigned int, unsigned short int, true);
+   TEST_TT(unsigned int, unsigned int, true);
+   TEST_TT(unsigned int, unsigned long int, true);
+   TEST_TT(unsigned int, wchar_t, true);
+   TEST_TT(unsigned int, float, false);
+   TEST_TT(unsigned int, double, false);
+   TEST_TT(unsigned int, long double, false);
+   TEST_TT(unsigned long int, bool, true);
+   TEST_TT(unsigned long int, char, true);
+   TEST_TT(unsigned long int, signed char, true);
+   TEST_TT(unsigned long int, short int, true);
+   TEST_TT(unsigned long int, int, true);
+   TEST_TT(unsigned long int, long int, true);
+   TEST_TT(unsigned long int, unsigned char, true);
+   TEST_TT(unsigned long int, unsigned short int, true);
+   TEST_TT(unsigned long int, unsigned int, true);
+   TEST_TT(unsigned long int, unsigned long int, true);
+   TEST_TT(unsigned long int, wchar_t, true);
+   TEST_TT(unsigned long int, float, false);
+   TEST_TT(unsigned long int, double, false);
+   TEST_TT(unsigned long int, long double, false);
+   TEST_TT(wchar_t, bool, true);
+   TEST_TT(wchar_t, char, true);
+   TEST_TT(wchar_t, signed char, true);
+   TEST_TT(wchar_t, short int, true);
+   TEST_TT(wchar_t, int, true);
+   TEST_TT(wchar_t, long int, true);
+   TEST_TT(wchar_t, unsigned char, true);
+   TEST_TT(wchar_t, unsigned short int, true);
+   TEST_TT(wchar_t, unsigned int, true);
+   TEST_TT(wchar_t, unsigned long int, true);
+   TEST_TT(wchar_t, wchar_t, true);
+   TEST_TT(wchar_t, float, false);
+   TEST_TT(wchar_t, double, false);
+   TEST_TT(wchar_t, long double, false);
+   TEST_TT(float, bool, false);
+   TEST_TT(float, char, false);
+   TEST_TT(float, signed char, false);
+   TEST_TT(float, short int, false);
+   TEST_TT(float, int, false);
+   TEST_TT(float, long int, false);
+   TEST_TT(float, unsigned char, false);
+   TEST_TT(float, unsigned short int, false);
+   TEST_TT(float, unsigned int, false);
+   TEST_TT(float, unsigned long int, false);
+   TEST_TT(float, wchar_t, false);
+   TEST_TT(float, float, false);
+   TEST_TT(float, double, false);
+   TEST_TT(float, long double, false);
+   TEST_TT(double, bool, false);
+   TEST_TT(double, char, false);
+   TEST_TT(double, signed char, false);
+   TEST_TT(double, short int, false);
+   TEST_TT(double, int, false);
+   TEST_TT(double, long int, false);
+   TEST_TT(double, unsigned char, false);
+   TEST_TT(double, unsigned short int, false);
+   TEST_TT(double, unsigned int, false);
+   TEST_TT(double, unsigned long int, false);
+   TEST_TT(double, wchar_t, false);
+   TEST_TT(double, float, false);
+   TEST_TT(double, double, false);
+   TEST_TT(double, long double, false);
+   TEST_TT(long double, bool, false);
+   TEST_TT(long double, char, false);
+   TEST_TT(long double, signed char, false);
+   TEST_TT(long double, short int, false);
+   TEST_TT(long double, int, false);
+   TEST_TT(long double, long int, false);
+   TEST_TT(long double, unsigned char, false);
+   TEST_TT(long double, unsigned short int, false);
+   TEST_TT(long double, unsigned int, false);
+   TEST_TT(long double, unsigned long int, false);
+   TEST_TT(long double, wchar_t, false);
+   TEST_TT(long double, float, false);
+   TEST_TT(long double, double, false);
+   TEST_TT(long double, long double, false);
+   TEST_TT(bool, void, false);
+   TEST_TT(void, bool, false);
+   TEST_TT(char, void, false);
+   TEST_TT(void, char, false);
+   TEST_TT(signed char, void, false);
+   TEST_TT(void, signed char, false);
+   TEST_TT(short int, void, false);
+   TEST_TT(void, short int, false);
+   TEST_TT(int, void, false);
+   TEST_TT(void, int, false);
+   TEST_TT(long int, void, false);
+   TEST_TT(void, long int, false);
+   TEST_TT(unsigned char, void, false);
+   TEST_TT(void, unsigned char, false);
+   TEST_TT(unsigned short int, void, false);
+   TEST_TT(void, unsigned short int, false);
+   TEST_TT(unsigned int, void, false);
+   TEST_TT(void, unsigned int, false);
+   TEST_TT(unsigned long int, void, false);
+   TEST_TT(void, unsigned long int, false);
+   TEST_TT(wchar_t, void, false);
+   TEST_TT(void, wchar_t, false);
+   TEST_TT(float, void, false);
+   TEST_TT(void, float, false);
+   TEST_TT(double, void, false);
+   TEST_TT(void, double, false);
+   TEST_TT(long double, void, false);
+   TEST_TT(void, long double, false);
+
+// test with three template parameters
+   TEST_TTR(bool, bool, bool, true);
+   TEST_TTR(bool, char, bool, true);
+   TEST_TTR(bool, signed char, bool, true);
+   TEST_TTR(bool, short int, bool, true);
+   TEST_TTR(bool, int, bool, true);
+   TEST_TTR(bool, long int, bool, true);
+   TEST_TTR(bool, unsigned char, bool, true);
+   TEST_TTR(bool, unsigned short int, bool, true);
+   TEST_TTR(bool, unsigned int, bool, true);
+   TEST_TTR(bool, unsigned long int, bool, true);
+   TEST_TTR(bool, wchar_t, bool, true);
+   TEST_TTR(bool, float, bool, false);
+   TEST_TTR(bool, double, bool, false);
+   TEST_TTR(bool, long double, bool, false);
+   TEST_TTR(char, bool, bool, true);
+   TEST_TTR(char, char, bool, true);
+   TEST_TTR(char, signed char, bool, true);
+   TEST_TTR(char, short int, bool, true);
+   TEST_TTR(char, int, bool, true);
+   TEST_TTR(char, long int, bool, true);
+   TEST_TTR(char, unsigned char, bool, true);
+   TEST_TTR(char, unsigned short int, bool, true);
+   TEST_TTR(char, unsigned int, bool, true);
+   TEST_TTR(char, unsigned long int, bool, true);
+   TEST_TTR(char, wchar_t, bool, true);
+   TEST_TTR(char, float, bool, false);
+   TEST_TTR(char, double, bool, false);
+   TEST_TTR(char, long double, bool, false);
+   TEST_TTR(signed char, bool, bool, true);
+   TEST_TTR(signed char, char, bool, true);
+   TEST_TTR(signed char, signed char, bool, true);
+   TEST_TTR(signed char, short int, bool, true);
+   TEST_TTR(signed char, int, bool, true);
+   TEST_TTR(signed char, long int, bool, true);
+   TEST_TTR(signed char, unsigned char, bool, true);
+   TEST_TTR(signed char, unsigned short int, bool, true);
+   TEST_TTR(signed char, unsigned int, bool, true);
+   TEST_TTR(signed char, unsigned long int, bool, true);
+   TEST_TTR(signed char, wchar_t, bool, true);
+   TEST_TTR(signed char, float, bool, false);
+   TEST_TTR(signed char, double, bool, false);
+   TEST_TTR(signed char, long double, bool, false);
+   TEST_TTR(short int, bool, bool, true);
+   TEST_TTR(short int, char, bool, true);
+   TEST_TTR(short int, signed char, bool, true);
+   TEST_TTR(short int, short int, bool, true);
+   TEST_TTR(short int, int, bool, true);
+   TEST_TTR(short int, long int, bool, true);
+   TEST_TTR(short int, unsigned char, bool, true);
+   TEST_TTR(short int, unsigned short int, bool, true);
+   TEST_TTR(short int, unsigned int, bool, true);
+   TEST_TTR(short int, unsigned long int, bool, true);
+   TEST_TTR(short int, wchar_t, bool, true);
+   TEST_TTR(short int, float, bool, false);
+   TEST_TTR(short int, double, bool, false);
+   TEST_TTR(short int, long double, bool, false);
+   TEST_TTR(int, bool, bool, true);
+   TEST_TTR(int, char, bool, true);
+   TEST_TTR(int, signed char, bool, true);
+   TEST_TTR(int, short int, bool, true);
+   TEST_TTR(int, int, bool, true);
+   TEST_TTR(int, long int, bool, true);
+   TEST_TTR(int, unsigned char, bool, true);
+   TEST_TTR(int, unsigned short int, bool, true);
+   TEST_TTR(int, unsigned int, bool, true);
+   TEST_TTR(int, unsigned long int, bool, true);
+   TEST_TTR(int, wchar_t, bool, true);
+   TEST_TTR(int, float, bool, false);
+   TEST_TTR(int, double, bool, false);
+   TEST_TTR(int, long double, bool, false);
+   TEST_TTR(long int, bool, bool, true);
+   TEST_TTR(long int, char, bool, true);
+   TEST_TTR(long int, signed char, bool, true);
+   TEST_TTR(long int, short int, bool, true);
+   TEST_TTR(long int, int, bool, true);
+   TEST_TTR(long int, long int, bool, true);
+   TEST_TTR(long int, unsigned char, bool, true);
+   TEST_TTR(long int, unsigned short int, bool, true);
+   TEST_TTR(long int, unsigned int, bool, true);
+   TEST_TTR(long int, unsigned long int, bool, true);
+   TEST_TTR(long int, wchar_t, bool, true);
+   TEST_TTR(long int, float, bool, false);
+   TEST_TTR(long int, double, bool, false);
+   TEST_TTR(long int, long double, bool, false);
+   TEST_TTR(unsigned char, bool, bool, true);
+   TEST_TTR(unsigned char, char, bool, true);
+   TEST_TTR(unsigned char, signed char, bool, true);
+   TEST_TTR(unsigned char, short int, bool, true);
+   TEST_TTR(unsigned char, int, bool, true);
+   TEST_TTR(unsigned char, long int, bool, true);
+   TEST_TTR(unsigned char, unsigned char, bool, true);
+   TEST_TTR(unsigned char, unsigned short int, bool, true);
+   TEST_TTR(unsigned char, unsigned int, bool, true);
+   TEST_TTR(unsigned char, unsigned long int, bool, true);
+   TEST_TTR(unsigned char, wchar_t, bool, true);
+   TEST_TTR(unsigned char, float, bool, false);
+   TEST_TTR(unsigned char, double, bool, false);
+   TEST_TTR(unsigned char, long double, bool, false);
+   TEST_TTR(unsigned short int, bool, bool, true);
+   TEST_TTR(unsigned short int, char, bool, true);
+   TEST_TTR(unsigned short int, signed char, bool, true);
+   TEST_TTR(unsigned short int, short int, bool, true);
+   TEST_TTR(unsigned short int, int, bool, true);
+   TEST_TTR(unsigned short int, long int, bool, true);
+   TEST_TTR(unsigned short int, unsigned char, bool, true);
+   TEST_TTR(unsigned short int, unsigned short int, bool, true);
+   TEST_TTR(unsigned short int, unsigned int, bool, true);
+   TEST_TTR(unsigned short int, unsigned long int, bool, true);
+   TEST_TTR(unsigned short int, wchar_t, bool, true);
+   TEST_TTR(unsigned short int, float, bool, false);
+   TEST_TTR(unsigned short int, double, bool, false);
+   TEST_TTR(unsigned short int, long double, bool, false);
+   TEST_TTR(unsigned int, bool, bool, true);
+   TEST_TTR(unsigned int, char, bool, true);
+   TEST_TTR(unsigned int, signed char, bool, true);
+   TEST_TTR(unsigned int, short int, bool, true);
+   TEST_TTR(unsigned int, int, bool, true);
+   TEST_TTR(unsigned int, long int, bool, true);
+   TEST_TTR(unsigned int, unsigned char, bool, true);
+   TEST_TTR(unsigned int, unsigned short int, bool, true);
+   TEST_TTR(unsigned int, unsigned int, bool, true);
+   TEST_TTR(unsigned int, unsigned long int, bool, true);
+   TEST_TTR(unsigned int, wchar_t, bool, true);
+   TEST_TTR(unsigned int, float, bool, false);
+   TEST_TTR(unsigned int, double, bool, false);
+   TEST_TTR(unsigned int, long double, bool, false);
+   TEST_TTR(unsigned long int, bool, bool, true);
+   TEST_TTR(unsigned long int, char, bool, true);
+   TEST_TTR(unsigned long int, signed char, bool, true);
+   TEST_TTR(unsigned long int, short int, bool, true);
+   TEST_TTR(unsigned long int, int, bool, true);
+   TEST_TTR(unsigned long int, long int, bool, true);
+   TEST_TTR(unsigned long int, unsigned char, bool, true);
+   TEST_TTR(unsigned long int, unsigned short int, bool, true);
+   TEST_TTR(unsigned long int, unsigned int, bool, true);
+   TEST_TTR(unsigned long int, unsigned long int, bool, true);
+   TEST_TTR(unsigned long int, wchar_t, bool, true);
+   TEST_TTR(unsigned long int, float, bool, false);
+   TEST_TTR(unsigned long int, double, bool, false);
+   TEST_TTR(unsigned long int, long double, bool, false);
+   TEST_TTR(wchar_t, bool, bool, true);
+   TEST_TTR(wchar_t, char, bool, true);
+   TEST_TTR(wchar_t, signed char, bool, true);
+   TEST_TTR(wchar_t, short int, bool, true);
+   TEST_TTR(wchar_t, int, bool, true);
+   TEST_TTR(wchar_t, long int, bool, true);
+   TEST_TTR(wchar_t, unsigned char, bool, true);
+   TEST_TTR(wchar_t, unsigned short int, bool, true);
+   TEST_TTR(wchar_t, unsigned int, bool, true);
+   TEST_TTR(wchar_t, unsigned long int, bool, true);
+   TEST_TTR(wchar_t, wchar_t, bool, true);
+   TEST_TTR(wchar_t, float, bool, false);
+   TEST_TTR(wchar_t, double, bool, false);
+   TEST_TTR(wchar_t, long double, bool, false);
+   TEST_TTR(float, bool, bool, false);
+   TEST_TTR(float, char, bool, false);
+   TEST_TTR(float, signed char, bool, false);
+   TEST_TTR(float, short int, bool, false);
+   TEST_TTR(float, int, bool, false);
+   TEST_TTR(float, long int, bool, false);
+   TEST_TTR(float, unsigned char, bool, false);
+   TEST_TTR(float, unsigned short int, bool, false);
+   TEST_TTR(float, unsigned int, bool, false);
+   TEST_TTR(float, unsigned long int, bool, false);
+   TEST_TTR(float, wchar_t, bool, false);
+   TEST_TTR(float, float, bool, false);
+   TEST_TTR(float, double, bool, false);
+   TEST_TTR(float, long double, bool, false);
+   TEST_TTR(double, bool, bool, false);
+   TEST_TTR(double, char, bool, false);
+   TEST_TTR(double, signed char, bool, false);
+   TEST_TTR(double, short int, bool, false);
+   TEST_TTR(double, int, bool, false);
+   TEST_TTR(double, long int, bool, false);
+   TEST_TTR(double, unsigned char, bool, false);
+   TEST_TTR(double, unsigned short int, bool, false);
+   TEST_TTR(double, unsigned int, bool, false);
+   TEST_TTR(double, unsigned long int, bool, false);
+   TEST_TTR(double, wchar_t, bool, false);
+   TEST_TTR(double, float, bool, false);
+   TEST_TTR(double, double, bool, false);
+   TEST_TTR(double, long double, bool, false);
+   TEST_TTR(long double, bool, bool, false);
+   TEST_TTR(long double, char, bool, false);
+   TEST_TTR(long double, signed char, bool, false);
+   TEST_TTR(long double, short int, bool, false);
+   TEST_TTR(long double, int, bool, false);
+   TEST_TTR(long double, long int, bool, false);
+   TEST_TTR(long double, unsigned char, bool, false);
+   TEST_TTR(long double, unsigned short int, bool, false);
+   TEST_TTR(long double, unsigned int, bool, false);
+   TEST_TTR(long double, unsigned long int, bool, false);
+   TEST_TTR(long double, wchar_t, bool, false);
+   TEST_TTR(long double, float, bool, false);
+   TEST_TTR(long double, double, bool, false);
+   TEST_TTR(long double, long double, bool, false);
+   TEST_TTR(bool, bool, tag, false);
+   TEST_TTR(bool, char, tag, false);
+   TEST_TTR(bool, signed char, tag, false);
+   TEST_TTR(bool, short int, tag, false);
+   TEST_TTR(bool, int, tag, false);
+   TEST_TTR(bool, long int, tag, false);
+   TEST_TTR(bool, unsigned char, tag, false);
+   TEST_TTR(bool, unsigned short int, tag, false);
+   TEST_TTR(bool, unsigned int, tag, false);
+   TEST_TTR(bool, unsigned long int, tag, false);
+   TEST_TTR(bool, wchar_t, tag, false);
+   TEST_TTR(bool, float, tag, false);
+   TEST_TTR(bool, double, tag, false);
+   TEST_TTR(bool, long double, tag, false);
+   TEST_TTR(char, bool, tag, false);
+   TEST_TTR(char, char, tag, false);
+   TEST_TTR(char, signed char, tag, false);
+   TEST_TTR(char, short int, tag, false);
+   TEST_TTR(char, int, tag, false);
+   TEST_TTR(char, long int, tag, false);
+   TEST_TTR(char, unsigned char, tag, false);
+   TEST_TTR(char, unsigned short int, tag, false);
+   TEST_TTR(char, unsigned int, tag, false);
+   TEST_TTR(char, unsigned long int, tag, false);
+   TEST_TTR(char, wchar_t, tag, false);
+   TEST_TTR(char, float, tag, false);
+   TEST_TTR(char, double, tag, false);
+   TEST_TTR(char, long double, tag, false);
+   TEST_TTR(signed char, bool, tag, false);
+   TEST_TTR(signed char, char, tag, false);
+   TEST_TTR(signed char, signed char, tag, false);
+   TEST_TTR(signed char, short int, tag, false);
+   TEST_TTR(signed char, int, tag, false);
+   TEST_TTR(signed char, long int, tag, false);
+   TEST_TTR(signed char, unsigned char, tag, false);
+   TEST_TTR(signed char, unsigned short int, tag, false);
+   TEST_TTR(signed char, unsigned int, tag, false);
+   TEST_TTR(signed char, unsigned long int, tag, false);
+   TEST_TTR(signed char, wchar_t, tag, false);
+   TEST_TTR(signed char, float, tag, false);
+   TEST_TTR(signed char, double, tag, false);
+   TEST_TTR(signed char, long double, tag, false);
+   TEST_TTR(short int, bool, tag, false);
+   TEST_TTR(short int, char, tag, false);
+   TEST_TTR(short int, signed char, tag, false);
+   TEST_TTR(short int, short int, tag, false);
+   TEST_TTR(short int, int, tag, false);
+   TEST_TTR(short int, long int, tag, false);
+   TEST_TTR(short int, unsigned char, tag, false);
+   TEST_TTR(short int, unsigned short int, tag, false);
+   TEST_TTR(short int, unsigned int, tag, false);
+   TEST_TTR(short int, unsigned long int, tag, false);
+   TEST_TTR(short int, wchar_t, tag, false);
+   TEST_TTR(short int, float, tag, false);
+   TEST_TTR(short int, double, tag, false);
+   TEST_TTR(short int, long double, tag, false);
+   TEST_TTR(int, bool, tag, false);
+   TEST_TTR(int, char, tag, false);
+   TEST_TTR(int, signed char, tag, false);
+   TEST_TTR(int, short int, tag, false);
+   TEST_TTR(int, int, tag, false);
+   TEST_TTR(int, long int, tag, false);
+   TEST_TTR(int, unsigned char, tag, false);
+   TEST_TTR(int, unsigned short int, tag, false);
+   TEST_TTR(int, unsigned int, tag, false);
+   TEST_TTR(int, unsigned long int, tag, false);
+   TEST_TTR(int, wchar_t, tag, false);
+   TEST_TTR(int, float, tag, false);
+   TEST_TTR(int, double, tag, false);
+   TEST_TTR(int, long double, tag, false);
+   TEST_TTR(long int, bool, tag, false);
+   TEST_TTR(long int, char, tag, false);
+   TEST_TTR(long int, signed char, tag, false);
+   TEST_TTR(long int, short int, tag, false);
+   TEST_TTR(long int, int, tag, false);
+   TEST_TTR(long int, long int, tag, false);
+   TEST_TTR(long int, unsigned char, tag, false);
+   TEST_TTR(long int, unsigned short int, tag, false);
+   TEST_TTR(long int, unsigned int, tag, false);
+   TEST_TTR(long int, unsigned long int, tag, false);
+   TEST_TTR(long int, wchar_t, tag, false);
+   TEST_TTR(long int, float, tag, false);
+   TEST_TTR(long int, double, tag, false);
+   TEST_TTR(long int, long double, tag, false);
+   TEST_TTR(unsigned char, bool, tag, false);
+   TEST_TTR(unsigned char, char, tag, false);
+   TEST_TTR(unsigned char, signed char, tag, false);
+   TEST_TTR(unsigned char, short int, tag, false);
+   TEST_TTR(unsigned char, int, tag, false);
+   TEST_TTR(unsigned char, long int, tag, false);
+   TEST_TTR(unsigned char, unsigned char, tag, false);
+   TEST_TTR(unsigned char, unsigned short int, tag, false);
+   TEST_TTR(unsigned char, unsigned int, tag, false);
+   TEST_TTR(unsigned char, unsigned long int, tag, false);
+   TEST_TTR(unsigned char, wchar_t, tag, false);
+   TEST_TTR(unsigned char, float, tag, false);
+   TEST_TTR(unsigned char, double, tag, false);
+   TEST_TTR(unsigned char, long double, tag, false);
+   TEST_TTR(unsigned short int, bool, tag, false);
+   TEST_TTR(unsigned short int, char, tag, false);
+   TEST_TTR(unsigned short int, signed char, tag, false);
+   TEST_TTR(unsigned short int, short int, tag, false);
+   TEST_TTR(unsigned short int, int, tag, false);
+   TEST_TTR(unsigned short int, long int, tag, false);
+   TEST_TTR(unsigned short int, unsigned char, tag, false);
+   TEST_TTR(unsigned short int, unsigned short int, tag, false);
+   TEST_TTR(unsigned short int, unsigned int, tag, false);
+   TEST_TTR(unsigned short int, unsigned long int, tag, false);
+   TEST_TTR(unsigned short int, wchar_t, tag, false);
+   TEST_TTR(unsigned short int, float, tag, false);
+   TEST_TTR(unsigned short int, double, tag, false);
+   TEST_TTR(unsigned short int, long double, tag, false);
+   TEST_TTR(unsigned int, bool, tag, false);
+   TEST_TTR(unsigned int, char, tag, false);
+   TEST_TTR(unsigned int, signed char, tag, false);
+   TEST_TTR(unsigned int, short int, tag, false);
+   TEST_TTR(unsigned int, int, tag, false);
+   TEST_TTR(unsigned int, long int, tag, false);
+   TEST_TTR(unsigned int, unsigned char, tag, false);
+   TEST_TTR(unsigned int, unsigned short int, tag, false);
+   TEST_TTR(unsigned int, unsigned int, tag, false);
+   TEST_TTR(unsigned int, unsigned long int, tag, false);
+   TEST_TTR(unsigned int, wchar_t, tag, false);
+   TEST_TTR(unsigned int, float, tag, false);
+   TEST_TTR(unsigned int, double, tag, false);
+   TEST_TTR(unsigned int, long double, tag, false);
+   TEST_TTR(unsigned long int, bool, tag, false);
+   TEST_TTR(unsigned long int, char, tag, false);
+   TEST_TTR(unsigned long int, signed char, tag, false);
+   TEST_TTR(unsigned long int, short int, tag, false);
+   TEST_TTR(unsigned long int, int, tag, false);
+   TEST_TTR(unsigned long int, long int, tag, false);
+   TEST_TTR(unsigned long int, unsigned char, tag, false);
+   TEST_TTR(unsigned long int, unsigned short int, tag, false);
+   TEST_TTR(unsigned long int, unsigned int, tag, false);
+   TEST_TTR(unsigned long int, unsigned long int, tag, false);
+   TEST_TTR(unsigned long int, wchar_t, tag, false);
+   TEST_TTR(unsigned long int, float, tag, false);
+   TEST_TTR(unsigned long int, double, tag, false);
+   TEST_TTR(unsigned long int, long double, tag, false);
+   TEST_TTR(wchar_t, bool, tag, false);
+   TEST_TTR(wchar_t, char, tag, false);
+   TEST_TTR(wchar_t, signed char, tag, false);
+   TEST_TTR(wchar_t, short int, tag, false);
+   TEST_TTR(wchar_t, int, tag, false);
+   TEST_TTR(wchar_t, long int, tag, false);
+   TEST_TTR(wchar_t, unsigned char, tag, false);
+   TEST_TTR(wchar_t, unsigned short int, tag, false);
+   TEST_TTR(wchar_t, unsigned int, tag, false);
+   TEST_TTR(wchar_t, unsigned long int, tag, false);
+   TEST_TTR(wchar_t, wchar_t, tag, false);
+   TEST_TTR(wchar_t, float, tag, false);
+   TEST_TTR(wchar_t, double, tag, false);
+   TEST_TTR(wchar_t, long double, tag, false);
+   TEST_TTR(float, bool, tag, false);
+   TEST_TTR(float, char, tag, false);
+   TEST_TTR(float, signed char, tag, false);
+   TEST_TTR(float, short int, tag, false);
+   TEST_TTR(float, int, tag, false);
+   TEST_TTR(float, long int, tag, false);
+   TEST_TTR(float, unsigned char, tag, false);
+   TEST_TTR(float, unsigned short int, tag, false);
+   TEST_TTR(float, unsigned int, tag, false);
+   TEST_TTR(float, unsigned long int, tag, false);
+   TEST_TTR(float, wchar_t, tag, false);
+   TEST_TTR(float, float, tag, false);
+   TEST_TTR(float, double, tag, false);
+   TEST_TTR(float, long double, tag, false);
+   TEST_TTR(double, bool, tag, false);
+   TEST_TTR(double, char, tag, false);
+   TEST_TTR(double, signed char, tag, false);
+   TEST_TTR(double, short int, tag, false);
+   TEST_TTR(double, int, tag, false);
+   TEST_TTR(double, long int, tag, false);
+   TEST_TTR(double, unsigned char, tag, false);
+   TEST_TTR(double, unsigned short int, tag, false);
+   TEST_TTR(double, unsigned int, tag, false);
+   TEST_TTR(double, unsigned long int, tag, false);
+   TEST_TTR(double, wchar_t, tag, false);
+   TEST_TTR(double, float, tag, false);
+   TEST_TTR(double, double, tag, false);
+   TEST_TTR(double, long double, tag, false);
+   TEST_TTR(long double, bool, tag, false);
+   TEST_TTR(long double, char, tag, false);
+   TEST_TTR(long double, signed char, tag, false);
+   TEST_TTR(long double, short int, tag, false);
+   TEST_TTR(long double, int, tag, false);
+   TEST_TTR(long double, long int, tag, false);
+   TEST_TTR(long double, unsigned char, tag, false);
+   TEST_TTR(long double, unsigned short int, tag, false);
+   TEST_TTR(long double, unsigned int, tag, false);
+   TEST_TTR(long double, unsigned long int, tag, false);
+   TEST_TTR(long double, wchar_t, tag, false);
+   TEST_TTR(long double, float, tag, false);
+   TEST_TTR(long double, double, tag, false);
+   TEST_TTR(long double, long double, tag, false);
+#	undef CV1
+#	define CV1(T) const T
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const T&
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T&
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T&
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const T
+#	undef CV2
+#	define CV2(T) const T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const T&
+#	undef CV2
+#	define CV2(T) const T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T
+#	undef CV2
+#	define CV2(T) volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T&
+#	undef CV2
+#	define CV2(T) volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T
+#	undef CV2
+#	define CV2(T) const volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T&
+#	undef CV2
+#	define CV2(T) const volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+   // pointers
+   TEST_TT(void*, bool, false);
+   TEST_TT(void*, int, false);
+   TEST_TT(void*, double, false);
+   TEST_TT(void*, A, false);
+   TEST_TT(void*, B, false);
+   TEST_TT(bool*, bool, false);
+   TEST_TT(bool*, int, false);
+   TEST_TT(bool*, double, false);
+   TEST_TT(bool*, A, false);
+   TEST_TT(bool*, B, false);
+   TEST_TT(int*, bool, false);
+   TEST_TT(int*, int, false);
+   TEST_TT(int*, double, false);
+   TEST_TT(int*, A, false);
+   TEST_TT(int*, B, false);
+   TEST_TT(double*, bool, false);
+   TEST_TT(double*, int, false);
+   TEST_TT(double*, double, false);
+   TEST_TT(double*, A, false);
+   TEST_TT(double*, B, false);
+   TEST_TT(A*, bool, false);
+   TEST_TT(A*, int, false);
+   TEST_TT(A*, double, false);
+   TEST_TT(A*, A, false);
+   TEST_TT(A*, B, false);
+   TEST_TT(B*, bool, false);
+   TEST_TT(B*, int, false);
+   TEST_TT(B*, double, false);
+   TEST_TT(B*, A, false);
+   TEST_TT(B*, B, false);
+   TEST_TT(bool, void*, false);
+   TEST_TT(bool, bool*, false);
+   TEST_TT(bool, int*, false);
+   TEST_TT(bool, double*, false);
+   TEST_TT(bool, A*, false);
+   TEST_TT(bool, B*, false);
+   TEST_TT(int, void*, false);
+   TEST_TT(int, bool*, false);
+   TEST_TT(int, int*, false);
+   TEST_TT(int, double*, false);
+   TEST_TT(int, A*, false);
+   TEST_TT(int, B*, false);
+   TEST_TT(double, void*, false);
+   TEST_TT(double, bool*, false);
+   TEST_TT(double, int*, false);
+   TEST_TT(double, double*, false);
+   TEST_TT(double, A*, false);
+   TEST_TT(double, B*, false);
+   TEST_TT(A, void*, false);
+   TEST_TT(A, bool*, false);
+   TEST_TT(A, int*, false);
+   TEST_TT(A, double*, false);
+   TEST_TT(A, A*, false);
+   TEST_TT(A, B*, false);
+   TEST_TT(B, void*, false);
+   TEST_TT(B, bool*, false);
+   TEST_TT(B, int*, false);
+   TEST_TT(B, double*, false);
+   TEST_TT(B, A*, false);
+   TEST_TT(B, B*, false);
+   TEST_TT(void*, void*, false);
+   TEST_TT(void*, bool*, false);
+   TEST_TT(void*, int*, false);
+   TEST_TT(void*, double*, false);
+   TEST_TT(void*, A*, false);
+   TEST_TT(void*, B*, false);
+   TEST_TT(bool*, void*, false);
+   TEST_TT(bool*, bool*, false);
+   TEST_TT(bool*, int*, false);
+   TEST_TT(bool*, double*, false);
+   TEST_TT(bool*, A*, false);
+   TEST_TT(bool*, B*, false);
+   TEST_TT(int*, void*, false);
+   TEST_TT(int*, bool*, false);
+   TEST_TT(int*, int*, false);
+   TEST_TT(int*, double*, false);
+   TEST_TT(int*, A*, false);
+   TEST_TT(int*, B*, false);
+   TEST_TT(double*, void*, false);
+   TEST_TT(double*, bool*, false);
+   TEST_TT(double*, int*, false);
+   TEST_TT(double*, double*, false);
+   TEST_TT(double*, A*, false);
+   TEST_TT(double*, B*, false);
+   TEST_TT(A*, void*, false);
+   TEST_TT(A*, bool*, false);
+   TEST_TT(A*, int*, false);
+   TEST_TT(A*, double*, false);
+   TEST_TT(A*, A*, false);
+   TEST_TT(A*, B*, false);
+   TEST_TT(B*, void*, false);
+   TEST_TT(B*, bool*, false);
+   TEST_TT(B*, int*, false);
+   TEST_TT(B*, double*, false);
+   TEST_TT(B*, A*, false);
+   TEST_TT(B*, B*, false);
+   TEST_TT(C, void*, true);
+   TEST_TT(D, void*, false);
+   TEST_TT(void*, C, false);
+   TEST_TT(void*, D, true);
+   TEST_TT(C, D, true);
+}
+}

Added: sandbox/type_traits/libs/type_traits/test/can_call_left_shift_assignment_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_left_shift_assignment_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,33 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_left_shift_assignment.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_left_shift_assignment
+#define BOOST_TT_TRAIT_OP <<=
+
+#include "can_call_binary_operators.hpp"
+#include "can_call_integral_no_constlhs_test.hpp"
+
+namespace {
+void specific() {
+   /* nothing specific */
+}
+}
+
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_left_shift_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_left_shift_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,56 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_left_shift.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_left_shift
+#define BOOST_TT_TRAIT_OP <<
+
+#include "can_call_binary_operators.hpp"
+#include "can_call_integral_test.hpp"
+
+#include <ostream>
+#include <string>
+
+#define TEST_SPECIFIC(T) TEST_TTR(std::ostream&, T, std::ostream&, true)
+namespace {
+
+void specific() {
+   TEST_SPECIFIC(long);
+   TEST_SPECIFIC(unsigned long);
+   TEST_SPECIFIC(bool);
+   TEST_SPECIFIC(short);
+   TEST_SPECIFIC(unsigned short);
+   TEST_SPECIFIC(int);
+   TEST_SPECIFIC(unsigned int);
+   TEST_SPECIFIC(double);
+   TEST_SPECIFIC(float);
+   TEST_SPECIFIC(void*);
+   TEST_SPECIFIC(char);
+   TEST_SPECIFIC(signed char);
+   TEST_SPECIFIC(unsigned char);
+   TEST_SPECIFIC(const char*);
+   TEST_SPECIFIC(char*);
+   TEST_SPECIFIC(const signed char*);
+   TEST_SPECIFIC(signed char*);
+   TEST_SPECIFIC(const unsigned char*);
+   TEST_SPECIFIC(unsigned char*);
+   TEST_SPECIFIC(std::string);
+}
+}
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_less_equal_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_less_equal_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,33 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_less_equal.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_less_equal
+#define BOOST_TT_TRAIT_OP <=
+
+#include "can_call_binary_operators.hpp"
+#include "can_call_comparison_test.hpp"
+
+namespace {
+void specific() {
+   /* nothing specific */
+}
+}
+
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_less_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_less_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,33 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_less.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_less
+#define BOOST_TT_TRAIT_OP <
+
+#include "can_call_binary_operators.hpp"
+#include "can_call_comparison_test.hpp"
+
+namespace {
+void specific() {
+   /* nothing specific */
+}
+}
+
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_modulus_assignment_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_modulus_assignment_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,33 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_modulus_assignment.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_modulus_assignment
+#define BOOST_TT_TRAIT_OP %=
+
+#include "can_call_binary_operators.hpp"
+#include "can_call_integral_no_constlhs_test.hpp"
+
+namespace {
+void specific() {
+   /* nothing specific */
+}
+}
+
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_modulus_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_modulus_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,33 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_modulus.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_modulus
+#define BOOST_TT_TRAIT_OP %
+
+#include "can_call_binary_operators.hpp"
+#include "can_call_integral_test.hpp"
+
+namespace {
+void specific() {
+   /* nothing specific */
+}
+}
+
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_multiplication_assignment_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_multiplication_assignment_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,33 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_multiplication_assignment.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_multiplication_assignment
+#define BOOST_TT_TRAIT_OP *=
+
+#include "can_call_binary_operators.hpp"
+#include "can_call_no_pointer_no_constlhs_test.hpp"
+
+namespace {
+void specific() {
+   /* nothing specific */
+}
+}
+
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_multiplication_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_multiplication_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,33 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_multiplication.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_multiplication
+#define BOOST_TT_TRAIT_OP *
+
+#include "can_call_binary_operators.hpp"
+#include "can_call_no_pointer_test.hpp"
+
+namespace {
+void specific() {
+   /* nothing specific */
+}
+}
+
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_no_pointer_no_constlhs_test.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_no_pointer_no_constlhs_test.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,1250 @@
+//  (C) Copyright Frederic Bron 2009-2011.
+//  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)
+
+namespace {
+
+void run2() {
+   // test with only one template parameter
+   TEST_T(void, false);
+   TEST_T(bool, true);
+   TEST_T(char, true);
+   TEST_T(signed char, true);
+   TEST_T(short int, true);
+   TEST_T(int, true);
+   TEST_T(long int, true);
+   TEST_T(unsigned char, true);
+   TEST_T(unsigned short int, true);
+   TEST_T(unsigned int, true);
+   TEST_T(unsigned long int, true);
+   TEST_T(wchar_t, true);
+   TEST_T(float, true);
+   TEST_T(double, true);
+   TEST_T(long double, true);
+   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), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	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), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	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 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);
+   TEST_TT(bool, short int, true);
+   TEST_TT(bool, int, true);
+   TEST_TT(bool, long int, true);
+   TEST_TT(bool, unsigned char, true);
+   TEST_TT(bool, unsigned short int, true);
+   TEST_TT(bool, unsigned int, true);
+   TEST_TT(bool, unsigned long int, true);
+   TEST_TT(bool, wchar_t, true);
+   TEST_TT(bool, float, true);
+   TEST_TT(bool, double, true);
+   TEST_TT(bool, long double, true);
+   TEST_TT(char, bool, true);
+   TEST_TT(char, char, true);
+   TEST_TT(char, signed char, true);
+   TEST_TT(char, short int, true);
+   TEST_TT(char, int, true);
+   TEST_TT(char, long int, true);
+   TEST_TT(char, unsigned char, true);
+   TEST_TT(char, unsigned short int, true);
+   TEST_TT(char, unsigned int, true);
+   TEST_TT(char, unsigned long int, true);
+   TEST_TT(char, wchar_t, true);
+   TEST_TT(char, float, true);
+   TEST_TT(char, double, true);
+   TEST_TT(char, long double, true);
+   TEST_TT(signed char, bool, true);
+   TEST_TT(signed char, char, true);
+   TEST_TT(signed char, signed char, true);
+   TEST_TT(signed char, short int, true);
+   TEST_TT(signed char, int, true);
+   TEST_TT(signed char, long int, true);
+   TEST_TT(signed char, unsigned char, true);
+   TEST_TT(signed char, unsigned short int, true);
+   TEST_TT(signed char, unsigned int, true);
+   TEST_TT(signed char, unsigned long int, true);
+   TEST_TT(signed char, wchar_t, true);
+   TEST_TT(signed char, float, true);
+   TEST_TT(signed char, double, true);
+   TEST_TT(signed char, long double, true);
+   TEST_TT(short int, bool, true);
+   TEST_TT(short int, char, true);
+   TEST_TT(short int, signed char, true);
+   TEST_TT(short int, short int, true);
+   TEST_TT(short int, int, true);
+   TEST_TT(short int, long int, true);
+   TEST_TT(short int, unsigned char, true);
+   TEST_TT(short int, unsigned short int, true);
+   TEST_TT(short int, unsigned int, true);
+   TEST_TT(short int, unsigned long int, true);
+   TEST_TT(short int, wchar_t, true);
+   TEST_TT(short int, float, true);
+   TEST_TT(short int, double, true);
+   TEST_TT(short int, long double, true);
+   TEST_TT(int, bool, true);
+   TEST_TT(int, char, true);
+   TEST_TT(int, signed char, true);
+   TEST_TT(int, short int, true);
+   TEST_TT(int, int, true);
+   TEST_TT(int, long int, true);
+   TEST_TT(int, unsigned char, true);
+   TEST_TT(int, unsigned short int, true);
+   TEST_TT(int, unsigned int, true);
+   TEST_TT(int, unsigned long int, true);
+   TEST_TT(int, wchar_t, true);
+   TEST_TT(int, float, true);
+   TEST_TT(int, double, true);
+   TEST_TT(int, long double, true);
+   TEST_TT(long int, bool, true);
+   TEST_TT(long int, char, true);
+   TEST_TT(long int, signed char, true);
+   TEST_TT(long int, short int, true);
+   TEST_TT(long int, int, true);
+   TEST_TT(long int, long int, true);
+   TEST_TT(long int, unsigned char, true);
+   TEST_TT(long int, unsigned short int, true);
+   TEST_TT(long int, unsigned int, true);
+   TEST_TT(long int, unsigned long int, true);
+   TEST_TT(long int, wchar_t, true);
+   TEST_TT(long int, float, true);
+   TEST_TT(long int, double, true);
+   TEST_TT(long int, long double, true);
+   TEST_TT(unsigned char, bool, true);
+   TEST_TT(unsigned char, char, true);
+   TEST_TT(unsigned char, signed char, true);
+   TEST_TT(unsigned char, short int, true);
+   TEST_TT(unsigned char, int, true);
+   TEST_TT(unsigned char, long int, true);
+   TEST_TT(unsigned char, unsigned char, true);
+   TEST_TT(unsigned char, unsigned short int, true);
+   TEST_TT(unsigned char, unsigned int, true);
+   TEST_TT(unsigned char, unsigned long int, true);
+   TEST_TT(unsigned char, wchar_t, true);
+   TEST_TT(unsigned char, float, true);
+   TEST_TT(unsigned char, double, true);
+   TEST_TT(unsigned char, long double, true);
+   TEST_TT(unsigned short int, bool, true);
+   TEST_TT(unsigned short int, char, true);
+   TEST_TT(unsigned short int, signed char, true);
+   TEST_TT(unsigned short int, short int, true);
+   TEST_TT(unsigned short int, int, true);
+   TEST_TT(unsigned short int, long int, true);
+   TEST_TT(unsigned short int, unsigned char, true);
+   TEST_TT(unsigned short int, unsigned short int, true);
+   TEST_TT(unsigned short int, unsigned int, true);
+   TEST_TT(unsigned short int, unsigned long int, true);
+   TEST_TT(unsigned short int, wchar_t, true);
+   TEST_TT(unsigned short int, float, true);
+   TEST_TT(unsigned short int, double, true);
+   TEST_TT(unsigned short int, long double, true);
+   TEST_TT(unsigned int, bool, true);
+   TEST_TT(unsigned int, char, true);
+   TEST_TT(unsigned int, signed char, true);
+   TEST_TT(unsigned int, short int, true);
+   TEST_TT(unsigned int, int, true);
+   TEST_TT(unsigned int, long int, true);
+   TEST_TT(unsigned int, unsigned char, true);
+   TEST_TT(unsigned int, unsigned short int, true);
+   TEST_TT(unsigned int, unsigned int, true);
+   TEST_TT(unsigned int, unsigned long int, true);
+   TEST_TT(unsigned int, wchar_t, true);
+   TEST_TT(unsigned int, float, true);
+   TEST_TT(unsigned int, double, true);
+   TEST_TT(unsigned int, long double, true);
+   TEST_TT(unsigned long int, bool, true);
+   TEST_TT(unsigned long int, char, true);
+   TEST_TT(unsigned long int, signed char, true);
+   TEST_TT(unsigned long int, short int, true);
+   TEST_TT(unsigned long int, int, true);
+   TEST_TT(unsigned long int, long int, true);
+   TEST_TT(unsigned long int, unsigned char, true);
+   TEST_TT(unsigned long int, unsigned short int, true);
+   TEST_TT(unsigned long int, unsigned int, true);
+   TEST_TT(unsigned long int, unsigned long int, true);
+   TEST_TT(unsigned long int, wchar_t, true);
+   TEST_TT(unsigned long int, float, true);
+   TEST_TT(unsigned long int, double, true);
+   TEST_TT(unsigned long int, long double, true);
+   TEST_TT(wchar_t, bool, true);
+   TEST_TT(wchar_t, char, true);
+   TEST_TT(wchar_t, signed char, true);
+   TEST_TT(wchar_t, short int, true);
+   TEST_TT(wchar_t, int, true);
+   TEST_TT(wchar_t, long int, true);
+   TEST_TT(wchar_t, unsigned char, true);
+   TEST_TT(wchar_t, unsigned short int, true);
+   TEST_TT(wchar_t, unsigned int, true);
+   TEST_TT(wchar_t, unsigned long int, true);
+   TEST_TT(wchar_t, wchar_t, true);
+   TEST_TT(wchar_t, float, true);
+   TEST_TT(wchar_t, double, true);
+   TEST_TT(wchar_t, long double, true);
+   TEST_TT(float, bool, true);
+   TEST_TT(float, char, true);
+   TEST_TT(float, signed char, true);
+   TEST_TT(float, short int, true);
+   TEST_TT(float, int, true);
+   TEST_TT(float, long int, true);
+   TEST_TT(float, unsigned char, true);
+   TEST_TT(float, unsigned short int, true);
+   TEST_TT(float, unsigned int, true);
+   TEST_TT(float, unsigned long int, true);
+   TEST_TT(float, wchar_t, true);
+   TEST_TT(float, float, true);
+   TEST_TT(float, double, true);
+   TEST_TT(float, long double, true);
+   TEST_TT(double, bool, true);
+   TEST_TT(double, char, true);
+   TEST_TT(double, signed char, true);
+   TEST_TT(double, short int, true);
+   TEST_TT(double, int, true);
+   TEST_TT(double, long int, true);
+   TEST_TT(double, unsigned char, true);
+   TEST_TT(double, unsigned short int, true);
+   TEST_TT(double, unsigned int, true);
+   TEST_TT(double, unsigned long int, true);
+   TEST_TT(double, wchar_t, true);
+   TEST_TT(double, float, true);
+   TEST_TT(double, double, true);
+   TEST_TT(double, long double, true);
+   TEST_TT(long double, bool, true);
+   TEST_TT(long double, char, true);
+   TEST_TT(long double, signed char, true);
+   TEST_TT(long double, short int, true);
+   TEST_TT(long double, int, true);
+   TEST_TT(long double, long int, true);
+   TEST_TT(long double, unsigned char, true);
+   TEST_TT(long double, unsigned short int, true);
+   TEST_TT(long double, unsigned int, true);
+   TEST_TT(long double, unsigned long int, true);
+   TEST_TT(long double, wchar_t, true);
+   TEST_TT(long double, float, true);
+   TEST_TT(long double, double, true);
+   TEST_TT(long double, long double, true);
+   TEST_TT(bool, void, false);
+   TEST_TT(void, bool, false);
+   TEST_TT(char, void, false);
+   TEST_TT(void, char, false);
+   TEST_TT(signed char, void, false);
+   TEST_TT(void, signed char, false);
+   TEST_TT(short int, void, false);
+   TEST_TT(void, short int, false);
+   TEST_TT(int, void, false);
+   TEST_TT(void, int, false);
+   TEST_TT(long int, void, false);
+   TEST_TT(void, long int, false);
+   TEST_TT(unsigned char, void, false);
+   TEST_TT(void, unsigned char, false);
+   TEST_TT(unsigned short int, void, false);
+   TEST_TT(void, unsigned short int, false);
+   TEST_TT(unsigned int, void, false);
+   TEST_TT(void, unsigned int, false);
+   TEST_TT(unsigned long int, void, false);
+   TEST_TT(void, unsigned long int, false);
+   TEST_TT(wchar_t, void, false);
+   TEST_TT(void, wchar_t, false);
+   TEST_TT(float, void, false);
+   TEST_TT(void, float, false);
+   TEST_TT(double, void, false);
+   TEST_TT(void, double, false);
+   TEST_TT(long double, void, false);
+   TEST_TT(void, long double, false);
+
+// test with three template parameters
+   TEST_TTR(bool, bool, bool, true);
+   TEST_TTR(bool, char, bool, true);
+   TEST_TTR(bool, signed char, bool, true);
+   TEST_TTR(bool, short int, bool, true);
+   TEST_TTR(bool, int, bool, true);
+   TEST_TTR(bool, long int, bool, true);
+   TEST_TTR(bool, unsigned char, bool, true);
+   TEST_TTR(bool, unsigned short int, bool, true);
+   TEST_TTR(bool, unsigned int, bool, true);
+   TEST_TTR(bool, unsigned long int, bool, true);
+   TEST_TTR(bool, wchar_t, bool, true);
+   TEST_TTR(bool, float, bool, true);
+   TEST_TTR(bool, double, bool, true);
+   TEST_TTR(bool, long double, bool, true);
+   TEST_TTR(char, bool, bool, true);
+   TEST_TTR(char, char, bool, true);
+   TEST_TTR(char, signed char, bool, true);
+   TEST_TTR(char, short int, bool, true);
+   TEST_TTR(char, int, bool, true);
+   TEST_TTR(char, long int, bool, true);
+   TEST_TTR(char, unsigned char, bool, true);
+   TEST_TTR(char, unsigned short int, bool, true);
+   TEST_TTR(char, unsigned int, bool, true);
+   TEST_TTR(char, unsigned long int, bool, true);
+   TEST_TTR(char, wchar_t, bool, true);
+   TEST_TTR(char, float, bool, true);
+   TEST_TTR(char, double, bool, true);
+   TEST_TTR(char, long double, bool, true);
+   TEST_TTR(signed char, bool, bool, true);
+   TEST_TTR(signed char, char, bool, true);
+   TEST_TTR(signed char, signed char, bool, true);
+   TEST_TTR(signed char, short int, bool, true);
+   TEST_TTR(signed char, int, bool, true);
+   TEST_TTR(signed char, long int, bool, true);
+   TEST_TTR(signed char, unsigned char, bool, true);
+   TEST_TTR(signed char, unsigned short int, bool, true);
+   TEST_TTR(signed char, unsigned int, bool, true);
+   TEST_TTR(signed char, unsigned long int, bool, true);
+   TEST_TTR(signed char, wchar_t, bool, true);
+   TEST_TTR(signed char, float, bool, true);
+   TEST_TTR(signed char, double, bool, true);
+   TEST_TTR(signed char, long double, bool, true);
+   TEST_TTR(short int, bool, bool, true);
+   TEST_TTR(short int, char, bool, true);
+   TEST_TTR(short int, signed char, bool, true);
+   TEST_TTR(short int, short int, bool, true);
+   TEST_TTR(short int, int, bool, true);
+   TEST_TTR(short int, long int, bool, true);
+   TEST_TTR(short int, unsigned char, bool, true);
+   TEST_TTR(short int, unsigned short int, bool, true);
+   TEST_TTR(short int, unsigned int, bool, true);
+   TEST_TTR(short int, unsigned long int, bool, true);
+   TEST_TTR(short int, wchar_t, bool, true);
+   TEST_TTR(short int, float, bool, true);
+   TEST_TTR(short int, double, bool, true);
+   TEST_TTR(short int, long double, bool, true);
+   TEST_TTR(int, bool, bool, true);
+   TEST_TTR(int, char, bool, true);
+   TEST_TTR(int, signed char, bool, true);
+   TEST_TTR(int, short int, bool, true);
+   TEST_TTR(int, int, bool, true);
+   TEST_TTR(int, long int, bool, true);
+   TEST_TTR(int, unsigned char, bool, true);
+   TEST_TTR(int, unsigned short int, bool, true);
+   TEST_TTR(int, unsigned int, bool, true);
+   TEST_TTR(int, unsigned long int, bool, true);
+   TEST_TTR(int, wchar_t, bool, true);
+   TEST_TTR(int, float, bool, true);
+   TEST_TTR(int, double, bool, true);
+   TEST_TTR(int, long double, bool, true);
+   TEST_TTR(long int, bool, bool, true);
+   TEST_TTR(long int, char, bool, true);
+   TEST_TTR(long int, signed char, bool, true);
+   TEST_TTR(long int, short int, bool, true);
+   TEST_TTR(long int, int, bool, true);
+   TEST_TTR(long int, long int, bool, true);
+   TEST_TTR(long int, unsigned char, bool, true);
+   TEST_TTR(long int, unsigned short int, bool, true);
+   TEST_TTR(long int, unsigned int, bool, true);
+   TEST_TTR(long int, unsigned long int, bool, true);
+   TEST_TTR(long int, wchar_t, bool, true);
+   TEST_TTR(long int, float, bool, true);
+   TEST_TTR(long int, double, bool, true);
+   TEST_TTR(long int, long double, bool, true);
+   TEST_TTR(unsigned char, bool, bool, true);
+   TEST_TTR(unsigned char, char, bool, true);
+   TEST_TTR(unsigned char, signed char, bool, true);
+   TEST_TTR(unsigned char, short int, bool, true);
+   TEST_TTR(unsigned char, int, bool, true);
+   TEST_TTR(unsigned char, long int, bool, true);
+   TEST_TTR(unsigned char, unsigned char, bool, true);
+   TEST_TTR(unsigned char, unsigned short int, bool, true);
+   TEST_TTR(unsigned char, unsigned int, bool, true);
+   TEST_TTR(unsigned char, unsigned long int, bool, true);
+   TEST_TTR(unsigned char, wchar_t, bool, true);
+   TEST_TTR(unsigned char, float, bool, true);
+   TEST_TTR(unsigned char, double, bool, true);
+   TEST_TTR(unsigned char, long double, bool, true);
+   TEST_TTR(unsigned short int, bool, bool, true);
+   TEST_TTR(unsigned short int, char, bool, true);
+   TEST_TTR(unsigned short int, signed char, bool, true);
+   TEST_TTR(unsigned short int, short int, bool, true);
+   TEST_TTR(unsigned short int, int, bool, true);
+   TEST_TTR(unsigned short int, long int, bool, true);
+   TEST_TTR(unsigned short int, unsigned char, bool, true);
+   TEST_TTR(unsigned short int, unsigned short int, bool, true);
+   TEST_TTR(unsigned short int, unsigned int, bool, true);
+   TEST_TTR(unsigned short int, unsigned long int, bool, true);
+   TEST_TTR(unsigned short int, wchar_t, bool, true);
+   TEST_TTR(unsigned short int, float, bool, true);
+   TEST_TTR(unsigned short int, double, bool, true);
+   TEST_TTR(unsigned short int, long double, bool, true);
+   TEST_TTR(unsigned int, bool, bool, true);
+   TEST_TTR(unsigned int, char, bool, true);
+   TEST_TTR(unsigned int, signed char, bool, true);
+   TEST_TTR(unsigned int, short int, bool, true);
+   TEST_TTR(unsigned int, int, bool, true);
+   TEST_TTR(unsigned int, long int, bool, true);
+   TEST_TTR(unsigned int, unsigned char, bool, true);
+   TEST_TTR(unsigned int, unsigned short int, bool, true);
+   TEST_TTR(unsigned int, unsigned int, bool, true);
+   TEST_TTR(unsigned int, unsigned long int, bool, true);
+   TEST_TTR(unsigned int, wchar_t, bool, true);
+   TEST_TTR(unsigned int, float, bool, true);
+   TEST_TTR(unsigned int, double, bool, true);
+   TEST_TTR(unsigned int, long double, bool, true);
+   TEST_TTR(unsigned long int, bool, bool, true);
+   TEST_TTR(unsigned long int, char, bool, true);
+   TEST_TTR(unsigned long int, signed char, bool, true);
+   TEST_TTR(unsigned long int, short int, bool, true);
+   TEST_TTR(unsigned long int, int, bool, true);
+   TEST_TTR(unsigned long int, long int, bool, true);
+   TEST_TTR(unsigned long int, unsigned char, bool, true);
+   TEST_TTR(unsigned long int, unsigned short int, bool, true);
+   TEST_TTR(unsigned long int, unsigned int, bool, true);
+   TEST_TTR(unsigned long int, unsigned long int, bool, true);
+   TEST_TTR(unsigned long int, wchar_t, bool, true);
+   TEST_TTR(unsigned long int, float, bool, true);
+   TEST_TTR(unsigned long int, double, bool, true);
+   TEST_TTR(unsigned long int, long double, bool, true);
+   TEST_TTR(wchar_t, bool, bool, true);
+   TEST_TTR(wchar_t, char, bool, true);
+   TEST_TTR(wchar_t, signed char, bool, true);
+   TEST_TTR(wchar_t, short int, bool, true);
+   TEST_TTR(wchar_t, int, bool, true);
+   TEST_TTR(wchar_t, long int, bool, true);
+   TEST_TTR(wchar_t, unsigned char, bool, true);
+   TEST_TTR(wchar_t, unsigned short int, bool, true);
+   TEST_TTR(wchar_t, unsigned int, bool, true);
+   TEST_TTR(wchar_t, unsigned long int, bool, true);
+   TEST_TTR(wchar_t, wchar_t, bool, true);
+   TEST_TTR(wchar_t, float, bool, true);
+   TEST_TTR(wchar_t, double, bool, true);
+   TEST_TTR(wchar_t, long double, bool, true);
+   TEST_TTR(float, bool, bool, true);
+   TEST_TTR(float, char, bool, true);
+   TEST_TTR(float, signed char, bool, true);
+   TEST_TTR(float, short int, bool, true);
+   TEST_TTR(float, int, bool, true);
+   TEST_TTR(float, long int, bool, true);
+   TEST_TTR(float, unsigned char, bool, true);
+   TEST_TTR(float, unsigned short int, bool, true);
+   TEST_TTR(float, unsigned int, bool, true);
+   TEST_TTR(float, unsigned long int, bool, true);
+   TEST_TTR(float, wchar_t, bool, true);
+   TEST_TTR(float, float, bool, true);
+   TEST_TTR(float, double, bool, true);
+   TEST_TTR(float, long double, bool, true);
+   TEST_TTR(double, bool, bool, true);
+   TEST_TTR(double, char, bool, true);
+   TEST_TTR(double, signed char, bool, true);
+   TEST_TTR(double, short int, bool, true);
+   TEST_TTR(double, int, bool, true);
+   TEST_TTR(double, long int, bool, true);
+   TEST_TTR(double, unsigned char, bool, true);
+   TEST_TTR(double, unsigned short int, bool, true);
+   TEST_TTR(double, unsigned int, bool, true);
+   TEST_TTR(double, unsigned long int, bool, true);
+   TEST_TTR(double, wchar_t, bool, true);
+   TEST_TTR(double, float, bool, true);
+   TEST_TTR(double, double, bool, true);
+   TEST_TTR(double, long double, bool, true);
+   TEST_TTR(long double, bool, bool, true);
+   TEST_TTR(long double, char, bool, true);
+   TEST_TTR(long double, signed char, bool, true);
+   TEST_TTR(long double, short int, bool, true);
+   TEST_TTR(long double, int, bool, true);
+   TEST_TTR(long double, long int, bool, true);
+   TEST_TTR(long double, unsigned char, bool, true);
+   TEST_TTR(long double, unsigned short int, bool, true);
+   TEST_TTR(long double, unsigned int, bool, true);
+   TEST_TTR(long double, unsigned long int, bool, true);
+   TEST_TTR(long double, wchar_t, bool, true);
+   TEST_TTR(long double, float, bool, true);
+   TEST_TTR(long double, double, bool, true);
+   TEST_TTR(long double, long double, bool, true);
+   TEST_TTR(bool, bool, tag, false);
+   TEST_TTR(bool, char, tag, false);
+   TEST_TTR(bool, signed char, tag, false);
+   TEST_TTR(bool, short int, tag, false);
+   TEST_TTR(bool, int, tag, false);
+   TEST_TTR(bool, long int, tag, false);
+   TEST_TTR(bool, unsigned char, tag, false);
+   TEST_TTR(bool, unsigned short int, tag, false);
+   TEST_TTR(bool, unsigned int, tag, false);
+   TEST_TTR(bool, unsigned long int, tag, false);
+   TEST_TTR(bool, wchar_t, tag, false);
+   TEST_TTR(bool, float, tag, false);
+   TEST_TTR(bool, double, tag, false);
+   TEST_TTR(bool, long double, tag, false);
+   TEST_TTR(char, bool, tag, false);
+   TEST_TTR(char, char, tag, false);
+   TEST_TTR(char, signed char, tag, false);
+   TEST_TTR(char, short int, tag, false);
+   TEST_TTR(char, int, tag, false);
+   TEST_TTR(char, long int, tag, false);
+   TEST_TTR(char, unsigned char, tag, false);
+   TEST_TTR(char, unsigned short int, tag, false);
+   TEST_TTR(char, unsigned int, tag, false);
+   TEST_TTR(char, unsigned long int, tag, false);
+   TEST_TTR(char, wchar_t, tag, false);
+   TEST_TTR(char, float, tag, false);
+   TEST_TTR(char, double, tag, false);
+   TEST_TTR(char, long double, tag, false);
+   TEST_TTR(signed char, bool, tag, false);
+   TEST_TTR(signed char, char, tag, false);
+   TEST_TTR(signed char, signed char, tag, false);
+   TEST_TTR(signed char, short int, tag, false);
+   TEST_TTR(signed char, int, tag, false);
+   TEST_TTR(signed char, long int, tag, false);
+   TEST_TTR(signed char, unsigned char, tag, false);
+   TEST_TTR(signed char, unsigned short int, tag, false);
+   TEST_TTR(signed char, unsigned int, tag, false);
+   TEST_TTR(signed char, unsigned long int, tag, false);
+   TEST_TTR(signed char, wchar_t, tag, false);
+   TEST_TTR(signed char, float, tag, false);
+   TEST_TTR(signed char, double, tag, false);
+   TEST_TTR(signed char, long double, tag, false);
+   TEST_TTR(short int, bool, tag, false);
+   TEST_TTR(short int, char, tag, false);
+   TEST_TTR(short int, signed char, tag, false);
+   TEST_TTR(short int, short int, tag, false);
+   TEST_TTR(short int, int, tag, false);
+   TEST_TTR(short int, long int, tag, false);
+   TEST_TTR(short int, unsigned char, tag, false);
+   TEST_TTR(short int, unsigned short int, tag, false);
+   TEST_TTR(short int, unsigned int, tag, false);
+   TEST_TTR(short int, unsigned long int, tag, false);
+   TEST_TTR(short int, wchar_t, tag, false);
+   TEST_TTR(short int, float, tag, false);
+   TEST_TTR(short int, double, tag, false);
+   TEST_TTR(short int, long double, tag, false);
+   TEST_TTR(int, bool, tag, false);
+   TEST_TTR(int, char, tag, false);
+   TEST_TTR(int, signed char, tag, false);
+   TEST_TTR(int, short int, tag, false);
+   TEST_TTR(int, int, tag, false);
+   TEST_TTR(int, long int, tag, false);
+   TEST_TTR(int, unsigned char, tag, false);
+   TEST_TTR(int, unsigned short int, tag, false);
+   TEST_TTR(int, unsigned int, tag, false);
+   TEST_TTR(int, unsigned long int, tag, false);
+   TEST_TTR(int, wchar_t, tag, false);
+   TEST_TTR(int, float, tag, false);
+   TEST_TTR(int, double, tag, false);
+   TEST_TTR(int, long double, tag, false);
+   TEST_TTR(long int, bool, tag, false);
+   TEST_TTR(long int, char, tag, false);
+   TEST_TTR(long int, signed char, tag, false);
+   TEST_TTR(long int, short int, tag, false);
+   TEST_TTR(long int, int, tag, false);
+   TEST_TTR(long int, long int, tag, false);
+   TEST_TTR(long int, unsigned char, tag, false);
+   TEST_TTR(long int, unsigned short int, tag, false);
+   TEST_TTR(long int, unsigned int, tag, false);
+   TEST_TTR(long int, unsigned long int, tag, false);
+   TEST_TTR(long int, wchar_t, tag, false);
+   TEST_TTR(long int, float, tag, false);
+   TEST_TTR(long int, double, tag, false);
+   TEST_TTR(long int, long double, tag, false);
+   TEST_TTR(unsigned char, bool, tag, false);
+   TEST_TTR(unsigned char, char, tag, false);
+   TEST_TTR(unsigned char, signed char, tag, false);
+   TEST_TTR(unsigned char, short int, tag, false);
+   TEST_TTR(unsigned char, int, tag, false);
+   TEST_TTR(unsigned char, long int, tag, false);
+   TEST_TTR(unsigned char, unsigned char, tag, false);
+   TEST_TTR(unsigned char, unsigned short int, tag, false);
+   TEST_TTR(unsigned char, unsigned int, tag, false);
+   TEST_TTR(unsigned char, unsigned long int, tag, false);
+   TEST_TTR(unsigned char, wchar_t, tag, false);
+   TEST_TTR(unsigned char, float, tag, false);
+   TEST_TTR(unsigned char, double, tag, false);
+   TEST_TTR(unsigned char, long double, tag, false);
+   TEST_TTR(unsigned short int, bool, tag, false);
+   TEST_TTR(unsigned short int, char, tag, false);
+   TEST_TTR(unsigned short int, signed char, tag, false);
+   TEST_TTR(unsigned short int, short int, tag, false);
+   TEST_TTR(unsigned short int, int, tag, false);
+   TEST_TTR(unsigned short int, long int, tag, false);
+   TEST_TTR(unsigned short int, unsigned char, tag, false);
+   TEST_TTR(unsigned short int, unsigned short int, tag, false);
+   TEST_TTR(unsigned short int, unsigned int, tag, false);
+   TEST_TTR(unsigned short int, unsigned long int, tag, false);
+   TEST_TTR(unsigned short int, wchar_t, tag, false);
+   TEST_TTR(unsigned short int, float, tag, false);
+   TEST_TTR(unsigned short int, double, tag, false);
+   TEST_TTR(unsigned short int, long double, tag, false);
+   TEST_TTR(unsigned int, bool, tag, false);
+   TEST_TTR(unsigned int, char, tag, false);
+   TEST_TTR(unsigned int, signed char, tag, false);
+   TEST_TTR(unsigned int, short int, tag, false);
+   TEST_TTR(unsigned int, int, tag, false);
+   TEST_TTR(unsigned int, long int, tag, false);
+   TEST_TTR(unsigned int, unsigned char, tag, false);
+   TEST_TTR(unsigned int, unsigned short int, tag, false);
+   TEST_TTR(unsigned int, unsigned int, tag, false);
+   TEST_TTR(unsigned int, unsigned long int, tag, false);
+   TEST_TTR(unsigned int, wchar_t, tag, false);
+   TEST_TTR(unsigned int, float, tag, false);
+   TEST_TTR(unsigned int, double, tag, false);
+   TEST_TTR(unsigned int, long double, tag, false);
+   TEST_TTR(unsigned long int, bool, tag, false);
+   TEST_TTR(unsigned long int, char, tag, false);
+   TEST_TTR(unsigned long int, signed char, tag, false);
+   TEST_TTR(unsigned long int, short int, tag, false);
+   TEST_TTR(unsigned long int, int, tag, false);
+   TEST_TTR(unsigned long int, long int, tag, false);
+   TEST_TTR(unsigned long int, unsigned char, tag, false);
+   TEST_TTR(unsigned long int, unsigned short int, tag, false);
+   TEST_TTR(unsigned long int, unsigned int, tag, false);
+   TEST_TTR(unsigned long int, unsigned long int, tag, false);
+   TEST_TTR(unsigned long int, wchar_t, tag, false);
+   TEST_TTR(unsigned long int, float, tag, false);
+   TEST_TTR(unsigned long int, double, tag, false);
+   TEST_TTR(unsigned long int, long double, tag, false);
+   TEST_TTR(wchar_t, bool, tag, false);
+   TEST_TTR(wchar_t, char, tag, false);
+   TEST_TTR(wchar_t, signed char, tag, false);
+   TEST_TTR(wchar_t, short int, tag, false);
+   TEST_TTR(wchar_t, int, tag, false);
+   TEST_TTR(wchar_t, long int, tag, false);
+   TEST_TTR(wchar_t, unsigned char, tag, false);
+   TEST_TTR(wchar_t, unsigned short int, tag, false);
+   TEST_TTR(wchar_t, unsigned int, tag, false);
+   TEST_TTR(wchar_t, unsigned long int, tag, false);
+   TEST_TTR(wchar_t, wchar_t, tag, false);
+   TEST_TTR(wchar_t, float, tag, false);
+   TEST_TTR(wchar_t, double, tag, false);
+   TEST_TTR(wchar_t, long double, tag, false);
+   TEST_TTR(float, bool, tag, false);
+   TEST_TTR(float, char, tag, false);
+   TEST_TTR(float, signed char, tag, false);
+   TEST_TTR(float, short int, tag, false);
+   TEST_TTR(float, int, tag, false);
+   TEST_TTR(float, long int, tag, false);
+   TEST_TTR(float, unsigned char, tag, false);
+   TEST_TTR(float, unsigned short int, tag, false);
+   TEST_TTR(float, unsigned int, tag, false);
+   TEST_TTR(float, unsigned long int, tag, false);
+   TEST_TTR(float, wchar_t, tag, false);
+   TEST_TTR(float, float, tag, false);
+   TEST_TTR(float, double, tag, false);
+   TEST_TTR(float, long double, tag, false);
+   TEST_TTR(double, bool, tag, false);
+   TEST_TTR(double, char, tag, false);
+   TEST_TTR(double, signed char, tag, false);
+   TEST_TTR(double, short int, tag, false);
+   TEST_TTR(double, int, tag, false);
+   TEST_TTR(double, long int, tag, false);
+   TEST_TTR(double, unsigned char, tag, false);
+   TEST_TTR(double, unsigned short int, tag, false);
+   TEST_TTR(double, unsigned int, tag, false);
+   TEST_TTR(double, unsigned long int, tag, false);
+   TEST_TTR(double, wchar_t, tag, false);
+   TEST_TTR(double, float, tag, false);
+   TEST_TTR(double, double, tag, false);
+   TEST_TTR(double, long double, tag, false);
+   TEST_TTR(long double, bool, tag, false);
+   TEST_TTR(long double, char, tag, false);
+   TEST_TTR(long double, signed char, tag, false);
+   TEST_TTR(long double, short int, tag, false);
+   TEST_TTR(long double, int, tag, false);
+   TEST_TTR(long double, long int, tag, false);
+   TEST_TTR(long double, unsigned char, tag, false);
+   TEST_TTR(long double, unsigned short int, tag, false);
+   TEST_TTR(long double, unsigned int, tag, false);
+   TEST_TTR(long double, unsigned long int, tag, false);
+   TEST_TTR(long double, wchar_t, tag, false);
+   TEST_TTR(long double, float, tag, false);
+   TEST_TTR(long double, double, tag, false);
+   TEST_TTR(long double, long double, tag, false);
+#	undef CV1
+#	define CV1(T) const T
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), false);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), false);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, false);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), false);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), false);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, false);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const T&
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), false);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), false);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, false);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T&
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T&
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), false);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), false);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, false);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const T
+#	undef CV2
+#	define CV2(T) const T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), false);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), false);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, false);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const T&
+#	undef CV2
+#	define CV2(T) const T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), false);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), false);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, false);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T
+#	undef CV2
+#	define CV2(T) volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T&
+#	undef CV2
+#	define CV2(T) volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T
+#	undef CV2
+#	define CV2(T) const volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), false);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), false);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, false);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T&
+#	undef CV2
+#	define CV2(T) const volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), false);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), false);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, false);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+   // pointers
+   TEST_TT(void*, bool, false);
+   TEST_TT(void*, int, false);
+   TEST_TT(void*, double, false);
+   TEST_TT(void*, A, false);
+   TEST_TT(void*, B, false);
+   TEST_TT(bool*, bool, false);
+   TEST_TT(bool*, int, false);
+   TEST_TT(bool*, double, false);
+   TEST_TT(bool*, A, false);
+   TEST_TT(bool*, B, false);
+   TEST_TT(int*, bool, false);
+   TEST_TT(int*, int, false);
+   TEST_TT(int*, double, false);
+   TEST_TT(int*, A, false);
+   TEST_TT(int*, B, false);
+   TEST_TT(double*, bool, false);
+   TEST_TT(double*, int, false);
+   TEST_TT(double*, double, false);
+   TEST_TT(double*, A, false);
+   TEST_TT(double*, B, false);
+   TEST_TT(A*, bool, false);
+   TEST_TT(A*, int, false);
+   TEST_TT(A*, double, false);
+   TEST_TT(A*, A, false);
+   TEST_TT(A*, B, false);
+   TEST_TT(B*, bool, false);
+   TEST_TT(B*, int, false);
+   TEST_TT(B*, double, false);
+   TEST_TT(B*, A, false);
+   TEST_TT(B*, B, false);
+   TEST_TT(bool, void*, false);
+   TEST_TT(bool, bool*, false);
+   TEST_TT(bool, int*, false);
+   TEST_TT(bool, double*, false);
+   TEST_TT(bool, A*, false);
+   TEST_TT(bool, B*, false);
+   TEST_TT(int, void*, false);
+   TEST_TT(int, bool*, false);
+   TEST_TT(int, int*, false);
+   TEST_TT(int, double*, false);
+   TEST_TT(int, A*, false);
+   TEST_TT(int, B*, false);
+   TEST_TT(double, void*, false);
+   TEST_TT(double, bool*, false);
+   TEST_TT(double, int*, false);
+   TEST_TT(double, double*, false);
+   TEST_TT(double, A*, false);
+   TEST_TT(double, B*, false);
+   TEST_TT(A, void*, false);
+   TEST_TT(A, bool*, false);
+   TEST_TT(A, int*, false);
+   TEST_TT(A, double*, false);
+   TEST_TT(A, A*, false);
+   TEST_TT(A, B*, false);
+   TEST_TT(B, void*, false);
+   TEST_TT(B, bool*, false);
+   TEST_TT(B, int*, false);
+   TEST_TT(B, double*, false);
+   TEST_TT(B, A*, false);
+   TEST_TT(B, B*, false);
+   TEST_TT(void*, void*, false);
+   TEST_TT(void*, bool*, false);
+   TEST_TT(void*, int*, false);
+   TEST_TT(void*, double*, false);
+   TEST_TT(void*, A*, false);
+   TEST_TT(void*, B*, false);
+   TEST_TT(bool*, void*, false);
+   TEST_TT(bool*, bool*, false);
+   TEST_TT(bool*, int*, false);
+   TEST_TT(bool*, double*, false);
+   TEST_TT(bool*, A*, false);
+   TEST_TT(bool*, B*, false);
+   TEST_TT(int*, void*, false);
+   TEST_TT(int*, bool*, false);
+   TEST_TT(int*, int*, false);
+   TEST_TT(int*, double*, false);
+   TEST_TT(int*, A*, false);
+   TEST_TT(int*, B*, false);
+   TEST_TT(double*, void*, false);
+   TEST_TT(double*, bool*, false);
+   TEST_TT(double*, int*, false);
+   TEST_TT(double*, double*, false);
+   TEST_TT(double*, A*, false);
+   TEST_TT(double*, B*, false);
+   TEST_TT(A*, void*, false);
+   TEST_TT(A*, bool*, false);
+   TEST_TT(A*, int*, false);
+   TEST_TT(A*, double*, false);
+   TEST_TT(A*, A*, false);
+   TEST_TT(A*, B*, false);
+   TEST_TT(B*, void*, false);
+   TEST_TT(B*, bool*, false);
+   TEST_TT(B*, int*, false);
+   TEST_TT(B*, double*, false);
+   TEST_TT(B*, A*, false);
+   TEST_TT(B*, B*, false);
+   TEST_TT(C, void*, true);
+   TEST_TT(D, void*, false);
+   TEST_TT(void*, C, false);
+   TEST_TT(void*, D, true);
+   TEST_TT(C, D, true);
+}
+}

Added: sandbox/type_traits/libs/type_traits/test/can_call_no_pointer_test.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_no_pointer_test.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,1250 @@
+//  (C) Copyright Frederic Bron 2009-2011.
+//  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)
+
+namespace {
+
+void run2() {
+   // test with only one template parameter
+   TEST_T(void, false);
+   TEST_T(bool, true);
+   TEST_T(char, true);
+   TEST_T(signed char, true);
+   TEST_T(short int, true);
+   TEST_T(int, true);
+   TEST_T(long int, true);
+   TEST_T(unsigned char, true);
+   TEST_T(unsigned short int, true);
+   TEST_T(unsigned int, true);
+   TEST_T(unsigned long int, true);
+   TEST_T(wchar_t, true);
+   TEST_T(float, true);
+   TEST_T(double, true);
+   TEST_T(long double, true);
+   TEST_T(void, false);
+#	undef CV
+#	define CV(T) const T
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	undef CV
+#	define CV(T) volatile T
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	undef CV
+#	define CV(T) const volatile T
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	undef CV
+#	define CV(T) const T&
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	undef CV
+#	define CV(T) volatile T&
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	undef CV
+#	define CV(T) const volatile T&
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   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);
+   TEST_TT(bool, short int, true);
+   TEST_TT(bool, int, true);
+   TEST_TT(bool, long int, true);
+   TEST_TT(bool, unsigned char, true);
+   TEST_TT(bool, unsigned short int, true);
+   TEST_TT(bool, unsigned int, true);
+   TEST_TT(bool, unsigned long int, true);
+   TEST_TT(bool, wchar_t, true);
+   TEST_TT(bool, float, true);
+   TEST_TT(bool, double, true);
+   TEST_TT(bool, long double, true);
+   TEST_TT(char, bool, true);
+   TEST_TT(char, char, true);
+   TEST_TT(char, signed char, true);
+   TEST_TT(char, short int, true);
+   TEST_TT(char, int, true);
+   TEST_TT(char, long int, true);
+   TEST_TT(char, unsigned char, true);
+   TEST_TT(char, unsigned short int, true);
+   TEST_TT(char, unsigned int, true);
+   TEST_TT(char, unsigned long int, true);
+   TEST_TT(char, wchar_t, true);
+   TEST_TT(char, float, true);
+   TEST_TT(char, double, true);
+   TEST_TT(char, long double, true);
+   TEST_TT(signed char, bool, true);
+   TEST_TT(signed char, char, true);
+   TEST_TT(signed char, signed char, true);
+   TEST_TT(signed char, short int, true);
+   TEST_TT(signed char, int, true);
+   TEST_TT(signed char, long int, true);
+   TEST_TT(signed char, unsigned char, true);
+   TEST_TT(signed char, unsigned short int, true);
+   TEST_TT(signed char, unsigned int, true);
+   TEST_TT(signed char, unsigned long int, true);
+   TEST_TT(signed char, wchar_t, true);
+   TEST_TT(signed char, float, true);
+   TEST_TT(signed char, double, true);
+   TEST_TT(signed char, long double, true);
+   TEST_TT(short int, bool, true);
+   TEST_TT(short int, char, true);
+   TEST_TT(short int, signed char, true);
+   TEST_TT(short int, short int, true);
+   TEST_TT(short int, int, true);
+   TEST_TT(short int, long int, true);
+   TEST_TT(short int, unsigned char, true);
+   TEST_TT(short int, unsigned short int, true);
+   TEST_TT(short int, unsigned int, true);
+   TEST_TT(short int, unsigned long int, true);
+   TEST_TT(short int, wchar_t, true);
+   TEST_TT(short int, float, true);
+   TEST_TT(short int, double, true);
+   TEST_TT(short int, long double, true);
+   TEST_TT(int, bool, true);
+   TEST_TT(int, char, true);
+   TEST_TT(int, signed char, true);
+   TEST_TT(int, short int, true);
+   TEST_TT(int, int, true);
+   TEST_TT(int, long int, true);
+   TEST_TT(int, unsigned char, true);
+   TEST_TT(int, unsigned short int, true);
+   TEST_TT(int, unsigned int, true);
+   TEST_TT(int, unsigned long int, true);
+   TEST_TT(int, wchar_t, true);
+   TEST_TT(int, float, true);
+   TEST_TT(int, double, true);
+   TEST_TT(int, long double, true);
+   TEST_TT(long int, bool, true);
+   TEST_TT(long int, char, true);
+   TEST_TT(long int, signed char, true);
+   TEST_TT(long int, short int, true);
+   TEST_TT(long int, int, true);
+   TEST_TT(long int, long int, true);
+   TEST_TT(long int, unsigned char, true);
+   TEST_TT(long int, unsigned short int, true);
+   TEST_TT(long int, unsigned int, true);
+   TEST_TT(long int, unsigned long int, true);
+   TEST_TT(long int, wchar_t, true);
+   TEST_TT(long int, float, true);
+   TEST_TT(long int, double, true);
+   TEST_TT(long int, long double, true);
+   TEST_TT(unsigned char, bool, true);
+   TEST_TT(unsigned char, char, true);
+   TEST_TT(unsigned char, signed char, true);
+   TEST_TT(unsigned char, short int, true);
+   TEST_TT(unsigned char, int, true);
+   TEST_TT(unsigned char, long int, true);
+   TEST_TT(unsigned char, unsigned char, true);
+   TEST_TT(unsigned char, unsigned short int, true);
+   TEST_TT(unsigned char, unsigned int, true);
+   TEST_TT(unsigned char, unsigned long int, true);
+   TEST_TT(unsigned char, wchar_t, true);
+   TEST_TT(unsigned char, float, true);
+   TEST_TT(unsigned char, double, true);
+   TEST_TT(unsigned char, long double, true);
+   TEST_TT(unsigned short int, bool, true);
+   TEST_TT(unsigned short int, char, true);
+   TEST_TT(unsigned short int, signed char, true);
+   TEST_TT(unsigned short int, short int, true);
+   TEST_TT(unsigned short int, int, true);
+   TEST_TT(unsigned short int, long int, true);
+   TEST_TT(unsigned short int, unsigned char, true);
+   TEST_TT(unsigned short int, unsigned short int, true);
+   TEST_TT(unsigned short int, unsigned int, true);
+   TEST_TT(unsigned short int, unsigned long int, true);
+   TEST_TT(unsigned short int, wchar_t, true);
+   TEST_TT(unsigned short int, float, true);
+   TEST_TT(unsigned short int, double, true);
+   TEST_TT(unsigned short int, long double, true);
+   TEST_TT(unsigned int, bool, true);
+   TEST_TT(unsigned int, char, true);
+   TEST_TT(unsigned int, signed char, true);
+   TEST_TT(unsigned int, short int, true);
+   TEST_TT(unsigned int, int, true);
+   TEST_TT(unsigned int, long int, true);
+   TEST_TT(unsigned int, unsigned char, true);
+   TEST_TT(unsigned int, unsigned short int, true);
+   TEST_TT(unsigned int, unsigned int, true);
+   TEST_TT(unsigned int, unsigned long int, true);
+   TEST_TT(unsigned int, wchar_t, true);
+   TEST_TT(unsigned int, float, true);
+   TEST_TT(unsigned int, double, true);
+   TEST_TT(unsigned int, long double, true);
+   TEST_TT(unsigned long int, bool, true);
+   TEST_TT(unsigned long int, char, true);
+   TEST_TT(unsigned long int, signed char, true);
+   TEST_TT(unsigned long int, short int, true);
+   TEST_TT(unsigned long int, int, true);
+   TEST_TT(unsigned long int, long int, true);
+   TEST_TT(unsigned long int, unsigned char, true);
+   TEST_TT(unsigned long int, unsigned short int, true);
+   TEST_TT(unsigned long int, unsigned int, true);
+   TEST_TT(unsigned long int, unsigned long int, true);
+   TEST_TT(unsigned long int, wchar_t, true);
+   TEST_TT(unsigned long int, float, true);
+   TEST_TT(unsigned long int, double, true);
+   TEST_TT(unsigned long int, long double, true);
+   TEST_TT(wchar_t, bool, true);
+   TEST_TT(wchar_t, char, true);
+   TEST_TT(wchar_t, signed char, true);
+   TEST_TT(wchar_t, short int, true);
+   TEST_TT(wchar_t, int, true);
+   TEST_TT(wchar_t, long int, true);
+   TEST_TT(wchar_t, unsigned char, true);
+   TEST_TT(wchar_t, unsigned short int, true);
+   TEST_TT(wchar_t, unsigned int, true);
+   TEST_TT(wchar_t, unsigned long int, true);
+   TEST_TT(wchar_t, wchar_t, true);
+   TEST_TT(wchar_t, float, true);
+   TEST_TT(wchar_t, double, true);
+   TEST_TT(wchar_t, long double, true);
+   TEST_TT(float, bool, true);
+   TEST_TT(float, char, true);
+   TEST_TT(float, signed char, true);
+   TEST_TT(float, short int, true);
+   TEST_TT(float, int, true);
+   TEST_TT(float, long int, true);
+   TEST_TT(float, unsigned char, true);
+   TEST_TT(float, unsigned short int, true);
+   TEST_TT(float, unsigned int, true);
+   TEST_TT(float, unsigned long int, true);
+   TEST_TT(float, wchar_t, true);
+   TEST_TT(float, float, true);
+   TEST_TT(float, double, true);
+   TEST_TT(float, long double, true);
+   TEST_TT(double, bool, true);
+   TEST_TT(double, char, true);
+   TEST_TT(double, signed char, true);
+   TEST_TT(double, short int, true);
+   TEST_TT(double, int, true);
+   TEST_TT(double, long int, true);
+   TEST_TT(double, unsigned char, true);
+   TEST_TT(double, unsigned short int, true);
+   TEST_TT(double, unsigned int, true);
+   TEST_TT(double, unsigned long int, true);
+   TEST_TT(double, wchar_t, true);
+   TEST_TT(double, float, true);
+   TEST_TT(double, double, true);
+   TEST_TT(double, long double, true);
+   TEST_TT(long double, bool, true);
+   TEST_TT(long double, char, true);
+   TEST_TT(long double, signed char, true);
+   TEST_TT(long double, short int, true);
+   TEST_TT(long double, int, true);
+   TEST_TT(long double, long int, true);
+   TEST_TT(long double, unsigned char, true);
+   TEST_TT(long double, unsigned short int, true);
+   TEST_TT(long double, unsigned int, true);
+   TEST_TT(long double, unsigned long int, true);
+   TEST_TT(long double, wchar_t, true);
+   TEST_TT(long double, float, true);
+   TEST_TT(long double, double, true);
+   TEST_TT(long double, long double, true);
+   TEST_TT(bool, void, false);
+   TEST_TT(void, bool, false);
+   TEST_TT(char, void, false);
+   TEST_TT(void, char, false);
+   TEST_TT(signed char, void, false);
+   TEST_TT(void, signed char, false);
+   TEST_TT(short int, void, false);
+   TEST_TT(void, short int, false);
+   TEST_TT(int, void, false);
+   TEST_TT(void, int, false);
+   TEST_TT(long int, void, false);
+   TEST_TT(void, long int, false);
+   TEST_TT(unsigned char, void, false);
+   TEST_TT(void, unsigned char, false);
+   TEST_TT(unsigned short int, void, false);
+   TEST_TT(void, unsigned short int, false);
+   TEST_TT(unsigned int, void, false);
+   TEST_TT(void, unsigned int, false);
+   TEST_TT(unsigned long int, void, false);
+   TEST_TT(void, unsigned long int, false);
+   TEST_TT(wchar_t, void, false);
+   TEST_TT(void, wchar_t, false);
+   TEST_TT(float, void, false);
+   TEST_TT(void, float, false);
+   TEST_TT(double, void, false);
+   TEST_TT(void, double, false);
+   TEST_TT(long double, void, false);
+   TEST_TT(void, long double, false);
+
+// test with three template parameters
+   TEST_TTR(bool, bool, bool, true);
+   TEST_TTR(bool, char, bool, true);
+   TEST_TTR(bool, signed char, bool, true);
+   TEST_TTR(bool, short int, bool, true);
+   TEST_TTR(bool, int, bool, true);
+   TEST_TTR(bool, long int, bool, true);
+   TEST_TTR(bool, unsigned char, bool, true);
+   TEST_TTR(bool, unsigned short int, bool, true);
+   TEST_TTR(bool, unsigned int, bool, true);
+   TEST_TTR(bool, unsigned long int, bool, true);
+   TEST_TTR(bool, wchar_t, bool, true);
+   TEST_TTR(bool, float, bool, true);
+   TEST_TTR(bool, double, bool, true);
+   TEST_TTR(bool, long double, bool, true);
+   TEST_TTR(char, bool, bool, true);
+   TEST_TTR(char, char, bool, true);
+   TEST_TTR(char, signed char, bool, true);
+   TEST_TTR(char, short int, bool, true);
+   TEST_TTR(char, int, bool, true);
+   TEST_TTR(char, long int, bool, true);
+   TEST_TTR(char, unsigned char, bool, true);
+   TEST_TTR(char, unsigned short int, bool, true);
+   TEST_TTR(char, unsigned int, bool, true);
+   TEST_TTR(char, unsigned long int, bool, true);
+   TEST_TTR(char, wchar_t, bool, true);
+   TEST_TTR(char, float, bool, true);
+   TEST_TTR(char, double, bool, true);
+   TEST_TTR(char, long double, bool, true);
+   TEST_TTR(signed char, bool, bool, true);
+   TEST_TTR(signed char, char, bool, true);
+   TEST_TTR(signed char, signed char, bool, true);
+   TEST_TTR(signed char, short int, bool, true);
+   TEST_TTR(signed char, int, bool, true);
+   TEST_TTR(signed char, long int, bool, true);
+   TEST_TTR(signed char, unsigned char, bool, true);
+   TEST_TTR(signed char, unsigned short int, bool, true);
+   TEST_TTR(signed char, unsigned int, bool, true);
+   TEST_TTR(signed char, unsigned long int, bool, true);
+   TEST_TTR(signed char, wchar_t, bool, true);
+   TEST_TTR(signed char, float, bool, true);
+   TEST_TTR(signed char, double, bool, true);
+   TEST_TTR(signed char, long double, bool, true);
+   TEST_TTR(short int, bool, bool, true);
+   TEST_TTR(short int, char, bool, true);
+   TEST_TTR(short int, signed char, bool, true);
+   TEST_TTR(short int, short int, bool, true);
+   TEST_TTR(short int, int, bool, true);
+   TEST_TTR(short int, long int, bool, true);
+   TEST_TTR(short int, unsigned char, bool, true);
+   TEST_TTR(short int, unsigned short int, bool, true);
+   TEST_TTR(short int, unsigned int, bool, true);
+   TEST_TTR(short int, unsigned long int, bool, true);
+   TEST_TTR(short int, wchar_t, bool, true);
+   TEST_TTR(short int, float, bool, true);
+   TEST_TTR(short int, double, bool, true);
+   TEST_TTR(short int, long double, bool, true);
+   TEST_TTR(int, bool, bool, true);
+   TEST_TTR(int, char, bool, true);
+   TEST_TTR(int, signed char, bool, true);
+   TEST_TTR(int, short int, bool, true);
+   TEST_TTR(int, int, bool, true);
+   TEST_TTR(int, long int, bool, true);
+   TEST_TTR(int, unsigned char, bool, true);
+   TEST_TTR(int, unsigned short int, bool, true);
+   TEST_TTR(int, unsigned int, bool, true);
+   TEST_TTR(int, unsigned long int, bool, true);
+   TEST_TTR(int, wchar_t, bool, true);
+   TEST_TTR(int, float, bool, true);
+   TEST_TTR(int, double, bool, true);
+   TEST_TTR(int, long double, bool, true);
+   TEST_TTR(long int, bool, bool, true);
+   TEST_TTR(long int, char, bool, true);
+   TEST_TTR(long int, signed char, bool, true);
+   TEST_TTR(long int, short int, bool, true);
+   TEST_TTR(long int, int, bool, true);
+   TEST_TTR(long int, long int, bool, true);
+   TEST_TTR(long int, unsigned char, bool, true);
+   TEST_TTR(long int, unsigned short int, bool, true);
+   TEST_TTR(long int, unsigned int, bool, true);
+   TEST_TTR(long int, unsigned long int, bool, true);
+   TEST_TTR(long int, wchar_t, bool, true);
+   TEST_TTR(long int, float, bool, true);
+   TEST_TTR(long int, double, bool, true);
+   TEST_TTR(long int, long double, bool, true);
+   TEST_TTR(unsigned char, bool, bool, true);
+   TEST_TTR(unsigned char, char, bool, true);
+   TEST_TTR(unsigned char, signed char, bool, true);
+   TEST_TTR(unsigned char, short int, bool, true);
+   TEST_TTR(unsigned char, int, bool, true);
+   TEST_TTR(unsigned char, long int, bool, true);
+   TEST_TTR(unsigned char, unsigned char, bool, true);
+   TEST_TTR(unsigned char, unsigned short int, bool, true);
+   TEST_TTR(unsigned char, unsigned int, bool, true);
+   TEST_TTR(unsigned char, unsigned long int, bool, true);
+   TEST_TTR(unsigned char, wchar_t, bool, true);
+   TEST_TTR(unsigned char, float, bool, true);
+   TEST_TTR(unsigned char, double, bool, true);
+   TEST_TTR(unsigned char, long double, bool, true);
+   TEST_TTR(unsigned short int, bool, bool, true);
+   TEST_TTR(unsigned short int, char, bool, true);
+   TEST_TTR(unsigned short int, signed char, bool, true);
+   TEST_TTR(unsigned short int, short int, bool, true);
+   TEST_TTR(unsigned short int, int, bool, true);
+   TEST_TTR(unsigned short int, long int, bool, true);
+   TEST_TTR(unsigned short int, unsigned char, bool, true);
+   TEST_TTR(unsigned short int, unsigned short int, bool, true);
+   TEST_TTR(unsigned short int, unsigned int, bool, true);
+   TEST_TTR(unsigned short int, unsigned long int, bool, true);
+   TEST_TTR(unsigned short int, wchar_t, bool, true);
+   TEST_TTR(unsigned short int, float, bool, true);
+   TEST_TTR(unsigned short int, double, bool, true);
+   TEST_TTR(unsigned short int, long double, bool, true);
+   TEST_TTR(unsigned int, bool, bool, true);
+   TEST_TTR(unsigned int, char, bool, true);
+   TEST_TTR(unsigned int, signed char, bool, true);
+   TEST_TTR(unsigned int, short int, bool, true);
+   TEST_TTR(unsigned int, int, bool, true);
+   TEST_TTR(unsigned int, long int, bool, true);
+   TEST_TTR(unsigned int, unsigned char, bool, true);
+   TEST_TTR(unsigned int, unsigned short int, bool, true);
+   TEST_TTR(unsigned int, unsigned int, bool, true);
+   TEST_TTR(unsigned int, unsigned long int, bool, true);
+   TEST_TTR(unsigned int, wchar_t, bool, true);
+   TEST_TTR(unsigned int, float, bool, true);
+   TEST_TTR(unsigned int, double, bool, true);
+   TEST_TTR(unsigned int, long double, bool, true);
+   TEST_TTR(unsigned long int, bool, bool, true);
+   TEST_TTR(unsigned long int, char, bool, true);
+   TEST_TTR(unsigned long int, signed char, bool, true);
+   TEST_TTR(unsigned long int, short int, bool, true);
+   TEST_TTR(unsigned long int, int, bool, true);
+   TEST_TTR(unsigned long int, long int, bool, true);
+   TEST_TTR(unsigned long int, unsigned char, bool, true);
+   TEST_TTR(unsigned long int, unsigned short int, bool, true);
+   TEST_TTR(unsigned long int, unsigned int, bool, true);
+   TEST_TTR(unsigned long int, unsigned long int, bool, true);
+   TEST_TTR(unsigned long int, wchar_t, bool, true);
+   TEST_TTR(unsigned long int, float, bool, true);
+   TEST_TTR(unsigned long int, double, bool, true);
+   TEST_TTR(unsigned long int, long double, bool, true);
+   TEST_TTR(wchar_t, bool, bool, true);
+   TEST_TTR(wchar_t, char, bool, true);
+   TEST_TTR(wchar_t, signed char, bool, true);
+   TEST_TTR(wchar_t, short int, bool, true);
+   TEST_TTR(wchar_t, int, bool, true);
+   TEST_TTR(wchar_t, long int, bool, true);
+   TEST_TTR(wchar_t, unsigned char, bool, true);
+   TEST_TTR(wchar_t, unsigned short int, bool, true);
+   TEST_TTR(wchar_t, unsigned int, bool, true);
+   TEST_TTR(wchar_t, unsigned long int, bool, true);
+   TEST_TTR(wchar_t, wchar_t, bool, true);
+   TEST_TTR(wchar_t, float, bool, true);
+   TEST_TTR(wchar_t, double, bool, true);
+   TEST_TTR(wchar_t, long double, bool, true);
+   TEST_TTR(float, bool, bool, true);
+   TEST_TTR(float, char, bool, true);
+   TEST_TTR(float, signed char, bool, true);
+   TEST_TTR(float, short int, bool, true);
+   TEST_TTR(float, int, bool, true);
+   TEST_TTR(float, long int, bool, true);
+   TEST_TTR(float, unsigned char, bool, true);
+   TEST_TTR(float, unsigned short int, bool, true);
+   TEST_TTR(float, unsigned int, bool, true);
+   TEST_TTR(float, unsigned long int, bool, true);
+   TEST_TTR(float, wchar_t, bool, true);
+   TEST_TTR(float, float, bool, true);
+   TEST_TTR(float, double, bool, true);
+   TEST_TTR(float, long double, bool, true);
+   TEST_TTR(double, bool, bool, true);
+   TEST_TTR(double, char, bool, true);
+   TEST_TTR(double, signed char, bool, true);
+   TEST_TTR(double, short int, bool, true);
+   TEST_TTR(double, int, bool, true);
+   TEST_TTR(double, long int, bool, true);
+   TEST_TTR(double, unsigned char, bool, true);
+   TEST_TTR(double, unsigned short int, bool, true);
+   TEST_TTR(double, unsigned int, bool, true);
+   TEST_TTR(double, unsigned long int, bool, true);
+   TEST_TTR(double, wchar_t, bool, true);
+   TEST_TTR(double, float, bool, true);
+   TEST_TTR(double, double, bool, true);
+   TEST_TTR(double, long double, bool, true);
+   TEST_TTR(long double, bool, bool, true);
+   TEST_TTR(long double, char, bool, true);
+   TEST_TTR(long double, signed char, bool, true);
+   TEST_TTR(long double, short int, bool, true);
+   TEST_TTR(long double, int, bool, true);
+   TEST_TTR(long double, long int, bool, true);
+   TEST_TTR(long double, unsigned char, bool, true);
+   TEST_TTR(long double, unsigned short int, bool, true);
+   TEST_TTR(long double, unsigned int, bool, true);
+   TEST_TTR(long double, unsigned long int, bool, true);
+   TEST_TTR(long double, wchar_t, bool, true);
+   TEST_TTR(long double, float, bool, true);
+   TEST_TTR(long double, double, bool, true);
+   TEST_TTR(long double, long double, bool, true);
+   TEST_TTR(bool, bool, tag, false);
+   TEST_TTR(bool, char, tag, false);
+   TEST_TTR(bool, signed char, tag, false);
+   TEST_TTR(bool, short int, tag, false);
+   TEST_TTR(bool, int, tag, false);
+   TEST_TTR(bool, long int, tag, false);
+   TEST_TTR(bool, unsigned char, tag, false);
+   TEST_TTR(bool, unsigned short int, tag, false);
+   TEST_TTR(bool, unsigned int, tag, false);
+   TEST_TTR(bool, unsigned long int, tag, false);
+   TEST_TTR(bool, wchar_t, tag, false);
+   TEST_TTR(bool, float, tag, false);
+   TEST_TTR(bool, double, tag, false);
+   TEST_TTR(bool, long double, tag, false);
+   TEST_TTR(char, bool, tag, false);
+   TEST_TTR(char, char, tag, false);
+   TEST_TTR(char, signed char, tag, false);
+   TEST_TTR(char, short int, tag, false);
+   TEST_TTR(char, int, tag, false);
+   TEST_TTR(char, long int, tag, false);
+   TEST_TTR(char, unsigned char, tag, false);
+   TEST_TTR(char, unsigned short int, tag, false);
+   TEST_TTR(char, unsigned int, tag, false);
+   TEST_TTR(char, unsigned long int, tag, false);
+   TEST_TTR(char, wchar_t, tag, false);
+   TEST_TTR(char, float, tag, false);
+   TEST_TTR(char, double, tag, false);
+   TEST_TTR(char, long double, tag, false);
+   TEST_TTR(signed char, bool, tag, false);
+   TEST_TTR(signed char, char, tag, false);
+   TEST_TTR(signed char, signed char, tag, false);
+   TEST_TTR(signed char, short int, tag, false);
+   TEST_TTR(signed char, int, tag, false);
+   TEST_TTR(signed char, long int, tag, false);
+   TEST_TTR(signed char, unsigned char, tag, false);
+   TEST_TTR(signed char, unsigned short int, tag, false);
+   TEST_TTR(signed char, unsigned int, tag, false);
+   TEST_TTR(signed char, unsigned long int, tag, false);
+   TEST_TTR(signed char, wchar_t, tag, false);
+   TEST_TTR(signed char, float, tag, false);
+   TEST_TTR(signed char, double, tag, false);
+   TEST_TTR(signed char, long double, tag, false);
+   TEST_TTR(short int, bool, tag, false);
+   TEST_TTR(short int, char, tag, false);
+   TEST_TTR(short int, signed char, tag, false);
+   TEST_TTR(short int, short int, tag, false);
+   TEST_TTR(short int, int, tag, false);
+   TEST_TTR(short int, long int, tag, false);
+   TEST_TTR(short int, unsigned char, tag, false);
+   TEST_TTR(short int, unsigned short int, tag, false);
+   TEST_TTR(short int, unsigned int, tag, false);
+   TEST_TTR(short int, unsigned long int, tag, false);
+   TEST_TTR(short int, wchar_t, tag, false);
+   TEST_TTR(short int, float, tag, false);
+   TEST_TTR(short int, double, tag, false);
+   TEST_TTR(short int, long double, tag, false);
+   TEST_TTR(int, bool, tag, false);
+   TEST_TTR(int, char, tag, false);
+   TEST_TTR(int, signed char, tag, false);
+   TEST_TTR(int, short int, tag, false);
+   TEST_TTR(int, int, tag, false);
+   TEST_TTR(int, long int, tag, false);
+   TEST_TTR(int, unsigned char, tag, false);
+   TEST_TTR(int, unsigned short int, tag, false);
+   TEST_TTR(int, unsigned int, tag, false);
+   TEST_TTR(int, unsigned long int, tag, false);
+   TEST_TTR(int, wchar_t, tag, false);
+   TEST_TTR(int, float, tag, false);
+   TEST_TTR(int, double, tag, false);
+   TEST_TTR(int, long double, tag, false);
+   TEST_TTR(long int, bool, tag, false);
+   TEST_TTR(long int, char, tag, false);
+   TEST_TTR(long int, signed char, tag, false);
+   TEST_TTR(long int, short int, tag, false);
+   TEST_TTR(long int, int, tag, false);
+   TEST_TTR(long int, long int, tag, false);
+   TEST_TTR(long int, unsigned char, tag, false);
+   TEST_TTR(long int, unsigned short int, tag, false);
+   TEST_TTR(long int, unsigned int, tag, false);
+   TEST_TTR(long int, unsigned long int, tag, false);
+   TEST_TTR(long int, wchar_t, tag, false);
+   TEST_TTR(long int, float, tag, false);
+   TEST_TTR(long int, double, tag, false);
+   TEST_TTR(long int, long double, tag, false);
+   TEST_TTR(unsigned char, bool, tag, false);
+   TEST_TTR(unsigned char, char, tag, false);
+   TEST_TTR(unsigned char, signed char, tag, false);
+   TEST_TTR(unsigned char, short int, tag, false);
+   TEST_TTR(unsigned char, int, tag, false);
+   TEST_TTR(unsigned char, long int, tag, false);
+   TEST_TTR(unsigned char, unsigned char, tag, false);
+   TEST_TTR(unsigned char, unsigned short int, tag, false);
+   TEST_TTR(unsigned char, unsigned int, tag, false);
+   TEST_TTR(unsigned char, unsigned long int, tag, false);
+   TEST_TTR(unsigned char, wchar_t, tag, false);
+   TEST_TTR(unsigned char, float, tag, false);
+   TEST_TTR(unsigned char, double, tag, false);
+   TEST_TTR(unsigned char, long double, tag, false);
+   TEST_TTR(unsigned short int, bool, tag, false);
+   TEST_TTR(unsigned short int, char, tag, false);
+   TEST_TTR(unsigned short int, signed char, tag, false);
+   TEST_TTR(unsigned short int, short int, tag, false);
+   TEST_TTR(unsigned short int, int, tag, false);
+   TEST_TTR(unsigned short int, long int, tag, false);
+   TEST_TTR(unsigned short int, unsigned char, tag, false);
+   TEST_TTR(unsigned short int, unsigned short int, tag, false);
+   TEST_TTR(unsigned short int, unsigned int, tag, false);
+   TEST_TTR(unsigned short int, unsigned long int, tag, false);
+   TEST_TTR(unsigned short int, wchar_t, tag, false);
+   TEST_TTR(unsigned short int, float, tag, false);
+   TEST_TTR(unsigned short int, double, tag, false);
+   TEST_TTR(unsigned short int, long double, tag, false);
+   TEST_TTR(unsigned int, bool, tag, false);
+   TEST_TTR(unsigned int, char, tag, false);
+   TEST_TTR(unsigned int, signed char, tag, false);
+   TEST_TTR(unsigned int, short int, tag, false);
+   TEST_TTR(unsigned int, int, tag, false);
+   TEST_TTR(unsigned int, long int, tag, false);
+   TEST_TTR(unsigned int, unsigned char, tag, false);
+   TEST_TTR(unsigned int, unsigned short int, tag, false);
+   TEST_TTR(unsigned int, unsigned int, tag, false);
+   TEST_TTR(unsigned int, unsigned long int, tag, false);
+   TEST_TTR(unsigned int, wchar_t, tag, false);
+   TEST_TTR(unsigned int, float, tag, false);
+   TEST_TTR(unsigned int, double, tag, false);
+   TEST_TTR(unsigned int, long double, tag, false);
+   TEST_TTR(unsigned long int, bool, tag, false);
+   TEST_TTR(unsigned long int, char, tag, false);
+   TEST_TTR(unsigned long int, signed char, tag, false);
+   TEST_TTR(unsigned long int, short int, tag, false);
+   TEST_TTR(unsigned long int, int, tag, false);
+   TEST_TTR(unsigned long int, long int, tag, false);
+   TEST_TTR(unsigned long int, unsigned char, tag, false);
+   TEST_TTR(unsigned long int, unsigned short int, tag, false);
+   TEST_TTR(unsigned long int, unsigned int, tag, false);
+   TEST_TTR(unsigned long int, unsigned long int, tag, false);
+   TEST_TTR(unsigned long int, wchar_t, tag, false);
+   TEST_TTR(unsigned long int, float, tag, false);
+   TEST_TTR(unsigned long int, double, tag, false);
+   TEST_TTR(unsigned long int, long double, tag, false);
+   TEST_TTR(wchar_t, bool, tag, false);
+   TEST_TTR(wchar_t, char, tag, false);
+   TEST_TTR(wchar_t, signed char, tag, false);
+   TEST_TTR(wchar_t, short int, tag, false);
+   TEST_TTR(wchar_t, int, tag, false);
+   TEST_TTR(wchar_t, long int, tag, false);
+   TEST_TTR(wchar_t, unsigned char, tag, false);
+   TEST_TTR(wchar_t, unsigned short int, tag, false);
+   TEST_TTR(wchar_t, unsigned int, tag, false);
+   TEST_TTR(wchar_t, unsigned long int, tag, false);
+   TEST_TTR(wchar_t, wchar_t, tag, false);
+   TEST_TTR(wchar_t, float, tag, false);
+   TEST_TTR(wchar_t, double, tag, false);
+   TEST_TTR(wchar_t, long double, tag, false);
+   TEST_TTR(float, bool, tag, false);
+   TEST_TTR(float, char, tag, false);
+   TEST_TTR(float, signed char, tag, false);
+   TEST_TTR(float, short int, tag, false);
+   TEST_TTR(float, int, tag, false);
+   TEST_TTR(float, long int, tag, false);
+   TEST_TTR(float, unsigned char, tag, false);
+   TEST_TTR(float, unsigned short int, tag, false);
+   TEST_TTR(float, unsigned int, tag, false);
+   TEST_TTR(float, unsigned long int, tag, false);
+   TEST_TTR(float, wchar_t, tag, false);
+   TEST_TTR(float, float, tag, false);
+   TEST_TTR(float, double, tag, false);
+   TEST_TTR(float, long double, tag, false);
+   TEST_TTR(double, bool, tag, false);
+   TEST_TTR(double, char, tag, false);
+   TEST_TTR(double, signed char, tag, false);
+   TEST_TTR(double, short int, tag, false);
+   TEST_TTR(double, int, tag, false);
+   TEST_TTR(double, long int, tag, false);
+   TEST_TTR(double, unsigned char, tag, false);
+   TEST_TTR(double, unsigned short int, tag, false);
+   TEST_TTR(double, unsigned int, tag, false);
+   TEST_TTR(double, unsigned long int, tag, false);
+   TEST_TTR(double, wchar_t, tag, false);
+   TEST_TTR(double, float, tag, false);
+   TEST_TTR(double, double, tag, false);
+   TEST_TTR(double, long double, tag, false);
+   TEST_TTR(long double, bool, tag, false);
+   TEST_TTR(long double, char, tag, false);
+   TEST_TTR(long double, signed char, tag, false);
+   TEST_TTR(long double, short int, tag, false);
+   TEST_TTR(long double, int, tag, false);
+   TEST_TTR(long double, long int, tag, false);
+   TEST_TTR(long double, unsigned char, tag, false);
+   TEST_TTR(long double, unsigned short int, tag, false);
+   TEST_TTR(long double, unsigned int, tag, false);
+   TEST_TTR(long double, unsigned long int, tag, false);
+   TEST_TTR(long double, wchar_t, tag, false);
+   TEST_TTR(long double, float, tag, false);
+   TEST_TTR(long double, double, tag, false);
+   TEST_TTR(long double, long double, tag, false);
+#	undef CV1
+#	define CV1(T) const T
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const T&
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T&
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T&
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const T
+#	undef CV2
+#	define CV2(T) const T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const T&
+#	undef CV2
+#	define CV2(T) const T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T
+#	undef CV2
+#	define CV2(T) volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T&
+#	undef CV2
+#	define CV2(T) volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T
+#	undef CV2
+#	define CV2(T) const volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T&
+#	undef CV2
+#	define CV2(T) const volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+   // pointers
+   TEST_TT(void*, bool, false);
+   TEST_TT(void*, int, false);
+   TEST_TT(void*, double, false);
+   TEST_TT(void*, A, false);
+   TEST_TT(void*, B, false);
+   TEST_TT(bool*, bool, false);
+   TEST_TT(bool*, int, false);
+   TEST_TT(bool*, double, false);
+   TEST_TT(bool*, A, false);
+   TEST_TT(bool*, B, false);
+   TEST_TT(int*, bool, false);
+   TEST_TT(int*, int, false);
+   TEST_TT(int*, double, false);
+   TEST_TT(int*, A, false);
+   TEST_TT(int*, B, false);
+   TEST_TT(double*, bool, false);
+   TEST_TT(double*, int, false);
+   TEST_TT(double*, double, false);
+   TEST_TT(double*, A, false);
+   TEST_TT(double*, B, false);
+   TEST_TT(A*, bool, false);
+   TEST_TT(A*, int, false);
+   TEST_TT(A*, double, false);
+   TEST_TT(A*, A, false);
+   TEST_TT(A*, B, false);
+   TEST_TT(B*, bool, false);
+   TEST_TT(B*, int, false);
+   TEST_TT(B*, double, false);
+   TEST_TT(B*, A, false);
+   TEST_TT(B*, B, false);
+   TEST_TT(bool, void*, false);
+   TEST_TT(bool, bool*, false);
+   TEST_TT(bool, int*, false);
+   TEST_TT(bool, double*, false);
+   TEST_TT(bool, A*, false);
+   TEST_TT(bool, B*, false);
+   TEST_TT(int, void*, false);
+   TEST_TT(int, bool*, false);
+   TEST_TT(int, int*, false);
+   TEST_TT(int, double*, false);
+   TEST_TT(int, A*, false);
+   TEST_TT(int, B*, false);
+   TEST_TT(double, void*, false);
+   TEST_TT(double, bool*, false);
+   TEST_TT(double, int*, false);
+   TEST_TT(double, double*, false);
+   TEST_TT(double, A*, false);
+   TEST_TT(double, B*, false);
+   TEST_TT(A, void*, false);
+   TEST_TT(A, bool*, false);
+   TEST_TT(A, int*, false);
+   TEST_TT(A, double*, false);
+   TEST_TT(A, A*, false);
+   TEST_TT(A, B*, false);
+   TEST_TT(B, void*, false);
+   TEST_TT(B, bool*, false);
+   TEST_TT(B, int*, false);
+   TEST_TT(B, double*, false);
+   TEST_TT(B, A*, false);
+   TEST_TT(B, B*, false);
+   TEST_TT(void*, void*, false);
+   TEST_TT(void*, bool*, false);
+   TEST_TT(void*, int*, false);
+   TEST_TT(void*, double*, false);
+   TEST_TT(void*, A*, false);
+   TEST_TT(void*, B*, false);
+   TEST_TT(bool*, void*, false);
+   TEST_TT(bool*, bool*, false);
+   TEST_TT(bool*, int*, false);
+   TEST_TT(bool*, double*, false);
+   TEST_TT(bool*, A*, false);
+   TEST_TT(bool*, B*, false);
+   TEST_TT(int*, void*, false);
+   TEST_TT(int*, bool*, false);
+   TEST_TT(int*, int*, false);
+   TEST_TT(int*, double*, false);
+   TEST_TT(int*, A*, false);
+   TEST_TT(int*, B*, false);
+   TEST_TT(double*, void*, false);
+   TEST_TT(double*, bool*, false);
+   TEST_TT(double*, int*, false);
+   TEST_TT(double*, double*, false);
+   TEST_TT(double*, A*, false);
+   TEST_TT(double*, B*, false);
+   TEST_TT(A*, void*, false);
+   TEST_TT(A*, bool*, false);
+   TEST_TT(A*, int*, false);
+   TEST_TT(A*, double*, false);
+   TEST_TT(A*, A*, false);
+   TEST_TT(A*, B*, false);
+   TEST_TT(B*, void*, false);
+   TEST_TT(B*, bool*, false);
+   TEST_TT(B*, int*, false);
+   TEST_TT(B*, double*, false);
+   TEST_TT(B*, A*, false);
+   TEST_TT(B*, B*, false);
+   TEST_TT(C, void*, true);
+   TEST_TT(D, void*, false);
+   TEST_TT(void*, C, false);
+   TEST_TT(void*, D, true);
+   TEST_TT(C, D, true);
+}
+}

Added: sandbox/type_traits/libs/type_traits/test/can_call_not_equal_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_not_equal_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,33 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_not_equal.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_not_equal
+#define BOOST_TT_TRAIT_OP !=
+
+#include "can_call_binary_operators.hpp"
+#include "can_call_comparison_test.hpp"
+
+namespace {
+void specific() {
+   /* nothing specific */
+}
+}
+
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_not_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_not_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,35 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_not.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_not
+#define BOOST_TT_TRAIT_OP !
+
+#include "can_call_prefix_operators.hpp"
+#include "can_call_unary_plus_not_test.hpp"
+
+#include <iostream>
+
+namespace {
+void specific() {
+   TEST_TR(std::ostream, bool, true);
+   TEST_TR(std::istream, bool, true);
+}
+}
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_or_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_or_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,33 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_or.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_or
+#define BOOST_TT_TRAIT_OP ||
+
+#include "can_call_binary_operators.hpp"
+#include "can_call_binary_logical_test.hpp"
+
+namespace {
+void specific() {
+   /* nothing specific */
+}
+}
+
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_post_decrement_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_post_decrement_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,33 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_post_decrement.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_post_decrement
+#define BOOST_TT_TRAIT_OP --
+
+#include "can_call_postfix_operators.hpp"
+#include "can_call_post_decrement_test.hpp"
+
+namespace {
+void specific() {
+   /* nothing specific */
+}
+}
+
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_post_decrement_test.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_post_decrement_test.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,97 @@
+//  (C) Copyright Frederic Bron 2009-2011.
+//  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)
+
+namespace {
+
+void run2() {
+   // test with only one template parameter
+   TEST_T(void, false);
+   TEST_T(bool, false);
+   TEST_T(char, true);
+   TEST_T(signed char, true);
+   TEST_T(short int, true);
+   TEST_T(int, true);
+   TEST_T(long int, true);
+   TEST_T(unsigned char, true);
+   TEST_T(unsigned short int, true);
+   TEST_T(unsigned int, true);
+   TEST_T(unsigned long int, true);
+   TEST_T(wchar_t, true);
+   TEST_T(float, true);
+   TEST_T(double, true);
+   TEST_T(long double, true);
+   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), true);
+   TEST_T(CV(double), true);
+#	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), true);
+   TEST_T(CV(double), true);
+#	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, true);
+   TEST_TR(signed char, bool, true);
+   TEST_TR(short int, bool, true);
+   TEST_TR(int, bool, true);
+   TEST_TR(long int, bool, true);
+   TEST_TR(unsigned char, bool, true);
+   TEST_TR(unsigned short int, bool, true);
+   TEST_TR(unsigned int, bool, true);
+   TEST_TR(unsigned long int, bool, true);
+   TEST_TR(wchar_t, bool, true);
+   TEST_TR(float, bool, true);
+   TEST_TR(double, bool, true);
+   TEST_TR(long double, bool, true);
+   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);
+
+   // 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);
+}
+}

Added: sandbox/type_traits/libs/type_traits/test/can_call_post_increment_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_post_increment_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,33 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_post_increment.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_post_increment
+#define BOOST_TT_TRAIT_OP ++
+
+#include "can_call_postfix_operators.hpp"
+#include "can_call_post_increment_test.hpp"
+
+namespace {
+void specific() {
+   /* nothing specific */
+}
+}
+
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_post_increment_test.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_post_increment_test.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,97 @@
+//  (C) Copyright Frederic Bron 2009-2011.
+//  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)
+
+namespace {
+
+void run2() {
+   // test with only one template parameter
+   TEST_T(void, false);
+   TEST_T(bool, true);
+   TEST_T(char, true);
+   TEST_T(signed char, true);
+   TEST_T(short int, true);
+   TEST_T(int, true);
+   TEST_T(long int, true);
+   TEST_T(unsigned char, true);
+   TEST_T(unsigned short int, true);
+   TEST_T(unsigned int, true);
+   TEST_T(unsigned long int, true);
+   TEST_T(wchar_t, true);
+   TEST_T(float, true);
+   TEST_T(double, true);
+   TEST_T(long double, true);
+   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), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	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), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	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, true);
+   TEST_TR(char, bool, true);
+   TEST_TR(signed char, bool, true);
+   TEST_TR(short int, bool, true);
+   TEST_TR(int, bool, true);
+   TEST_TR(long int, bool, true);
+   TEST_TR(unsigned char, bool, true);
+   TEST_TR(unsigned short int, bool, true);
+   TEST_TR(unsigned int, bool, true);
+   TEST_TR(unsigned long int, bool, true);
+   TEST_TR(wchar_t, bool, true);
+   TEST_TR(float, bool, true);
+   TEST_TR(double, bool, true);
+   TEST_TR(long double, bool, true);
+   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);
+
+   // 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);
+}
+}

Added: sandbox/type_traits/libs/type_traits/test/can_call_postfix_operators.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_postfix_operators.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,126 @@
+//  (C) Copyright Frederic Bron 2009-2011.
+//  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)
+
+// 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 without { };
+
+struct ret { };
+
+struct internal { ret operator BOOST_TT_TRAIT_OP (int) const; };
+
+struct external { };
+ret operator BOOST_TT_TRAIT_OP (const external&, int);
+
+struct comma1_ret { };
+struct ret_with_comma1 { comma1_ret operator,(int); };
+
+struct internal_comma1 { ret_with_comma1 operator BOOST_TT_TRAIT_OP (int) const; };
+
+struct external_comma1 { };
+ret_with_comma1 operator BOOST_TT_TRAIT_OP (const external_comma1&, int);
+
+struct ret_with_comma2 { void operator,(int); };
+
+struct internal_comma2 { ret_with_comma2 operator BOOST_TT_TRAIT_OP (int) const; };
+
+struct external_comma2 { };
+ret_with_comma2 operator BOOST_TT_TRAIT_OP (const external_comma2&, int);
+
+struct returns_int { int operator BOOST_TT_TRAIT_OP (int); };
+
+struct returns_void { void operator BOOST_TT_TRAIT_OP (int); };
+
+struct returns_void_star { void *operator BOOST_TT_TRAIT_OP (int); };
+
+struct returns_double { double operator BOOST_TT_TRAIT_OP (int); };
+
+struct ret1 { };
+struct convertible_to_ret1 { operator ret1 () const; };
+struct returns_convertible_to_ret1 { convertible_to_ret1 operator BOOST_TT_TRAIT_OP (int); };
+
+struct convertible_to_ret2 { };
+struct ret2 { ret2(const convertible_to_ret2); };
+struct returns_convertible_to_ret2 { convertible_to_ret2 operator BOOST_TT_TRAIT_OP (int); };
+
+class Base1 { };
+class Derived1 : public Base1 { };
+
+bool operator BOOST_TT_TRAIT_OP (const Base1&, int) { 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&, int) { return true; }
+
+struct tag { };
+
+//class internal_private { ret operator BOOST_TT_TRAIT_OP (int) const; };
+
+void run1() {
+   TEST_T(void, false);
+   TEST_TR(void, void, false);
+   TEST_TR(void, int, false);
+
+   TEST_T(without, false);
+   TEST_T(internal, true);
+   TEST_T(external, true);
+   TEST_T(internal_comma1, true);
+   TEST_T(external_comma1, true);
+   TEST_T(internal_comma2, true);
+   TEST_T(external_comma2, true);
+   TEST_T(returns_int, true);
+   TEST_T(returns_void, true);
+   TEST_T(returns_void_star, true);
+   TEST_T(returns_double, true);
+   TEST_T(returns_convertible_to_ret1, true);
+   TEST_T(returns_convertible_to_ret2, true);
+   TEST_T(Base1, true);
+   TEST_T(Derived1, true);
+   TEST_T(Base2, false);
+   TEST_T(Derived2, true);
+
+   TEST_TR(without, void, false);
+   TEST_TR(without, bool, false);
+   TEST_TR(internal, void, false);
+   TEST_TR(internal, bool, false);
+   TEST_TR(internal, ret, true);
+   TEST_TR(internal_comma1, void, false);
+   TEST_TR(internal_comma1, bool, false);
+   TEST_TR(internal_comma1, ret_with_comma1, true);
+   TEST_TR(internal_comma2, void, false);
+   TEST_TR(internal_comma2, bool, false);
+   TEST_TR(internal_comma2, ret_with_comma2, true);
+   TEST_TR(external, void, false);
+   TEST_TR(external, bool, false);
+   TEST_TR(external, ret, true);
+   TEST_TR(returns_int, void, false);
+   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, void, false);
+   TEST_TR(returns_double, bool, true);
+   TEST_TR(returns_double, double, true);
+   TEST_TR(returns_convertible_to_ret1, void, false);
+   TEST_TR(returns_convertible_to_ret1, ret1, true);
+   TEST_TR(returns_convertible_to_ret2, ret2, true);
+   TEST_TR(Base1, bool, true);
+   TEST_TR(Derived1, bool, true);
+   TEST_TR(Base2, bool, false);
+   TEST_TR(Derived2, bool, true);
+// compile time error
+// TEST_T(internal_private, false);
+}
+
+}

Added: sandbox/type_traits/libs/type_traits/test/can_call_pre_decrement_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_pre_decrement_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,33 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_pre_decrement.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_pre_decrement
+#define BOOST_TT_TRAIT_OP --
+
+#include "can_call_prefix_operators.hpp"
+#include "can_call_pre_decrement_test.hpp"
+
+namespace {
+void specific() {
+   /* nothing specific */
+}
+}
+
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_pre_decrement_test.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_pre_decrement_test.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,97 @@
+//  (C) Copyright Frederic Bron 2009-2011.
+//  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)
+
+namespace {
+
+void run2() {
+   // test with only one template parameter
+   TEST_T(void, false);
+   TEST_T(bool, false);
+   TEST_T(char, true);
+   TEST_T(signed char, true);
+   TEST_T(short int, true);
+   TEST_T(int, true);
+   TEST_T(long int, true);
+   TEST_T(unsigned char, true);
+   TEST_T(unsigned short int, true);
+   TEST_T(unsigned int, true);
+   TEST_T(unsigned long int, true);
+   TEST_T(wchar_t, true);
+   TEST_T(float, true);
+   TEST_T(double, true);
+   TEST_T(long double, true);
+   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), true);
+   TEST_T(CV(double), true);
+#	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), true);
+   TEST_T(CV(double), true);
+#	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, true);
+   TEST_TR(signed char, bool, true);
+   TEST_TR(short int, bool, true);
+   TEST_TR(int, bool, true);
+   TEST_TR(long int, bool, true);
+   TEST_TR(unsigned char, bool, true);
+   TEST_TR(unsigned short int, bool, true);
+   TEST_TR(unsigned int, bool, true);
+   TEST_TR(unsigned long int, bool, true);
+   TEST_TR(wchar_t, bool, true);
+   TEST_TR(float, bool, true);
+   TEST_TR(double, bool, true);
+   TEST_TR(long double, bool, true);
+   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);
+
+   // 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);
+}
+}

Added: sandbox/type_traits/libs/type_traits/test/can_call_pre_increment_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_pre_increment_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,33 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_pre_increment.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_pre_increment
+#define BOOST_TT_TRAIT_OP ++
+
+#include "can_call_prefix_operators.hpp"
+#include "can_call_pre_increment_test.hpp"
+
+namespace {
+void specific() {
+   /* nothing specific */
+}
+}
+
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_pre_increment_test.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_pre_increment_test.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,97 @@
+//  (C) Copyright Frederic Bron 2009-2011.
+//  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)
+
+namespace {
+
+void run2() {
+   // test with only one template parameter
+   TEST_T(void, false);
+   TEST_T(bool, true);
+   TEST_T(char, true);
+   TEST_T(signed char, true);
+   TEST_T(short int, true);
+   TEST_T(int, true);
+   TEST_T(long int, true);
+   TEST_T(unsigned char, true);
+   TEST_T(unsigned short int, true);
+   TEST_T(unsigned int, true);
+   TEST_T(unsigned long int, true);
+   TEST_T(wchar_t, true);
+   TEST_T(float, true);
+   TEST_T(double, true);
+   TEST_T(long double, true);
+   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), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	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), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	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, true);
+   TEST_TR(char, bool, true);
+   TEST_TR(signed char, bool, true);
+   TEST_TR(short int, bool, true);
+   TEST_TR(int, bool, true);
+   TEST_TR(long int, bool, true);
+   TEST_TR(unsigned char, bool, true);
+   TEST_TR(unsigned short int, bool, true);
+   TEST_TR(unsigned int, bool, true);
+   TEST_TR(unsigned long int, bool, true);
+   TEST_TR(wchar_t, bool, true);
+   TEST_TR(float, bool, true);
+   TEST_TR(double, bool, true);
+   TEST_TR(long double, bool, true);
+   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);
+
+   // 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);
+}
+}

Added: sandbox/type_traits/libs/type_traits/test/can_call_prefix_operators.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_prefix_operators.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,123 @@
+//  (C) Copyright Frederic Bron 2009-2011.
+//  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)
+
+// 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 without { };
+
+struct ret { };
+
+struct internal { ret operator BOOST_TT_TRAIT_OP () const; };
+
+struct external { };
+ret operator BOOST_TT_TRAIT_OP (const external&);
+
+struct comma1_ret { };
+struct ret_with_comma1 { comma1_ret operator,(int); };
+
+struct internal_comma1 { ret_with_comma1 operator BOOST_TT_TRAIT_OP () const; };
+
+struct external_comma1 { };
+ret_with_comma1 operator BOOST_TT_TRAIT_OP (const external_comma1&);
+
+struct ret_with_comma2 { void operator,(int); };
+
+struct internal_comma2 { ret_with_comma2 operator BOOST_TT_TRAIT_OP () const; };
+
+struct external_comma2 { };
+ret_with_comma2 operator BOOST_TT_TRAIT_OP (const external_comma2&);
+
+struct returns_int { int operator BOOST_TT_TRAIT_OP (); };
+
+struct returns_void { void operator BOOST_TT_TRAIT_OP (); };
+
+struct returns_void_star { void *operator BOOST_TT_TRAIT_OP (); };
+
+struct returns_double { double operator BOOST_TT_TRAIT_OP (); };
+
+struct ret1 { };
+struct convertible_to_ret1 { operator ret1 () const; };
+struct returns_convertible_to_ret1 { convertible_to_ret1 operator BOOST_TT_TRAIT_OP (); };
+
+struct convertible_to_ret2 { };
+struct ret2 { ret2(const convertible_to_ret2); };
+struct returns_convertible_to_ret2 { convertible_to_ret2 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 { };
+
+//class internal_private { ret operator BOOST_TT_TRAIT_OP () const; };
+
+void run1() {
+   TEST_T(void, false);
+   TEST_TR(void, void, false);
+   TEST_TR(void, int, false);
+
+   TEST_T(without, false);
+   TEST_T(internal, true);
+   TEST_T(external, true);
+   TEST_T(internal_comma1, true);
+   TEST_T(external_comma1, true);
+   TEST_T(internal_comma2, true);
+   TEST_T(external_comma2, true);
+   TEST_T(returns_int, true);
+   TEST_T(returns_void, true);
+   TEST_T(returns_void_star, true);
+   TEST_T(returns_double, true);
+   TEST_T(returns_convertible_to_ret1, true);
+   TEST_T(returns_convertible_to_ret2, true);
+   TEST_T(Base1, true);
+   TEST_T(Derived1, true);
+   TEST_T(Base2, false);
+   TEST_T(Derived2, true);
+
+   TEST_TR(without, void, false);
+   TEST_TR(without, bool, false);
+   TEST_TR(internal_comma1, void, false);
+   TEST_TR(internal_comma1, bool, false);
+   TEST_TR(internal_comma1, ret_with_comma1, true);
+   TEST_TR(internal_comma2, void, false);
+   TEST_TR(internal_comma2, bool, false);
+   TEST_TR(internal_comma2, ret_with_comma2, true);
+   TEST_TR(external, void, false);
+   TEST_TR(external, bool, false);
+   TEST_TR(external, ret, true);
+   TEST_TR(returns_int, void, false);
+   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, void, false);
+   TEST_TR(returns_double, bool, true);
+   TEST_TR(returns_double, double, true);
+   TEST_TR(returns_convertible_to_ret1, void, false);
+   TEST_TR(returns_convertible_to_ret1, ret1, true);
+   TEST_TR(returns_convertible_to_ret2, ret2, true);
+   TEST_TR(Base1, bool, true);
+   TEST_TR(Derived1, bool, true);
+   TEST_TR(Base2, bool, false);
+   TEST_TR(Derived2, bool, true);
+// compile time error
+// TEST_T(internal_private, false);
+}
+
+}

Added: sandbox/type_traits/libs/type_traits/test/can_call_right_shift_assignment_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_right_shift_assignment_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,33 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_right_shift_assignment.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_right_shift_assignment
+#define BOOST_TT_TRAIT_OP >>=
+
+#include "can_call_binary_operators.hpp"
+#include "can_call_integral_no_constlhs_test.hpp"
+
+namespace {
+void specific() {
+   /* nothing specific */
+}
+}
+
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_right_shift_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_right_shift_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,53 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_right_shift.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_right_shift
+#define BOOST_TT_TRAIT_OP >>
+
+#include "can_call_binary_operators.hpp"
+#include "can_call_integral_test.hpp"
+
+#include <istream>
+#include <string>
+
+#define TEST_SPECIFIC(T) TEST_TTR(std::istream&, T, std::istream&, true)
+namespace {
+
+void specific() {
+   TEST_SPECIFIC(bool&);
+   TEST_SPECIFIC(short&);
+   TEST_SPECIFIC(unsigned short&);
+   TEST_SPECIFIC(int&);
+   TEST_SPECIFIC(unsigned int&);
+   TEST_SPECIFIC(long&);
+   TEST_SPECIFIC(unsigned long&);
+   TEST_SPECIFIC(float&);
+   TEST_SPECIFIC(double&);
+   TEST_SPECIFIC(void*&);
+   TEST_SPECIFIC(char&);
+   TEST_SPECIFIC(signed char&);
+   TEST_SPECIFIC(unsigned char&);
+   TEST_SPECIFIC(char*);
+   TEST_SPECIFIC(signed char*);
+   TEST_SPECIFIC(unsigned char*);
+   TEST_SPECIFIC(std::string&);
+}
+}
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_subtraction_assignment_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_subtraction_assignment_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,33 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_subtraction_assignment.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_subtraction_assignment
+#define BOOST_TT_TRAIT_OP -=
+
+#include "can_call_binary_operators.hpp"
+#include "can_call_subtraction_assignment_test.hpp"
+
+namespace {
+void specific() {
+   /* nothing specific */
+}
+}
+
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_subtraction_assignment_test.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_subtraction_assignment_test.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,1250 @@
+//  (C) Copyright Frederic Bron 2009-2011.
+//  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)
+
+namespace {
+
+void run2() {
+   // test with only one template parameter
+   TEST_T(void, false);
+   TEST_T(bool, true);
+   TEST_T(char, true);
+   TEST_T(signed char, true);
+   TEST_T(short int, true);
+   TEST_T(int, true);
+   TEST_T(long int, true);
+   TEST_T(unsigned char, true);
+   TEST_T(unsigned short int, true);
+   TEST_T(unsigned int, true);
+   TEST_T(unsigned long int, true);
+   TEST_T(wchar_t, true);
+   TEST_T(float, true);
+   TEST_T(double, true);
+   TEST_T(long double, true);
+   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), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	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), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	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 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);
+   TEST_TT(bool, short int, true);
+   TEST_TT(bool, int, true);
+   TEST_TT(bool, long int, true);
+   TEST_TT(bool, unsigned char, true);
+   TEST_TT(bool, unsigned short int, true);
+   TEST_TT(bool, unsigned int, true);
+   TEST_TT(bool, unsigned long int, true);
+   TEST_TT(bool, wchar_t, true);
+   TEST_TT(bool, float, true);
+   TEST_TT(bool, double, true);
+   TEST_TT(bool, long double, true);
+   TEST_TT(char, bool, true);
+   TEST_TT(char, char, true);
+   TEST_TT(char, signed char, true);
+   TEST_TT(char, short int, true);
+   TEST_TT(char, int, true);
+   TEST_TT(char, long int, true);
+   TEST_TT(char, unsigned char, true);
+   TEST_TT(char, unsigned short int, true);
+   TEST_TT(char, unsigned int, true);
+   TEST_TT(char, unsigned long int, true);
+   TEST_TT(char, wchar_t, true);
+   TEST_TT(char, float, true);
+   TEST_TT(char, double, true);
+   TEST_TT(char, long double, true);
+   TEST_TT(signed char, bool, true);
+   TEST_TT(signed char, char, true);
+   TEST_TT(signed char, signed char, true);
+   TEST_TT(signed char, short int, true);
+   TEST_TT(signed char, int, true);
+   TEST_TT(signed char, long int, true);
+   TEST_TT(signed char, unsigned char, true);
+   TEST_TT(signed char, unsigned short int, true);
+   TEST_TT(signed char, unsigned int, true);
+   TEST_TT(signed char, unsigned long int, true);
+   TEST_TT(signed char, wchar_t, true);
+   TEST_TT(signed char, float, true);
+   TEST_TT(signed char, double, true);
+   TEST_TT(signed char, long double, true);
+   TEST_TT(short int, bool, true);
+   TEST_TT(short int, char, true);
+   TEST_TT(short int, signed char, true);
+   TEST_TT(short int, short int, true);
+   TEST_TT(short int, int, true);
+   TEST_TT(short int, long int, true);
+   TEST_TT(short int, unsigned char, true);
+   TEST_TT(short int, unsigned short int, true);
+   TEST_TT(short int, unsigned int, true);
+   TEST_TT(short int, unsigned long int, true);
+   TEST_TT(short int, wchar_t, true);
+   TEST_TT(short int, float, true);
+   TEST_TT(short int, double, true);
+   TEST_TT(short int, long double, true);
+   TEST_TT(int, bool, true);
+   TEST_TT(int, char, true);
+   TEST_TT(int, signed char, true);
+   TEST_TT(int, short int, true);
+   TEST_TT(int, int, true);
+   TEST_TT(int, long int, true);
+   TEST_TT(int, unsigned char, true);
+   TEST_TT(int, unsigned short int, true);
+   TEST_TT(int, unsigned int, true);
+   TEST_TT(int, unsigned long int, true);
+   TEST_TT(int, wchar_t, true);
+   TEST_TT(int, float, true);
+   TEST_TT(int, double, true);
+   TEST_TT(int, long double, true);
+   TEST_TT(long int, bool, true);
+   TEST_TT(long int, char, true);
+   TEST_TT(long int, signed char, true);
+   TEST_TT(long int, short int, true);
+   TEST_TT(long int, int, true);
+   TEST_TT(long int, long int, true);
+   TEST_TT(long int, unsigned char, true);
+   TEST_TT(long int, unsigned short int, true);
+   TEST_TT(long int, unsigned int, true);
+   TEST_TT(long int, unsigned long int, true);
+   TEST_TT(long int, wchar_t, true);
+   TEST_TT(long int, float, true);
+   TEST_TT(long int, double, true);
+   TEST_TT(long int, long double, true);
+   TEST_TT(unsigned char, bool, true);
+   TEST_TT(unsigned char, char, true);
+   TEST_TT(unsigned char, signed char, true);
+   TEST_TT(unsigned char, short int, true);
+   TEST_TT(unsigned char, int, true);
+   TEST_TT(unsigned char, long int, true);
+   TEST_TT(unsigned char, unsigned char, true);
+   TEST_TT(unsigned char, unsigned short int, true);
+   TEST_TT(unsigned char, unsigned int, true);
+   TEST_TT(unsigned char, unsigned long int, true);
+   TEST_TT(unsigned char, wchar_t, true);
+   TEST_TT(unsigned char, float, true);
+   TEST_TT(unsigned char, double, true);
+   TEST_TT(unsigned char, long double, true);
+   TEST_TT(unsigned short int, bool, true);
+   TEST_TT(unsigned short int, char, true);
+   TEST_TT(unsigned short int, signed char, true);
+   TEST_TT(unsigned short int, short int, true);
+   TEST_TT(unsigned short int, int, true);
+   TEST_TT(unsigned short int, long int, true);
+   TEST_TT(unsigned short int, unsigned char, true);
+   TEST_TT(unsigned short int, unsigned short int, true);
+   TEST_TT(unsigned short int, unsigned int, true);
+   TEST_TT(unsigned short int, unsigned long int, true);
+   TEST_TT(unsigned short int, wchar_t, true);
+   TEST_TT(unsigned short int, float, true);
+   TEST_TT(unsigned short int, double, true);
+   TEST_TT(unsigned short int, long double, true);
+   TEST_TT(unsigned int, bool, true);
+   TEST_TT(unsigned int, char, true);
+   TEST_TT(unsigned int, signed char, true);
+   TEST_TT(unsigned int, short int, true);
+   TEST_TT(unsigned int, int, true);
+   TEST_TT(unsigned int, long int, true);
+   TEST_TT(unsigned int, unsigned char, true);
+   TEST_TT(unsigned int, unsigned short int, true);
+   TEST_TT(unsigned int, unsigned int, true);
+   TEST_TT(unsigned int, unsigned long int, true);
+   TEST_TT(unsigned int, wchar_t, true);
+   TEST_TT(unsigned int, float, true);
+   TEST_TT(unsigned int, double, true);
+   TEST_TT(unsigned int, long double, true);
+   TEST_TT(unsigned long int, bool, true);
+   TEST_TT(unsigned long int, char, true);
+   TEST_TT(unsigned long int, signed char, true);
+   TEST_TT(unsigned long int, short int, true);
+   TEST_TT(unsigned long int, int, true);
+   TEST_TT(unsigned long int, long int, true);
+   TEST_TT(unsigned long int, unsigned char, true);
+   TEST_TT(unsigned long int, unsigned short int, true);
+   TEST_TT(unsigned long int, unsigned int, true);
+   TEST_TT(unsigned long int, unsigned long int, true);
+   TEST_TT(unsigned long int, wchar_t, true);
+   TEST_TT(unsigned long int, float, true);
+   TEST_TT(unsigned long int, double, true);
+   TEST_TT(unsigned long int, long double, true);
+   TEST_TT(wchar_t, bool, true);
+   TEST_TT(wchar_t, char, true);
+   TEST_TT(wchar_t, signed char, true);
+   TEST_TT(wchar_t, short int, true);
+   TEST_TT(wchar_t, int, true);
+   TEST_TT(wchar_t, long int, true);
+   TEST_TT(wchar_t, unsigned char, true);
+   TEST_TT(wchar_t, unsigned short int, true);
+   TEST_TT(wchar_t, unsigned int, true);
+   TEST_TT(wchar_t, unsigned long int, true);
+   TEST_TT(wchar_t, wchar_t, true);
+   TEST_TT(wchar_t, float, true);
+   TEST_TT(wchar_t, double, true);
+   TEST_TT(wchar_t, long double, true);
+   TEST_TT(float, bool, true);
+   TEST_TT(float, char, true);
+   TEST_TT(float, signed char, true);
+   TEST_TT(float, short int, true);
+   TEST_TT(float, int, true);
+   TEST_TT(float, long int, true);
+   TEST_TT(float, unsigned char, true);
+   TEST_TT(float, unsigned short int, true);
+   TEST_TT(float, unsigned int, true);
+   TEST_TT(float, unsigned long int, true);
+   TEST_TT(float, wchar_t, true);
+   TEST_TT(float, float, true);
+   TEST_TT(float, double, true);
+   TEST_TT(float, long double, true);
+   TEST_TT(double, bool, true);
+   TEST_TT(double, char, true);
+   TEST_TT(double, signed char, true);
+   TEST_TT(double, short int, true);
+   TEST_TT(double, int, true);
+   TEST_TT(double, long int, true);
+   TEST_TT(double, unsigned char, true);
+   TEST_TT(double, unsigned short int, true);
+   TEST_TT(double, unsigned int, true);
+   TEST_TT(double, unsigned long int, true);
+   TEST_TT(double, wchar_t, true);
+   TEST_TT(double, float, true);
+   TEST_TT(double, double, true);
+   TEST_TT(double, long double, true);
+   TEST_TT(long double, bool, true);
+   TEST_TT(long double, char, true);
+   TEST_TT(long double, signed char, true);
+   TEST_TT(long double, short int, true);
+   TEST_TT(long double, int, true);
+   TEST_TT(long double, long int, true);
+   TEST_TT(long double, unsigned char, true);
+   TEST_TT(long double, unsigned short int, true);
+   TEST_TT(long double, unsigned int, true);
+   TEST_TT(long double, unsigned long int, true);
+   TEST_TT(long double, wchar_t, true);
+   TEST_TT(long double, float, true);
+   TEST_TT(long double, double, true);
+   TEST_TT(long double, long double, true);
+   TEST_TT(bool, void, false);
+   TEST_TT(void, bool, false);
+   TEST_TT(char, void, false);
+   TEST_TT(void, char, false);
+   TEST_TT(signed char, void, false);
+   TEST_TT(void, signed char, false);
+   TEST_TT(short int, void, false);
+   TEST_TT(void, short int, false);
+   TEST_TT(int, void, false);
+   TEST_TT(void, int, false);
+   TEST_TT(long int, void, false);
+   TEST_TT(void, long int, false);
+   TEST_TT(unsigned char, void, false);
+   TEST_TT(void, unsigned char, false);
+   TEST_TT(unsigned short int, void, false);
+   TEST_TT(void, unsigned short int, false);
+   TEST_TT(unsigned int, void, false);
+   TEST_TT(void, unsigned int, false);
+   TEST_TT(unsigned long int, void, false);
+   TEST_TT(void, unsigned long int, false);
+   TEST_TT(wchar_t, void, false);
+   TEST_TT(void, wchar_t, false);
+   TEST_TT(float, void, false);
+   TEST_TT(void, float, false);
+   TEST_TT(double, void, false);
+   TEST_TT(void, double, false);
+   TEST_TT(long double, void, false);
+   TEST_TT(void, long double, false);
+
+// test with three template parameters
+   TEST_TTR(bool, bool, bool, true);
+   TEST_TTR(bool, char, bool, true);
+   TEST_TTR(bool, signed char, bool, true);
+   TEST_TTR(bool, short int, bool, true);
+   TEST_TTR(bool, int, bool, true);
+   TEST_TTR(bool, long int, bool, true);
+   TEST_TTR(bool, unsigned char, bool, true);
+   TEST_TTR(bool, unsigned short int, bool, true);
+   TEST_TTR(bool, unsigned int, bool, true);
+   TEST_TTR(bool, unsigned long int, bool, true);
+   TEST_TTR(bool, wchar_t, bool, true);
+   TEST_TTR(bool, float, bool, true);
+   TEST_TTR(bool, double, bool, true);
+   TEST_TTR(bool, long double, bool, true);
+   TEST_TTR(char, bool, bool, true);
+   TEST_TTR(char, char, bool, true);
+   TEST_TTR(char, signed char, bool, true);
+   TEST_TTR(char, short int, bool, true);
+   TEST_TTR(char, int, bool, true);
+   TEST_TTR(char, long int, bool, true);
+   TEST_TTR(char, unsigned char, bool, true);
+   TEST_TTR(char, unsigned short int, bool, true);
+   TEST_TTR(char, unsigned int, bool, true);
+   TEST_TTR(char, unsigned long int, bool, true);
+   TEST_TTR(char, wchar_t, bool, true);
+   TEST_TTR(char, float, bool, true);
+   TEST_TTR(char, double, bool, true);
+   TEST_TTR(char, long double, bool, true);
+   TEST_TTR(signed char, bool, bool, true);
+   TEST_TTR(signed char, char, bool, true);
+   TEST_TTR(signed char, signed char, bool, true);
+   TEST_TTR(signed char, short int, bool, true);
+   TEST_TTR(signed char, int, bool, true);
+   TEST_TTR(signed char, long int, bool, true);
+   TEST_TTR(signed char, unsigned char, bool, true);
+   TEST_TTR(signed char, unsigned short int, bool, true);
+   TEST_TTR(signed char, unsigned int, bool, true);
+   TEST_TTR(signed char, unsigned long int, bool, true);
+   TEST_TTR(signed char, wchar_t, bool, true);
+   TEST_TTR(signed char, float, bool, true);
+   TEST_TTR(signed char, double, bool, true);
+   TEST_TTR(signed char, long double, bool, true);
+   TEST_TTR(short int, bool, bool, true);
+   TEST_TTR(short int, char, bool, true);
+   TEST_TTR(short int, signed char, bool, true);
+   TEST_TTR(short int, short int, bool, true);
+   TEST_TTR(short int, int, bool, true);
+   TEST_TTR(short int, long int, bool, true);
+   TEST_TTR(short int, unsigned char, bool, true);
+   TEST_TTR(short int, unsigned short int, bool, true);
+   TEST_TTR(short int, unsigned int, bool, true);
+   TEST_TTR(short int, unsigned long int, bool, true);
+   TEST_TTR(short int, wchar_t, bool, true);
+   TEST_TTR(short int, float, bool, true);
+   TEST_TTR(short int, double, bool, true);
+   TEST_TTR(short int, long double, bool, true);
+   TEST_TTR(int, bool, bool, true);
+   TEST_TTR(int, char, bool, true);
+   TEST_TTR(int, signed char, bool, true);
+   TEST_TTR(int, short int, bool, true);
+   TEST_TTR(int, int, bool, true);
+   TEST_TTR(int, long int, bool, true);
+   TEST_TTR(int, unsigned char, bool, true);
+   TEST_TTR(int, unsigned short int, bool, true);
+   TEST_TTR(int, unsigned int, bool, true);
+   TEST_TTR(int, unsigned long int, bool, true);
+   TEST_TTR(int, wchar_t, bool, true);
+   TEST_TTR(int, float, bool, true);
+   TEST_TTR(int, double, bool, true);
+   TEST_TTR(int, long double, bool, true);
+   TEST_TTR(long int, bool, bool, true);
+   TEST_TTR(long int, char, bool, true);
+   TEST_TTR(long int, signed char, bool, true);
+   TEST_TTR(long int, short int, bool, true);
+   TEST_TTR(long int, int, bool, true);
+   TEST_TTR(long int, long int, bool, true);
+   TEST_TTR(long int, unsigned char, bool, true);
+   TEST_TTR(long int, unsigned short int, bool, true);
+   TEST_TTR(long int, unsigned int, bool, true);
+   TEST_TTR(long int, unsigned long int, bool, true);
+   TEST_TTR(long int, wchar_t, bool, true);
+   TEST_TTR(long int, float, bool, true);
+   TEST_TTR(long int, double, bool, true);
+   TEST_TTR(long int, long double, bool, true);
+   TEST_TTR(unsigned char, bool, bool, true);
+   TEST_TTR(unsigned char, char, bool, true);
+   TEST_TTR(unsigned char, signed char, bool, true);
+   TEST_TTR(unsigned char, short int, bool, true);
+   TEST_TTR(unsigned char, int, bool, true);
+   TEST_TTR(unsigned char, long int, bool, true);
+   TEST_TTR(unsigned char, unsigned char, bool, true);
+   TEST_TTR(unsigned char, unsigned short int, bool, true);
+   TEST_TTR(unsigned char, unsigned int, bool, true);
+   TEST_TTR(unsigned char, unsigned long int, bool, true);
+   TEST_TTR(unsigned char, wchar_t, bool, true);
+   TEST_TTR(unsigned char, float, bool, true);
+   TEST_TTR(unsigned char, double, bool, true);
+   TEST_TTR(unsigned char, long double, bool, true);
+   TEST_TTR(unsigned short int, bool, bool, true);
+   TEST_TTR(unsigned short int, char, bool, true);
+   TEST_TTR(unsigned short int, signed char, bool, true);
+   TEST_TTR(unsigned short int, short int, bool, true);
+   TEST_TTR(unsigned short int, int, bool, true);
+   TEST_TTR(unsigned short int, long int, bool, true);
+   TEST_TTR(unsigned short int, unsigned char, bool, true);
+   TEST_TTR(unsigned short int, unsigned short int, bool, true);
+   TEST_TTR(unsigned short int, unsigned int, bool, true);
+   TEST_TTR(unsigned short int, unsigned long int, bool, true);
+   TEST_TTR(unsigned short int, wchar_t, bool, true);
+   TEST_TTR(unsigned short int, float, bool, true);
+   TEST_TTR(unsigned short int, double, bool, true);
+   TEST_TTR(unsigned short int, long double, bool, true);
+   TEST_TTR(unsigned int, bool, bool, true);
+   TEST_TTR(unsigned int, char, bool, true);
+   TEST_TTR(unsigned int, signed char, bool, true);
+   TEST_TTR(unsigned int, short int, bool, true);
+   TEST_TTR(unsigned int, int, bool, true);
+   TEST_TTR(unsigned int, long int, bool, true);
+   TEST_TTR(unsigned int, unsigned char, bool, true);
+   TEST_TTR(unsigned int, unsigned short int, bool, true);
+   TEST_TTR(unsigned int, unsigned int, bool, true);
+   TEST_TTR(unsigned int, unsigned long int, bool, true);
+   TEST_TTR(unsigned int, wchar_t, bool, true);
+   TEST_TTR(unsigned int, float, bool, true);
+   TEST_TTR(unsigned int, double, bool, true);
+   TEST_TTR(unsigned int, long double, bool, true);
+   TEST_TTR(unsigned long int, bool, bool, true);
+   TEST_TTR(unsigned long int, char, bool, true);
+   TEST_TTR(unsigned long int, signed char, bool, true);
+   TEST_TTR(unsigned long int, short int, bool, true);
+   TEST_TTR(unsigned long int, int, bool, true);
+   TEST_TTR(unsigned long int, long int, bool, true);
+   TEST_TTR(unsigned long int, unsigned char, bool, true);
+   TEST_TTR(unsigned long int, unsigned short int, bool, true);
+   TEST_TTR(unsigned long int, unsigned int, bool, true);
+   TEST_TTR(unsigned long int, unsigned long int, bool, true);
+   TEST_TTR(unsigned long int, wchar_t, bool, true);
+   TEST_TTR(unsigned long int, float, bool, true);
+   TEST_TTR(unsigned long int, double, bool, true);
+   TEST_TTR(unsigned long int, long double, bool, true);
+   TEST_TTR(wchar_t, bool, bool, true);
+   TEST_TTR(wchar_t, char, bool, true);
+   TEST_TTR(wchar_t, signed char, bool, true);
+   TEST_TTR(wchar_t, short int, bool, true);
+   TEST_TTR(wchar_t, int, bool, true);
+   TEST_TTR(wchar_t, long int, bool, true);
+   TEST_TTR(wchar_t, unsigned char, bool, true);
+   TEST_TTR(wchar_t, unsigned short int, bool, true);
+   TEST_TTR(wchar_t, unsigned int, bool, true);
+   TEST_TTR(wchar_t, unsigned long int, bool, true);
+   TEST_TTR(wchar_t, wchar_t, bool, true);
+   TEST_TTR(wchar_t, float, bool, true);
+   TEST_TTR(wchar_t, double, bool, true);
+   TEST_TTR(wchar_t, long double, bool, true);
+   TEST_TTR(float, bool, bool, true);
+   TEST_TTR(float, char, bool, true);
+   TEST_TTR(float, signed char, bool, true);
+   TEST_TTR(float, short int, bool, true);
+   TEST_TTR(float, int, bool, true);
+   TEST_TTR(float, long int, bool, true);
+   TEST_TTR(float, unsigned char, bool, true);
+   TEST_TTR(float, unsigned short int, bool, true);
+   TEST_TTR(float, unsigned int, bool, true);
+   TEST_TTR(float, unsigned long int, bool, true);
+   TEST_TTR(float, wchar_t, bool, true);
+   TEST_TTR(float, float, bool, true);
+   TEST_TTR(float, double, bool, true);
+   TEST_TTR(float, long double, bool, true);
+   TEST_TTR(double, bool, bool, true);
+   TEST_TTR(double, char, bool, true);
+   TEST_TTR(double, signed char, bool, true);
+   TEST_TTR(double, short int, bool, true);
+   TEST_TTR(double, int, bool, true);
+   TEST_TTR(double, long int, bool, true);
+   TEST_TTR(double, unsigned char, bool, true);
+   TEST_TTR(double, unsigned short int, bool, true);
+   TEST_TTR(double, unsigned int, bool, true);
+   TEST_TTR(double, unsigned long int, bool, true);
+   TEST_TTR(double, wchar_t, bool, true);
+   TEST_TTR(double, float, bool, true);
+   TEST_TTR(double, double, bool, true);
+   TEST_TTR(double, long double, bool, true);
+   TEST_TTR(long double, bool, bool, true);
+   TEST_TTR(long double, char, bool, true);
+   TEST_TTR(long double, signed char, bool, true);
+   TEST_TTR(long double, short int, bool, true);
+   TEST_TTR(long double, int, bool, true);
+   TEST_TTR(long double, long int, bool, true);
+   TEST_TTR(long double, unsigned char, bool, true);
+   TEST_TTR(long double, unsigned short int, bool, true);
+   TEST_TTR(long double, unsigned int, bool, true);
+   TEST_TTR(long double, unsigned long int, bool, true);
+   TEST_TTR(long double, wchar_t, bool, true);
+   TEST_TTR(long double, float, bool, true);
+   TEST_TTR(long double, double, bool, true);
+   TEST_TTR(long double, long double, bool, true);
+   TEST_TTR(bool, bool, tag, false);
+   TEST_TTR(bool, char, tag, false);
+   TEST_TTR(bool, signed char, tag, false);
+   TEST_TTR(bool, short int, tag, false);
+   TEST_TTR(bool, int, tag, false);
+   TEST_TTR(bool, long int, tag, false);
+   TEST_TTR(bool, unsigned char, tag, false);
+   TEST_TTR(bool, unsigned short int, tag, false);
+   TEST_TTR(bool, unsigned int, tag, false);
+   TEST_TTR(bool, unsigned long int, tag, false);
+   TEST_TTR(bool, wchar_t, tag, false);
+   TEST_TTR(bool, float, tag, false);
+   TEST_TTR(bool, double, tag, false);
+   TEST_TTR(bool, long double, tag, false);
+   TEST_TTR(char, bool, tag, false);
+   TEST_TTR(char, char, tag, false);
+   TEST_TTR(char, signed char, tag, false);
+   TEST_TTR(char, short int, tag, false);
+   TEST_TTR(char, int, tag, false);
+   TEST_TTR(char, long int, tag, false);
+   TEST_TTR(char, unsigned char, tag, false);
+   TEST_TTR(char, unsigned short int, tag, false);
+   TEST_TTR(char, unsigned int, tag, false);
+   TEST_TTR(char, unsigned long int, tag, false);
+   TEST_TTR(char, wchar_t, tag, false);
+   TEST_TTR(char, float, tag, false);
+   TEST_TTR(char, double, tag, false);
+   TEST_TTR(char, long double, tag, false);
+   TEST_TTR(signed char, bool, tag, false);
+   TEST_TTR(signed char, char, tag, false);
+   TEST_TTR(signed char, signed char, tag, false);
+   TEST_TTR(signed char, short int, tag, false);
+   TEST_TTR(signed char, int, tag, false);
+   TEST_TTR(signed char, long int, tag, false);
+   TEST_TTR(signed char, unsigned char, tag, false);
+   TEST_TTR(signed char, unsigned short int, tag, false);
+   TEST_TTR(signed char, unsigned int, tag, false);
+   TEST_TTR(signed char, unsigned long int, tag, false);
+   TEST_TTR(signed char, wchar_t, tag, false);
+   TEST_TTR(signed char, float, tag, false);
+   TEST_TTR(signed char, double, tag, false);
+   TEST_TTR(signed char, long double, tag, false);
+   TEST_TTR(short int, bool, tag, false);
+   TEST_TTR(short int, char, tag, false);
+   TEST_TTR(short int, signed char, tag, false);
+   TEST_TTR(short int, short int, tag, false);
+   TEST_TTR(short int, int, tag, false);
+   TEST_TTR(short int, long int, tag, false);
+   TEST_TTR(short int, unsigned char, tag, false);
+   TEST_TTR(short int, unsigned short int, tag, false);
+   TEST_TTR(short int, unsigned int, tag, false);
+   TEST_TTR(short int, unsigned long int, tag, false);
+   TEST_TTR(short int, wchar_t, tag, false);
+   TEST_TTR(short int, float, tag, false);
+   TEST_TTR(short int, double, tag, false);
+   TEST_TTR(short int, long double, tag, false);
+   TEST_TTR(int, bool, tag, false);
+   TEST_TTR(int, char, tag, false);
+   TEST_TTR(int, signed char, tag, false);
+   TEST_TTR(int, short int, tag, false);
+   TEST_TTR(int, int, tag, false);
+   TEST_TTR(int, long int, tag, false);
+   TEST_TTR(int, unsigned char, tag, false);
+   TEST_TTR(int, unsigned short int, tag, false);
+   TEST_TTR(int, unsigned int, tag, false);
+   TEST_TTR(int, unsigned long int, tag, false);
+   TEST_TTR(int, wchar_t, tag, false);
+   TEST_TTR(int, float, tag, false);
+   TEST_TTR(int, double, tag, false);
+   TEST_TTR(int, long double, tag, false);
+   TEST_TTR(long int, bool, tag, false);
+   TEST_TTR(long int, char, tag, false);
+   TEST_TTR(long int, signed char, tag, false);
+   TEST_TTR(long int, short int, tag, false);
+   TEST_TTR(long int, int, tag, false);
+   TEST_TTR(long int, long int, tag, false);
+   TEST_TTR(long int, unsigned char, tag, false);
+   TEST_TTR(long int, unsigned short int, tag, false);
+   TEST_TTR(long int, unsigned int, tag, false);
+   TEST_TTR(long int, unsigned long int, tag, false);
+   TEST_TTR(long int, wchar_t, tag, false);
+   TEST_TTR(long int, float, tag, false);
+   TEST_TTR(long int, double, tag, false);
+   TEST_TTR(long int, long double, tag, false);
+   TEST_TTR(unsigned char, bool, tag, false);
+   TEST_TTR(unsigned char, char, tag, false);
+   TEST_TTR(unsigned char, signed char, tag, false);
+   TEST_TTR(unsigned char, short int, tag, false);
+   TEST_TTR(unsigned char, int, tag, false);
+   TEST_TTR(unsigned char, long int, tag, false);
+   TEST_TTR(unsigned char, unsigned char, tag, false);
+   TEST_TTR(unsigned char, unsigned short int, tag, false);
+   TEST_TTR(unsigned char, unsigned int, tag, false);
+   TEST_TTR(unsigned char, unsigned long int, tag, false);
+   TEST_TTR(unsigned char, wchar_t, tag, false);
+   TEST_TTR(unsigned char, float, tag, false);
+   TEST_TTR(unsigned char, double, tag, false);
+   TEST_TTR(unsigned char, long double, tag, false);
+   TEST_TTR(unsigned short int, bool, tag, false);
+   TEST_TTR(unsigned short int, char, tag, false);
+   TEST_TTR(unsigned short int, signed char, tag, false);
+   TEST_TTR(unsigned short int, short int, tag, false);
+   TEST_TTR(unsigned short int, int, tag, false);
+   TEST_TTR(unsigned short int, long int, tag, false);
+   TEST_TTR(unsigned short int, unsigned char, tag, false);
+   TEST_TTR(unsigned short int, unsigned short int, tag, false);
+   TEST_TTR(unsigned short int, unsigned int, tag, false);
+   TEST_TTR(unsigned short int, unsigned long int, tag, false);
+   TEST_TTR(unsigned short int, wchar_t, tag, false);
+   TEST_TTR(unsigned short int, float, tag, false);
+   TEST_TTR(unsigned short int, double, tag, false);
+   TEST_TTR(unsigned short int, long double, tag, false);
+   TEST_TTR(unsigned int, bool, tag, false);
+   TEST_TTR(unsigned int, char, tag, false);
+   TEST_TTR(unsigned int, signed char, tag, false);
+   TEST_TTR(unsigned int, short int, tag, false);
+   TEST_TTR(unsigned int, int, tag, false);
+   TEST_TTR(unsigned int, long int, tag, false);
+   TEST_TTR(unsigned int, unsigned char, tag, false);
+   TEST_TTR(unsigned int, unsigned short int, tag, false);
+   TEST_TTR(unsigned int, unsigned int, tag, false);
+   TEST_TTR(unsigned int, unsigned long int, tag, false);
+   TEST_TTR(unsigned int, wchar_t, tag, false);
+   TEST_TTR(unsigned int, float, tag, false);
+   TEST_TTR(unsigned int, double, tag, false);
+   TEST_TTR(unsigned int, long double, tag, false);
+   TEST_TTR(unsigned long int, bool, tag, false);
+   TEST_TTR(unsigned long int, char, tag, false);
+   TEST_TTR(unsigned long int, signed char, tag, false);
+   TEST_TTR(unsigned long int, short int, tag, false);
+   TEST_TTR(unsigned long int, int, tag, false);
+   TEST_TTR(unsigned long int, long int, tag, false);
+   TEST_TTR(unsigned long int, unsigned char, tag, false);
+   TEST_TTR(unsigned long int, unsigned short int, tag, false);
+   TEST_TTR(unsigned long int, unsigned int, tag, false);
+   TEST_TTR(unsigned long int, unsigned long int, tag, false);
+   TEST_TTR(unsigned long int, wchar_t, tag, false);
+   TEST_TTR(unsigned long int, float, tag, false);
+   TEST_TTR(unsigned long int, double, tag, false);
+   TEST_TTR(unsigned long int, long double, tag, false);
+   TEST_TTR(wchar_t, bool, tag, false);
+   TEST_TTR(wchar_t, char, tag, false);
+   TEST_TTR(wchar_t, signed char, tag, false);
+   TEST_TTR(wchar_t, short int, tag, false);
+   TEST_TTR(wchar_t, int, tag, false);
+   TEST_TTR(wchar_t, long int, tag, false);
+   TEST_TTR(wchar_t, unsigned char, tag, false);
+   TEST_TTR(wchar_t, unsigned short int, tag, false);
+   TEST_TTR(wchar_t, unsigned int, tag, false);
+   TEST_TTR(wchar_t, unsigned long int, tag, false);
+   TEST_TTR(wchar_t, wchar_t, tag, false);
+   TEST_TTR(wchar_t, float, tag, false);
+   TEST_TTR(wchar_t, double, tag, false);
+   TEST_TTR(wchar_t, long double, tag, false);
+   TEST_TTR(float, bool, tag, false);
+   TEST_TTR(float, char, tag, false);
+   TEST_TTR(float, signed char, tag, false);
+   TEST_TTR(float, short int, tag, false);
+   TEST_TTR(float, int, tag, false);
+   TEST_TTR(float, long int, tag, false);
+   TEST_TTR(float, unsigned char, tag, false);
+   TEST_TTR(float, unsigned short int, tag, false);
+   TEST_TTR(float, unsigned int, tag, false);
+   TEST_TTR(float, unsigned long int, tag, false);
+   TEST_TTR(float, wchar_t, tag, false);
+   TEST_TTR(float, float, tag, false);
+   TEST_TTR(float, double, tag, false);
+   TEST_TTR(float, long double, tag, false);
+   TEST_TTR(double, bool, tag, false);
+   TEST_TTR(double, char, tag, false);
+   TEST_TTR(double, signed char, tag, false);
+   TEST_TTR(double, short int, tag, false);
+   TEST_TTR(double, int, tag, false);
+   TEST_TTR(double, long int, tag, false);
+   TEST_TTR(double, unsigned char, tag, false);
+   TEST_TTR(double, unsigned short int, tag, false);
+   TEST_TTR(double, unsigned int, tag, false);
+   TEST_TTR(double, unsigned long int, tag, false);
+   TEST_TTR(double, wchar_t, tag, false);
+   TEST_TTR(double, float, tag, false);
+   TEST_TTR(double, double, tag, false);
+   TEST_TTR(double, long double, tag, false);
+   TEST_TTR(long double, bool, tag, false);
+   TEST_TTR(long double, char, tag, false);
+   TEST_TTR(long double, signed char, tag, false);
+   TEST_TTR(long double, short int, tag, false);
+   TEST_TTR(long double, int, tag, false);
+   TEST_TTR(long double, long int, tag, false);
+   TEST_TTR(long double, unsigned char, tag, false);
+   TEST_TTR(long double, unsigned short int, tag, false);
+   TEST_TTR(long double, unsigned int, tag, false);
+   TEST_TTR(long double, unsigned long int, tag, false);
+   TEST_TTR(long double, wchar_t, tag, false);
+   TEST_TTR(long double, float, tag, false);
+   TEST_TTR(long double, double, tag, false);
+   TEST_TTR(long double, long double, tag, false);
+#	undef CV1
+#	define CV1(T) const T
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), false);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), false);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, false);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), false);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), false);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, false);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const T&
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), false);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), false);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, false);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T&
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T&
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), false);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), false);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, false);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const T
+#	undef CV2
+#	define CV2(T) const T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), false);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), false);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, false);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const T&
+#	undef CV2
+#	define CV2(T) const T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), false);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), false);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, false);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T
+#	undef CV2
+#	define CV2(T) volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T&
+#	undef CV2
+#	define CV2(T) volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T
+#	undef CV2
+#	define CV2(T) const volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), false);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), false);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, false);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T&
+#	undef CV2
+#	define CV2(T) const volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), false);
+   TEST_TT(CV1(bool), CV2(double), false);
+   TEST_TT(CV1(int), CV2(bool), false);
+   TEST_TT(CV1(int), CV2(double), false);
+   TEST_TT(CV1(double), CV2(bool), false);
+   TEST_TT(CV1(double), CV2(int), false);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(double), bool, false);
+   TEST_TTR(CV1(int), CV2(bool), bool, false);
+   TEST_TTR(CV1(int), CV2(double), bool, false);
+   TEST_TTR(CV1(double), CV2(bool), bool, false);
+   TEST_TTR(CV1(double), CV2(int), bool, false);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+   // pointers
+   TEST_TT(void*, bool, false);
+   TEST_TT(void*, int, false);
+   TEST_TT(void*, double, false);
+   TEST_TT(void*, A, false);
+   TEST_TT(void*, B, false);
+   TEST_TT(bool*, bool, true);
+   TEST_TT(bool*, int, true);
+   TEST_TT(bool*, double, false);
+   TEST_TT(bool*, A, false);
+   TEST_TT(bool*, B, false);
+   TEST_TT(int*, bool, true);
+   TEST_TT(int*, int, true);
+   TEST_TT(int*, double, false);
+   TEST_TT(int*, A, false);
+   TEST_TT(int*, B, false);
+   TEST_TT(double*, bool, true);
+   TEST_TT(double*, int, true);
+   TEST_TT(double*, double, false);
+   TEST_TT(double*, A, false);
+   TEST_TT(double*, B, false);
+   TEST_TT(A*, bool, true);
+   TEST_TT(A*, int, true);
+   TEST_TT(A*, double, false);
+   TEST_TT(A*, A, false);
+   TEST_TT(A*, B, false);
+   TEST_TT(B*, bool, true);
+   TEST_TT(B*, int, true);
+   TEST_TT(B*, double, false);
+   TEST_TT(B*, A, false);
+   TEST_TT(B*, B, false);
+   TEST_TT(bool, void*, false);
+   TEST_TT(bool, bool*, false);
+   TEST_TT(bool, int*, false);
+   TEST_TT(bool, double*, false);
+   TEST_TT(bool, A*, false);
+   TEST_TT(bool, B*, false);
+   TEST_TT(int, void*, false);
+   TEST_TT(int, bool*, false);
+   TEST_TT(int, int*, false);
+   TEST_TT(int, double*, false);
+   TEST_TT(int, A*, false);
+   TEST_TT(int, B*, false);
+   TEST_TT(double, void*, false);
+   TEST_TT(double, bool*, false);
+   TEST_TT(double, int*, false);
+   TEST_TT(double, double*, false);
+   TEST_TT(double, A*, false);
+   TEST_TT(double, B*, false);
+   TEST_TT(A, void*, false);
+   TEST_TT(A, bool*, false);
+   TEST_TT(A, int*, false);
+   TEST_TT(A, double*, false);
+   TEST_TT(A, A*, false);
+   TEST_TT(A, B*, false);
+   TEST_TT(B, void*, false);
+   TEST_TT(B, bool*, false);
+   TEST_TT(B, int*, false);
+   TEST_TT(B, double*, false);
+   TEST_TT(B, A*, false);
+   TEST_TT(B, B*, false);
+   TEST_TT(void*, void*, false);
+   TEST_TT(void*, bool*, false);
+   TEST_TT(void*, int*, false);
+   TEST_TT(void*, double*, false);
+   TEST_TT(void*, A*, false);
+   TEST_TT(void*, B*, false);
+   TEST_TT(bool*, void*, false);
+   TEST_TT(bool*, bool*, false);
+   TEST_TT(bool*, int*, false);
+   TEST_TT(bool*, double*, false);
+   TEST_TT(bool*, A*, false);
+   TEST_TT(bool*, B*, false);
+   TEST_TT(int*, void*, false);
+   TEST_TT(int*, bool*, false);
+   TEST_TT(int*, int*, false);
+   TEST_TT(int*, double*, false);
+   TEST_TT(int*, A*, false);
+   TEST_TT(int*, B*, false);
+   TEST_TT(double*, void*, false);
+   TEST_TT(double*, bool*, false);
+   TEST_TT(double*, int*, false);
+   TEST_TT(double*, double*, false);
+   TEST_TT(double*, A*, false);
+   TEST_TT(double*, B*, false);
+   TEST_TT(A*, void*, false);
+   TEST_TT(A*, bool*, false);
+   TEST_TT(A*, int*, false);
+   TEST_TT(A*, double*, false);
+   TEST_TT(A*, A*, false);
+   TEST_TT(A*, B*, false);
+   TEST_TT(B*, void*, false);
+   TEST_TT(B*, bool*, false);
+   TEST_TT(B*, int*, false);
+   TEST_TT(B*, double*, false);
+   TEST_TT(B*, A*, false);
+   TEST_TT(B*, B*, false);
+   TEST_TT(C, void*, true);
+   TEST_TT(D, void*, false);
+   TEST_TT(void*, C, false);
+   TEST_TT(void*, D, true);
+   TEST_TT(C, D, true);
+}
+}

Added: sandbox/type_traits/libs/type_traits/test/can_call_subtraction_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_subtraction_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,33 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_subtraction.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_subtraction
+#define BOOST_TT_TRAIT_OP -
+
+#include "can_call_binary_operators.hpp"
+#include "can_call_subtraction_test.hpp"
+
+namespace {
+void specific() {
+   /* nothing specific */
+}
+}
+
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_subtraction_test.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_subtraction_test.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,1250 @@
+//  (C) Copyright Frederic Bron 2009-2011.
+//  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)
+
+namespace {
+
+void run2() {
+   // test with only one template parameter
+   TEST_T(void, false);
+   TEST_T(bool, true);
+   TEST_T(char, true);
+   TEST_T(signed char, true);
+   TEST_T(short int, true);
+   TEST_T(int, true);
+   TEST_T(long int, true);
+   TEST_T(unsigned char, true);
+   TEST_T(unsigned short int, true);
+   TEST_T(unsigned int, true);
+   TEST_T(unsigned long int, true);
+   TEST_T(wchar_t, true);
+   TEST_T(float, true);
+   TEST_T(double, true);
+   TEST_T(long double, true);
+   TEST_T(void, false);
+#	undef CV
+#	define CV(T) const T
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	undef CV
+#	define CV(T) volatile T
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	undef CV
+#	define CV(T) const volatile T
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	undef CV
+#	define CV(T) const T&
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	undef CV
+#	define CV(T) volatile T&
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	undef CV
+#	define CV(T) const volatile T&
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   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);
+   TEST_TT(bool, short int, true);
+   TEST_TT(bool, int, true);
+   TEST_TT(bool, long int, true);
+   TEST_TT(bool, unsigned char, true);
+   TEST_TT(bool, unsigned short int, true);
+   TEST_TT(bool, unsigned int, true);
+   TEST_TT(bool, unsigned long int, true);
+   TEST_TT(bool, wchar_t, true);
+   TEST_TT(bool, float, true);
+   TEST_TT(bool, double, true);
+   TEST_TT(bool, long double, true);
+   TEST_TT(char, bool, true);
+   TEST_TT(char, char, true);
+   TEST_TT(char, signed char, true);
+   TEST_TT(char, short int, true);
+   TEST_TT(char, int, true);
+   TEST_TT(char, long int, true);
+   TEST_TT(char, unsigned char, true);
+   TEST_TT(char, unsigned short int, true);
+   TEST_TT(char, unsigned int, true);
+   TEST_TT(char, unsigned long int, true);
+   TEST_TT(char, wchar_t, true);
+   TEST_TT(char, float, true);
+   TEST_TT(char, double, true);
+   TEST_TT(char, long double, true);
+   TEST_TT(signed char, bool, true);
+   TEST_TT(signed char, char, true);
+   TEST_TT(signed char, signed char, true);
+   TEST_TT(signed char, short int, true);
+   TEST_TT(signed char, int, true);
+   TEST_TT(signed char, long int, true);
+   TEST_TT(signed char, unsigned char, true);
+   TEST_TT(signed char, unsigned short int, true);
+   TEST_TT(signed char, unsigned int, true);
+   TEST_TT(signed char, unsigned long int, true);
+   TEST_TT(signed char, wchar_t, true);
+   TEST_TT(signed char, float, true);
+   TEST_TT(signed char, double, true);
+   TEST_TT(signed char, long double, true);
+   TEST_TT(short int, bool, true);
+   TEST_TT(short int, char, true);
+   TEST_TT(short int, signed char, true);
+   TEST_TT(short int, short int, true);
+   TEST_TT(short int, int, true);
+   TEST_TT(short int, long int, true);
+   TEST_TT(short int, unsigned char, true);
+   TEST_TT(short int, unsigned short int, true);
+   TEST_TT(short int, unsigned int, true);
+   TEST_TT(short int, unsigned long int, true);
+   TEST_TT(short int, wchar_t, true);
+   TEST_TT(short int, float, true);
+   TEST_TT(short int, double, true);
+   TEST_TT(short int, long double, true);
+   TEST_TT(int, bool, true);
+   TEST_TT(int, char, true);
+   TEST_TT(int, signed char, true);
+   TEST_TT(int, short int, true);
+   TEST_TT(int, int, true);
+   TEST_TT(int, long int, true);
+   TEST_TT(int, unsigned char, true);
+   TEST_TT(int, unsigned short int, true);
+   TEST_TT(int, unsigned int, true);
+   TEST_TT(int, unsigned long int, true);
+   TEST_TT(int, wchar_t, true);
+   TEST_TT(int, float, true);
+   TEST_TT(int, double, true);
+   TEST_TT(int, long double, true);
+   TEST_TT(long int, bool, true);
+   TEST_TT(long int, char, true);
+   TEST_TT(long int, signed char, true);
+   TEST_TT(long int, short int, true);
+   TEST_TT(long int, int, true);
+   TEST_TT(long int, long int, true);
+   TEST_TT(long int, unsigned char, true);
+   TEST_TT(long int, unsigned short int, true);
+   TEST_TT(long int, unsigned int, true);
+   TEST_TT(long int, unsigned long int, true);
+   TEST_TT(long int, wchar_t, true);
+   TEST_TT(long int, float, true);
+   TEST_TT(long int, double, true);
+   TEST_TT(long int, long double, true);
+   TEST_TT(unsigned char, bool, true);
+   TEST_TT(unsigned char, char, true);
+   TEST_TT(unsigned char, signed char, true);
+   TEST_TT(unsigned char, short int, true);
+   TEST_TT(unsigned char, int, true);
+   TEST_TT(unsigned char, long int, true);
+   TEST_TT(unsigned char, unsigned char, true);
+   TEST_TT(unsigned char, unsigned short int, true);
+   TEST_TT(unsigned char, unsigned int, true);
+   TEST_TT(unsigned char, unsigned long int, true);
+   TEST_TT(unsigned char, wchar_t, true);
+   TEST_TT(unsigned char, float, true);
+   TEST_TT(unsigned char, double, true);
+   TEST_TT(unsigned char, long double, true);
+   TEST_TT(unsigned short int, bool, true);
+   TEST_TT(unsigned short int, char, true);
+   TEST_TT(unsigned short int, signed char, true);
+   TEST_TT(unsigned short int, short int, true);
+   TEST_TT(unsigned short int, int, true);
+   TEST_TT(unsigned short int, long int, true);
+   TEST_TT(unsigned short int, unsigned char, true);
+   TEST_TT(unsigned short int, unsigned short int, true);
+   TEST_TT(unsigned short int, unsigned int, true);
+   TEST_TT(unsigned short int, unsigned long int, true);
+   TEST_TT(unsigned short int, wchar_t, true);
+   TEST_TT(unsigned short int, float, true);
+   TEST_TT(unsigned short int, double, true);
+   TEST_TT(unsigned short int, long double, true);
+   TEST_TT(unsigned int, bool, true);
+   TEST_TT(unsigned int, char, true);
+   TEST_TT(unsigned int, signed char, true);
+   TEST_TT(unsigned int, short int, true);
+   TEST_TT(unsigned int, int, true);
+   TEST_TT(unsigned int, long int, true);
+   TEST_TT(unsigned int, unsigned char, true);
+   TEST_TT(unsigned int, unsigned short int, true);
+   TEST_TT(unsigned int, unsigned int, true);
+   TEST_TT(unsigned int, unsigned long int, true);
+   TEST_TT(unsigned int, wchar_t, true);
+   TEST_TT(unsigned int, float, true);
+   TEST_TT(unsigned int, double, true);
+   TEST_TT(unsigned int, long double, true);
+   TEST_TT(unsigned long int, bool, true);
+   TEST_TT(unsigned long int, char, true);
+   TEST_TT(unsigned long int, signed char, true);
+   TEST_TT(unsigned long int, short int, true);
+   TEST_TT(unsigned long int, int, true);
+   TEST_TT(unsigned long int, long int, true);
+   TEST_TT(unsigned long int, unsigned char, true);
+   TEST_TT(unsigned long int, unsigned short int, true);
+   TEST_TT(unsigned long int, unsigned int, true);
+   TEST_TT(unsigned long int, unsigned long int, true);
+   TEST_TT(unsigned long int, wchar_t, true);
+   TEST_TT(unsigned long int, float, true);
+   TEST_TT(unsigned long int, double, true);
+   TEST_TT(unsigned long int, long double, true);
+   TEST_TT(wchar_t, bool, true);
+   TEST_TT(wchar_t, char, true);
+   TEST_TT(wchar_t, signed char, true);
+   TEST_TT(wchar_t, short int, true);
+   TEST_TT(wchar_t, int, true);
+   TEST_TT(wchar_t, long int, true);
+   TEST_TT(wchar_t, unsigned char, true);
+   TEST_TT(wchar_t, unsigned short int, true);
+   TEST_TT(wchar_t, unsigned int, true);
+   TEST_TT(wchar_t, unsigned long int, true);
+   TEST_TT(wchar_t, wchar_t, true);
+   TEST_TT(wchar_t, float, true);
+   TEST_TT(wchar_t, double, true);
+   TEST_TT(wchar_t, long double, true);
+   TEST_TT(float, bool, true);
+   TEST_TT(float, char, true);
+   TEST_TT(float, signed char, true);
+   TEST_TT(float, short int, true);
+   TEST_TT(float, int, true);
+   TEST_TT(float, long int, true);
+   TEST_TT(float, unsigned char, true);
+   TEST_TT(float, unsigned short int, true);
+   TEST_TT(float, unsigned int, true);
+   TEST_TT(float, unsigned long int, true);
+   TEST_TT(float, wchar_t, true);
+   TEST_TT(float, float, true);
+   TEST_TT(float, double, true);
+   TEST_TT(float, long double, true);
+   TEST_TT(double, bool, true);
+   TEST_TT(double, char, true);
+   TEST_TT(double, signed char, true);
+   TEST_TT(double, short int, true);
+   TEST_TT(double, int, true);
+   TEST_TT(double, long int, true);
+   TEST_TT(double, unsigned char, true);
+   TEST_TT(double, unsigned short int, true);
+   TEST_TT(double, unsigned int, true);
+   TEST_TT(double, unsigned long int, true);
+   TEST_TT(double, wchar_t, true);
+   TEST_TT(double, float, true);
+   TEST_TT(double, double, true);
+   TEST_TT(double, long double, true);
+   TEST_TT(long double, bool, true);
+   TEST_TT(long double, char, true);
+   TEST_TT(long double, signed char, true);
+   TEST_TT(long double, short int, true);
+   TEST_TT(long double, int, true);
+   TEST_TT(long double, long int, true);
+   TEST_TT(long double, unsigned char, true);
+   TEST_TT(long double, unsigned short int, true);
+   TEST_TT(long double, unsigned int, true);
+   TEST_TT(long double, unsigned long int, true);
+   TEST_TT(long double, wchar_t, true);
+   TEST_TT(long double, float, true);
+   TEST_TT(long double, double, true);
+   TEST_TT(long double, long double, true);
+   TEST_TT(bool, void, false);
+   TEST_TT(void, bool, false);
+   TEST_TT(char, void, false);
+   TEST_TT(void, char, false);
+   TEST_TT(signed char, void, false);
+   TEST_TT(void, signed char, false);
+   TEST_TT(short int, void, false);
+   TEST_TT(void, short int, false);
+   TEST_TT(int, void, false);
+   TEST_TT(void, int, false);
+   TEST_TT(long int, void, false);
+   TEST_TT(void, long int, false);
+   TEST_TT(unsigned char, void, false);
+   TEST_TT(void, unsigned char, false);
+   TEST_TT(unsigned short int, void, false);
+   TEST_TT(void, unsigned short int, false);
+   TEST_TT(unsigned int, void, false);
+   TEST_TT(void, unsigned int, false);
+   TEST_TT(unsigned long int, void, false);
+   TEST_TT(void, unsigned long int, false);
+   TEST_TT(wchar_t, void, false);
+   TEST_TT(void, wchar_t, false);
+   TEST_TT(float, void, false);
+   TEST_TT(void, float, false);
+   TEST_TT(double, void, false);
+   TEST_TT(void, double, false);
+   TEST_TT(long double, void, false);
+   TEST_TT(void, long double, false);
+
+// test with three template parameters
+   TEST_TTR(bool, bool, bool, true);
+   TEST_TTR(bool, char, bool, true);
+   TEST_TTR(bool, signed char, bool, true);
+   TEST_TTR(bool, short int, bool, true);
+   TEST_TTR(bool, int, bool, true);
+   TEST_TTR(bool, long int, bool, true);
+   TEST_TTR(bool, unsigned char, bool, true);
+   TEST_TTR(bool, unsigned short int, bool, true);
+   TEST_TTR(bool, unsigned int, bool, true);
+   TEST_TTR(bool, unsigned long int, bool, true);
+   TEST_TTR(bool, wchar_t, bool, true);
+   TEST_TTR(bool, float, bool, true);
+   TEST_TTR(bool, double, bool, true);
+   TEST_TTR(bool, long double, bool, true);
+   TEST_TTR(char, bool, bool, true);
+   TEST_TTR(char, char, bool, true);
+   TEST_TTR(char, signed char, bool, true);
+   TEST_TTR(char, short int, bool, true);
+   TEST_TTR(char, int, bool, true);
+   TEST_TTR(char, long int, bool, true);
+   TEST_TTR(char, unsigned char, bool, true);
+   TEST_TTR(char, unsigned short int, bool, true);
+   TEST_TTR(char, unsigned int, bool, true);
+   TEST_TTR(char, unsigned long int, bool, true);
+   TEST_TTR(char, wchar_t, bool, true);
+   TEST_TTR(char, float, bool, true);
+   TEST_TTR(char, double, bool, true);
+   TEST_TTR(char, long double, bool, true);
+   TEST_TTR(signed char, bool, bool, true);
+   TEST_TTR(signed char, char, bool, true);
+   TEST_TTR(signed char, signed char, bool, true);
+   TEST_TTR(signed char, short int, bool, true);
+   TEST_TTR(signed char, int, bool, true);
+   TEST_TTR(signed char, long int, bool, true);
+   TEST_TTR(signed char, unsigned char, bool, true);
+   TEST_TTR(signed char, unsigned short int, bool, true);
+   TEST_TTR(signed char, unsigned int, bool, true);
+   TEST_TTR(signed char, unsigned long int, bool, true);
+   TEST_TTR(signed char, wchar_t, bool, true);
+   TEST_TTR(signed char, float, bool, true);
+   TEST_TTR(signed char, double, bool, true);
+   TEST_TTR(signed char, long double, bool, true);
+   TEST_TTR(short int, bool, bool, true);
+   TEST_TTR(short int, char, bool, true);
+   TEST_TTR(short int, signed char, bool, true);
+   TEST_TTR(short int, short int, bool, true);
+   TEST_TTR(short int, int, bool, true);
+   TEST_TTR(short int, long int, bool, true);
+   TEST_TTR(short int, unsigned char, bool, true);
+   TEST_TTR(short int, unsigned short int, bool, true);
+   TEST_TTR(short int, unsigned int, bool, true);
+   TEST_TTR(short int, unsigned long int, bool, true);
+   TEST_TTR(short int, wchar_t, bool, true);
+   TEST_TTR(short int, float, bool, true);
+   TEST_TTR(short int, double, bool, true);
+   TEST_TTR(short int, long double, bool, true);
+   TEST_TTR(int, bool, bool, true);
+   TEST_TTR(int, char, bool, true);
+   TEST_TTR(int, signed char, bool, true);
+   TEST_TTR(int, short int, bool, true);
+   TEST_TTR(int, int, bool, true);
+   TEST_TTR(int, long int, bool, true);
+   TEST_TTR(int, unsigned char, bool, true);
+   TEST_TTR(int, unsigned short int, bool, true);
+   TEST_TTR(int, unsigned int, bool, true);
+   TEST_TTR(int, unsigned long int, bool, true);
+   TEST_TTR(int, wchar_t, bool, true);
+   TEST_TTR(int, float, bool, true);
+   TEST_TTR(int, double, bool, true);
+   TEST_TTR(int, long double, bool, true);
+   TEST_TTR(long int, bool, bool, true);
+   TEST_TTR(long int, char, bool, true);
+   TEST_TTR(long int, signed char, bool, true);
+   TEST_TTR(long int, short int, bool, true);
+   TEST_TTR(long int, int, bool, true);
+   TEST_TTR(long int, long int, bool, true);
+   TEST_TTR(long int, unsigned char, bool, true);
+   TEST_TTR(long int, unsigned short int, bool, true);
+   TEST_TTR(long int, unsigned int, bool, true);
+   TEST_TTR(long int, unsigned long int, bool, true);
+   TEST_TTR(long int, wchar_t, bool, true);
+   TEST_TTR(long int, float, bool, true);
+   TEST_TTR(long int, double, bool, true);
+   TEST_TTR(long int, long double, bool, true);
+   TEST_TTR(unsigned char, bool, bool, true);
+   TEST_TTR(unsigned char, char, bool, true);
+   TEST_TTR(unsigned char, signed char, bool, true);
+   TEST_TTR(unsigned char, short int, bool, true);
+   TEST_TTR(unsigned char, int, bool, true);
+   TEST_TTR(unsigned char, long int, bool, true);
+   TEST_TTR(unsigned char, unsigned char, bool, true);
+   TEST_TTR(unsigned char, unsigned short int, bool, true);
+   TEST_TTR(unsigned char, unsigned int, bool, true);
+   TEST_TTR(unsigned char, unsigned long int, bool, true);
+   TEST_TTR(unsigned char, wchar_t, bool, true);
+   TEST_TTR(unsigned char, float, bool, true);
+   TEST_TTR(unsigned char, double, bool, true);
+   TEST_TTR(unsigned char, long double, bool, true);
+   TEST_TTR(unsigned short int, bool, bool, true);
+   TEST_TTR(unsigned short int, char, bool, true);
+   TEST_TTR(unsigned short int, signed char, bool, true);
+   TEST_TTR(unsigned short int, short int, bool, true);
+   TEST_TTR(unsigned short int, int, bool, true);
+   TEST_TTR(unsigned short int, long int, bool, true);
+   TEST_TTR(unsigned short int, unsigned char, bool, true);
+   TEST_TTR(unsigned short int, unsigned short int, bool, true);
+   TEST_TTR(unsigned short int, unsigned int, bool, true);
+   TEST_TTR(unsigned short int, unsigned long int, bool, true);
+   TEST_TTR(unsigned short int, wchar_t, bool, true);
+   TEST_TTR(unsigned short int, float, bool, true);
+   TEST_TTR(unsigned short int, double, bool, true);
+   TEST_TTR(unsigned short int, long double, bool, true);
+   TEST_TTR(unsigned int, bool, bool, true);
+   TEST_TTR(unsigned int, char, bool, true);
+   TEST_TTR(unsigned int, signed char, bool, true);
+   TEST_TTR(unsigned int, short int, bool, true);
+   TEST_TTR(unsigned int, int, bool, true);
+   TEST_TTR(unsigned int, long int, bool, true);
+   TEST_TTR(unsigned int, unsigned char, bool, true);
+   TEST_TTR(unsigned int, unsigned short int, bool, true);
+   TEST_TTR(unsigned int, unsigned int, bool, true);
+   TEST_TTR(unsigned int, unsigned long int, bool, true);
+   TEST_TTR(unsigned int, wchar_t, bool, true);
+   TEST_TTR(unsigned int, float, bool, true);
+   TEST_TTR(unsigned int, double, bool, true);
+   TEST_TTR(unsigned int, long double, bool, true);
+   TEST_TTR(unsigned long int, bool, bool, true);
+   TEST_TTR(unsigned long int, char, bool, true);
+   TEST_TTR(unsigned long int, signed char, bool, true);
+   TEST_TTR(unsigned long int, short int, bool, true);
+   TEST_TTR(unsigned long int, int, bool, true);
+   TEST_TTR(unsigned long int, long int, bool, true);
+   TEST_TTR(unsigned long int, unsigned char, bool, true);
+   TEST_TTR(unsigned long int, unsigned short int, bool, true);
+   TEST_TTR(unsigned long int, unsigned int, bool, true);
+   TEST_TTR(unsigned long int, unsigned long int, bool, true);
+   TEST_TTR(unsigned long int, wchar_t, bool, true);
+   TEST_TTR(unsigned long int, float, bool, true);
+   TEST_TTR(unsigned long int, double, bool, true);
+   TEST_TTR(unsigned long int, long double, bool, true);
+   TEST_TTR(wchar_t, bool, bool, true);
+   TEST_TTR(wchar_t, char, bool, true);
+   TEST_TTR(wchar_t, signed char, bool, true);
+   TEST_TTR(wchar_t, short int, bool, true);
+   TEST_TTR(wchar_t, int, bool, true);
+   TEST_TTR(wchar_t, long int, bool, true);
+   TEST_TTR(wchar_t, unsigned char, bool, true);
+   TEST_TTR(wchar_t, unsigned short int, bool, true);
+   TEST_TTR(wchar_t, unsigned int, bool, true);
+   TEST_TTR(wchar_t, unsigned long int, bool, true);
+   TEST_TTR(wchar_t, wchar_t, bool, true);
+   TEST_TTR(wchar_t, float, bool, true);
+   TEST_TTR(wchar_t, double, bool, true);
+   TEST_TTR(wchar_t, long double, bool, true);
+   TEST_TTR(float, bool, bool, true);
+   TEST_TTR(float, char, bool, true);
+   TEST_TTR(float, signed char, bool, true);
+   TEST_TTR(float, short int, bool, true);
+   TEST_TTR(float, int, bool, true);
+   TEST_TTR(float, long int, bool, true);
+   TEST_TTR(float, unsigned char, bool, true);
+   TEST_TTR(float, unsigned short int, bool, true);
+   TEST_TTR(float, unsigned int, bool, true);
+   TEST_TTR(float, unsigned long int, bool, true);
+   TEST_TTR(float, wchar_t, bool, true);
+   TEST_TTR(float, float, bool, true);
+   TEST_TTR(float, double, bool, true);
+   TEST_TTR(float, long double, bool, true);
+   TEST_TTR(double, bool, bool, true);
+   TEST_TTR(double, char, bool, true);
+   TEST_TTR(double, signed char, bool, true);
+   TEST_TTR(double, short int, bool, true);
+   TEST_TTR(double, int, bool, true);
+   TEST_TTR(double, long int, bool, true);
+   TEST_TTR(double, unsigned char, bool, true);
+   TEST_TTR(double, unsigned short int, bool, true);
+   TEST_TTR(double, unsigned int, bool, true);
+   TEST_TTR(double, unsigned long int, bool, true);
+   TEST_TTR(double, wchar_t, bool, true);
+   TEST_TTR(double, float, bool, true);
+   TEST_TTR(double, double, bool, true);
+   TEST_TTR(double, long double, bool, true);
+   TEST_TTR(long double, bool, bool, true);
+   TEST_TTR(long double, char, bool, true);
+   TEST_TTR(long double, signed char, bool, true);
+   TEST_TTR(long double, short int, bool, true);
+   TEST_TTR(long double, int, bool, true);
+   TEST_TTR(long double, long int, bool, true);
+   TEST_TTR(long double, unsigned char, bool, true);
+   TEST_TTR(long double, unsigned short int, bool, true);
+   TEST_TTR(long double, unsigned int, bool, true);
+   TEST_TTR(long double, unsigned long int, bool, true);
+   TEST_TTR(long double, wchar_t, bool, true);
+   TEST_TTR(long double, float, bool, true);
+   TEST_TTR(long double, double, bool, true);
+   TEST_TTR(long double, long double, bool, true);
+   TEST_TTR(bool, bool, tag, false);
+   TEST_TTR(bool, char, tag, false);
+   TEST_TTR(bool, signed char, tag, false);
+   TEST_TTR(bool, short int, tag, false);
+   TEST_TTR(bool, int, tag, false);
+   TEST_TTR(bool, long int, tag, false);
+   TEST_TTR(bool, unsigned char, tag, false);
+   TEST_TTR(bool, unsigned short int, tag, false);
+   TEST_TTR(bool, unsigned int, tag, false);
+   TEST_TTR(bool, unsigned long int, tag, false);
+   TEST_TTR(bool, wchar_t, tag, false);
+   TEST_TTR(bool, float, tag, false);
+   TEST_TTR(bool, double, tag, false);
+   TEST_TTR(bool, long double, tag, false);
+   TEST_TTR(char, bool, tag, false);
+   TEST_TTR(char, char, tag, false);
+   TEST_TTR(char, signed char, tag, false);
+   TEST_TTR(char, short int, tag, false);
+   TEST_TTR(char, int, tag, false);
+   TEST_TTR(char, long int, tag, false);
+   TEST_TTR(char, unsigned char, tag, false);
+   TEST_TTR(char, unsigned short int, tag, false);
+   TEST_TTR(char, unsigned int, tag, false);
+   TEST_TTR(char, unsigned long int, tag, false);
+   TEST_TTR(char, wchar_t, tag, false);
+   TEST_TTR(char, float, tag, false);
+   TEST_TTR(char, double, tag, false);
+   TEST_TTR(char, long double, tag, false);
+   TEST_TTR(signed char, bool, tag, false);
+   TEST_TTR(signed char, char, tag, false);
+   TEST_TTR(signed char, signed char, tag, false);
+   TEST_TTR(signed char, short int, tag, false);
+   TEST_TTR(signed char, int, tag, false);
+   TEST_TTR(signed char, long int, tag, false);
+   TEST_TTR(signed char, unsigned char, tag, false);
+   TEST_TTR(signed char, unsigned short int, tag, false);
+   TEST_TTR(signed char, unsigned int, tag, false);
+   TEST_TTR(signed char, unsigned long int, tag, false);
+   TEST_TTR(signed char, wchar_t, tag, false);
+   TEST_TTR(signed char, float, tag, false);
+   TEST_TTR(signed char, double, tag, false);
+   TEST_TTR(signed char, long double, tag, false);
+   TEST_TTR(short int, bool, tag, false);
+   TEST_TTR(short int, char, tag, false);
+   TEST_TTR(short int, signed char, tag, false);
+   TEST_TTR(short int, short int, tag, false);
+   TEST_TTR(short int, int, tag, false);
+   TEST_TTR(short int, long int, tag, false);
+   TEST_TTR(short int, unsigned char, tag, false);
+   TEST_TTR(short int, unsigned short int, tag, false);
+   TEST_TTR(short int, unsigned int, tag, false);
+   TEST_TTR(short int, unsigned long int, tag, false);
+   TEST_TTR(short int, wchar_t, tag, false);
+   TEST_TTR(short int, float, tag, false);
+   TEST_TTR(short int, double, tag, false);
+   TEST_TTR(short int, long double, tag, false);
+   TEST_TTR(int, bool, tag, false);
+   TEST_TTR(int, char, tag, false);
+   TEST_TTR(int, signed char, tag, false);
+   TEST_TTR(int, short int, tag, false);
+   TEST_TTR(int, int, tag, false);
+   TEST_TTR(int, long int, tag, false);
+   TEST_TTR(int, unsigned char, tag, false);
+   TEST_TTR(int, unsigned short int, tag, false);
+   TEST_TTR(int, unsigned int, tag, false);
+   TEST_TTR(int, unsigned long int, tag, false);
+   TEST_TTR(int, wchar_t, tag, false);
+   TEST_TTR(int, float, tag, false);
+   TEST_TTR(int, double, tag, false);
+   TEST_TTR(int, long double, tag, false);
+   TEST_TTR(long int, bool, tag, false);
+   TEST_TTR(long int, char, tag, false);
+   TEST_TTR(long int, signed char, tag, false);
+   TEST_TTR(long int, short int, tag, false);
+   TEST_TTR(long int, int, tag, false);
+   TEST_TTR(long int, long int, tag, false);
+   TEST_TTR(long int, unsigned char, tag, false);
+   TEST_TTR(long int, unsigned short int, tag, false);
+   TEST_TTR(long int, unsigned int, tag, false);
+   TEST_TTR(long int, unsigned long int, tag, false);
+   TEST_TTR(long int, wchar_t, tag, false);
+   TEST_TTR(long int, float, tag, false);
+   TEST_TTR(long int, double, tag, false);
+   TEST_TTR(long int, long double, tag, false);
+   TEST_TTR(unsigned char, bool, tag, false);
+   TEST_TTR(unsigned char, char, tag, false);
+   TEST_TTR(unsigned char, signed char, tag, false);
+   TEST_TTR(unsigned char, short int, tag, false);
+   TEST_TTR(unsigned char, int, tag, false);
+   TEST_TTR(unsigned char, long int, tag, false);
+   TEST_TTR(unsigned char, unsigned char, tag, false);
+   TEST_TTR(unsigned char, unsigned short int, tag, false);
+   TEST_TTR(unsigned char, unsigned int, tag, false);
+   TEST_TTR(unsigned char, unsigned long int, tag, false);
+   TEST_TTR(unsigned char, wchar_t, tag, false);
+   TEST_TTR(unsigned char, float, tag, false);
+   TEST_TTR(unsigned char, double, tag, false);
+   TEST_TTR(unsigned char, long double, tag, false);
+   TEST_TTR(unsigned short int, bool, tag, false);
+   TEST_TTR(unsigned short int, char, tag, false);
+   TEST_TTR(unsigned short int, signed char, tag, false);
+   TEST_TTR(unsigned short int, short int, tag, false);
+   TEST_TTR(unsigned short int, int, tag, false);
+   TEST_TTR(unsigned short int, long int, tag, false);
+   TEST_TTR(unsigned short int, unsigned char, tag, false);
+   TEST_TTR(unsigned short int, unsigned short int, tag, false);
+   TEST_TTR(unsigned short int, unsigned int, tag, false);
+   TEST_TTR(unsigned short int, unsigned long int, tag, false);
+   TEST_TTR(unsigned short int, wchar_t, tag, false);
+   TEST_TTR(unsigned short int, float, tag, false);
+   TEST_TTR(unsigned short int, double, tag, false);
+   TEST_TTR(unsigned short int, long double, tag, false);
+   TEST_TTR(unsigned int, bool, tag, false);
+   TEST_TTR(unsigned int, char, tag, false);
+   TEST_TTR(unsigned int, signed char, tag, false);
+   TEST_TTR(unsigned int, short int, tag, false);
+   TEST_TTR(unsigned int, int, tag, false);
+   TEST_TTR(unsigned int, long int, tag, false);
+   TEST_TTR(unsigned int, unsigned char, tag, false);
+   TEST_TTR(unsigned int, unsigned short int, tag, false);
+   TEST_TTR(unsigned int, unsigned int, tag, false);
+   TEST_TTR(unsigned int, unsigned long int, tag, false);
+   TEST_TTR(unsigned int, wchar_t, tag, false);
+   TEST_TTR(unsigned int, float, tag, false);
+   TEST_TTR(unsigned int, double, tag, false);
+   TEST_TTR(unsigned int, long double, tag, false);
+   TEST_TTR(unsigned long int, bool, tag, false);
+   TEST_TTR(unsigned long int, char, tag, false);
+   TEST_TTR(unsigned long int, signed char, tag, false);
+   TEST_TTR(unsigned long int, short int, tag, false);
+   TEST_TTR(unsigned long int, int, tag, false);
+   TEST_TTR(unsigned long int, long int, tag, false);
+   TEST_TTR(unsigned long int, unsigned char, tag, false);
+   TEST_TTR(unsigned long int, unsigned short int, tag, false);
+   TEST_TTR(unsigned long int, unsigned int, tag, false);
+   TEST_TTR(unsigned long int, unsigned long int, tag, false);
+   TEST_TTR(unsigned long int, wchar_t, tag, false);
+   TEST_TTR(unsigned long int, float, tag, false);
+   TEST_TTR(unsigned long int, double, tag, false);
+   TEST_TTR(unsigned long int, long double, tag, false);
+   TEST_TTR(wchar_t, bool, tag, false);
+   TEST_TTR(wchar_t, char, tag, false);
+   TEST_TTR(wchar_t, signed char, tag, false);
+   TEST_TTR(wchar_t, short int, tag, false);
+   TEST_TTR(wchar_t, int, tag, false);
+   TEST_TTR(wchar_t, long int, tag, false);
+   TEST_TTR(wchar_t, unsigned char, tag, false);
+   TEST_TTR(wchar_t, unsigned short int, tag, false);
+   TEST_TTR(wchar_t, unsigned int, tag, false);
+   TEST_TTR(wchar_t, unsigned long int, tag, false);
+   TEST_TTR(wchar_t, wchar_t, tag, false);
+   TEST_TTR(wchar_t, float, tag, false);
+   TEST_TTR(wchar_t, double, tag, false);
+   TEST_TTR(wchar_t, long double, tag, false);
+   TEST_TTR(float, bool, tag, false);
+   TEST_TTR(float, char, tag, false);
+   TEST_TTR(float, signed char, tag, false);
+   TEST_TTR(float, short int, tag, false);
+   TEST_TTR(float, int, tag, false);
+   TEST_TTR(float, long int, tag, false);
+   TEST_TTR(float, unsigned char, tag, false);
+   TEST_TTR(float, unsigned short int, tag, false);
+   TEST_TTR(float, unsigned int, tag, false);
+   TEST_TTR(float, unsigned long int, tag, false);
+   TEST_TTR(float, wchar_t, tag, false);
+   TEST_TTR(float, float, tag, false);
+   TEST_TTR(float, double, tag, false);
+   TEST_TTR(float, long double, tag, false);
+   TEST_TTR(double, bool, tag, false);
+   TEST_TTR(double, char, tag, false);
+   TEST_TTR(double, signed char, tag, false);
+   TEST_TTR(double, short int, tag, false);
+   TEST_TTR(double, int, tag, false);
+   TEST_TTR(double, long int, tag, false);
+   TEST_TTR(double, unsigned char, tag, false);
+   TEST_TTR(double, unsigned short int, tag, false);
+   TEST_TTR(double, unsigned int, tag, false);
+   TEST_TTR(double, unsigned long int, tag, false);
+   TEST_TTR(double, wchar_t, tag, false);
+   TEST_TTR(double, float, tag, false);
+   TEST_TTR(double, double, tag, false);
+   TEST_TTR(double, long double, tag, false);
+   TEST_TTR(long double, bool, tag, false);
+   TEST_TTR(long double, char, tag, false);
+   TEST_TTR(long double, signed char, tag, false);
+   TEST_TTR(long double, short int, tag, false);
+   TEST_TTR(long double, int, tag, false);
+   TEST_TTR(long double, long int, tag, false);
+   TEST_TTR(long double, unsigned char, tag, false);
+   TEST_TTR(long double, unsigned short int, tag, false);
+   TEST_TTR(long double, unsigned int, tag, false);
+   TEST_TTR(long double, unsigned long int, tag, false);
+   TEST_TTR(long double, wchar_t, tag, false);
+   TEST_TTR(long double, float, tag, false);
+   TEST_TTR(long double, double, tag, false);
+   TEST_TTR(long double, long double, tag, false);
+#	undef CV1
+#	define CV1(T) const T
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const T&
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T&
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T&
+#	undef CV2
+#	define CV2(T) T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) T
+#	undef CV2
+#	define CV2(T) const volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const T
+#	undef CV2
+#	define CV2(T) const T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const T&
+#	undef CV2
+#	define CV2(T) const T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T
+#	undef CV2
+#	define CV2(T) volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) volatile T&
+#	undef CV2
+#	define CV2(T) volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T
+#	undef CV2
+#	define CV2(T) const volatile T
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+#	undef CV1
+#	define CV1(T) const volatile T&
+#	undef CV2
+#	define CV2(T) const volatile T&
+   // test with only two template parameters
+   TEST_TT(CV1(bool), CV2(int), true);
+   TEST_TT(CV1(bool), CV2(double), true);
+   TEST_TT(CV1(int), CV2(bool), true);
+   TEST_TT(CV1(int), CV2(double), true);
+   TEST_TT(CV1(double), CV2(bool), true);
+   TEST_TT(CV1(double), CV2(int), true);
+
+   // test with three template parameters
+   TEST_TTR(CV1(bool), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(double), bool, true);
+   TEST_TTR(CV1(int), CV2(bool), bool, true);
+   TEST_TTR(CV1(int), CV2(double), bool, true);
+   TEST_TTR(CV1(double), CV2(bool), bool, true);
+   TEST_TTR(CV1(double), CV2(int), bool, true);
+   TEST_TTR(CV1(bool), CV2(int), tag, false);
+   TEST_TTR(CV1(bool), CV2(double), tag, false);
+   TEST_TTR(CV1(int), CV2(bool), tag, false);
+   TEST_TTR(CV1(int), CV2(double), tag, false);
+   TEST_TTR(CV1(double), CV2(bool), tag, false);
+   TEST_TTR(CV1(double), CV2(int), tag, false);
+
+   // pointers
+   TEST_TT(void*, bool, false);
+   TEST_TT(void*, int, false);
+   TEST_TT(void*, double, false);
+   TEST_TT(void*, A, false);
+   TEST_TT(void*, B, false);
+   TEST_TT(bool*, bool, true);
+   TEST_TT(bool*, int, true);
+   TEST_TT(bool*, double, false);
+   TEST_TT(bool*, A, false);
+   TEST_TT(bool*, B, false);
+   TEST_TT(int*, bool, true);
+   TEST_TT(int*, int, true);
+   TEST_TT(int*, double, false);
+   TEST_TT(int*, A, false);
+   TEST_TT(int*, B, false);
+   TEST_TT(double*, bool, true);
+   TEST_TT(double*, int, true);
+   TEST_TT(double*, double, false);
+   TEST_TT(double*, A, false);
+   TEST_TT(double*, B, false);
+   TEST_TT(A*, bool, true);
+   TEST_TT(A*, int, true);
+   TEST_TT(A*, double, false);
+   TEST_TT(A*, A, false);
+   TEST_TT(A*, B, false);
+   TEST_TT(B*, bool, true);
+   TEST_TT(B*, int, true);
+   TEST_TT(B*, double, false);
+   TEST_TT(B*, A, false);
+   TEST_TT(B*, B, false);
+   TEST_TT(bool, void*, false);
+   TEST_TT(bool, bool*, false);
+   TEST_TT(bool, int*, false);
+   TEST_TT(bool, double*, false);
+   TEST_TT(bool, A*, false);
+   TEST_TT(bool, B*, false);
+   TEST_TT(int, void*, false);
+   TEST_TT(int, bool*, false);
+   TEST_TT(int, int*, false);
+   TEST_TT(int, double*, false);
+   TEST_TT(int, A*, false);
+   TEST_TT(int, B*, false);
+   TEST_TT(double, void*, false);
+   TEST_TT(double, bool*, false);
+   TEST_TT(double, int*, false);
+   TEST_TT(double, double*, false);
+   TEST_TT(double, A*, false);
+   TEST_TT(double, B*, false);
+   TEST_TT(A, void*, false);
+   TEST_TT(A, bool*, false);
+   TEST_TT(A, int*, false);
+   TEST_TT(A, double*, false);
+   TEST_TT(A, A*, false);
+   TEST_TT(A, B*, false);
+   TEST_TT(B, void*, false);
+   TEST_TT(B, bool*, false);
+   TEST_TT(B, int*, false);
+   TEST_TT(B, double*, false);
+   TEST_TT(B, A*, false);
+   TEST_TT(B, B*, false);
+   TEST_TT(void*, void*, false);
+   TEST_TT(void*, bool*, false);
+   TEST_TT(void*, int*, false);
+   TEST_TT(void*, double*, false);
+   TEST_TT(void*, A*, false);
+   TEST_TT(void*, B*, false);
+   TEST_TT(bool*, void*, false);
+   TEST_TT(bool*, bool*, true);
+   TEST_TT(bool*, int*, false);
+   TEST_TT(bool*, double*, false);
+   TEST_TT(bool*, A*, false);
+   TEST_TT(bool*, B*, false);
+   TEST_TT(int*, void*, false);
+   TEST_TT(int*, bool*, false);
+   TEST_TT(int*, int*, true);
+   TEST_TT(int*, double*, false);
+   TEST_TT(int*, A*, false);
+   TEST_TT(int*, B*, false);
+   TEST_TT(double*, void*, false);
+   TEST_TT(double*, bool*, false);
+   TEST_TT(double*, int*, false);
+   TEST_TT(double*, double*, true);
+   TEST_TT(double*, A*, false);
+   TEST_TT(double*, B*, false);
+   TEST_TT(A*, void*, false);
+   TEST_TT(A*, bool*, false);
+   TEST_TT(A*, int*, false);
+   TEST_TT(A*, double*, false);
+   TEST_TT(A*, A*, true);
+   TEST_TT(A*, B*, false);
+   TEST_TT(B*, void*, false);
+   TEST_TT(B*, bool*, false);
+   TEST_TT(B*, int*, false);
+   TEST_TT(B*, double*, false);
+   TEST_TT(B*, A*, false);
+   TEST_TT(B*, B*, true);
+   TEST_TT(C, void*, true);
+   TEST_TT(D, void*, false);
+   TEST_TT(void*, C, false);
+   TEST_TT(void*, D, true);
+   TEST_TT(C, D, true);
+}
+}

Added: sandbox/type_traits/libs/type_traits/test/can_call_unary_minus_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_unary_minus_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,33 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_unary_minus.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_unary_minus
+#define BOOST_TT_TRAIT_OP -
+
+#include "can_call_prefix_operators.hpp"
+#include "can_call_unary_minus_test.hpp"
+
+namespace {
+void specific() {
+   /* nothing specific */
+}
+}
+
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_unary_minus_test.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_unary_minus_test.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,97 @@
+//  (C) Copyright Frederic Bron 2009-2011.
+//  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)
+
+namespace {
+
+void run2() {
+   // test with only one template parameter
+   TEST_T(void, false);
+   TEST_T(bool, true);
+   TEST_T(char, true);
+   TEST_T(signed char, true);
+   TEST_T(short int, true);
+   TEST_T(int, true);
+   TEST_T(long int, true);
+   TEST_T(unsigned char, true);
+   TEST_T(unsigned short int, true);
+   TEST_T(unsigned int, true);
+   TEST_T(unsigned long int, true);
+   TEST_T(wchar_t, true);
+   TEST_T(float, true);
+   TEST_T(double, true);
+   TEST_T(long double, true);
+   TEST_T(void, false);
+#	undef CV
+#	define CV(T) const T
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	undef CV
+#	define CV(T) volatile T
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	undef CV
+#	define CV(T) const volatile T
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	undef CV
+#	define CV(T) const T&
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	undef CV
+#	define CV(T) volatile T&
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	undef CV
+#	define CV(T) const volatile T&
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+
+   // test with three template parameters
+   TEST_TR(bool, bool, true);
+   TEST_TR(char, bool, true);
+   TEST_TR(signed char, bool, true);
+   TEST_TR(short int, bool, true);
+   TEST_TR(int, bool, true);
+   TEST_TR(long int, bool, true);
+   TEST_TR(unsigned char, bool, true);
+   TEST_TR(unsigned short int, bool, true);
+   TEST_TR(unsigned int, bool, true);
+   TEST_TR(unsigned long int, bool, true);
+   TEST_TR(wchar_t, bool, true);
+   TEST_TR(float, bool, true);
+   TEST_TR(double, bool, true);
+   TEST_TR(long double, bool, true);
+   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);
+
+   // pointers
+   TEST_T(void*, false);
+   TEST_T(bool*, false);
+   TEST_T(char*, false);
+   TEST_T(int*, false);
+   TEST_T(long*, false);
+   TEST_T(wchar_t*, false);
+   TEST_T(double*, false);
+   TEST_T(without*, false);
+}
+}

Added: sandbox/type_traits/libs/type_traits/test/can_call_unary_plus_not_test.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_unary_plus_not_test.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,97 @@
+//  (C) Copyright Frederic Bron 2009-2011.
+//  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)
+
+namespace {
+
+void run2() {
+   // test with only one template parameter
+   TEST_T(void, false);
+   TEST_T(bool, true);
+   TEST_T(char, true);
+   TEST_T(signed char, true);
+   TEST_T(short int, true);
+   TEST_T(int, true);
+   TEST_T(long int, true);
+   TEST_T(unsigned char, true);
+   TEST_T(unsigned short int, true);
+   TEST_T(unsigned int, true);
+   TEST_T(unsigned long int, true);
+   TEST_T(wchar_t, true);
+   TEST_T(float, true);
+   TEST_T(double, true);
+   TEST_T(long double, true);
+   TEST_T(void, false);
+#	undef CV
+#	define CV(T) const T
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	undef CV
+#	define CV(T) volatile T
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	undef CV
+#	define CV(T) const volatile T
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	undef CV
+#	define CV(T) const T&
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	undef CV
+#	define CV(T) volatile T&
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+#	undef CV
+#	define CV(T) const volatile T&
+   TEST_T(CV(bool), true);
+   TEST_T(CV(int), true);
+   TEST_T(CV(double), true);
+
+   // test with three template parameters
+   TEST_TR(bool, bool, true);
+   TEST_TR(char, bool, true);
+   TEST_TR(signed char, bool, true);
+   TEST_TR(short int, bool, true);
+   TEST_TR(int, bool, true);
+   TEST_TR(long int, bool, true);
+   TEST_TR(unsigned char, bool, true);
+   TEST_TR(unsigned short int, bool, true);
+   TEST_TR(unsigned int, bool, true);
+   TEST_TR(unsigned long int, bool, true);
+   TEST_TR(wchar_t, bool, true);
+   TEST_TR(float, bool, true);
+   TEST_TR(double, bool, true);
+   TEST_TR(long double, bool, true);
+   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);
+
+   // pointers
+   TEST_T(void*, true);
+   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);
+}
+}

Added: sandbox/type_traits/libs/type_traits/test/can_call_unary_plus_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_unary_plus_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
@@ -0,0 +1,33 @@
+//  (C) Copyright 2009-2011 Frederic Bron.
+//  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/can_call_unary_plus.hpp>
+#endif
+
+#define BOOST_TT_TRAIT_NAME can_call_unary_plus
+#define BOOST_TT_TRAIT_OP +
+
+#include "can_call_prefix_operators.hpp"
+#include "can_call_unary_plus_not_test.hpp"
+
+namespace {
+void specific() {
+   /* nothing specific */
+}
+}
+
+
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+   run1();
+   run2();
+   specific();
+TT_TEST_END

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,1250 +0,0 @@
-//  (C) Copyright Frederic Bron 2009-2011.
-//  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)
-
-namespace {
-
-void run2() {
-   // test with only one template parameter
-   TEST_T(void, false);
-   TEST_T(bool, true);
-   TEST_T(char, true);
-   TEST_T(signed char, true);
-   TEST_T(short int, true);
-   TEST_T(int, true);
-   TEST_T(long int, true);
-   TEST_T(unsigned char, true);
-   TEST_T(unsigned short int, true);
-   TEST_T(unsigned int, true);
-   TEST_T(unsigned long int, true);
-   TEST_T(wchar_t, true);
-   TEST_T(float, true);
-   TEST_T(double, true);
-   TEST_T(long double, true);
-   TEST_T(void, false);
-#	undef CV
-#	define CV(T) const T
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	undef CV
-#	define CV(T) volatile T
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	undef CV
-#	define CV(T) const volatile T
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	undef CV
-#	define CV(T) const T&
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	undef CV
-#	define CV(T) volatile T&
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	undef CV
-#	define CV(T) const volatile T&
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   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);
-   TEST_TT(bool, short int, true);
-   TEST_TT(bool, int, true);
-   TEST_TT(bool, long int, true);
-   TEST_TT(bool, unsigned char, true);
-   TEST_TT(bool, unsigned short int, true);
-   TEST_TT(bool, unsigned int, true);
-   TEST_TT(bool, unsigned long int, true);
-   TEST_TT(bool, wchar_t, true);
-   TEST_TT(bool, float, true);
-   TEST_TT(bool, double, true);
-   TEST_TT(bool, long double, true);
-   TEST_TT(char, bool, true);
-   TEST_TT(char, char, true);
-   TEST_TT(char, signed char, true);
-   TEST_TT(char, short int, true);
-   TEST_TT(char, int, true);
-   TEST_TT(char, long int, true);
-   TEST_TT(char, unsigned char, true);
-   TEST_TT(char, unsigned short int, true);
-   TEST_TT(char, unsigned int, true);
-   TEST_TT(char, unsigned long int, true);
-   TEST_TT(char, wchar_t, true);
-   TEST_TT(char, float, true);
-   TEST_TT(char, double, true);
-   TEST_TT(char, long double, true);
-   TEST_TT(signed char, bool, true);
-   TEST_TT(signed char, char, true);
-   TEST_TT(signed char, signed char, true);
-   TEST_TT(signed char, short int, true);
-   TEST_TT(signed char, int, true);
-   TEST_TT(signed char, long int, true);
-   TEST_TT(signed char, unsigned char, true);
-   TEST_TT(signed char, unsigned short int, true);
-   TEST_TT(signed char, unsigned int, true);
-   TEST_TT(signed char, unsigned long int, true);
-   TEST_TT(signed char, wchar_t, true);
-   TEST_TT(signed char, float, true);
-   TEST_TT(signed char, double, true);
-   TEST_TT(signed char, long double, true);
-   TEST_TT(short int, bool, true);
-   TEST_TT(short int, char, true);
-   TEST_TT(short int, signed char, true);
-   TEST_TT(short int, short int, true);
-   TEST_TT(short int, int, true);
-   TEST_TT(short int, long int, true);
-   TEST_TT(short int, unsigned char, true);
-   TEST_TT(short int, unsigned short int, true);
-   TEST_TT(short int, unsigned int, true);
-   TEST_TT(short int, unsigned long int, true);
-   TEST_TT(short int, wchar_t, true);
-   TEST_TT(short int, float, true);
-   TEST_TT(short int, double, true);
-   TEST_TT(short int, long double, true);
-   TEST_TT(int, bool, true);
-   TEST_TT(int, char, true);
-   TEST_TT(int, signed char, true);
-   TEST_TT(int, short int, true);
-   TEST_TT(int, int, true);
-   TEST_TT(int, long int, true);
-   TEST_TT(int, unsigned char, true);
-   TEST_TT(int, unsigned short int, true);
-   TEST_TT(int, unsigned int, true);
-   TEST_TT(int, unsigned long int, true);
-   TEST_TT(int, wchar_t, true);
-   TEST_TT(int, float, true);
-   TEST_TT(int, double, true);
-   TEST_TT(int, long double, true);
-   TEST_TT(long int, bool, true);
-   TEST_TT(long int, char, true);
-   TEST_TT(long int, signed char, true);
-   TEST_TT(long int, short int, true);
-   TEST_TT(long int, int, true);
-   TEST_TT(long int, long int, true);
-   TEST_TT(long int, unsigned char, true);
-   TEST_TT(long int, unsigned short int, true);
-   TEST_TT(long int, unsigned int, true);
-   TEST_TT(long int, unsigned long int, true);
-   TEST_TT(long int, wchar_t, true);
-   TEST_TT(long int, float, true);
-   TEST_TT(long int, double, true);
-   TEST_TT(long int, long double, true);
-   TEST_TT(unsigned char, bool, true);
-   TEST_TT(unsigned char, char, true);
-   TEST_TT(unsigned char, signed char, true);
-   TEST_TT(unsigned char, short int, true);
-   TEST_TT(unsigned char, int, true);
-   TEST_TT(unsigned char, long int, true);
-   TEST_TT(unsigned char, unsigned char, true);
-   TEST_TT(unsigned char, unsigned short int, true);
-   TEST_TT(unsigned char, unsigned int, true);
-   TEST_TT(unsigned char, unsigned long int, true);
-   TEST_TT(unsigned char, wchar_t, true);
-   TEST_TT(unsigned char, float, true);
-   TEST_TT(unsigned char, double, true);
-   TEST_TT(unsigned char, long double, true);
-   TEST_TT(unsigned short int, bool, true);
-   TEST_TT(unsigned short int, char, true);
-   TEST_TT(unsigned short int, signed char, true);
-   TEST_TT(unsigned short int, short int, true);
-   TEST_TT(unsigned short int, int, true);
-   TEST_TT(unsigned short int, long int, true);
-   TEST_TT(unsigned short int, unsigned char, true);
-   TEST_TT(unsigned short int, unsigned short int, true);
-   TEST_TT(unsigned short int, unsigned int, true);
-   TEST_TT(unsigned short int, unsigned long int, true);
-   TEST_TT(unsigned short int, wchar_t, true);
-   TEST_TT(unsigned short int, float, true);
-   TEST_TT(unsigned short int, double, true);
-   TEST_TT(unsigned short int, long double, true);
-   TEST_TT(unsigned int, bool, true);
-   TEST_TT(unsigned int, char, true);
-   TEST_TT(unsigned int, signed char, true);
-   TEST_TT(unsigned int, short int, true);
-   TEST_TT(unsigned int, int, true);
-   TEST_TT(unsigned int, long int, true);
-   TEST_TT(unsigned int, unsigned char, true);
-   TEST_TT(unsigned int, unsigned short int, true);
-   TEST_TT(unsigned int, unsigned int, true);
-   TEST_TT(unsigned int, unsigned long int, true);
-   TEST_TT(unsigned int, wchar_t, true);
-   TEST_TT(unsigned int, float, true);
-   TEST_TT(unsigned int, double, true);
-   TEST_TT(unsigned int, long double, true);
-   TEST_TT(unsigned long int, bool, true);
-   TEST_TT(unsigned long int, char, true);
-   TEST_TT(unsigned long int, signed char, true);
-   TEST_TT(unsigned long int, short int, true);
-   TEST_TT(unsigned long int, int, true);
-   TEST_TT(unsigned long int, long int, true);
-   TEST_TT(unsigned long int, unsigned char, true);
-   TEST_TT(unsigned long int, unsigned short int, true);
-   TEST_TT(unsigned long int, unsigned int, true);
-   TEST_TT(unsigned long int, unsigned long int, true);
-   TEST_TT(unsigned long int, wchar_t, true);
-   TEST_TT(unsigned long int, float, true);
-   TEST_TT(unsigned long int, double, true);
-   TEST_TT(unsigned long int, long double, true);
-   TEST_TT(wchar_t, bool, true);
-   TEST_TT(wchar_t, char, true);
-   TEST_TT(wchar_t, signed char, true);
-   TEST_TT(wchar_t, short int, true);
-   TEST_TT(wchar_t, int, true);
-   TEST_TT(wchar_t, long int, true);
-   TEST_TT(wchar_t, unsigned char, true);
-   TEST_TT(wchar_t, unsigned short int, true);
-   TEST_TT(wchar_t, unsigned int, true);
-   TEST_TT(wchar_t, unsigned long int, true);
-   TEST_TT(wchar_t, wchar_t, true);
-   TEST_TT(wchar_t, float, true);
-   TEST_TT(wchar_t, double, true);
-   TEST_TT(wchar_t, long double, true);
-   TEST_TT(float, bool, true);
-   TEST_TT(float, char, true);
-   TEST_TT(float, signed char, true);
-   TEST_TT(float, short int, true);
-   TEST_TT(float, int, true);
-   TEST_TT(float, long int, true);
-   TEST_TT(float, unsigned char, true);
-   TEST_TT(float, unsigned short int, true);
-   TEST_TT(float, unsigned int, true);
-   TEST_TT(float, unsigned long int, true);
-   TEST_TT(float, wchar_t, true);
-   TEST_TT(float, float, true);
-   TEST_TT(float, double, true);
-   TEST_TT(float, long double, true);
-   TEST_TT(double, bool, true);
-   TEST_TT(double, char, true);
-   TEST_TT(double, signed char, true);
-   TEST_TT(double, short int, true);
-   TEST_TT(double, int, true);
-   TEST_TT(double, long int, true);
-   TEST_TT(double, unsigned char, true);
-   TEST_TT(double, unsigned short int, true);
-   TEST_TT(double, unsigned int, true);
-   TEST_TT(double, unsigned long int, true);
-   TEST_TT(double, wchar_t, true);
-   TEST_TT(double, float, true);
-   TEST_TT(double, double, true);
-   TEST_TT(double, long double, true);
-   TEST_TT(long double, bool, true);
-   TEST_TT(long double, char, true);
-   TEST_TT(long double, signed char, true);
-   TEST_TT(long double, short int, true);
-   TEST_TT(long double, int, true);
-   TEST_TT(long double, long int, true);
-   TEST_TT(long double, unsigned char, true);
-   TEST_TT(long double, unsigned short int, true);
-   TEST_TT(long double, unsigned int, true);
-   TEST_TT(long double, unsigned long int, true);
-   TEST_TT(long double, wchar_t, true);
-   TEST_TT(long double, float, true);
-   TEST_TT(long double, double, true);
-   TEST_TT(long double, long double, true);
-   TEST_TT(bool, void, false);
-   TEST_TT(void, bool, false);
-   TEST_TT(char, void, false);
-   TEST_TT(void, char, false);
-   TEST_TT(signed char, void, false);
-   TEST_TT(void, signed char, false);
-   TEST_TT(short int, void, false);
-   TEST_TT(void, short int, false);
-   TEST_TT(int, void, false);
-   TEST_TT(void, int, false);
-   TEST_TT(long int, void, false);
-   TEST_TT(void, long int, false);
-   TEST_TT(unsigned char, void, false);
-   TEST_TT(void, unsigned char, false);
-   TEST_TT(unsigned short int, void, false);
-   TEST_TT(void, unsigned short int, false);
-   TEST_TT(unsigned int, void, false);
-   TEST_TT(void, unsigned int, false);
-   TEST_TT(unsigned long int, void, false);
-   TEST_TT(void, unsigned long int, false);
-   TEST_TT(wchar_t, void, false);
-   TEST_TT(void, wchar_t, false);
-   TEST_TT(float, void, false);
-   TEST_TT(void, float, false);
-   TEST_TT(double, void, false);
-   TEST_TT(void, double, false);
-   TEST_TT(long double, void, false);
-   TEST_TT(void, long double, false);
-
-// test with three template parameters
-   TEST_TTR(bool, bool, bool, true);
-   TEST_TTR(bool, char, bool, true);
-   TEST_TTR(bool, signed char, bool, true);
-   TEST_TTR(bool, short int, bool, true);
-   TEST_TTR(bool, int, bool, true);
-   TEST_TTR(bool, long int, bool, true);
-   TEST_TTR(bool, unsigned char, bool, true);
-   TEST_TTR(bool, unsigned short int, bool, true);
-   TEST_TTR(bool, unsigned int, bool, true);
-   TEST_TTR(bool, unsigned long int, bool, true);
-   TEST_TTR(bool, wchar_t, bool, true);
-   TEST_TTR(bool, float, bool, true);
-   TEST_TTR(bool, double, bool, true);
-   TEST_TTR(bool, long double, bool, true);
-   TEST_TTR(char, bool, bool, true);
-   TEST_TTR(char, char, bool, true);
-   TEST_TTR(char, signed char, bool, true);
-   TEST_TTR(char, short int, bool, true);
-   TEST_TTR(char, int, bool, true);
-   TEST_TTR(char, long int, bool, true);
-   TEST_TTR(char, unsigned char, bool, true);
-   TEST_TTR(char, unsigned short int, bool, true);
-   TEST_TTR(char, unsigned int, bool, true);
-   TEST_TTR(char, unsigned long int, bool, true);
-   TEST_TTR(char, wchar_t, bool, true);
-   TEST_TTR(char, float, bool, true);
-   TEST_TTR(char, double, bool, true);
-   TEST_TTR(char, long double, bool, true);
-   TEST_TTR(signed char, bool, bool, true);
-   TEST_TTR(signed char, char, bool, true);
-   TEST_TTR(signed char, signed char, bool, true);
-   TEST_TTR(signed char, short int, bool, true);
-   TEST_TTR(signed char, int, bool, true);
-   TEST_TTR(signed char, long int, bool, true);
-   TEST_TTR(signed char, unsigned char, bool, true);
-   TEST_TTR(signed char, unsigned short int, bool, true);
-   TEST_TTR(signed char, unsigned int, bool, true);
-   TEST_TTR(signed char, unsigned long int, bool, true);
-   TEST_TTR(signed char, wchar_t, bool, true);
-   TEST_TTR(signed char, float, bool, true);
-   TEST_TTR(signed char, double, bool, true);
-   TEST_TTR(signed char, long double, bool, true);
-   TEST_TTR(short int, bool, bool, true);
-   TEST_TTR(short int, char, bool, true);
-   TEST_TTR(short int, signed char, bool, true);
-   TEST_TTR(short int, short int, bool, true);
-   TEST_TTR(short int, int, bool, true);
-   TEST_TTR(short int, long int, bool, true);
-   TEST_TTR(short int, unsigned char, bool, true);
-   TEST_TTR(short int, unsigned short int, bool, true);
-   TEST_TTR(short int, unsigned int, bool, true);
-   TEST_TTR(short int, unsigned long int, bool, true);
-   TEST_TTR(short int, wchar_t, bool, true);
-   TEST_TTR(short int, float, bool, true);
-   TEST_TTR(short int, double, bool, true);
-   TEST_TTR(short int, long double, bool, true);
-   TEST_TTR(int, bool, bool, true);
-   TEST_TTR(int, char, bool, true);
-   TEST_TTR(int, signed char, bool, true);
-   TEST_TTR(int, short int, bool, true);
-   TEST_TTR(int, int, bool, true);
-   TEST_TTR(int, long int, bool, true);
-   TEST_TTR(int, unsigned char, bool, true);
-   TEST_TTR(int, unsigned short int, bool, true);
-   TEST_TTR(int, unsigned int, bool, true);
-   TEST_TTR(int, unsigned long int, bool, true);
-   TEST_TTR(int, wchar_t, bool, true);
-   TEST_TTR(int, float, bool, true);
-   TEST_TTR(int, double, bool, true);
-   TEST_TTR(int, long double, bool, true);
-   TEST_TTR(long int, bool, bool, true);
-   TEST_TTR(long int, char, bool, true);
-   TEST_TTR(long int, signed char, bool, true);
-   TEST_TTR(long int, short int, bool, true);
-   TEST_TTR(long int, int, bool, true);
-   TEST_TTR(long int, long int, bool, true);
-   TEST_TTR(long int, unsigned char, bool, true);
-   TEST_TTR(long int, unsigned short int, bool, true);
-   TEST_TTR(long int, unsigned int, bool, true);
-   TEST_TTR(long int, unsigned long int, bool, true);
-   TEST_TTR(long int, wchar_t, bool, true);
-   TEST_TTR(long int, float, bool, true);
-   TEST_TTR(long int, double, bool, true);
-   TEST_TTR(long int, long double, bool, true);
-   TEST_TTR(unsigned char, bool, bool, true);
-   TEST_TTR(unsigned char, char, bool, true);
-   TEST_TTR(unsigned char, signed char, bool, true);
-   TEST_TTR(unsigned char, short int, bool, true);
-   TEST_TTR(unsigned char, int, bool, true);
-   TEST_TTR(unsigned char, long int, bool, true);
-   TEST_TTR(unsigned char, unsigned char, bool, true);
-   TEST_TTR(unsigned char, unsigned short int, bool, true);
-   TEST_TTR(unsigned char, unsigned int, bool, true);
-   TEST_TTR(unsigned char, unsigned long int, bool, true);
-   TEST_TTR(unsigned char, wchar_t, bool, true);
-   TEST_TTR(unsigned char, float, bool, true);
-   TEST_TTR(unsigned char, double, bool, true);
-   TEST_TTR(unsigned char, long double, bool, true);
-   TEST_TTR(unsigned short int, bool, bool, true);
-   TEST_TTR(unsigned short int, char, bool, true);
-   TEST_TTR(unsigned short int, signed char, bool, true);
-   TEST_TTR(unsigned short int, short int, bool, true);
-   TEST_TTR(unsigned short int, int, bool, true);
-   TEST_TTR(unsigned short int, long int, bool, true);
-   TEST_TTR(unsigned short int, unsigned char, bool, true);
-   TEST_TTR(unsigned short int, unsigned short int, bool, true);
-   TEST_TTR(unsigned short int, unsigned int, bool, true);
-   TEST_TTR(unsigned short int, unsigned long int, bool, true);
-   TEST_TTR(unsigned short int, wchar_t, bool, true);
-   TEST_TTR(unsigned short int, float, bool, true);
-   TEST_TTR(unsigned short int, double, bool, true);
-   TEST_TTR(unsigned short int, long double, bool, true);
-   TEST_TTR(unsigned int, bool, bool, true);
-   TEST_TTR(unsigned int, char, bool, true);
-   TEST_TTR(unsigned int, signed char, bool, true);
-   TEST_TTR(unsigned int, short int, bool, true);
-   TEST_TTR(unsigned int, int, bool, true);
-   TEST_TTR(unsigned int, long int, bool, true);
-   TEST_TTR(unsigned int, unsigned char, bool, true);
-   TEST_TTR(unsigned int, unsigned short int, bool, true);
-   TEST_TTR(unsigned int, unsigned int, bool, true);
-   TEST_TTR(unsigned int, unsigned long int, bool, true);
-   TEST_TTR(unsigned int, wchar_t, bool, true);
-   TEST_TTR(unsigned int, float, bool, true);
-   TEST_TTR(unsigned int, double, bool, true);
-   TEST_TTR(unsigned int, long double, bool, true);
-   TEST_TTR(unsigned long int, bool, bool, true);
-   TEST_TTR(unsigned long int, char, bool, true);
-   TEST_TTR(unsigned long int, signed char, bool, true);
-   TEST_TTR(unsigned long int, short int, bool, true);
-   TEST_TTR(unsigned long int, int, bool, true);
-   TEST_TTR(unsigned long int, long int, bool, true);
-   TEST_TTR(unsigned long int, unsigned char, bool, true);
-   TEST_TTR(unsigned long int, unsigned short int, bool, true);
-   TEST_TTR(unsigned long int, unsigned int, bool, true);
-   TEST_TTR(unsigned long int, unsigned long int, bool, true);
-   TEST_TTR(unsigned long int, wchar_t, bool, true);
-   TEST_TTR(unsigned long int, float, bool, true);
-   TEST_TTR(unsigned long int, double, bool, true);
-   TEST_TTR(unsigned long int, long double, bool, true);
-   TEST_TTR(wchar_t, bool, bool, true);
-   TEST_TTR(wchar_t, char, bool, true);
-   TEST_TTR(wchar_t, signed char, bool, true);
-   TEST_TTR(wchar_t, short int, bool, true);
-   TEST_TTR(wchar_t, int, bool, true);
-   TEST_TTR(wchar_t, long int, bool, true);
-   TEST_TTR(wchar_t, unsigned char, bool, true);
-   TEST_TTR(wchar_t, unsigned short int, bool, true);
-   TEST_TTR(wchar_t, unsigned int, bool, true);
-   TEST_TTR(wchar_t, unsigned long int, bool, true);
-   TEST_TTR(wchar_t, wchar_t, bool, true);
-   TEST_TTR(wchar_t, float, bool, true);
-   TEST_TTR(wchar_t, double, bool, true);
-   TEST_TTR(wchar_t, long double, bool, true);
-   TEST_TTR(float, bool, bool, true);
-   TEST_TTR(float, char, bool, true);
-   TEST_TTR(float, signed char, bool, true);
-   TEST_TTR(float, short int, bool, true);
-   TEST_TTR(float, int, bool, true);
-   TEST_TTR(float, long int, bool, true);
-   TEST_TTR(float, unsigned char, bool, true);
-   TEST_TTR(float, unsigned short int, bool, true);
-   TEST_TTR(float, unsigned int, bool, true);
-   TEST_TTR(float, unsigned long int, bool, true);
-   TEST_TTR(float, wchar_t, bool, true);
-   TEST_TTR(float, float, bool, true);
-   TEST_TTR(float, double, bool, true);
-   TEST_TTR(float, long double, bool, true);
-   TEST_TTR(double, bool, bool, true);
-   TEST_TTR(double, char, bool, true);
-   TEST_TTR(double, signed char, bool, true);
-   TEST_TTR(double, short int, bool, true);
-   TEST_TTR(double, int, bool, true);
-   TEST_TTR(double, long int, bool, true);
-   TEST_TTR(double, unsigned char, bool, true);
-   TEST_TTR(double, unsigned short int, bool, true);
-   TEST_TTR(double, unsigned int, bool, true);
-   TEST_TTR(double, unsigned long int, bool, true);
-   TEST_TTR(double, wchar_t, bool, true);
-   TEST_TTR(double, float, bool, true);
-   TEST_TTR(double, double, bool, true);
-   TEST_TTR(double, long double, bool, true);
-   TEST_TTR(long double, bool, bool, true);
-   TEST_TTR(long double, char, bool, true);
-   TEST_TTR(long double, signed char, bool, true);
-   TEST_TTR(long double, short int, bool, true);
-   TEST_TTR(long double, int, bool, true);
-   TEST_TTR(long double, long int, bool, true);
-   TEST_TTR(long double, unsigned char, bool, true);
-   TEST_TTR(long double, unsigned short int, bool, true);
-   TEST_TTR(long double, unsigned int, bool, true);
-   TEST_TTR(long double, unsigned long int, bool, true);
-   TEST_TTR(long double, wchar_t, bool, true);
-   TEST_TTR(long double, float, bool, true);
-   TEST_TTR(long double, double, bool, true);
-   TEST_TTR(long double, long double, bool, true);
-   TEST_TTR(bool, bool, tag, false);
-   TEST_TTR(bool, char, tag, false);
-   TEST_TTR(bool, signed char, tag, false);
-   TEST_TTR(bool, short int, tag, false);
-   TEST_TTR(bool, int, tag, false);
-   TEST_TTR(bool, long int, tag, false);
-   TEST_TTR(bool, unsigned char, tag, false);
-   TEST_TTR(bool, unsigned short int, tag, false);
-   TEST_TTR(bool, unsigned int, tag, false);
-   TEST_TTR(bool, unsigned long int, tag, false);
-   TEST_TTR(bool, wchar_t, tag, false);
-   TEST_TTR(bool, float, tag, false);
-   TEST_TTR(bool, double, tag, false);
-   TEST_TTR(bool, long double, tag, false);
-   TEST_TTR(char, bool, tag, false);
-   TEST_TTR(char, char, tag, false);
-   TEST_TTR(char, signed char, tag, false);
-   TEST_TTR(char, short int, tag, false);
-   TEST_TTR(char, int, tag, false);
-   TEST_TTR(char, long int, tag, false);
-   TEST_TTR(char, unsigned char, tag, false);
-   TEST_TTR(char, unsigned short int, tag, false);
-   TEST_TTR(char, unsigned int, tag, false);
-   TEST_TTR(char, unsigned long int, tag, false);
-   TEST_TTR(char, wchar_t, tag, false);
-   TEST_TTR(char, float, tag, false);
-   TEST_TTR(char, double, tag, false);
-   TEST_TTR(char, long double, tag, false);
-   TEST_TTR(signed char, bool, tag, false);
-   TEST_TTR(signed char, char, tag, false);
-   TEST_TTR(signed char, signed char, tag, false);
-   TEST_TTR(signed char, short int, tag, false);
-   TEST_TTR(signed char, int, tag, false);
-   TEST_TTR(signed char, long int, tag, false);
-   TEST_TTR(signed char, unsigned char, tag, false);
-   TEST_TTR(signed char, unsigned short int, tag, false);
-   TEST_TTR(signed char, unsigned int, tag, false);
-   TEST_TTR(signed char, unsigned long int, tag, false);
-   TEST_TTR(signed char, wchar_t, tag, false);
-   TEST_TTR(signed char, float, tag, false);
-   TEST_TTR(signed char, double, tag, false);
-   TEST_TTR(signed char, long double, tag, false);
-   TEST_TTR(short int, bool, tag, false);
-   TEST_TTR(short int, char, tag, false);
-   TEST_TTR(short int, signed char, tag, false);
-   TEST_TTR(short int, short int, tag, false);
-   TEST_TTR(short int, int, tag, false);
-   TEST_TTR(short int, long int, tag, false);
-   TEST_TTR(short int, unsigned char, tag, false);
-   TEST_TTR(short int, unsigned short int, tag, false);
-   TEST_TTR(short int, unsigned int, tag, false);
-   TEST_TTR(short int, unsigned long int, tag, false);
-   TEST_TTR(short int, wchar_t, tag, false);
-   TEST_TTR(short int, float, tag, false);
-   TEST_TTR(short int, double, tag, false);
-   TEST_TTR(short int, long double, tag, false);
-   TEST_TTR(int, bool, tag, false);
-   TEST_TTR(int, char, tag, false);
-   TEST_TTR(int, signed char, tag, false);
-   TEST_TTR(int, short int, tag, false);
-   TEST_TTR(int, int, tag, false);
-   TEST_TTR(int, long int, tag, false);
-   TEST_TTR(int, unsigned char, tag, false);
-   TEST_TTR(int, unsigned short int, tag, false);
-   TEST_TTR(int, unsigned int, tag, false);
-   TEST_TTR(int, unsigned long int, tag, false);
-   TEST_TTR(int, wchar_t, tag, false);
-   TEST_TTR(int, float, tag, false);
-   TEST_TTR(int, double, tag, false);
-   TEST_TTR(int, long double, tag, false);
-   TEST_TTR(long int, bool, tag, false);
-   TEST_TTR(long int, char, tag, false);
-   TEST_TTR(long int, signed char, tag, false);
-   TEST_TTR(long int, short int, tag, false);
-   TEST_TTR(long int, int, tag, false);
-   TEST_TTR(long int, long int, tag, false);
-   TEST_TTR(long int, unsigned char, tag, false);
-   TEST_TTR(long int, unsigned short int, tag, false);
-   TEST_TTR(long int, unsigned int, tag, false);
-   TEST_TTR(long int, unsigned long int, tag, false);
-   TEST_TTR(long int, wchar_t, tag, false);
-   TEST_TTR(long int, float, tag, false);
-   TEST_TTR(long int, double, tag, false);
-   TEST_TTR(long int, long double, tag, false);
-   TEST_TTR(unsigned char, bool, tag, false);
-   TEST_TTR(unsigned char, char, tag, false);
-   TEST_TTR(unsigned char, signed char, tag, false);
-   TEST_TTR(unsigned char, short int, tag, false);
-   TEST_TTR(unsigned char, int, tag, false);
-   TEST_TTR(unsigned char, long int, tag, false);
-   TEST_TTR(unsigned char, unsigned char, tag, false);
-   TEST_TTR(unsigned char, unsigned short int, tag, false);
-   TEST_TTR(unsigned char, unsigned int, tag, false);
-   TEST_TTR(unsigned char, unsigned long int, tag, false);
-   TEST_TTR(unsigned char, wchar_t, tag, false);
-   TEST_TTR(unsigned char, float, tag, false);
-   TEST_TTR(unsigned char, double, tag, false);
-   TEST_TTR(unsigned char, long double, tag, false);
-   TEST_TTR(unsigned short int, bool, tag, false);
-   TEST_TTR(unsigned short int, char, tag, false);
-   TEST_TTR(unsigned short int, signed char, tag, false);
-   TEST_TTR(unsigned short int, short int, tag, false);
-   TEST_TTR(unsigned short int, int, tag, false);
-   TEST_TTR(unsigned short int, long int, tag, false);
-   TEST_TTR(unsigned short int, unsigned char, tag, false);
-   TEST_TTR(unsigned short int, unsigned short int, tag, false);
-   TEST_TTR(unsigned short int, unsigned int, tag, false);
-   TEST_TTR(unsigned short int, unsigned long int, tag, false);
-   TEST_TTR(unsigned short int, wchar_t, tag, false);
-   TEST_TTR(unsigned short int, float, tag, false);
-   TEST_TTR(unsigned short int, double, tag, false);
-   TEST_TTR(unsigned short int, long double, tag, false);
-   TEST_TTR(unsigned int, bool, tag, false);
-   TEST_TTR(unsigned int, char, tag, false);
-   TEST_TTR(unsigned int, signed char, tag, false);
-   TEST_TTR(unsigned int, short int, tag, false);
-   TEST_TTR(unsigned int, int, tag, false);
-   TEST_TTR(unsigned int, long int, tag, false);
-   TEST_TTR(unsigned int, unsigned char, tag, false);
-   TEST_TTR(unsigned int, unsigned short int, tag, false);
-   TEST_TTR(unsigned int, unsigned int, tag, false);
-   TEST_TTR(unsigned int, unsigned long int, tag, false);
-   TEST_TTR(unsigned int, wchar_t, tag, false);
-   TEST_TTR(unsigned int, float, tag, false);
-   TEST_TTR(unsigned int, double, tag, false);
-   TEST_TTR(unsigned int, long double, tag, false);
-   TEST_TTR(unsigned long int, bool, tag, false);
-   TEST_TTR(unsigned long int, char, tag, false);
-   TEST_TTR(unsigned long int, signed char, tag, false);
-   TEST_TTR(unsigned long int, short int, tag, false);
-   TEST_TTR(unsigned long int, int, tag, false);
-   TEST_TTR(unsigned long int, long int, tag, false);
-   TEST_TTR(unsigned long int, unsigned char, tag, false);
-   TEST_TTR(unsigned long int, unsigned short int, tag, false);
-   TEST_TTR(unsigned long int, unsigned int, tag, false);
-   TEST_TTR(unsigned long int, unsigned long int, tag, false);
-   TEST_TTR(unsigned long int, wchar_t, tag, false);
-   TEST_TTR(unsigned long int, float, tag, false);
-   TEST_TTR(unsigned long int, double, tag, false);
-   TEST_TTR(unsigned long int, long double, tag, false);
-   TEST_TTR(wchar_t, bool, tag, false);
-   TEST_TTR(wchar_t, char, tag, false);
-   TEST_TTR(wchar_t, signed char, tag, false);
-   TEST_TTR(wchar_t, short int, tag, false);
-   TEST_TTR(wchar_t, int, tag, false);
-   TEST_TTR(wchar_t, long int, tag, false);
-   TEST_TTR(wchar_t, unsigned char, tag, false);
-   TEST_TTR(wchar_t, unsigned short int, tag, false);
-   TEST_TTR(wchar_t, unsigned int, tag, false);
-   TEST_TTR(wchar_t, unsigned long int, tag, false);
-   TEST_TTR(wchar_t, wchar_t, tag, false);
-   TEST_TTR(wchar_t, float, tag, false);
-   TEST_TTR(wchar_t, double, tag, false);
-   TEST_TTR(wchar_t, long double, tag, false);
-   TEST_TTR(float, bool, tag, false);
-   TEST_TTR(float, char, tag, false);
-   TEST_TTR(float, signed char, tag, false);
-   TEST_TTR(float, short int, tag, false);
-   TEST_TTR(float, int, tag, false);
-   TEST_TTR(float, long int, tag, false);
-   TEST_TTR(float, unsigned char, tag, false);
-   TEST_TTR(float, unsigned short int, tag, false);
-   TEST_TTR(float, unsigned int, tag, false);
-   TEST_TTR(float, unsigned long int, tag, false);
-   TEST_TTR(float, wchar_t, tag, false);
-   TEST_TTR(float, float, tag, false);
-   TEST_TTR(float, double, tag, false);
-   TEST_TTR(float, long double, tag, false);
-   TEST_TTR(double, bool, tag, false);
-   TEST_TTR(double, char, tag, false);
-   TEST_TTR(double, signed char, tag, false);
-   TEST_TTR(double, short int, tag, false);
-   TEST_TTR(double, int, tag, false);
-   TEST_TTR(double, long int, tag, false);
-   TEST_TTR(double, unsigned char, tag, false);
-   TEST_TTR(double, unsigned short int, tag, false);
-   TEST_TTR(double, unsigned int, tag, false);
-   TEST_TTR(double, unsigned long int, tag, false);
-   TEST_TTR(double, wchar_t, tag, false);
-   TEST_TTR(double, float, tag, false);
-   TEST_TTR(double, double, tag, false);
-   TEST_TTR(double, long double, tag, false);
-   TEST_TTR(long double, bool, tag, false);
-   TEST_TTR(long double, char, tag, false);
-   TEST_TTR(long double, signed char, tag, false);
-   TEST_TTR(long double, short int, tag, false);
-   TEST_TTR(long double, int, tag, false);
-   TEST_TTR(long double, long int, tag, false);
-   TEST_TTR(long double, unsigned char, tag, false);
-   TEST_TTR(long double, unsigned short int, tag, false);
-   TEST_TTR(long double, unsigned int, tag, false);
-   TEST_TTR(long double, unsigned long int, tag, false);
-   TEST_TTR(long double, wchar_t, tag, false);
-   TEST_TTR(long double, float, tag, false);
-   TEST_TTR(long double, double, tag, false);
-   TEST_TTR(long double, long double, tag, false);
-#	undef CV1
-#	define CV1(T) const T
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const T&
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T&
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T&
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const T
-#	undef CV2
-#	define CV2(T) const T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const T&
-#	undef CV2
-#	define CV2(T) const T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T
-#	undef CV2
-#	define CV2(T) volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T&
-#	undef CV2
-#	define CV2(T) volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T
-#	undef CV2
-#	define CV2(T) const volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T&
-#	undef CV2
-#	define CV2(T) const volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-   // pointers
-   TEST_TT(void*, bool, true);
-   TEST_TT(void*, int, true);
-   TEST_TT(void*, double, true);
-   TEST_TT(void*, A, false);
-   TEST_TT(void*, B, false);
-   TEST_TT(bool*, bool, true);
-   TEST_TT(bool*, int, true);
-   TEST_TT(bool*, double, true);
-   TEST_TT(bool*, A, false);
-   TEST_TT(bool*, B, false);
-   TEST_TT(int*, bool, true);
-   TEST_TT(int*, int, true);
-   TEST_TT(int*, double, true);
-   TEST_TT(int*, A, false);
-   TEST_TT(int*, B, false);
-   TEST_TT(double*, bool, true);
-   TEST_TT(double*, int, true);
-   TEST_TT(double*, double, true);
-   TEST_TT(double*, A, false);
-   TEST_TT(double*, B, false);
-   TEST_TT(A*, bool, true);
-   TEST_TT(A*, int, true);
-   TEST_TT(A*, double, true);
-   TEST_TT(A*, A, false);
-   TEST_TT(A*, B, false);
-   TEST_TT(B*, bool, true);
-   TEST_TT(B*, int, true);
-   TEST_TT(B*, double, true);
-   TEST_TT(B*, A, false);
-   TEST_TT(B*, B, false);
-   TEST_TT(bool, void*, true);
-   TEST_TT(bool, bool*, true);
-   TEST_TT(bool, int*, true);
-   TEST_TT(bool, double*, true);
-   TEST_TT(bool, A*, true);
-   TEST_TT(bool, B*, true);
-   TEST_TT(int, void*, true);
-   TEST_TT(int, bool*, true);
-   TEST_TT(int, int*, true);
-   TEST_TT(int, double*, true);
-   TEST_TT(int, A*, true);
-   TEST_TT(int, B*, true);
-   TEST_TT(double, void*, true);
-   TEST_TT(double, bool*, true);
-   TEST_TT(double, int*, true);
-   TEST_TT(double, double*, true);
-   TEST_TT(double, A*, true);
-   TEST_TT(double, B*, true);
-   TEST_TT(A, void*, false);
-   TEST_TT(A, bool*, false);
-   TEST_TT(A, int*, false);
-   TEST_TT(A, double*, false);
-   TEST_TT(A, A*, false);
-   TEST_TT(A, B*, false);
-   TEST_TT(B, void*, false);
-   TEST_TT(B, bool*, false);
-   TEST_TT(B, int*, false);
-   TEST_TT(B, double*, false);
-   TEST_TT(B, A*, false);
-   TEST_TT(B, B*, false);
-   TEST_TT(void*, void*, true);
-   TEST_TT(void*, bool*, true);
-   TEST_TT(void*, int*, true);
-   TEST_TT(void*, double*, true);
-   TEST_TT(void*, A*, true);
-   TEST_TT(void*, B*, true);
-   TEST_TT(bool*, void*, true);
-   TEST_TT(bool*, bool*, true);
-   TEST_TT(bool*, int*, true);
-   TEST_TT(bool*, double*, true);
-   TEST_TT(bool*, A*, true);
-   TEST_TT(bool*, B*, true);
-   TEST_TT(int*, void*, true);
-   TEST_TT(int*, bool*, true);
-   TEST_TT(int*, int*, true);
-   TEST_TT(int*, double*, true);
-   TEST_TT(int*, A*, true);
-   TEST_TT(int*, B*, true);
-   TEST_TT(double*, void*, true);
-   TEST_TT(double*, bool*, true);
-   TEST_TT(double*, int*, true);
-   TEST_TT(double*, double*, true);
-   TEST_TT(double*, A*, true);
-   TEST_TT(double*, B*, true);
-   TEST_TT(A*, void*, true);
-   TEST_TT(A*, bool*, true);
-   TEST_TT(A*, int*, true);
-   TEST_TT(A*, double*, true);
-   TEST_TT(A*, A*, true);
-   TEST_TT(A*, B*, true);
-   TEST_TT(B*, void*, true);
-   TEST_TT(B*, bool*, true);
-   TEST_TT(B*, int*, true);
-   TEST_TT(B*, double*, true);
-   TEST_TT(B*, A*, true);
-   TEST_TT(B*, B*, true);
-   TEST_TT(C, void*, true);
-   TEST_TT(D, void*, false);
-   TEST_TT(void*, C, false);
-   TEST_TT(void*, D, true);
-   TEST_TT(C, D, true);
-}
-}

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,1250 +0,0 @@
-//  (C) Copyright Frederic Bron 2009-2011.
-//  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)
-
-namespace {
-
-void run2() {
-   // test with only one template parameter
-   TEST_T(void, false);
-   TEST_T(bool, true);
-   TEST_T(char, true);
-   TEST_T(signed char, true);
-   TEST_T(short int, true);
-   TEST_T(int, true);
-   TEST_T(long int, true);
-   TEST_T(unsigned char, true);
-   TEST_T(unsigned short int, true);
-   TEST_T(unsigned int, true);
-   TEST_T(unsigned long int, true);
-   TEST_T(wchar_t, true);
-   TEST_T(float, true);
-   TEST_T(double, true);
-   TEST_T(long double, true);
-   TEST_T(void, false);
-#	undef CV
-#	define CV(T) const T
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	undef CV
-#	define CV(T) volatile T
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	undef CV
-#	define CV(T) const volatile T
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	undef CV
-#	define CV(T) const T&
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	undef CV
-#	define CV(T) volatile T&
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	undef CV
-#	define CV(T) const volatile T&
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   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);
-   TEST_TT(bool, short int, true);
-   TEST_TT(bool, int, true);
-   TEST_TT(bool, long int, true);
-   TEST_TT(bool, unsigned char, true);
-   TEST_TT(bool, unsigned short int, true);
-   TEST_TT(bool, unsigned int, true);
-   TEST_TT(bool, unsigned long int, true);
-   TEST_TT(bool, wchar_t, true);
-   TEST_TT(bool, float, true);
-   TEST_TT(bool, double, true);
-   TEST_TT(bool, long double, true);
-   TEST_TT(char, bool, true);
-   TEST_TT(char, char, true);
-   TEST_TT(char, signed char, true);
-   TEST_TT(char, short int, true);
-   TEST_TT(char, int, true);
-   TEST_TT(char, long int, true);
-   TEST_TT(char, unsigned char, true);
-   TEST_TT(char, unsigned short int, true);
-   TEST_TT(char, unsigned int, true);
-   TEST_TT(char, unsigned long int, true);
-   TEST_TT(char, wchar_t, true);
-   TEST_TT(char, float, true);
-   TEST_TT(char, double, true);
-   TEST_TT(char, long double, true);
-   TEST_TT(signed char, bool, true);
-   TEST_TT(signed char, char, true);
-   TEST_TT(signed char, signed char, true);
-   TEST_TT(signed char, short int, true);
-   TEST_TT(signed char, int, true);
-   TEST_TT(signed char, long int, true);
-   TEST_TT(signed char, unsigned char, true);
-   TEST_TT(signed char, unsigned short int, true);
-   TEST_TT(signed char, unsigned int, true);
-   TEST_TT(signed char, unsigned long int, true);
-   TEST_TT(signed char, wchar_t, true);
-   TEST_TT(signed char, float, true);
-   TEST_TT(signed char, double, true);
-   TEST_TT(signed char, long double, true);
-   TEST_TT(short int, bool, true);
-   TEST_TT(short int, char, true);
-   TEST_TT(short int, signed char, true);
-   TEST_TT(short int, short int, true);
-   TEST_TT(short int, int, true);
-   TEST_TT(short int, long int, true);
-   TEST_TT(short int, unsigned char, true);
-   TEST_TT(short int, unsigned short int, true);
-   TEST_TT(short int, unsigned int, true);
-   TEST_TT(short int, unsigned long int, true);
-   TEST_TT(short int, wchar_t, true);
-   TEST_TT(short int, float, true);
-   TEST_TT(short int, double, true);
-   TEST_TT(short int, long double, true);
-   TEST_TT(int, bool, true);
-   TEST_TT(int, char, true);
-   TEST_TT(int, signed char, true);
-   TEST_TT(int, short int, true);
-   TEST_TT(int, int, true);
-   TEST_TT(int, long int, true);
-   TEST_TT(int, unsigned char, true);
-   TEST_TT(int, unsigned short int, true);
-   TEST_TT(int, unsigned int, true);
-   TEST_TT(int, unsigned long int, true);
-   TEST_TT(int, wchar_t, true);
-   TEST_TT(int, float, true);
-   TEST_TT(int, double, true);
-   TEST_TT(int, long double, true);
-   TEST_TT(long int, bool, true);
-   TEST_TT(long int, char, true);
-   TEST_TT(long int, signed char, true);
-   TEST_TT(long int, short int, true);
-   TEST_TT(long int, int, true);
-   TEST_TT(long int, long int, true);
-   TEST_TT(long int, unsigned char, true);
-   TEST_TT(long int, unsigned short int, true);
-   TEST_TT(long int, unsigned int, true);
-   TEST_TT(long int, unsigned long int, true);
-   TEST_TT(long int, wchar_t, true);
-   TEST_TT(long int, float, true);
-   TEST_TT(long int, double, true);
-   TEST_TT(long int, long double, true);
-   TEST_TT(unsigned char, bool, true);
-   TEST_TT(unsigned char, char, true);
-   TEST_TT(unsigned char, signed char, true);
-   TEST_TT(unsigned char, short int, true);
-   TEST_TT(unsigned char, int, true);
-   TEST_TT(unsigned char, long int, true);
-   TEST_TT(unsigned char, unsigned char, true);
-   TEST_TT(unsigned char, unsigned short int, true);
-   TEST_TT(unsigned char, unsigned int, true);
-   TEST_TT(unsigned char, unsigned long int, true);
-   TEST_TT(unsigned char, wchar_t, true);
-   TEST_TT(unsigned char, float, true);
-   TEST_TT(unsigned char, double, true);
-   TEST_TT(unsigned char, long double, true);
-   TEST_TT(unsigned short int, bool, true);
-   TEST_TT(unsigned short int, char, true);
-   TEST_TT(unsigned short int, signed char, true);
-   TEST_TT(unsigned short int, short int, true);
-   TEST_TT(unsigned short int, int, true);
-   TEST_TT(unsigned short int, long int, true);
-   TEST_TT(unsigned short int, unsigned char, true);
-   TEST_TT(unsigned short int, unsigned short int, true);
-   TEST_TT(unsigned short int, unsigned int, true);
-   TEST_TT(unsigned short int, unsigned long int, true);
-   TEST_TT(unsigned short int, wchar_t, true);
-   TEST_TT(unsigned short int, float, true);
-   TEST_TT(unsigned short int, double, true);
-   TEST_TT(unsigned short int, long double, true);
-   TEST_TT(unsigned int, bool, true);
-   TEST_TT(unsigned int, char, true);
-   TEST_TT(unsigned int, signed char, true);
-   TEST_TT(unsigned int, short int, true);
-   TEST_TT(unsigned int, int, true);
-   TEST_TT(unsigned int, long int, true);
-   TEST_TT(unsigned int, unsigned char, true);
-   TEST_TT(unsigned int, unsigned short int, true);
-   TEST_TT(unsigned int, unsigned int, true);
-   TEST_TT(unsigned int, unsigned long int, true);
-   TEST_TT(unsigned int, wchar_t, true);
-   TEST_TT(unsigned int, float, true);
-   TEST_TT(unsigned int, double, true);
-   TEST_TT(unsigned int, long double, true);
-   TEST_TT(unsigned long int, bool, true);
-   TEST_TT(unsigned long int, char, true);
-   TEST_TT(unsigned long int, signed char, true);
-   TEST_TT(unsigned long int, short int, true);
-   TEST_TT(unsigned long int, int, true);
-   TEST_TT(unsigned long int, long int, true);
-   TEST_TT(unsigned long int, unsigned char, true);
-   TEST_TT(unsigned long int, unsigned short int, true);
-   TEST_TT(unsigned long int, unsigned int, true);
-   TEST_TT(unsigned long int, unsigned long int, true);
-   TEST_TT(unsigned long int, wchar_t, true);
-   TEST_TT(unsigned long int, float, true);
-   TEST_TT(unsigned long int, double, true);
-   TEST_TT(unsigned long int, long double, true);
-   TEST_TT(wchar_t, bool, true);
-   TEST_TT(wchar_t, char, true);
-   TEST_TT(wchar_t, signed char, true);
-   TEST_TT(wchar_t, short int, true);
-   TEST_TT(wchar_t, int, true);
-   TEST_TT(wchar_t, long int, true);
-   TEST_TT(wchar_t, unsigned char, true);
-   TEST_TT(wchar_t, unsigned short int, true);
-   TEST_TT(wchar_t, unsigned int, true);
-   TEST_TT(wchar_t, unsigned long int, true);
-   TEST_TT(wchar_t, wchar_t, true);
-   TEST_TT(wchar_t, float, true);
-   TEST_TT(wchar_t, double, true);
-   TEST_TT(wchar_t, long double, true);
-   TEST_TT(float, bool, true);
-   TEST_TT(float, char, true);
-   TEST_TT(float, signed char, true);
-   TEST_TT(float, short int, true);
-   TEST_TT(float, int, true);
-   TEST_TT(float, long int, true);
-   TEST_TT(float, unsigned char, true);
-   TEST_TT(float, unsigned short int, true);
-   TEST_TT(float, unsigned int, true);
-   TEST_TT(float, unsigned long int, true);
-   TEST_TT(float, wchar_t, true);
-   TEST_TT(float, float, true);
-   TEST_TT(float, double, true);
-   TEST_TT(float, long double, true);
-   TEST_TT(double, bool, true);
-   TEST_TT(double, char, true);
-   TEST_TT(double, signed char, true);
-   TEST_TT(double, short int, true);
-   TEST_TT(double, int, true);
-   TEST_TT(double, long int, true);
-   TEST_TT(double, unsigned char, true);
-   TEST_TT(double, unsigned short int, true);
-   TEST_TT(double, unsigned int, true);
-   TEST_TT(double, unsigned long int, true);
-   TEST_TT(double, wchar_t, true);
-   TEST_TT(double, float, true);
-   TEST_TT(double, double, true);
-   TEST_TT(double, long double, true);
-   TEST_TT(long double, bool, true);
-   TEST_TT(long double, char, true);
-   TEST_TT(long double, signed char, true);
-   TEST_TT(long double, short int, true);
-   TEST_TT(long double, int, true);
-   TEST_TT(long double, long int, true);
-   TEST_TT(long double, unsigned char, true);
-   TEST_TT(long double, unsigned short int, true);
-   TEST_TT(long double, unsigned int, true);
-   TEST_TT(long double, unsigned long int, true);
-   TEST_TT(long double, wchar_t, true);
-   TEST_TT(long double, float, true);
-   TEST_TT(long double, double, true);
-   TEST_TT(long double, long double, true);
-   TEST_TT(bool, void, false);
-   TEST_TT(void, bool, false);
-   TEST_TT(char, void, false);
-   TEST_TT(void, char, false);
-   TEST_TT(signed char, void, false);
-   TEST_TT(void, signed char, false);
-   TEST_TT(short int, void, false);
-   TEST_TT(void, short int, false);
-   TEST_TT(int, void, false);
-   TEST_TT(void, int, false);
-   TEST_TT(long int, void, false);
-   TEST_TT(void, long int, false);
-   TEST_TT(unsigned char, void, false);
-   TEST_TT(void, unsigned char, false);
-   TEST_TT(unsigned short int, void, false);
-   TEST_TT(void, unsigned short int, false);
-   TEST_TT(unsigned int, void, false);
-   TEST_TT(void, unsigned int, false);
-   TEST_TT(unsigned long int, void, false);
-   TEST_TT(void, unsigned long int, false);
-   TEST_TT(wchar_t, void, false);
-   TEST_TT(void, wchar_t, false);
-   TEST_TT(float, void, false);
-   TEST_TT(void, float, false);
-   TEST_TT(double, void, false);
-   TEST_TT(void, double, false);
-   TEST_TT(long double, void, false);
-   TEST_TT(void, long double, false);
-
-// test with three template parameters
-   TEST_TTR(bool, bool, bool, true);
-   TEST_TTR(bool, char, bool, true);
-   TEST_TTR(bool, signed char, bool, true);
-   TEST_TTR(bool, short int, bool, true);
-   TEST_TTR(bool, int, bool, true);
-   TEST_TTR(bool, long int, bool, true);
-   TEST_TTR(bool, unsigned char, bool, true);
-   TEST_TTR(bool, unsigned short int, bool, true);
-   TEST_TTR(bool, unsigned int, bool, true);
-   TEST_TTR(bool, unsigned long int, bool, true);
-   TEST_TTR(bool, wchar_t, bool, true);
-   TEST_TTR(bool, float, bool, true);
-   TEST_TTR(bool, double, bool, true);
-   TEST_TTR(bool, long double, bool, true);
-   TEST_TTR(char, bool, bool, true);
-   TEST_TTR(char, char, bool, true);
-   TEST_TTR(char, signed char, bool, true);
-   TEST_TTR(char, short int, bool, true);
-   TEST_TTR(char, int, bool, true);
-   TEST_TTR(char, long int, bool, true);
-   TEST_TTR(char, unsigned char, bool, true);
-   TEST_TTR(char, unsigned short int, bool, true);
-   TEST_TTR(char, unsigned int, bool, true);
-   TEST_TTR(char, unsigned long int, bool, true);
-   TEST_TTR(char, wchar_t, bool, true);
-   TEST_TTR(char, float, bool, true);
-   TEST_TTR(char, double, bool, true);
-   TEST_TTR(char, long double, bool, true);
-   TEST_TTR(signed char, bool, bool, true);
-   TEST_TTR(signed char, char, bool, true);
-   TEST_TTR(signed char, signed char, bool, true);
-   TEST_TTR(signed char, short int, bool, true);
-   TEST_TTR(signed char, int, bool, true);
-   TEST_TTR(signed char, long int, bool, true);
-   TEST_TTR(signed char, unsigned char, bool, true);
-   TEST_TTR(signed char, unsigned short int, bool, true);
-   TEST_TTR(signed char, unsigned int, bool, true);
-   TEST_TTR(signed char, unsigned long int, bool, true);
-   TEST_TTR(signed char, wchar_t, bool, true);
-   TEST_TTR(signed char, float, bool, true);
-   TEST_TTR(signed char, double, bool, true);
-   TEST_TTR(signed char, long double, bool, true);
-   TEST_TTR(short int, bool, bool, true);
-   TEST_TTR(short int, char, bool, true);
-   TEST_TTR(short int, signed char, bool, true);
-   TEST_TTR(short int, short int, bool, true);
-   TEST_TTR(short int, int, bool, true);
-   TEST_TTR(short int, long int, bool, true);
-   TEST_TTR(short int, unsigned char, bool, true);
-   TEST_TTR(short int, unsigned short int, bool, true);
-   TEST_TTR(short int, unsigned int, bool, true);
-   TEST_TTR(short int, unsigned long int, bool, true);
-   TEST_TTR(short int, wchar_t, bool, true);
-   TEST_TTR(short int, float, bool, true);
-   TEST_TTR(short int, double, bool, true);
-   TEST_TTR(short int, long double, bool, true);
-   TEST_TTR(int, bool, bool, true);
-   TEST_TTR(int, char, bool, true);
-   TEST_TTR(int, signed char, bool, true);
-   TEST_TTR(int, short int, bool, true);
-   TEST_TTR(int, int, bool, true);
-   TEST_TTR(int, long int, bool, true);
-   TEST_TTR(int, unsigned char, bool, true);
-   TEST_TTR(int, unsigned short int, bool, true);
-   TEST_TTR(int, unsigned int, bool, true);
-   TEST_TTR(int, unsigned long int, bool, true);
-   TEST_TTR(int, wchar_t, bool, true);
-   TEST_TTR(int, float, bool, true);
-   TEST_TTR(int, double, bool, true);
-   TEST_TTR(int, long double, bool, true);
-   TEST_TTR(long int, bool, bool, true);
-   TEST_TTR(long int, char, bool, true);
-   TEST_TTR(long int, signed char, bool, true);
-   TEST_TTR(long int, short int, bool, true);
-   TEST_TTR(long int, int, bool, true);
-   TEST_TTR(long int, long int, bool, true);
-   TEST_TTR(long int, unsigned char, bool, true);
-   TEST_TTR(long int, unsigned short int, bool, true);
-   TEST_TTR(long int, unsigned int, bool, true);
-   TEST_TTR(long int, unsigned long int, bool, true);
-   TEST_TTR(long int, wchar_t, bool, true);
-   TEST_TTR(long int, float, bool, true);
-   TEST_TTR(long int, double, bool, true);
-   TEST_TTR(long int, long double, bool, true);
-   TEST_TTR(unsigned char, bool, bool, true);
-   TEST_TTR(unsigned char, char, bool, true);
-   TEST_TTR(unsigned char, signed char, bool, true);
-   TEST_TTR(unsigned char, short int, bool, true);
-   TEST_TTR(unsigned char, int, bool, true);
-   TEST_TTR(unsigned char, long int, bool, true);
-   TEST_TTR(unsigned char, unsigned char, bool, true);
-   TEST_TTR(unsigned char, unsigned short int, bool, true);
-   TEST_TTR(unsigned char, unsigned int, bool, true);
-   TEST_TTR(unsigned char, unsigned long int, bool, true);
-   TEST_TTR(unsigned char, wchar_t, bool, true);
-   TEST_TTR(unsigned char, float, bool, true);
-   TEST_TTR(unsigned char, double, bool, true);
-   TEST_TTR(unsigned char, long double, bool, true);
-   TEST_TTR(unsigned short int, bool, bool, true);
-   TEST_TTR(unsigned short int, char, bool, true);
-   TEST_TTR(unsigned short int, signed char, bool, true);
-   TEST_TTR(unsigned short int, short int, bool, true);
-   TEST_TTR(unsigned short int, int, bool, true);
-   TEST_TTR(unsigned short int, long int, bool, true);
-   TEST_TTR(unsigned short int, unsigned char, bool, true);
-   TEST_TTR(unsigned short int, unsigned short int, bool, true);
-   TEST_TTR(unsigned short int, unsigned int, bool, true);
-   TEST_TTR(unsigned short int, unsigned long int, bool, true);
-   TEST_TTR(unsigned short int, wchar_t, bool, true);
-   TEST_TTR(unsigned short int, float, bool, true);
-   TEST_TTR(unsigned short int, double, bool, true);
-   TEST_TTR(unsigned short int, long double, bool, true);
-   TEST_TTR(unsigned int, bool, bool, true);
-   TEST_TTR(unsigned int, char, bool, true);
-   TEST_TTR(unsigned int, signed char, bool, true);
-   TEST_TTR(unsigned int, short int, bool, true);
-   TEST_TTR(unsigned int, int, bool, true);
-   TEST_TTR(unsigned int, long int, bool, true);
-   TEST_TTR(unsigned int, unsigned char, bool, true);
-   TEST_TTR(unsigned int, unsigned short int, bool, true);
-   TEST_TTR(unsigned int, unsigned int, bool, true);
-   TEST_TTR(unsigned int, unsigned long int, bool, true);
-   TEST_TTR(unsigned int, wchar_t, bool, true);
-   TEST_TTR(unsigned int, float, bool, true);
-   TEST_TTR(unsigned int, double, bool, true);
-   TEST_TTR(unsigned int, long double, bool, true);
-   TEST_TTR(unsigned long int, bool, bool, true);
-   TEST_TTR(unsigned long int, char, bool, true);
-   TEST_TTR(unsigned long int, signed char, bool, true);
-   TEST_TTR(unsigned long int, short int, bool, true);
-   TEST_TTR(unsigned long int, int, bool, true);
-   TEST_TTR(unsigned long int, long int, bool, true);
-   TEST_TTR(unsigned long int, unsigned char, bool, true);
-   TEST_TTR(unsigned long int, unsigned short int, bool, true);
-   TEST_TTR(unsigned long int, unsigned int, bool, true);
-   TEST_TTR(unsigned long int, unsigned long int, bool, true);
-   TEST_TTR(unsigned long int, wchar_t, bool, true);
-   TEST_TTR(unsigned long int, float, bool, true);
-   TEST_TTR(unsigned long int, double, bool, true);
-   TEST_TTR(unsigned long int, long double, bool, true);
-   TEST_TTR(wchar_t, bool, bool, true);
-   TEST_TTR(wchar_t, char, bool, true);
-   TEST_TTR(wchar_t, signed char, bool, true);
-   TEST_TTR(wchar_t, short int, bool, true);
-   TEST_TTR(wchar_t, int, bool, true);
-   TEST_TTR(wchar_t, long int, bool, true);
-   TEST_TTR(wchar_t, unsigned char, bool, true);
-   TEST_TTR(wchar_t, unsigned short int, bool, true);
-   TEST_TTR(wchar_t, unsigned int, bool, true);
-   TEST_TTR(wchar_t, unsigned long int, bool, true);
-   TEST_TTR(wchar_t, wchar_t, bool, true);
-   TEST_TTR(wchar_t, float, bool, true);
-   TEST_TTR(wchar_t, double, bool, true);
-   TEST_TTR(wchar_t, long double, bool, true);
-   TEST_TTR(float, bool, bool, true);
-   TEST_TTR(float, char, bool, true);
-   TEST_TTR(float, signed char, bool, true);
-   TEST_TTR(float, short int, bool, true);
-   TEST_TTR(float, int, bool, true);
-   TEST_TTR(float, long int, bool, true);
-   TEST_TTR(float, unsigned char, bool, true);
-   TEST_TTR(float, unsigned short int, bool, true);
-   TEST_TTR(float, unsigned int, bool, true);
-   TEST_TTR(float, unsigned long int, bool, true);
-   TEST_TTR(float, wchar_t, bool, true);
-   TEST_TTR(float, float, bool, true);
-   TEST_TTR(float, double, bool, true);
-   TEST_TTR(float, long double, bool, true);
-   TEST_TTR(double, bool, bool, true);
-   TEST_TTR(double, char, bool, true);
-   TEST_TTR(double, signed char, bool, true);
-   TEST_TTR(double, short int, bool, true);
-   TEST_TTR(double, int, bool, true);
-   TEST_TTR(double, long int, bool, true);
-   TEST_TTR(double, unsigned char, bool, true);
-   TEST_TTR(double, unsigned short int, bool, true);
-   TEST_TTR(double, unsigned int, bool, true);
-   TEST_TTR(double, unsigned long int, bool, true);
-   TEST_TTR(double, wchar_t, bool, true);
-   TEST_TTR(double, float, bool, true);
-   TEST_TTR(double, double, bool, true);
-   TEST_TTR(double, long double, bool, true);
-   TEST_TTR(long double, bool, bool, true);
-   TEST_TTR(long double, char, bool, true);
-   TEST_TTR(long double, signed char, bool, true);
-   TEST_TTR(long double, short int, bool, true);
-   TEST_TTR(long double, int, bool, true);
-   TEST_TTR(long double, long int, bool, true);
-   TEST_TTR(long double, unsigned char, bool, true);
-   TEST_TTR(long double, unsigned short int, bool, true);
-   TEST_TTR(long double, unsigned int, bool, true);
-   TEST_TTR(long double, unsigned long int, bool, true);
-   TEST_TTR(long double, wchar_t, bool, true);
-   TEST_TTR(long double, float, bool, true);
-   TEST_TTR(long double, double, bool, true);
-   TEST_TTR(long double, long double, bool, true);
-   TEST_TTR(bool, bool, tag, false);
-   TEST_TTR(bool, char, tag, false);
-   TEST_TTR(bool, signed char, tag, false);
-   TEST_TTR(bool, short int, tag, false);
-   TEST_TTR(bool, int, tag, false);
-   TEST_TTR(bool, long int, tag, false);
-   TEST_TTR(bool, unsigned char, tag, false);
-   TEST_TTR(bool, unsigned short int, tag, false);
-   TEST_TTR(bool, unsigned int, tag, false);
-   TEST_TTR(bool, unsigned long int, tag, false);
-   TEST_TTR(bool, wchar_t, tag, false);
-   TEST_TTR(bool, float, tag, false);
-   TEST_TTR(bool, double, tag, false);
-   TEST_TTR(bool, long double, tag, false);
-   TEST_TTR(char, bool, tag, false);
-   TEST_TTR(char, char, tag, false);
-   TEST_TTR(char, signed char, tag, false);
-   TEST_TTR(char, short int, tag, false);
-   TEST_TTR(char, int, tag, false);
-   TEST_TTR(char, long int, tag, false);
-   TEST_TTR(char, unsigned char, tag, false);
-   TEST_TTR(char, unsigned short int, tag, false);
-   TEST_TTR(char, unsigned int, tag, false);
-   TEST_TTR(char, unsigned long int, tag, false);
-   TEST_TTR(char, wchar_t, tag, false);
-   TEST_TTR(char, float, tag, false);
-   TEST_TTR(char, double, tag, false);
-   TEST_TTR(char, long double, tag, false);
-   TEST_TTR(signed char, bool, tag, false);
-   TEST_TTR(signed char, char, tag, false);
-   TEST_TTR(signed char, signed char, tag, false);
-   TEST_TTR(signed char, short int, tag, false);
-   TEST_TTR(signed char, int, tag, false);
-   TEST_TTR(signed char, long int, tag, false);
-   TEST_TTR(signed char, unsigned char, tag, false);
-   TEST_TTR(signed char, unsigned short int, tag, false);
-   TEST_TTR(signed char, unsigned int, tag, false);
-   TEST_TTR(signed char, unsigned long int, tag, false);
-   TEST_TTR(signed char, wchar_t, tag, false);
-   TEST_TTR(signed char, float, tag, false);
-   TEST_TTR(signed char, double, tag, false);
-   TEST_TTR(signed char, long double, tag, false);
-   TEST_TTR(short int, bool, tag, false);
-   TEST_TTR(short int, char, tag, false);
-   TEST_TTR(short int, signed char, tag, false);
-   TEST_TTR(short int, short int, tag, false);
-   TEST_TTR(short int, int, tag, false);
-   TEST_TTR(short int, long int, tag, false);
-   TEST_TTR(short int, unsigned char, tag, false);
-   TEST_TTR(short int, unsigned short int, tag, false);
-   TEST_TTR(short int, unsigned int, tag, false);
-   TEST_TTR(short int, unsigned long int, tag, false);
-   TEST_TTR(short int, wchar_t, tag, false);
-   TEST_TTR(short int, float, tag, false);
-   TEST_TTR(short int, double, tag, false);
-   TEST_TTR(short int, long double, tag, false);
-   TEST_TTR(int, bool, tag, false);
-   TEST_TTR(int, char, tag, false);
-   TEST_TTR(int, signed char, tag, false);
-   TEST_TTR(int, short int, tag, false);
-   TEST_TTR(int, int, tag, false);
-   TEST_TTR(int, long int, tag, false);
-   TEST_TTR(int, unsigned char, tag, false);
-   TEST_TTR(int, unsigned short int, tag, false);
-   TEST_TTR(int, unsigned int, tag, false);
-   TEST_TTR(int, unsigned long int, tag, false);
-   TEST_TTR(int, wchar_t, tag, false);
-   TEST_TTR(int, float, tag, false);
-   TEST_TTR(int, double, tag, false);
-   TEST_TTR(int, long double, tag, false);
-   TEST_TTR(long int, bool, tag, false);
-   TEST_TTR(long int, char, tag, false);
-   TEST_TTR(long int, signed char, tag, false);
-   TEST_TTR(long int, short int, tag, false);
-   TEST_TTR(long int, int, tag, false);
-   TEST_TTR(long int, long int, tag, false);
-   TEST_TTR(long int, unsigned char, tag, false);
-   TEST_TTR(long int, unsigned short int, tag, false);
-   TEST_TTR(long int, unsigned int, tag, false);
-   TEST_TTR(long int, unsigned long int, tag, false);
-   TEST_TTR(long int, wchar_t, tag, false);
-   TEST_TTR(long int, float, tag, false);
-   TEST_TTR(long int, double, tag, false);
-   TEST_TTR(long int, long double, tag, false);
-   TEST_TTR(unsigned char, bool, tag, false);
-   TEST_TTR(unsigned char, char, tag, false);
-   TEST_TTR(unsigned char, signed char, tag, false);
-   TEST_TTR(unsigned char, short int, tag, false);
-   TEST_TTR(unsigned char, int, tag, false);
-   TEST_TTR(unsigned char, long int, tag, false);
-   TEST_TTR(unsigned char, unsigned char, tag, false);
-   TEST_TTR(unsigned char, unsigned short int, tag, false);
-   TEST_TTR(unsigned char, unsigned int, tag, false);
-   TEST_TTR(unsigned char, unsigned long int, tag, false);
-   TEST_TTR(unsigned char, wchar_t, tag, false);
-   TEST_TTR(unsigned char, float, tag, false);
-   TEST_TTR(unsigned char, double, tag, false);
-   TEST_TTR(unsigned char, long double, tag, false);
-   TEST_TTR(unsigned short int, bool, tag, false);
-   TEST_TTR(unsigned short int, char, tag, false);
-   TEST_TTR(unsigned short int, signed char, tag, false);
-   TEST_TTR(unsigned short int, short int, tag, false);
-   TEST_TTR(unsigned short int, int, tag, false);
-   TEST_TTR(unsigned short int, long int, tag, false);
-   TEST_TTR(unsigned short int, unsigned char, tag, false);
-   TEST_TTR(unsigned short int, unsigned short int, tag, false);
-   TEST_TTR(unsigned short int, unsigned int, tag, false);
-   TEST_TTR(unsigned short int, unsigned long int, tag, false);
-   TEST_TTR(unsigned short int, wchar_t, tag, false);
-   TEST_TTR(unsigned short int, float, tag, false);
-   TEST_TTR(unsigned short int, double, tag, false);
-   TEST_TTR(unsigned short int, long double, tag, false);
-   TEST_TTR(unsigned int, bool, tag, false);
-   TEST_TTR(unsigned int, char, tag, false);
-   TEST_TTR(unsigned int, signed char, tag, false);
-   TEST_TTR(unsigned int, short int, tag, false);
-   TEST_TTR(unsigned int, int, tag, false);
-   TEST_TTR(unsigned int, long int, tag, false);
-   TEST_TTR(unsigned int, unsigned char, tag, false);
-   TEST_TTR(unsigned int, unsigned short int, tag, false);
-   TEST_TTR(unsigned int, unsigned int, tag, false);
-   TEST_TTR(unsigned int, unsigned long int, tag, false);
-   TEST_TTR(unsigned int, wchar_t, tag, false);
-   TEST_TTR(unsigned int, float, tag, false);
-   TEST_TTR(unsigned int, double, tag, false);
-   TEST_TTR(unsigned int, long double, tag, false);
-   TEST_TTR(unsigned long int, bool, tag, false);
-   TEST_TTR(unsigned long int, char, tag, false);
-   TEST_TTR(unsigned long int, signed char, tag, false);
-   TEST_TTR(unsigned long int, short int, tag, false);
-   TEST_TTR(unsigned long int, int, tag, false);
-   TEST_TTR(unsigned long int, long int, tag, false);
-   TEST_TTR(unsigned long int, unsigned char, tag, false);
-   TEST_TTR(unsigned long int, unsigned short int, tag, false);
-   TEST_TTR(unsigned long int, unsigned int, tag, false);
-   TEST_TTR(unsigned long int, unsigned long int, tag, false);
-   TEST_TTR(unsigned long int, wchar_t, tag, false);
-   TEST_TTR(unsigned long int, float, tag, false);
-   TEST_TTR(unsigned long int, double, tag, false);
-   TEST_TTR(unsigned long int, long double, tag, false);
-   TEST_TTR(wchar_t, bool, tag, false);
-   TEST_TTR(wchar_t, char, tag, false);
-   TEST_TTR(wchar_t, signed char, tag, false);
-   TEST_TTR(wchar_t, short int, tag, false);
-   TEST_TTR(wchar_t, int, tag, false);
-   TEST_TTR(wchar_t, long int, tag, false);
-   TEST_TTR(wchar_t, unsigned char, tag, false);
-   TEST_TTR(wchar_t, unsigned short int, tag, false);
-   TEST_TTR(wchar_t, unsigned int, tag, false);
-   TEST_TTR(wchar_t, unsigned long int, tag, false);
-   TEST_TTR(wchar_t, wchar_t, tag, false);
-   TEST_TTR(wchar_t, float, tag, false);
-   TEST_TTR(wchar_t, double, tag, false);
-   TEST_TTR(wchar_t, long double, tag, false);
-   TEST_TTR(float, bool, tag, false);
-   TEST_TTR(float, char, tag, false);
-   TEST_TTR(float, signed char, tag, false);
-   TEST_TTR(float, short int, tag, false);
-   TEST_TTR(float, int, tag, false);
-   TEST_TTR(float, long int, tag, false);
-   TEST_TTR(float, unsigned char, tag, false);
-   TEST_TTR(float, unsigned short int, tag, false);
-   TEST_TTR(float, unsigned int, tag, false);
-   TEST_TTR(float, unsigned long int, tag, false);
-   TEST_TTR(float, wchar_t, tag, false);
-   TEST_TTR(float, float, tag, false);
-   TEST_TTR(float, double, tag, false);
-   TEST_TTR(float, long double, tag, false);
-   TEST_TTR(double, bool, tag, false);
-   TEST_TTR(double, char, tag, false);
-   TEST_TTR(double, signed char, tag, false);
-   TEST_TTR(double, short int, tag, false);
-   TEST_TTR(double, int, tag, false);
-   TEST_TTR(double, long int, tag, false);
-   TEST_TTR(double, unsigned char, tag, false);
-   TEST_TTR(double, unsigned short int, tag, false);
-   TEST_TTR(double, unsigned int, tag, false);
-   TEST_TTR(double, unsigned long int, tag, false);
-   TEST_TTR(double, wchar_t, tag, false);
-   TEST_TTR(double, float, tag, false);
-   TEST_TTR(double, double, tag, false);
-   TEST_TTR(double, long double, tag, false);
-   TEST_TTR(long double, bool, tag, false);
-   TEST_TTR(long double, char, tag, false);
-   TEST_TTR(long double, signed char, tag, false);
-   TEST_TTR(long double, short int, tag, false);
-   TEST_TTR(long double, int, tag, false);
-   TEST_TTR(long double, long int, tag, false);
-   TEST_TTR(long double, unsigned char, tag, false);
-   TEST_TTR(long double, unsigned short int, tag, false);
-   TEST_TTR(long double, unsigned int, tag, false);
-   TEST_TTR(long double, unsigned long int, tag, false);
-   TEST_TTR(long double, wchar_t, tag, false);
-   TEST_TTR(long double, float, tag, false);
-   TEST_TTR(long double, double, tag, false);
-   TEST_TTR(long double, long double, tag, false);
-#	undef CV1
-#	define CV1(T) const T
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const T&
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T&
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T&
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const T
-#	undef CV2
-#	define CV2(T) const T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const T&
-#	undef CV2
-#	define CV2(T) const T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T
-#	undef CV2
-#	define CV2(T) volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T&
-#	undef CV2
-#	define CV2(T) volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T
-#	undef CV2
-#	define CV2(T) const volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T&
-#	undef CV2
-#	define CV2(T) const volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-   // pointers
-   TEST_TT(void*, bool, false);
-   TEST_TT(void*, int, false);
-   TEST_TT(void*, double, false);
-   TEST_TT(void*, A, false);
-   TEST_TT(void*, B, false);
-   TEST_TT(bool*, bool, true);
-   TEST_TT(bool*, int, true);
-   TEST_TT(bool*, double, false);
-   TEST_TT(bool*, A, false);
-   TEST_TT(bool*, B, false);
-   TEST_TT(int*, bool, true);
-   TEST_TT(int*, int, true);
-   TEST_TT(int*, double, false);
-   TEST_TT(int*, A, false);
-   TEST_TT(int*, B, false);
-   TEST_TT(double*, bool, true);
-   TEST_TT(double*, int, true);
-   TEST_TT(double*, double, false);
-   TEST_TT(double*, A, false);
-   TEST_TT(double*, B, false);
-   TEST_TT(A*, bool, true);
-   TEST_TT(A*, int, true);
-   TEST_TT(A*, double, false);
-   TEST_TT(A*, A, false);
-   TEST_TT(A*, B, false);
-   TEST_TT(B*, bool, true);
-   TEST_TT(B*, int, true);
-   TEST_TT(B*, double, false);
-   TEST_TT(B*, A, false);
-   TEST_TT(B*, B, false);
-   TEST_TT(bool, void*, false);
-   TEST_TT(bool, bool*, false);
-   TEST_TT(bool, int*, false);
-   TEST_TT(bool, double*, false);
-   TEST_TT(bool, A*, false);
-   TEST_TT(bool, B*, false);
-   TEST_TT(int, void*, false);
-   TEST_TT(int, bool*, false);
-   TEST_TT(int, int*, false);
-   TEST_TT(int, double*, false);
-   TEST_TT(int, A*, false);
-   TEST_TT(int, B*, false);
-   TEST_TT(double, void*, false);
-   TEST_TT(double, bool*, false);
-   TEST_TT(double, int*, false);
-   TEST_TT(double, double*, false);
-   TEST_TT(double, A*, false);
-   TEST_TT(double, B*, false);
-   TEST_TT(A, void*, false);
-   TEST_TT(A, bool*, false);
-   TEST_TT(A, int*, false);
-   TEST_TT(A, double*, false);
-   TEST_TT(A, A*, false);
-   TEST_TT(A, B*, false);
-   TEST_TT(B, void*, false);
-   TEST_TT(B, bool*, false);
-   TEST_TT(B, int*, false);
-   TEST_TT(B, double*, false);
-   TEST_TT(B, A*, false);
-   TEST_TT(B, B*, false);
-   TEST_TT(void*, void*, false);
-   TEST_TT(void*, bool*, false);
-   TEST_TT(void*, int*, false);
-   TEST_TT(void*, double*, false);
-   TEST_TT(void*, A*, false);
-   TEST_TT(void*, B*, false);
-   TEST_TT(bool*, void*, false);
-   TEST_TT(bool*, bool*, true);
-   TEST_TT(bool*, int*, false);
-   TEST_TT(bool*, double*, false);
-   TEST_TT(bool*, A*, false);
-   TEST_TT(bool*, B*, false);
-   TEST_TT(int*, void*, false);
-   TEST_TT(int*, bool*, false);
-   TEST_TT(int*, int*, true);
-   TEST_TT(int*, double*, false);
-   TEST_TT(int*, A*, false);
-   TEST_TT(int*, B*, false);
-   TEST_TT(double*, void*, false);
-   TEST_TT(double*, bool*, false);
-   TEST_TT(double*, int*, false);
-   TEST_TT(double*, double*, true);
-   TEST_TT(double*, A*, false);
-   TEST_TT(double*, B*, false);
-   TEST_TT(A*, void*, false);
-   TEST_TT(A*, bool*, false);
-   TEST_TT(A*, int*, false);
-   TEST_TT(A*, double*, false);
-   TEST_TT(A*, A*, true);
-   TEST_TT(A*, B*, false);
-   TEST_TT(B*, void*, false);
-   TEST_TT(B*, bool*, false);
-   TEST_TT(B*, int*, false);
-   TEST_TT(B*, double*, false);
-   TEST_TT(B*, A*, false);
-   TEST_TT(B*, B*, true);
-   TEST_TT(C, void*, true);
-   TEST_TT(D, void*, false);
-   TEST_TT(void*, C, false);
-   TEST_TT(void*, D, true);
-   TEST_TT(C, D, true);
-}
-}

Deleted: sandbox/type_traits/libs/type_traits/test/has_binary_operator_test.hpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_binary_operator_test.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,127 +0,0 @@
-//  (C) Copyright Frederic Bron 2009-2011.
-//  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)
-
-// 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,TYPE,RET>::value), RESULT)
-// test with two template parameters
-#define TEST_TT(TYPE1,TYPE2,RESULT) BOOST_CHECK_INTEGRAL_CONSTANT((::tt::BOOST_TT_TRAIT_NAME<TYPE1,TYPE2>::value), RESULT)
-// test with two template parameters plus return value
-#define TEST_TTR(TYPE1,TYPE2,RET,RESULT) BOOST_CHECK_INTEGRAL_CONSTANT((::tt::BOOST_TT_TRAIT_NAME<TYPE1,TYPE2,RET>::value), RESULT)
-
-namespace {
-
-struct without { };
-
-struct ret { };
-
-struct internal { ret operator BOOST_TT_TRAIT_OP (const internal&) const; };
-
-struct external { };
-ret operator BOOST_TT_TRAIT_OP (const external&, const external&);
-
-struct comma1_ret { };
-struct ret_with_comma1 { comma1_ret operator,(int); };
-
-struct internal_comma1 { ret_with_comma1 operator BOOST_TT_TRAIT_OP (const internal_comma1&) const; };
-
-struct external_comma1 { };
-ret_with_comma1 operator BOOST_TT_TRAIT_OP (const external_comma1&, const external_comma1&);
-
-struct ret_with_comma2 { void operator,(int); };
-
-struct internal_comma2 { ret_with_comma2 operator BOOST_TT_TRAIT_OP (const internal_comma2&) const; };
-
-struct external_comma2 { };
-ret_with_comma2 operator BOOST_TT_TRAIT_OP (const external_comma2&, const external_comma2&);
-
-struct returns_int { int operator BOOST_TT_TRAIT_OP (const returns_int&); };
-
-struct returns_void { void operator BOOST_TT_TRAIT_OP (const returns_void&); };
-
-struct returns_void_star { void *operator BOOST_TT_TRAIT_OP (const returns_void_star&); };
-
-struct returns_double { double operator BOOST_TT_TRAIT_OP (const returns_double&); };
-
-struct ret1 { };
-struct convertible_to_ret1 { operator ret1 () const; };
-struct returns_convertible_to_ret1 { convertible_to_ret1 operator BOOST_TT_TRAIT_OP (const returns_convertible_to_ret1&); };
-
-struct convertible_to_ret2 { };
-struct ret2 { ret2(const convertible_to_ret2); };
-struct returns_convertible_to_ret2 { convertible_to_ret2 operator BOOST_TT_TRAIT_OP (const returns_convertible_to_ret2&); };
-
-class Base1 { };
-class Derived1 : public Base1 { };
-
-bool operator BOOST_TT_TRAIT_OP (const Base1&, 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&, const Derived2&) { return true; }
-
-struct tag { };
-
-struct A { };
-struct B : public A { };
-
-struct C { };
-struct D { };
-bool operator BOOST_TT_TRAIT_OP (const C&, void*) { return true; }
-bool operator BOOST_TT_TRAIT_OP (void*, const D&) { return true; }
-bool operator BOOST_TT_TRAIT_OP (const C&, const D&) { return true; }
-
-//class internal_private { ret operator BOOST_TT_TRAIT_OP (const internal_private&) const; };
-
-void run1() {
-   TEST_T(without, false);
-   TEST_T(internal, true);
-   TEST_T(external, true);
-   TEST_T(internal_comma1, true);
-   TEST_T(external_comma1, true);
-   TEST_T(internal_comma2, true);
-   TEST_T(external_comma2, true);
-   TEST_T(returns_int, true);
-   TEST_T(returns_void, true);
-   TEST_T(returns_void_star, true);
-   TEST_T(returns_double, true);
-   TEST_T(returns_convertible_to_ret1, true);
-   TEST_T(returns_convertible_to_ret2, 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(internal_comma1, bool, false);
-   TEST_TR(internal_comma1, ret_with_comma1, true);
-   TEST_TR(internal_comma2, bool, false);
-   TEST_TR(internal_comma2, ret_with_comma2, true);
-   TEST_TR(external, bool, false);
-   TEST_TR(external, ret, true);
-   TEST_TR(returns_int, bool, true);
-   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_convertible_to_ret1, ret1, true);
-   TEST_TR(returns_convertible_to_ret2, ret2, true);
-   TEST_TR(Base1, bool, true);
-   TEST_TR(Derived1, bool, true);
-   TEST_TR(Base2, bool, false);
-   TEST_TR(Derived2, bool, true);
-// compile time error
-// TEST_T(internal_private, false);
-}
-
-}

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,1250 +0,0 @@
-//  (C) Copyright Frederic Bron 2009-2011.
-//  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)
-
-namespace {
-
-void run2() {
-   // test with only one template parameter
-   TEST_T(void, false);
-   TEST_T(bool, true);
-   TEST_T(char, true);
-   TEST_T(signed char, true);
-   TEST_T(short int, true);
-   TEST_T(int, true);
-   TEST_T(long int, true);
-   TEST_T(unsigned char, true);
-   TEST_T(unsigned short int, true);
-   TEST_T(unsigned int, true);
-   TEST_T(unsigned long int, true);
-   TEST_T(wchar_t, true);
-   TEST_T(float, true);
-   TEST_T(double, true);
-   TEST_T(long double, true);
-   TEST_T(void, false);
-#	undef CV
-#	define CV(T) const T
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	undef CV
-#	define CV(T) volatile T
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	undef CV
-#	define CV(T) const volatile T
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	undef CV
-#	define CV(T) const T&
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	undef CV
-#	define CV(T) volatile T&
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	undef CV
-#	define CV(T) const volatile T&
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   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);
-   TEST_TT(bool, short int, true);
-   TEST_TT(bool, int, true);
-   TEST_TT(bool, long int, true);
-   TEST_TT(bool, unsigned char, true);
-   TEST_TT(bool, unsigned short int, true);
-   TEST_TT(bool, unsigned int, true);
-   TEST_TT(bool, unsigned long int, true);
-   TEST_TT(bool, wchar_t, true);
-   TEST_TT(bool, float, true);
-   TEST_TT(bool, double, true);
-   TEST_TT(bool, long double, true);
-   TEST_TT(char, bool, true);
-   TEST_TT(char, char, true);
-   TEST_TT(char, signed char, true);
-   TEST_TT(char, short int, true);
-   TEST_TT(char, int, true);
-   TEST_TT(char, long int, true);
-   TEST_TT(char, unsigned char, true);
-   TEST_TT(char, unsigned short int, true);
-   TEST_TT(char, unsigned int, true);
-   TEST_TT(char, unsigned long int, true);
-   TEST_TT(char, wchar_t, true);
-   TEST_TT(char, float, true);
-   TEST_TT(char, double, true);
-   TEST_TT(char, long double, true);
-   TEST_TT(signed char, bool, true);
-   TEST_TT(signed char, char, true);
-   TEST_TT(signed char, signed char, true);
-   TEST_TT(signed char, short int, true);
-   TEST_TT(signed char, int, true);
-   TEST_TT(signed char, long int, true);
-   TEST_TT(signed char, unsigned char, true);
-   TEST_TT(signed char, unsigned short int, true);
-   TEST_TT(signed char, unsigned int, true);
-   TEST_TT(signed char, unsigned long int, true);
-   TEST_TT(signed char, wchar_t, true);
-   TEST_TT(signed char, float, true);
-   TEST_TT(signed char, double, true);
-   TEST_TT(signed char, long double, true);
-   TEST_TT(short int, bool, true);
-   TEST_TT(short int, char, true);
-   TEST_TT(short int, signed char, true);
-   TEST_TT(short int, short int, true);
-   TEST_TT(short int, int, true);
-   TEST_TT(short int, long int, true);
-   TEST_TT(short int, unsigned char, true);
-   TEST_TT(short int, unsigned short int, true);
-   TEST_TT(short int, unsigned int, true);
-   TEST_TT(short int, unsigned long int, true);
-   TEST_TT(short int, wchar_t, true);
-   TEST_TT(short int, float, true);
-   TEST_TT(short int, double, true);
-   TEST_TT(short int, long double, true);
-   TEST_TT(int, bool, true);
-   TEST_TT(int, char, true);
-   TEST_TT(int, signed char, true);
-   TEST_TT(int, short int, true);
-   TEST_TT(int, int, true);
-   TEST_TT(int, long int, true);
-   TEST_TT(int, unsigned char, true);
-   TEST_TT(int, unsigned short int, true);
-   TEST_TT(int, unsigned int, true);
-   TEST_TT(int, unsigned long int, true);
-   TEST_TT(int, wchar_t, true);
-   TEST_TT(int, float, true);
-   TEST_TT(int, double, true);
-   TEST_TT(int, long double, true);
-   TEST_TT(long int, bool, true);
-   TEST_TT(long int, char, true);
-   TEST_TT(long int, signed char, true);
-   TEST_TT(long int, short int, true);
-   TEST_TT(long int, int, true);
-   TEST_TT(long int, long int, true);
-   TEST_TT(long int, unsigned char, true);
-   TEST_TT(long int, unsigned short int, true);
-   TEST_TT(long int, unsigned int, true);
-   TEST_TT(long int, unsigned long int, true);
-   TEST_TT(long int, wchar_t, true);
-   TEST_TT(long int, float, true);
-   TEST_TT(long int, double, true);
-   TEST_TT(long int, long double, true);
-   TEST_TT(unsigned char, bool, true);
-   TEST_TT(unsigned char, char, true);
-   TEST_TT(unsigned char, signed char, true);
-   TEST_TT(unsigned char, short int, true);
-   TEST_TT(unsigned char, int, true);
-   TEST_TT(unsigned char, long int, true);
-   TEST_TT(unsigned char, unsigned char, true);
-   TEST_TT(unsigned char, unsigned short int, true);
-   TEST_TT(unsigned char, unsigned int, true);
-   TEST_TT(unsigned char, unsigned long int, true);
-   TEST_TT(unsigned char, wchar_t, true);
-   TEST_TT(unsigned char, float, true);
-   TEST_TT(unsigned char, double, true);
-   TEST_TT(unsigned char, long double, true);
-   TEST_TT(unsigned short int, bool, true);
-   TEST_TT(unsigned short int, char, true);
-   TEST_TT(unsigned short int, signed char, true);
-   TEST_TT(unsigned short int, short int, true);
-   TEST_TT(unsigned short int, int, true);
-   TEST_TT(unsigned short int, long int, true);
-   TEST_TT(unsigned short int, unsigned char, true);
-   TEST_TT(unsigned short int, unsigned short int, true);
-   TEST_TT(unsigned short int, unsigned int, true);
-   TEST_TT(unsigned short int, unsigned long int, true);
-   TEST_TT(unsigned short int, wchar_t, true);
-   TEST_TT(unsigned short int, float, true);
-   TEST_TT(unsigned short int, double, true);
-   TEST_TT(unsigned short int, long double, true);
-   TEST_TT(unsigned int, bool, true);
-   TEST_TT(unsigned int, char, true);
-   TEST_TT(unsigned int, signed char, true);
-   TEST_TT(unsigned int, short int, true);
-   TEST_TT(unsigned int, int, true);
-   TEST_TT(unsigned int, long int, true);
-   TEST_TT(unsigned int, unsigned char, true);
-   TEST_TT(unsigned int, unsigned short int, true);
-   TEST_TT(unsigned int, unsigned int, true);
-   TEST_TT(unsigned int, unsigned long int, true);
-   TEST_TT(unsigned int, wchar_t, true);
-   TEST_TT(unsigned int, float, true);
-   TEST_TT(unsigned int, double, true);
-   TEST_TT(unsigned int, long double, true);
-   TEST_TT(unsigned long int, bool, true);
-   TEST_TT(unsigned long int, char, true);
-   TEST_TT(unsigned long int, signed char, true);
-   TEST_TT(unsigned long int, short int, true);
-   TEST_TT(unsigned long int, int, true);
-   TEST_TT(unsigned long int, long int, true);
-   TEST_TT(unsigned long int, unsigned char, true);
-   TEST_TT(unsigned long int, unsigned short int, true);
-   TEST_TT(unsigned long int, unsigned int, true);
-   TEST_TT(unsigned long int, unsigned long int, true);
-   TEST_TT(unsigned long int, wchar_t, true);
-   TEST_TT(unsigned long int, float, true);
-   TEST_TT(unsigned long int, double, true);
-   TEST_TT(unsigned long int, long double, true);
-   TEST_TT(wchar_t, bool, true);
-   TEST_TT(wchar_t, char, true);
-   TEST_TT(wchar_t, signed char, true);
-   TEST_TT(wchar_t, short int, true);
-   TEST_TT(wchar_t, int, true);
-   TEST_TT(wchar_t, long int, true);
-   TEST_TT(wchar_t, unsigned char, true);
-   TEST_TT(wchar_t, unsigned short int, true);
-   TEST_TT(wchar_t, unsigned int, true);
-   TEST_TT(wchar_t, unsigned long int, true);
-   TEST_TT(wchar_t, wchar_t, true);
-   TEST_TT(wchar_t, float, true);
-   TEST_TT(wchar_t, double, true);
-   TEST_TT(wchar_t, long double, true);
-   TEST_TT(float, bool, true);
-   TEST_TT(float, char, true);
-   TEST_TT(float, signed char, true);
-   TEST_TT(float, short int, true);
-   TEST_TT(float, int, true);
-   TEST_TT(float, long int, true);
-   TEST_TT(float, unsigned char, true);
-   TEST_TT(float, unsigned short int, true);
-   TEST_TT(float, unsigned int, true);
-   TEST_TT(float, unsigned long int, true);
-   TEST_TT(float, wchar_t, true);
-   TEST_TT(float, float, true);
-   TEST_TT(float, double, true);
-   TEST_TT(float, long double, true);
-   TEST_TT(double, bool, true);
-   TEST_TT(double, char, true);
-   TEST_TT(double, signed char, true);
-   TEST_TT(double, short int, true);
-   TEST_TT(double, int, true);
-   TEST_TT(double, long int, true);
-   TEST_TT(double, unsigned char, true);
-   TEST_TT(double, unsigned short int, true);
-   TEST_TT(double, unsigned int, true);
-   TEST_TT(double, unsigned long int, true);
-   TEST_TT(double, wchar_t, true);
-   TEST_TT(double, float, true);
-   TEST_TT(double, double, true);
-   TEST_TT(double, long double, true);
-   TEST_TT(long double, bool, true);
-   TEST_TT(long double, char, true);
-   TEST_TT(long double, signed char, true);
-   TEST_TT(long double, short int, true);
-   TEST_TT(long double, int, true);
-   TEST_TT(long double, long int, true);
-   TEST_TT(long double, unsigned char, true);
-   TEST_TT(long double, unsigned short int, true);
-   TEST_TT(long double, unsigned int, true);
-   TEST_TT(long double, unsigned long int, true);
-   TEST_TT(long double, wchar_t, true);
-   TEST_TT(long double, float, true);
-   TEST_TT(long double, double, true);
-   TEST_TT(long double, long double, true);
-   TEST_TT(bool, void, false);
-   TEST_TT(void, bool, false);
-   TEST_TT(char, void, false);
-   TEST_TT(void, char, false);
-   TEST_TT(signed char, void, false);
-   TEST_TT(void, signed char, false);
-   TEST_TT(short int, void, false);
-   TEST_TT(void, short int, false);
-   TEST_TT(int, void, false);
-   TEST_TT(void, int, false);
-   TEST_TT(long int, void, false);
-   TEST_TT(void, long int, false);
-   TEST_TT(unsigned char, void, false);
-   TEST_TT(void, unsigned char, false);
-   TEST_TT(unsigned short int, void, false);
-   TEST_TT(void, unsigned short int, false);
-   TEST_TT(unsigned int, void, false);
-   TEST_TT(void, unsigned int, false);
-   TEST_TT(unsigned long int, void, false);
-   TEST_TT(void, unsigned long int, false);
-   TEST_TT(wchar_t, void, false);
-   TEST_TT(void, wchar_t, false);
-   TEST_TT(float, void, false);
-   TEST_TT(void, float, false);
-   TEST_TT(double, void, false);
-   TEST_TT(void, double, false);
-   TEST_TT(long double, void, false);
-   TEST_TT(void, long double, false);
-
-// test with three template parameters
-   TEST_TTR(bool, bool, bool, true);
-   TEST_TTR(bool, char, bool, true);
-   TEST_TTR(bool, signed char, bool, true);
-   TEST_TTR(bool, short int, bool, true);
-   TEST_TTR(bool, int, bool, true);
-   TEST_TTR(bool, long int, bool, true);
-   TEST_TTR(bool, unsigned char, bool, true);
-   TEST_TTR(bool, unsigned short int, bool, true);
-   TEST_TTR(bool, unsigned int, bool, true);
-   TEST_TTR(bool, unsigned long int, bool, true);
-   TEST_TTR(bool, wchar_t, bool, true);
-   TEST_TTR(bool, float, bool, true);
-   TEST_TTR(bool, double, bool, true);
-   TEST_TTR(bool, long double, bool, true);
-   TEST_TTR(char, bool, bool, true);
-   TEST_TTR(char, char, bool, true);
-   TEST_TTR(char, signed char, bool, true);
-   TEST_TTR(char, short int, bool, true);
-   TEST_TTR(char, int, bool, true);
-   TEST_TTR(char, long int, bool, true);
-   TEST_TTR(char, unsigned char, bool, true);
-   TEST_TTR(char, unsigned short int, bool, true);
-   TEST_TTR(char, unsigned int, bool, true);
-   TEST_TTR(char, unsigned long int, bool, true);
-   TEST_TTR(char, wchar_t, bool, true);
-   TEST_TTR(char, float, bool, true);
-   TEST_TTR(char, double, bool, true);
-   TEST_TTR(char, long double, bool, true);
-   TEST_TTR(signed char, bool, bool, true);
-   TEST_TTR(signed char, char, bool, true);
-   TEST_TTR(signed char, signed char, bool, true);
-   TEST_TTR(signed char, short int, bool, true);
-   TEST_TTR(signed char, int, bool, true);
-   TEST_TTR(signed char, long int, bool, true);
-   TEST_TTR(signed char, unsigned char, bool, true);
-   TEST_TTR(signed char, unsigned short int, bool, true);
-   TEST_TTR(signed char, unsigned int, bool, true);
-   TEST_TTR(signed char, unsigned long int, bool, true);
-   TEST_TTR(signed char, wchar_t, bool, true);
-   TEST_TTR(signed char, float, bool, true);
-   TEST_TTR(signed char, double, bool, true);
-   TEST_TTR(signed char, long double, bool, true);
-   TEST_TTR(short int, bool, bool, true);
-   TEST_TTR(short int, char, bool, true);
-   TEST_TTR(short int, signed char, bool, true);
-   TEST_TTR(short int, short int, bool, true);
-   TEST_TTR(short int, int, bool, true);
-   TEST_TTR(short int, long int, bool, true);
-   TEST_TTR(short int, unsigned char, bool, true);
-   TEST_TTR(short int, unsigned short int, bool, true);
-   TEST_TTR(short int, unsigned int, bool, true);
-   TEST_TTR(short int, unsigned long int, bool, true);
-   TEST_TTR(short int, wchar_t, bool, true);
-   TEST_TTR(short int, float, bool, true);
-   TEST_TTR(short int, double, bool, true);
-   TEST_TTR(short int, long double, bool, true);
-   TEST_TTR(int, bool, bool, true);
-   TEST_TTR(int, char, bool, true);
-   TEST_TTR(int, signed char, bool, true);
-   TEST_TTR(int, short int, bool, true);
-   TEST_TTR(int, int, bool, true);
-   TEST_TTR(int, long int, bool, true);
-   TEST_TTR(int, unsigned char, bool, true);
-   TEST_TTR(int, unsigned short int, bool, true);
-   TEST_TTR(int, unsigned int, bool, true);
-   TEST_TTR(int, unsigned long int, bool, true);
-   TEST_TTR(int, wchar_t, bool, true);
-   TEST_TTR(int, float, bool, true);
-   TEST_TTR(int, double, bool, true);
-   TEST_TTR(int, long double, bool, true);
-   TEST_TTR(long int, bool, bool, true);
-   TEST_TTR(long int, char, bool, true);
-   TEST_TTR(long int, signed char, bool, true);
-   TEST_TTR(long int, short int, bool, true);
-   TEST_TTR(long int, int, bool, true);
-   TEST_TTR(long int, long int, bool, true);
-   TEST_TTR(long int, unsigned char, bool, true);
-   TEST_TTR(long int, unsigned short int, bool, true);
-   TEST_TTR(long int, unsigned int, bool, true);
-   TEST_TTR(long int, unsigned long int, bool, true);
-   TEST_TTR(long int, wchar_t, bool, true);
-   TEST_TTR(long int, float, bool, true);
-   TEST_TTR(long int, double, bool, true);
-   TEST_TTR(long int, long double, bool, true);
-   TEST_TTR(unsigned char, bool, bool, true);
-   TEST_TTR(unsigned char, char, bool, true);
-   TEST_TTR(unsigned char, signed char, bool, true);
-   TEST_TTR(unsigned char, short int, bool, true);
-   TEST_TTR(unsigned char, int, bool, true);
-   TEST_TTR(unsigned char, long int, bool, true);
-   TEST_TTR(unsigned char, unsigned char, bool, true);
-   TEST_TTR(unsigned char, unsigned short int, bool, true);
-   TEST_TTR(unsigned char, unsigned int, bool, true);
-   TEST_TTR(unsigned char, unsigned long int, bool, true);
-   TEST_TTR(unsigned char, wchar_t, bool, true);
-   TEST_TTR(unsigned char, float, bool, true);
-   TEST_TTR(unsigned char, double, bool, true);
-   TEST_TTR(unsigned char, long double, bool, true);
-   TEST_TTR(unsigned short int, bool, bool, true);
-   TEST_TTR(unsigned short int, char, bool, true);
-   TEST_TTR(unsigned short int, signed char, bool, true);
-   TEST_TTR(unsigned short int, short int, bool, true);
-   TEST_TTR(unsigned short int, int, bool, true);
-   TEST_TTR(unsigned short int, long int, bool, true);
-   TEST_TTR(unsigned short int, unsigned char, bool, true);
-   TEST_TTR(unsigned short int, unsigned short int, bool, true);
-   TEST_TTR(unsigned short int, unsigned int, bool, true);
-   TEST_TTR(unsigned short int, unsigned long int, bool, true);
-   TEST_TTR(unsigned short int, wchar_t, bool, true);
-   TEST_TTR(unsigned short int, float, bool, true);
-   TEST_TTR(unsigned short int, double, bool, true);
-   TEST_TTR(unsigned short int, long double, bool, true);
-   TEST_TTR(unsigned int, bool, bool, true);
-   TEST_TTR(unsigned int, char, bool, true);
-   TEST_TTR(unsigned int, signed char, bool, true);
-   TEST_TTR(unsigned int, short int, bool, true);
-   TEST_TTR(unsigned int, int, bool, true);
-   TEST_TTR(unsigned int, long int, bool, true);
-   TEST_TTR(unsigned int, unsigned char, bool, true);
-   TEST_TTR(unsigned int, unsigned short int, bool, true);
-   TEST_TTR(unsigned int, unsigned int, bool, true);
-   TEST_TTR(unsigned int, unsigned long int, bool, true);
-   TEST_TTR(unsigned int, wchar_t, bool, true);
-   TEST_TTR(unsigned int, float, bool, true);
-   TEST_TTR(unsigned int, double, bool, true);
-   TEST_TTR(unsigned int, long double, bool, true);
-   TEST_TTR(unsigned long int, bool, bool, true);
-   TEST_TTR(unsigned long int, char, bool, true);
-   TEST_TTR(unsigned long int, signed char, bool, true);
-   TEST_TTR(unsigned long int, short int, bool, true);
-   TEST_TTR(unsigned long int, int, bool, true);
-   TEST_TTR(unsigned long int, long int, bool, true);
-   TEST_TTR(unsigned long int, unsigned char, bool, true);
-   TEST_TTR(unsigned long int, unsigned short int, bool, true);
-   TEST_TTR(unsigned long int, unsigned int, bool, true);
-   TEST_TTR(unsigned long int, unsigned long int, bool, true);
-   TEST_TTR(unsigned long int, wchar_t, bool, true);
-   TEST_TTR(unsigned long int, float, bool, true);
-   TEST_TTR(unsigned long int, double, bool, true);
-   TEST_TTR(unsigned long int, long double, bool, true);
-   TEST_TTR(wchar_t, bool, bool, true);
-   TEST_TTR(wchar_t, char, bool, true);
-   TEST_TTR(wchar_t, signed char, bool, true);
-   TEST_TTR(wchar_t, short int, bool, true);
-   TEST_TTR(wchar_t, int, bool, true);
-   TEST_TTR(wchar_t, long int, bool, true);
-   TEST_TTR(wchar_t, unsigned char, bool, true);
-   TEST_TTR(wchar_t, unsigned short int, bool, true);
-   TEST_TTR(wchar_t, unsigned int, bool, true);
-   TEST_TTR(wchar_t, unsigned long int, bool, true);
-   TEST_TTR(wchar_t, wchar_t, bool, true);
-   TEST_TTR(wchar_t, float, bool, true);
-   TEST_TTR(wchar_t, double, bool, true);
-   TEST_TTR(wchar_t, long double, bool, true);
-   TEST_TTR(float, bool, bool, true);
-   TEST_TTR(float, char, bool, true);
-   TEST_TTR(float, signed char, bool, true);
-   TEST_TTR(float, short int, bool, true);
-   TEST_TTR(float, int, bool, true);
-   TEST_TTR(float, long int, bool, true);
-   TEST_TTR(float, unsigned char, bool, true);
-   TEST_TTR(float, unsigned short int, bool, true);
-   TEST_TTR(float, unsigned int, bool, true);
-   TEST_TTR(float, unsigned long int, bool, true);
-   TEST_TTR(float, wchar_t, bool, true);
-   TEST_TTR(float, float, bool, true);
-   TEST_TTR(float, double, bool, true);
-   TEST_TTR(float, long double, bool, true);
-   TEST_TTR(double, bool, bool, true);
-   TEST_TTR(double, char, bool, true);
-   TEST_TTR(double, signed char, bool, true);
-   TEST_TTR(double, short int, bool, true);
-   TEST_TTR(double, int, bool, true);
-   TEST_TTR(double, long int, bool, true);
-   TEST_TTR(double, unsigned char, bool, true);
-   TEST_TTR(double, unsigned short int, bool, true);
-   TEST_TTR(double, unsigned int, bool, true);
-   TEST_TTR(double, unsigned long int, bool, true);
-   TEST_TTR(double, wchar_t, bool, true);
-   TEST_TTR(double, float, bool, true);
-   TEST_TTR(double, double, bool, true);
-   TEST_TTR(double, long double, bool, true);
-   TEST_TTR(long double, bool, bool, true);
-   TEST_TTR(long double, char, bool, true);
-   TEST_TTR(long double, signed char, bool, true);
-   TEST_TTR(long double, short int, bool, true);
-   TEST_TTR(long double, int, bool, true);
-   TEST_TTR(long double, long int, bool, true);
-   TEST_TTR(long double, unsigned char, bool, true);
-   TEST_TTR(long double, unsigned short int, bool, true);
-   TEST_TTR(long double, unsigned int, bool, true);
-   TEST_TTR(long double, unsigned long int, bool, true);
-   TEST_TTR(long double, wchar_t, bool, true);
-   TEST_TTR(long double, float, bool, true);
-   TEST_TTR(long double, double, bool, true);
-   TEST_TTR(long double, long double, bool, true);
-   TEST_TTR(bool, bool, tag, false);
-   TEST_TTR(bool, char, tag, false);
-   TEST_TTR(bool, signed char, tag, false);
-   TEST_TTR(bool, short int, tag, false);
-   TEST_TTR(bool, int, tag, false);
-   TEST_TTR(bool, long int, tag, false);
-   TEST_TTR(bool, unsigned char, tag, false);
-   TEST_TTR(bool, unsigned short int, tag, false);
-   TEST_TTR(bool, unsigned int, tag, false);
-   TEST_TTR(bool, unsigned long int, tag, false);
-   TEST_TTR(bool, wchar_t, tag, false);
-   TEST_TTR(bool, float, tag, false);
-   TEST_TTR(bool, double, tag, false);
-   TEST_TTR(bool, long double, tag, false);
-   TEST_TTR(char, bool, tag, false);
-   TEST_TTR(char, char, tag, false);
-   TEST_TTR(char, signed char, tag, false);
-   TEST_TTR(char, short int, tag, false);
-   TEST_TTR(char, int, tag, false);
-   TEST_TTR(char, long int, tag, false);
-   TEST_TTR(char, unsigned char, tag, false);
-   TEST_TTR(char, unsigned short int, tag, false);
-   TEST_TTR(char, unsigned int, tag, false);
-   TEST_TTR(char, unsigned long int, tag, false);
-   TEST_TTR(char, wchar_t, tag, false);
-   TEST_TTR(char, float, tag, false);
-   TEST_TTR(char, double, tag, false);
-   TEST_TTR(char, long double, tag, false);
-   TEST_TTR(signed char, bool, tag, false);
-   TEST_TTR(signed char, char, tag, false);
-   TEST_TTR(signed char, signed char, tag, false);
-   TEST_TTR(signed char, short int, tag, false);
-   TEST_TTR(signed char, int, tag, false);
-   TEST_TTR(signed char, long int, tag, false);
-   TEST_TTR(signed char, unsigned char, tag, false);
-   TEST_TTR(signed char, unsigned short int, tag, false);
-   TEST_TTR(signed char, unsigned int, tag, false);
-   TEST_TTR(signed char, unsigned long int, tag, false);
-   TEST_TTR(signed char, wchar_t, tag, false);
-   TEST_TTR(signed char, float, tag, false);
-   TEST_TTR(signed char, double, tag, false);
-   TEST_TTR(signed char, long double, tag, false);
-   TEST_TTR(short int, bool, tag, false);
-   TEST_TTR(short int, char, tag, false);
-   TEST_TTR(short int, signed char, tag, false);
-   TEST_TTR(short int, short int, tag, false);
-   TEST_TTR(short int, int, tag, false);
-   TEST_TTR(short int, long int, tag, false);
-   TEST_TTR(short int, unsigned char, tag, false);
-   TEST_TTR(short int, unsigned short int, tag, false);
-   TEST_TTR(short int, unsigned int, tag, false);
-   TEST_TTR(short int, unsigned long int, tag, false);
-   TEST_TTR(short int, wchar_t, tag, false);
-   TEST_TTR(short int, float, tag, false);
-   TEST_TTR(short int, double, tag, false);
-   TEST_TTR(short int, long double, tag, false);
-   TEST_TTR(int, bool, tag, false);
-   TEST_TTR(int, char, tag, false);
-   TEST_TTR(int, signed char, tag, false);
-   TEST_TTR(int, short int, tag, false);
-   TEST_TTR(int, int, tag, false);
-   TEST_TTR(int, long int, tag, false);
-   TEST_TTR(int, unsigned char, tag, false);
-   TEST_TTR(int, unsigned short int, tag, false);
-   TEST_TTR(int, unsigned int, tag, false);
-   TEST_TTR(int, unsigned long int, tag, false);
-   TEST_TTR(int, wchar_t, tag, false);
-   TEST_TTR(int, float, tag, false);
-   TEST_TTR(int, double, tag, false);
-   TEST_TTR(int, long double, tag, false);
-   TEST_TTR(long int, bool, tag, false);
-   TEST_TTR(long int, char, tag, false);
-   TEST_TTR(long int, signed char, tag, false);
-   TEST_TTR(long int, short int, tag, false);
-   TEST_TTR(long int, int, tag, false);
-   TEST_TTR(long int, long int, tag, false);
-   TEST_TTR(long int, unsigned char, tag, false);
-   TEST_TTR(long int, unsigned short int, tag, false);
-   TEST_TTR(long int, unsigned int, tag, false);
-   TEST_TTR(long int, unsigned long int, tag, false);
-   TEST_TTR(long int, wchar_t, tag, false);
-   TEST_TTR(long int, float, tag, false);
-   TEST_TTR(long int, double, tag, false);
-   TEST_TTR(long int, long double, tag, false);
-   TEST_TTR(unsigned char, bool, tag, false);
-   TEST_TTR(unsigned char, char, tag, false);
-   TEST_TTR(unsigned char, signed char, tag, false);
-   TEST_TTR(unsigned char, short int, tag, false);
-   TEST_TTR(unsigned char, int, tag, false);
-   TEST_TTR(unsigned char, long int, tag, false);
-   TEST_TTR(unsigned char, unsigned char, tag, false);
-   TEST_TTR(unsigned char, unsigned short int, tag, false);
-   TEST_TTR(unsigned char, unsigned int, tag, false);
-   TEST_TTR(unsigned char, unsigned long int, tag, false);
-   TEST_TTR(unsigned char, wchar_t, tag, false);
-   TEST_TTR(unsigned char, float, tag, false);
-   TEST_TTR(unsigned char, double, tag, false);
-   TEST_TTR(unsigned char, long double, tag, false);
-   TEST_TTR(unsigned short int, bool, tag, false);
-   TEST_TTR(unsigned short int, char, tag, false);
-   TEST_TTR(unsigned short int, signed char, tag, false);
-   TEST_TTR(unsigned short int, short int, tag, false);
-   TEST_TTR(unsigned short int, int, tag, false);
-   TEST_TTR(unsigned short int, long int, tag, false);
-   TEST_TTR(unsigned short int, unsigned char, tag, false);
-   TEST_TTR(unsigned short int, unsigned short int, tag, false);
-   TEST_TTR(unsigned short int, unsigned int, tag, false);
-   TEST_TTR(unsigned short int, unsigned long int, tag, false);
-   TEST_TTR(unsigned short int, wchar_t, tag, false);
-   TEST_TTR(unsigned short int, float, tag, false);
-   TEST_TTR(unsigned short int, double, tag, false);
-   TEST_TTR(unsigned short int, long double, tag, false);
-   TEST_TTR(unsigned int, bool, tag, false);
-   TEST_TTR(unsigned int, char, tag, false);
-   TEST_TTR(unsigned int, signed char, tag, false);
-   TEST_TTR(unsigned int, short int, tag, false);
-   TEST_TTR(unsigned int, int, tag, false);
-   TEST_TTR(unsigned int, long int, tag, false);
-   TEST_TTR(unsigned int, unsigned char, tag, false);
-   TEST_TTR(unsigned int, unsigned short int, tag, false);
-   TEST_TTR(unsigned int, unsigned int, tag, false);
-   TEST_TTR(unsigned int, unsigned long int, tag, false);
-   TEST_TTR(unsigned int, wchar_t, tag, false);
-   TEST_TTR(unsigned int, float, tag, false);
-   TEST_TTR(unsigned int, double, tag, false);
-   TEST_TTR(unsigned int, long double, tag, false);
-   TEST_TTR(unsigned long int, bool, tag, false);
-   TEST_TTR(unsigned long int, char, tag, false);
-   TEST_TTR(unsigned long int, signed char, tag, false);
-   TEST_TTR(unsigned long int, short int, tag, false);
-   TEST_TTR(unsigned long int, int, tag, false);
-   TEST_TTR(unsigned long int, long int, tag, false);
-   TEST_TTR(unsigned long int, unsigned char, tag, false);
-   TEST_TTR(unsigned long int, unsigned short int, tag, false);
-   TEST_TTR(unsigned long int, unsigned int, tag, false);
-   TEST_TTR(unsigned long int, unsigned long int, tag, false);
-   TEST_TTR(unsigned long int, wchar_t, tag, false);
-   TEST_TTR(unsigned long int, float, tag, false);
-   TEST_TTR(unsigned long int, double, tag, false);
-   TEST_TTR(unsigned long int, long double, tag, false);
-   TEST_TTR(wchar_t, bool, tag, false);
-   TEST_TTR(wchar_t, char, tag, false);
-   TEST_TTR(wchar_t, signed char, tag, false);
-   TEST_TTR(wchar_t, short int, tag, false);
-   TEST_TTR(wchar_t, int, tag, false);
-   TEST_TTR(wchar_t, long int, tag, false);
-   TEST_TTR(wchar_t, unsigned char, tag, false);
-   TEST_TTR(wchar_t, unsigned short int, tag, false);
-   TEST_TTR(wchar_t, unsigned int, tag, false);
-   TEST_TTR(wchar_t, unsigned long int, tag, false);
-   TEST_TTR(wchar_t, wchar_t, tag, false);
-   TEST_TTR(wchar_t, float, tag, false);
-   TEST_TTR(wchar_t, double, tag, false);
-   TEST_TTR(wchar_t, long double, tag, false);
-   TEST_TTR(float, bool, tag, false);
-   TEST_TTR(float, char, tag, false);
-   TEST_TTR(float, signed char, tag, false);
-   TEST_TTR(float, short int, tag, false);
-   TEST_TTR(float, int, tag, false);
-   TEST_TTR(float, long int, tag, false);
-   TEST_TTR(float, unsigned char, tag, false);
-   TEST_TTR(float, unsigned short int, tag, false);
-   TEST_TTR(float, unsigned int, tag, false);
-   TEST_TTR(float, unsigned long int, tag, false);
-   TEST_TTR(float, wchar_t, tag, false);
-   TEST_TTR(float, float, tag, false);
-   TEST_TTR(float, double, tag, false);
-   TEST_TTR(float, long double, tag, false);
-   TEST_TTR(double, bool, tag, false);
-   TEST_TTR(double, char, tag, false);
-   TEST_TTR(double, signed char, tag, false);
-   TEST_TTR(double, short int, tag, false);
-   TEST_TTR(double, int, tag, false);
-   TEST_TTR(double, long int, tag, false);
-   TEST_TTR(double, unsigned char, tag, false);
-   TEST_TTR(double, unsigned short int, tag, false);
-   TEST_TTR(double, unsigned int, tag, false);
-   TEST_TTR(double, unsigned long int, tag, false);
-   TEST_TTR(double, wchar_t, tag, false);
-   TEST_TTR(double, float, tag, false);
-   TEST_TTR(double, double, tag, false);
-   TEST_TTR(double, long double, tag, false);
-   TEST_TTR(long double, bool, tag, false);
-   TEST_TTR(long double, char, tag, false);
-   TEST_TTR(long double, signed char, tag, false);
-   TEST_TTR(long double, short int, tag, false);
-   TEST_TTR(long double, int, tag, false);
-   TEST_TTR(long double, long int, tag, false);
-   TEST_TTR(long double, unsigned char, tag, false);
-   TEST_TTR(long double, unsigned short int, tag, false);
-   TEST_TTR(long double, unsigned int, tag, false);
-   TEST_TTR(long double, unsigned long int, tag, false);
-   TEST_TTR(long double, wchar_t, tag, false);
-   TEST_TTR(long double, float, tag, false);
-   TEST_TTR(long double, double, tag, false);
-   TEST_TTR(long double, long double, tag, false);
-#	undef CV1
-#	define CV1(T) const T
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const T&
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T&
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T&
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const T
-#	undef CV2
-#	define CV2(T) const T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const T&
-#	undef CV2
-#	define CV2(T) const T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T
-#	undef CV2
-#	define CV2(T) volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T&
-#	undef CV2
-#	define CV2(T) volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T
-#	undef CV2
-#	define CV2(T) const volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T&
-#	undef CV2
-#	define CV2(T) const volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-   // pointers
-   TEST_TT(void*, bool, false);
-   TEST_TT(void*, int, false);
-   TEST_TT(void*, double, false);
-   TEST_TT(void*, A, false);
-   TEST_TT(void*, B, false);
-   TEST_TT(bool*, bool, true);
-   TEST_TT(bool*, int, true);
-   TEST_TT(bool*, double, false);
-   TEST_TT(bool*, A, false);
-   TEST_TT(bool*, B, false);
-   TEST_TT(int*, bool, true);
-   TEST_TT(int*, int, true);
-   TEST_TT(int*, double, false);
-   TEST_TT(int*, A, false);
-   TEST_TT(int*, B, false);
-   TEST_TT(double*, bool, true);
-   TEST_TT(double*, int, true);
-   TEST_TT(double*, double, false);
-   TEST_TT(double*, A, false);
-   TEST_TT(double*, B, false);
-   TEST_TT(A*, bool, true);
-   TEST_TT(A*, int, true);
-   TEST_TT(A*, double, false);
-   TEST_TT(A*, A, false);
-   TEST_TT(A*, B, false);
-   TEST_TT(B*, bool, true);
-   TEST_TT(B*, int, true);
-   TEST_TT(B*, double, false);
-   TEST_TT(B*, A, false);
-   TEST_TT(B*, B, false);
-   TEST_TT(bool, void*, false);
-   TEST_TT(bool, bool*, true);
-   TEST_TT(bool, int*, true);
-   TEST_TT(bool, double*, true);
-   TEST_TT(bool, A*, true);
-   TEST_TT(bool, B*, true);
-   TEST_TT(int, void*, false);
-   TEST_TT(int, bool*, true);
-   TEST_TT(int, int*, true);
-   TEST_TT(int, double*, true);
-   TEST_TT(int, A*, true);
-   TEST_TT(int, B*, true);
-   TEST_TT(double, void*, false);
-   TEST_TT(double, bool*, false);
-   TEST_TT(double, int*, false);
-   TEST_TT(double, double*, false);
-   TEST_TT(double, A*, false);
-   TEST_TT(double, B*, false);
-   TEST_TT(A, void*, false);
-   TEST_TT(A, bool*, false);
-   TEST_TT(A, int*, false);
-   TEST_TT(A, double*, false);
-   TEST_TT(A, A*, false);
-   TEST_TT(A, B*, false);
-   TEST_TT(B, void*, false);
-   TEST_TT(B, bool*, false);
-   TEST_TT(B, int*, false);
-   TEST_TT(B, double*, false);
-   TEST_TT(B, A*, false);
-   TEST_TT(B, B*, false);
-   TEST_TT(void*, void*, false);
-   TEST_TT(void*, bool*, false);
-   TEST_TT(void*, int*, false);
-   TEST_TT(void*, double*, false);
-   TEST_TT(void*, A*, false);
-   TEST_TT(void*, B*, false);
-   TEST_TT(bool*, void*, false);
-   TEST_TT(bool*, bool*, false);
-   TEST_TT(bool*, int*, false);
-   TEST_TT(bool*, double*, false);
-   TEST_TT(bool*, A*, false);
-   TEST_TT(bool*, B*, false);
-   TEST_TT(int*, void*, false);
-   TEST_TT(int*, bool*, false);
-   TEST_TT(int*, int*, false);
-   TEST_TT(int*, double*, false);
-   TEST_TT(int*, A*, false);
-   TEST_TT(int*, B*, false);
-   TEST_TT(double*, void*, false);
-   TEST_TT(double*, bool*, false);
-   TEST_TT(double*, int*, false);
-   TEST_TT(double*, double*, false);
-   TEST_TT(double*, A*, false);
-   TEST_TT(double*, B*, false);
-   TEST_TT(A*, void*, false);
-   TEST_TT(A*, bool*, false);
-   TEST_TT(A*, int*, false);
-   TEST_TT(A*, double*, false);
-   TEST_TT(A*, A*, false);
-   TEST_TT(A*, B*, false);
-   TEST_TT(B*, void*, false);
-   TEST_TT(B*, bool*, false);
-   TEST_TT(B*, int*, false);
-   TEST_TT(B*, double*, false);
-   TEST_TT(B*, A*, false);
-   TEST_TT(B*, B*, false);
-   TEST_TT(C, void*, true);
-   TEST_TT(D, void*, false);
-   TEST_TT(void*, C, false);
-   TEST_TT(void*, D, true);
-   TEST_TT(C, D, true);
-}
-}

Deleted: sandbox/type_traits/libs/type_traits/test/has_comparison_operator_test.hpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_comparison_operator_test.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,1250 +0,0 @@
-//  (C) Copyright Frederic Bron 2009-2011.
-//  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)
-
-namespace {
-
-void run2() {
-   // test with only one template parameter
-   TEST_T(void, false);
-   TEST_T(bool, true);
-   TEST_T(char, true);
-   TEST_T(signed char, true);
-   TEST_T(short int, true);
-   TEST_T(int, true);
-   TEST_T(long int, true);
-   TEST_T(unsigned char, true);
-   TEST_T(unsigned short int, true);
-   TEST_T(unsigned int, true);
-   TEST_T(unsigned long int, true);
-   TEST_T(wchar_t, true);
-   TEST_T(float, true);
-   TEST_T(double, true);
-   TEST_T(long double, true);
-   TEST_T(void, false);
-#	undef CV
-#	define CV(T) const T
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	undef CV
-#	define CV(T) volatile T
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	undef CV
-#	define CV(T) const volatile T
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	undef CV
-#	define CV(T) const T&
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	undef CV
-#	define CV(T) volatile T&
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	undef CV
-#	define CV(T) const volatile T&
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   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);
-   TEST_TT(bool, short int, true);
-   TEST_TT(bool, int, true);
-   TEST_TT(bool, long int, true);
-   TEST_TT(bool, unsigned char, true);
-   TEST_TT(bool, unsigned short int, true);
-   TEST_TT(bool, unsigned int, true);
-   TEST_TT(bool, unsigned long int, true);
-   TEST_TT(bool, wchar_t, true);
-   TEST_TT(bool, float, true);
-   TEST_TT(bool, double, true);
-   TEST_TT(bool, long double, true);
-   TEST_TT(char, bool, true);
-   TEST_TT(char, char, true);
-   TEST_TT(char, signed char, true);
-   TEST_TT(char, short int, true);
-   TEST_TT(char, int, true);
-   TEST_TT(char, long int, true);
-   TEST_TT(char, unsigned char, true);
-   TEST_TT(char, unsigned short int, true);
-   TEST_TT(char, unsigned int, true);
-   TEST_TT(char, unsigned long int, true);
-   TEST_TT(char, wchar_t, true);
-   TEST_TT(char, float, true);
-   TEST_TT(char, double, true);
-   TEST_TT(char, long double, true);
-   TEST_TT(signed char, bool, true);
-   TEST_TT(signed char, char, true);
-   TEST_TT(signed char, signed char, true);
-   TEST_TT(signed char, short int, true);
-   TEST_TT(signed char, int, true);
-   TEST_TT(signed char, long int, true);
-   TEST_TT(signed char, unsigned char, true);
-   TEST_TT(signed char, unsigned short int, true);
-   TEST_TT(signed char, unsigned int, true);
-   TEST_TT(signed char, unsigned long int, true);
-   TEST_TT(signed char, wchar_t, true);
-   TEST_TT(signed char, float, true);
-   TEST_TT(signed char, double, true);
-   TEST_TT(signed char, long double, true);
-   TEST_TT(short int, bool, true);
-   TEST_TT(short int, char, true);
-   TEST_TT(short int, signed char, true);
-   TEST_TT(short int, short int, true);
-   TEST_TT(short int, int, true);
-   TEST_TT(short int, long int, true);
-   TEST_TT(short int, unsigned char, true);
-   TEST_TT(short int, unsigned short int, true);
-   TEST_TT(short int, unsigned int, true);
-   TEST_TT(short int, unsigned long int, true);
-   TEST_TT(short int, wchar_t, true);
-   TEST_TT(short int, float, true);
-   TEST_TT(short int, double, true);
-   TEST_TT(short int, long double, true);
-   TEST_TT(int, bool, true);
-   TEST_TT(int, char, true);
-   TEST_TT(int, signed char, true);
-   TEST_TT(int, short int, true);
-   TEST_TT(int, int, true);
-   TEST_TT(int, long int, true);
-   TEST_TT(int, unsigned char, true);
-   TEST_TT(int, unsigned short int, true);
-   TEST_TT(int, unsigned int, true);
-   TEST_TT(int, unsigned long int, true);
-   TEST_TT(int, wchar_t, true);
-   TEST_TT(int, float, true);
-   TEST_TT(int, double, true);
-   TEST_TT(int, long double, true);
-   TEST_TT(long int, bool, true);
-   TEST_TT(long int, char, true);
-   TEST_TT(long int, signed char, true);
-   TEST_TT(long int, short int, true);
-   TEST_TT(long int, int, true);
-   TEST_TT(long int, long int, true);
-   TEST_TT(long int, unsigned char, true);
-   TEST_TT(long int, unsigned short int, true);
-   TEST_TT(long int, unsigned int, true);
-   TEST_TT(long int, unsigned long int, true);
-   TEST_TT(long int, wchar_t, true);
-   TEST_TT(long int, float, true);
-   TEST_TT(long int, double, true);
-   TEST_TT(long int, long double, true);
-   TEST_TT(unsigned char, bool, true);
-   TEST_TT(unsigned char, char, true);
-   TEST_TT(unsigned char, signed char, true);
-   TEST_TT(unsigned char, short int, true);
-   TEST_TT(unsigned char, int, true);
-   TEST_TT(unsigned char, long int, true);
-   TEST_TT(unsigned char, unsigned char, true);
-   TEST_TT(unsigned char, unsigned short int, true);
-   TEST_TT(unsigned char, unsigned int, true);
-   TEST_TT(unsigned char, unsigned long int, true);
-   TEST_TT(unsigned char, wchar_t, true);
-   TEST_TT(unsigned char, float, true);
-   TEST_TT(unsigned char, double, true);
-   TEST_TT(unsigned char, long double, true);
-   TEST_TT(unsigned short int, bool, true);
-   TEST_TT(unsigned short int, char, true);
-   TEST_TT(unsigned short int, signed char, true);
-   TEST_TT(unsigned short int, short int, true);
-   TEST_TT(unsigned short int, int, true);
-   TEST_TT(unsigned short int, long int, true);
-   TEST_TT(unsigned short int, unsigned char, true);
-   TEST_TT(unsigned short int, unsigned short int, true);
-   TEST_TT(unsigned short int, unsigned int, true);
-   TEST_TT(unsigned short int, unsigned long int, true);
-   TEST_TT(unsigned short int, wchar_t, true);
-   TEST_TT(unsigned short int, float, true);
-   TEST_TT(unsigned short int, double, true);
-   TEST_TT(unsigned short int, long double, true);
-   TEST_TT(unsigned int, bool, true);
-   TEST_TT(unsigned int, char, true);
-   TEST_TT(unsigned int, signed char, true);
-   TEST_TT(unsigned int, short int, true);
-   TEST_TT(unsigned int, int, true);
-   TEST_TT(unsigned int, long int, true);
-   TEST_TT(unsigned int, unsigned char, true);
-   TEST_TT(unsigned int, unsigned short int, true);
-   TEST_TT(unsigned int, unsigned int, true);
-   TEST_TT(unsigned int, unsigned long int, true);
-   TEST_TT(unsigned int, wchar_t, true);
-   TEST_TT(unsigned int, float, true);
-   TEST_TT(unsigned int, double, true);
-   TEST_TT(unsigned int, long double, true);
-   TEST_TT(unsigned long int, bool, true);
-   TEST_TT(unsigned long int, char, true);
-   TEST_TT(unsigned long int, signed char, true);
-   TEST_TT(unsigned long int, short int, true);
-   TEST_TT(unsigned long int, int, true);
-   TEST_TT(unsigned long int, long int, true);
-   TEST_TT(unsigned long int, unsigned char, true);
-   TEST_TT(unsigned long int, unsigned short int, true);
-   TEST_TT(unsigned long int, unsigned int, true);
-   TEST_TT(unsigned long int, unsigned long int, true);
-   TEST_TT(unsigned long int, wchar_t, true);
-   TEST_TT(unsigned long int, float, true);
-   TEST_TT(unsigned long int, double, true);
-   TEST_TT(unsigned long int, long double, true);
-   TEST_TT(wchar_t, bool, true);
-   TEST_TT(wchar_t, char, true);
-   TEST_TT(wchar_t, signed char, true);
-   TEST_TT(wchar_t, short int, true);
-   TEST_TT(wchar_t, int, true);
-   TEST_TT(wchar_t, long int, true);
-   TEST_TT(wchar_t, unsigned char, true);
-   TEST_TT(wchar_t, unsigned short int, true);
-   TEST_TT(wchar_t, unsigned int, true);
-   TEST_TT(wchar_t, unsigned long int, true);
-   TEST_TT(wchar_t, wchar_t, true);
-   TEST_TT(wchar_t, float, true);
-   TEST_TT(wchar_t, double, true);
-   TEST_TT(wchar_t, long double, true);
-   TEST_TT(float, bool, true);
-   TEST_TT(float, char, true);
-   TEST_TT(float, signed char, true);
-   TEST_TT(float, short int, true);
-   TEST_TT(float, int, true);
-   TEST_TT(float, long int, true);
-   TEST_TT(float, unsigned char, true);
-   TEST_TT(float, unsigned short int, true);
-   TEST_TT(float, unsigned int, true);
-   TEST_TT(float, unsigned long int, true);
-   TEST_TT(float, wchar_t, true);
-   TEST_TT(float, float, true);
-   TEST_TT(float, double, true);
-   TEST_TT(float, long double, true);
-   TEST_TT(double, bool, true);
-   TEST_TT(double, char, true);
-   TEST_TT(double, signed char, true);
-   TEST_TT(double, short int, true);
-   TEST_TT(double, int, true);
-   TEST_TT(double, long int, true);
-   TEST_TT(double, unsigned char, true);
-   TEST_TT(double, unsigned short int, true);
-   TEST_TT(double, unsigned int, true);
-   TEST_TT(double, unsigned long int, true);
-   TEST_TT(double, wchar_t, true);
-   TEST_TT(double, float, true);
-   TEST_TT(double, double, true);
-   TEST_TT(double, long double, true);
-   TEST_TT(long double, bool, true);
-   TEST_TT(long double, char, true);
-   TEST_TT(long double, signed char, true);
-   TEST_TT(long double, short int, true);
-   TEST_TT(long double, int, true);
-   TEST_TT(long double, long int, true);
-   TEST_TT(long double, unsigned char, true);
-   TEST_TT(long double, unsigned short int, true);
-   TEST_TT(long double, unsigned int, true);
-   TEST_TT(long double, unsigned long int, true);
-   TEST_TT(long double, wchar_t, true);
-   TEST_TT(long double, float, true);
-   TEST_TT(long double, double, true);
-   TEST_TT(long double, long double, true);
-   TEST_TT(bool, void, false);
-   TEST_TT(void, bool, false);
-   TEST_TT(char, void, false);
-   TEST_TT(void, char, false);
-   TEST_TT(signed char, void, false);
-   TEST_TT(void, signed char, false);
-   TEST_TT(short int, void, false);
-   TEST_TT(void, short int, false);
-   TEST_TT(int, void, false);
-   TEST_TT(void, int, false);
-   TEST_TT(long int, void, false);
-   TEST_TT(void, long int, false);
-   TEST_TT(unsigned char, void, false);
-   TEST_TT(void, unsigned char, false);
-   TEST_TT(unsigned short int, void, false);
-   TEST_TT(void, unsigned short int, false);
-   TEST_TT(unsigned int, void, false);
-   TEST_TT(void, unsigned int, false);
-   TEST_TT(unsigned long int, void, false);
-   TEST_TT(void, unsigned long int, false);
-   TEST_TT(wchar_t, void, false);
-   TEST_TT(void, wchar_t, false);
-   TEST_TT(float, void, false);
-   TEST_TT(void, float, false);
-   TEST_TT(double, void, false);
-   TEST_TT(void, double, false);
-   TEST_TT(long double, void, false);
-   TEST_TT(void, long double, false);
-
-// test with three template parameters
-   TEST_TTR(bool, bool, bool, true);
-   TEST_TTR(bool, char, bool, true);
-   TEST_TTR(bool, signed char, bool, true);
-   TEST_TTR(bool, short int, bool, true);
-   TEST_TTR(bool, int, bool, true);
-   TEST_TTR(bool, long int, bool, true);
-   TEST_TTR(bool, unsigned char, bool, true);
-   TEST_TTR(bool, unsigned short int, bool, true);
-   TEST_TTR(bool, unsigned int, bool, true);
-   TEST_TTR(bool, unsigned long int, bool, true);
-   TEST_TTR(bool, wchar_t, bool, true);
-   TEST_TTR(bool, float, bool, true);
-   TEST_TTR(bool, double, bool, true);
-   TEST_TTR(bool, long double, bool, true);
-   TEST_TTR(char, bool, bool, true);
-   TEST_TTR(char, char, bool, true);
-   TEST_TTR(char, signed char, bool, true);
-   TEST_TTR(char, short int, bool, true);
-   TEST_TTR(char, int, bool, true);
-   TEST_TTR(char, long int, bool, true);
-   TEST_TTR(char, unsigned char, bool, true);
-   TEST_TTR(char, unsigned short int, bool, true);
-   TEST_TTR(char, unsigned int, bool, true);
-   TEST_TTR(char, unsigned long int, bool, true);
-   TEST_TTR(char, wchar_t, bool, true);
-   TEST_TTR(char, float, bool, true);
-   TEST_TTR(char, double, bool, true);
-   TEST_TTR(char, long double, bool, true);
-   TEST_TTR(signed char, bool, bool, true);
-   TEST_TTR(signed char, char, bool, true);
-   TEST_TTR(signed char, signed char, bool, true);
-   TEST_TTR(signed char, short int, bool, true);
-   TEST_TTR(signed char, int, bool, true);
-   TEST_TTR(signed char, long int, bool, true);
-   TEST_TTR(signed char, unsigned char, bool, true);
-   TEST_TTR(signed char, unsigned short int, bool, true);
-   TEST_TTR(signed char, unsigned int, bool, true);
-   TEST_TTR(signed char, unsigned long int, bool, true);
-   TEST_TTR(signed char, wchar_t, bool, true);
-   TEST_TTR(signed char, float, bool, true);
-   TEST_TTR(signed char, double, bool, true);
-   TEST_TTR(signed char, long double, bool, true);
-   TEST_TTR(short int, bool, bool, true);
-   TEST_TTR(short int, char, bool, true);
-   TEST_TTR(short int, signed char, bool, true);
-   TEST_TTR(short int, short int, bool, true);
-   TEST_TTR(short int, int, bool, true);
-   TEST_TTR(short int, long int, bool, true);
-   TEST_TTR(short int, unsigned char, bool, true);
-   TEST_TTR(short int, unsigned short int, bool, true);
-   TEST_TTR(short int, unsigned int, bool, true);
-   TEST_TTR(short int, unsigned long int, bool, true);
-   TEST_TTR(short int, wchar_t, bool, true);
-   TEST_TTR(short int, float, bool, true);
-   TEST_TTR(short int, double, bool, true);
-   TEST_TTR(short int, long double, bool, true);
-   TEST_TTR(int, bool, bool, true);
-   TEST_TTR(int, char, bool, true);
-   TEST_TTR(int, signed char, bool, true);
-   TEST_TTR(int, short int, bool, true);
-   TEST_TTR(int, int, bool, true);
-   TEST_TTR(int, long int, bool, true);
-   TEST_TTR(int, unsigned char, bool, true);
-   TEST_TTR(int, unsigned short int, bool, true);
-   TEST_TTR(int, unsigned int, bool, true);
-   TEST_TTR(int, unsigned long int, bool, true);
-   TEST_TTR(int, wchar_t, bool, true);
-   TEST_TTR(int, float, bool, true);
-   TEST_TTR(int, double, bool, true);
-   TEST_TTR(int, long double, bool, true);
-   TEST_TTR(long int, bool, bool, true);
-   TEST_TTR(long int, char, bool, true);
-   TEST_TTR(long int, signed char, bool, true);
-   TEST_TTR(long int, short int, bool, true);
-   TEST_TTR(long int, int, bool, true);
-   TEST_TTR(long int, long int, bool, true);
-   TEST_TTR(long int, unsigned char, bool, true);
-   TEST_TTR(long int, unsigned short int, bool, true);
-   TEST_TTR(long int, unsigned int, bool, true);
-   TEST_TTR(long int, unsigned long int, bool, true);
-   TEST_TTR(long int, wchar_t, bool, true);
-   TEST_TTR(long int, float, bool, true);
-   TEST_TTR(long int, double, bool, true);
-   TEST_TTR(long int, long double, bool, true);
-   TEST_TTR(unsigned char, bool, bool, true);
-   TEST_TTR(unsigned char, char, bool, true);
-   TEST_TTR(unsigned char, signed char, bool, true);
-   TEST_TTR(unsigned char, short int, bool, true);
-   TEST_TTR(unsigned char, int, bool, true);
-   TEST_TTR(unsigned char, long int, bool, true);
-   TEST_TTR(unsigned char, unsigned char, bool, true);
-   TEST_TTR(unsigned char, unsigned short int, bool, true);
-   TEST_TTR(unsigned char, unsigned int, bool, true);
-   TEST_TTR(unsigned char, unsigned long int, bool, true);
-   TEST_TTR(unsigned char, wchar_t, bool, true);
-   TEST_TTR(unsigned char, float, bool, true);
-   TEST_TTR(unsigned char, double, bool, true);
-   TEST_TTR(unsigned char, long double, bool, true);
-   TEST_TTR(unsigned short int, bool, bool, true);
-   TEST_TTR(unsigned short int, char, bool, true);
-   TEST_TTR(unsigned short int, signed char, bool, true);
-   TEST_TTR(unsigned short int, short int, bool, true);
-   TEST_TTR(unsigned short int, int, bool, true);
-   TEST_TTR(unsigned short int, long int, bool, true);
-   TEST_TTR(unsigned short int, unsigned char, bool, true);
-   TEST_TTR(unsigned short int, unsigned short int, bool, true);
-   TEST_TTR(unsigned short int, unsigned int, bool, true);
-   TEST_TTR(unsigned short int, unsigned long int, bool, true);
-   TEST_TTR(unsigned short int, wchar_t, bool, true);
-   TEST_TTR(unsigned short int, float, bool, true);
-   TEST_TTR(unsigned short int, double, bool, true);
-   TEST_TTR(unsigned short int, long double, bool, true);
-   TEST_TTR(unsigned int, bool, bool, true);
-   TEST_TTR(unsigned int, char, bool, true);
-   TEST_TTR(unsigned int, signed char, bool, true);
-   TEST_TTR(unsigned int, short int, bool, true);
-   TEST_TTR(unsigned int, int, bool, true);
-   TEST_TTR(unsigned int, long int, bool, true);
-   TEST_TTR(unsigned int, unsigned char, bool, true);
-   TEST_TTR(unsigned int, unsigned short int, bool, true);
-   TEST_TTR(unsigned int, unsigned int, bool, true);
-   TEST_TTR(unsigned int, unsigned long int, bool, true);
-   TEST_TTR(unsigned int, wchar_t, bool, true);
-   TEST_TTR(unsigned int, float, bool, true);
-   TEST_TTR(unsigned int, double, bool, true);
-   TEST_TTR(unsigned int, long double, bool, true);
-   TEST_TTR(unsigned long int, bool, bool, true);
-   TEST_TTR(unsigned long int, char, bool, true);
-   TEST_TTR(unsigned long int, signed char, bool, true);
-   TEST_TTR(unsigned long int, short int, bool, true);
-   TEST_TTR(unsigned long int, int, bool, true);
-   TEST_TTR(unsigned long int, long int, bool, true);
-   TEST_TTR(unsigned long int, unsigned char, bool, true);
-   TEST_TTR(unsigned long int, unsigned short int, bool, true);
-   TEST_TTR(unsigned long int, unsigned int, bool, true);
-   TEST_TTR(unsigned long int, unsigned long int, bool, true);
-   TEST_TTR(unsigned long int, wchar_t, bool, true);
-   TEST_TTR(unsigned long int, float, bool, true);
-   TEST_TTR(unsigned long int, double, bool, true);
-   TEST_TTR(unsigned long int, long double, bool, true);
-   TEST_TTR(wchar_t, bool, bool, true);
-   TEST_TTR(wchar_t, char, bool, true);
-   TEST_TTR(wchar_t, signed char, bool, true);
-   TEST_TTR(wchar_t, short int, bool, true);
-   TEST_TTR(wchar_t, int, bool, true);
-   TEST_TTR(wchar_t, long int, bool, true);
-   TEST_TTR(wchar_t, unsigned char, bool, true);
-   TEST_TTR(wchar_t, unsigned short int, bool, true);
-   TEST_TTR(wchar_t, unsigned int, bool, true);
-   TEST_TTR(wchar_t, unsigned long int, bool, true);
-   TEST_TTR(wchar_t, wchar_t, bool, true);
-   TEST_TTR(wchar_t, float, bool, true);
-   TEST_TTR(wchar_t, double, bool, true);
-   TEST_TTR(wchar_t, long double, bool, true);
-   TEST_TTR(float, bool, bool, true);
-   TEST_TTR(float, char, bool, true);
-   TEST_TTR(float, signed char, bool, true);
-   TEST_TTR(float, short int, bool, true);
-   TEST_TTR(float, int, bool, true);
-   TEST_TTR(float, long int, bool, true);
-   TEST_TTR(float, unsigned char, bool, true);
-   TEST_TTR(float, unsigned short int, bool, true);
-   TEST_TTR(float, unsigned int, bool, true);
-   TEST_TTR(float, unsigned long int, bool, true);
-   TEST_TTR(float, wchar_t, bool, true);
-   TEST_TTR(float, float, bool, true);
-   TEST_TTR(float, double, bool, true);
-   TEST_TTR(float, long double, bool, true);
-   TEST_TTR(double, bool, bool, true);
-   TEST_TTR(double, char, bool, true);
-   TEST_TTR(double, signed char, bool, true);
-   TEST_TTR(double, short int, bool, true);
-   TEST_TTR(double, int, bool, true);
-   TEST_TTR(double, long int, bool, true);
-   TEST_TTR(double, unsigned char, bool, true);
-   TEST_TTR(double, unsigned short int, bool, true);
-   TEST_TTR(double, unsigned int, bool, true);
-   TEST_TTR(double, unsigned long int, bool, true);
-   TEST_TTR(double, wchar_t, bool, true);
-   TEST_TTR(double, float, bool, true);
-   TEST_TTR(double, double, bool, true);
-   TEST_TTR(double, long double, bool, true);
-   TEST_TTR(long double, bool, bool, true);
-   TEST_TTR(long double, char, bool, true);
-   TEST_TTR(long double, signed char, bool, true);
-   TEST_TTR(long double, short int, bool, true);
-   TEST_TTR(long double, int, bool, true);
-   TEST_TTR(long double, long int, bool, true);
-   TEST_TTR(long double, unsigned char, bool, true);
-   TEST_TTR(long double, unsigned short int, bool, true);
-   TEST_TTR(long double, unsigned int, bool, true);
-   TEST_TTR(long double, unsigned long int, bool, true);
-   TEST_TTR(long double, wchar_t, bool, true);
-   TEST_TTR(long double, float, bool, true);
-   TEST_TTR(long double, double, bool, true);
-   TEST_TTR(long double, long double, bool, true);
-   TEST_TTR(bool, bool, tag, false);
-   TEST_TTR(bool, char, tag, false);
-   TEST_TTR(bool, signed char, tag, false);
-   TEST_TTR(bool, short int, tag, false);
-   TEST_TTR(bool, int, tag, false);
-   TEST_TTR(bool, long int, tag, false);
-   TEST_TTR(bool, unsigned char, tag, false);
-   TEST_TTR(bool, unsigned short int, tag, false);
-   TEST_TTR(bool, unsigned int, tag, false);
-   TEST_TTR(bool, unsigned long int, tag, false);
-   TEST_TTR(bool, wchar_t, tag, false);
-   TEST_TTR(bool, float, tag, false);
-   TEST_TTR(bool, double, tag, false);
-   TEST_TTR(bool, long double, tag, false);
-   TEST_TTR(char, bool, tag, false);
-   TEST_TTR(char, char, tag, false);
-   TEST_TTR(char, signed char, tag, false);
-   TEST_TTR(char, short int, tag, false);
-   TEST_TTR(char, int, tag, false);
-   TEST_TTR(char, long int, tag, false);
-   TEST_TTR(char, unsigned char, tag, false);
-   TEST_TTR(char, unsigned short int, tag, false);
-   TEST_TTR(char, unsigned int, tag, false);
-   TEST_TTR(char, unsigned long int, tag, false);
-   TEST_TTR(char, wchar_t, tag, false);
-   TEST_TTR(char, float, tag, false);
-   TEST_TTR(char, double, tag, false);
-   TEST_TTR(char, long double, tag, false);
-   TEST_TTR(signed char, bool, tag, false);
-   TEST_TTR(signed char, char, tag, false);
-   TEST_TTR(signed char, signed char, tag, false);
-   TEST_TTR(signed char, short int, tag, false);
-   TEST_TTR(signed char, int, tag, false);
-   TEST_TTR(signed char, long int, tag, false);
-   TEST_TTR(signed char, unsigned char, tag, false);
-   TEST_TTR(signed char, unsigned short int, tag, false);
-   TEST_TTR(signed char, unsigned int, tag, false);
-   TEST_TTR(signed char, unsigned long int, tag, false);
-   TEST_TTR(signed char, wchar_t, tag, false);
-   TEST_TTR(signed char, float, tag, false);
-   TEST_TTR(signed char, double, tag, false);
-   TEST_TTR(signed char, long double, tag, false);
-   TEST_TTR(short int, bool, tag, false);
-   TEST_TTR(short int, char, tag, false);
-   TEST_TTR(short int, signed char, tag, false);
-   TEST_TTR(short int, short int, tag, false);
-   TEST_TTR(short int, int, tag, false);
-   TEST_TTR(short int, long int, tag, false);
-   TEST_TTR(short int, unsigned char, tag, false);
-   TEST_TTR(short int, unsigned short int, tag, false);
-   TEST_TTR(short int, unsigned int, tag, false);
-   TEST_TTR(short int, unsigned long int, tag, false);
-   TEST_TTR(short int, wchar_t, tag, false);
-   TEST_TTR(short int, float, tag, false);
-   TEST_TTR(short int, double, tag, false);
-   TEST_TTR(short int, long double, tag, false);
-   TEST_TTR(int, bool, tag, false);
-   TEST_TTR(int, char, tag, false);
-   TEST_TTR(int, signed char, tag, false);
-   TEST_TTR(int, short int, tag, false);
-   TEST_TTR(int, int, tag, false);
-   TEST_TTR(int, long int, tag, false);
-   TEST_TTR(int, unsigned char, tag, false);
-   TEST_TTR(int, unsigned short int, tag, false);
-   TEST_TTR(int, unsigned int, tag, false);
-   TEST_TTR(int, unsigned long int, tag, false);
-   TEST_TTR(int, wchar_t, tag, false);
-   TEST_TTR(int, float, tag, false);
-   TEST_TTR(int, double, tag, false);
-   TEST_TTR(int, long double, tag, false);
-   TEST_TTR(long int, bool, tag, false);
-   TEST_TTR(long int, char, tag, false);
-   TEST_TTR(long int, signed char, tag, false);
-   TEST_TTR(long int, short int, tag, false);
-   TEST_TTR(long int, int, tag, false);
-   TEST_TTR(long int, long int, tag, false);
-   TEST_TTR(long int, unsigned char, tag, false);
-   TEST_TTR(long int, unsigned short int, tag, false);
-   TEST_TTR(long int, unsigned int, tag, false);
-   TEST_TTR(long int, unsigned long int, tag, false);
-   TEST_TTR(long int, wchar_t, tag, false);
-   TEST_TTR(long int, float, tag, false);
-   TEST_TTR(long int, double, tag, false);
-   TEST_TTR(long int, long double, tag, false);
-   TEST_TTR(unsigned char, bool, tag, false);
-   TEST_TTR(unsigned char, char, tag, false);
-   TEST_TTR(unsigned char, signed char, tag, false);
-   TEST_TTR(unsigned char, short int, tag, false);
-   TEST_TTR(unsigned char, int, tag, false);
-   TEST_TTR(unsigned char, long int, tag, false);
-   TEST_TTR(unsigned char, unsigned char, tag, false);
-   TEST_TTR(unsigned char, unsigned short int, tag, false);
-   TEST_TTR(unsigned char, unsigned int, tag, false);
-   TEST_TTR(unsigned char, unsigned long int, tag, false);
-   TEST_TTR(unsigned char, wchar_t, tag, false);
-   TEST_TTR(unsigned char, float, tag, false);
-   TEST_TTR(unsigned char, double, tag, false);
-   TEST_TTR(unsigned char, long double, tag, false);
-   TEST_TTR(unsigned short int, bool, tag, false);
-   TEST_TTR(unsigned short int, char, tag, false);
-   TEST_TTR(unsigned short int, signed char, tag, false);
-   TEST_TTR(unsigned short int, short int, tag, false);
-   TEST_TTR(unsigned short int, int, tag, false);
-   TEST_TTR(unsigned short int, long int, tag, false);
-   TEST_TTR(unsigned short int, unsigned char, tag, false);
-   TEST_TTR(unsigned short int, unsigned short int, tag, false);
-   TEST_TTR(unsigned short int, unsigned int, tag, false);
-   TEST_TTR(unsigned short int, unsigned long int, tag, false);
-   TEST_TTR(unsigned short int, wchar_t, tag, false);
-   TEST_TTR(unsigned short int, float, tag, false);
-   TEST_TTR(unsigned short int, double, tag, false);
-   TEST_TTR(unsigned short int, long double, tag, false);
-   TEST_TTR(unsigned int, bool, tag, false);
-   TEST_TTR(unsigned int, char, tag, false);
-   TEST_TTR(unsigned int, signed char, tag, false);
-   TEST_TTR(unsigned int, short int, tag, false);
-   TEST_TTR(unsigned int, int, tag, false);
-   TEST_TTR(unsigned int, long int, tag, false);
-   TEST_TTR(unsigned int, unsigned char, tag, false);
-   TEST_TTR(unsigned int, unsigned short int, tag, false);
-   TEST_TTR(unsigned int, unsigned int, tag, false);
-   TEST_TTR(unsigned int, unsigned long int, tag, false);
-   TEST_TTR(unsigned int, wchar_t, tag, false);
-   TEST_TTR(unsigned int, float, tag, false);
-   TEST_TTR(unsigned int, double, tag, false);
-   TEST_TTR(unsigned int, long double, tag, false);
-   TEST_TTR(unsigned long int, bool, tag, false);
-   TEST_TTR(unsigned long int, char, tag, false);
-   TEST_TTR(unsigned long int, signed char, tag, false);
-   TEST_TTR(unsigned long int, short int, tag, false);
-   TEST_TTR(unsigned long int, int, tag, false);
-   TEST_TTR(unsigned long int, long int, tag, false);
-   TEST_TTR(unsigned long int, unsigned char, tag, false);
-   TEST_TTR(unsigned long int, unsigned short int, tag, false);
-   TEST_TTR(unsigned long int, unsigned int, tag, false);
-   TEST_TTR(unsigned long int, unsigned long int, tag, false);
-   TEST_TTR(unsigned long int, wchar_t, tag, false);
-   TEST_TTR(unsigned long int, float, tag, false);
-   TEST_TTR(unsigned long int, double, tag, false);
-   TEST_TTR(unsigned long int, long double, tag, false);
-   TEST_TTR(wchar_t, bool, tag, false);
-   TEST_TTR(wchar_t, char, tag, false);
-   TEST_TTR(wchar_t, signed char, tag, false);
-   TEST_TTR(wchar_t, short int, tag, false);
-   TEST_TTR(wchar_t, int, tag, false);
-   TEST_TTR(wchar_t, long int, tag, false);
-   TEST_TTR(wchar_t, unsigned char, tag, false);
-   TEST_TTR(wchar_t, unsigned short int, tag, false);
-   TEST_TTR(wchar_t, unsigned int, tag, false);
-   TEST_TTR(wchar_t, unsigned long int, tag, false);
-   TEST_TTR(wchar_t, wchar_t, tag, false);
-   TEST_TTR(wchar_t, float, tag, false);
-   TEST_TTR(wchar_t, double, tag, false);
-   TEST_TTR(wchar_t, long double, tag, false);
-   TEST_TTR(float, bool, tag, false);
-   TEST_TTR(float, char, tag, false);
-   TEST_TTR(float, signed char, tag, false);
-   TEST_TTR(float, short int, tag, false);
-   TEST_TTR(float, int, tag, false);
-   TEST_TTR(float, long int, tag, false);
-   TEST_TTR(float, unsigned char, tag, false);
-   TEST_TTR(float, unsigned short int, tag, false);
-   TEST_TTR(float, unsigned int, tag, false);
-   TEST_TTR(float, unsigned long int, tag, false);
-   TEST_TTR(float, wchar_t, tag, false);
-   TEST_TTR(float, float, tag, false);
-   TEST_TTR(float, double, tag, false);
-   TEST_TTR(float, long double, tag, false);
-   TEST_TTR(double, bool, tag, false);
-   TEST_TTR(double, char, tag, false);
-   TEST_TTR(double, signed char, tag, false);
-   TEST_TTR(double, short int, tag, false);
-   TEST_TTR(double, int, tag, false);
-   TEST_TTR(double, long int, tag, false);
-   TEST_TTR(double, unsigned char, tag, false);
-   TEST_TTR(double, unsigned short int, tag, false);
-   TEST_TTR(double, unsigned int, tag, false);
-   TEST_TTR(double, unsigned long int, tag, false);
-   TEST_TTR(double, wchar_t, tag, false);
-   TEST_TTR(double, float, tag, false);
-   TEST_TTR(double, double, tag, false);
-   TEST_TTR(double, long double, tag, false);
-   TEST_TTR(long double, bool, tag, false);
-   TEST_TTR(long double, char, tag, false);
-   TEST_TTR(long double, signed char, tag, false);
-   TEST_TTR(long double, short int, tag, false);
-   TEST_TTR(long double, int, tag, false);
-   TEST_TTR(long double, long int, tag, false);
-   TEST_TTR(long double, unsigned char, tag, false);
-   TEST_TTR(long double, unsigned short int, tag, false);
-   TEST_TTR(long double, unsigned int, tag, false);
-   TEST_TTR(long double, unsigned long int, tag, false);
-   TEST_TTR(long double, wchar_t, tag, false);
-   TEST_TTR(long double, float, tag, false);
-   TEST_TTR(long double, double, tag, false);
-   TEST_TTR(long double, long double, tag, false);
-#	undef CV1
-#	define CV1(T) const T
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const T&
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T&
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T&
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const T
-#	undef CV2
-#	define CV2(T) const T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const T&
-#	undef CV2
-#	define CV2(T) const T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T
-#	undef CV2
-#	define CV2(T) volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T&
-#	undef CV2
-#	define CV2(T) volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T
-#	undef CV2
-#	define CV2(T) const volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T&
-#	undef CV2
-#	define CV2(T) const volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-   // pointers
-   TEST_TT(void*, bool, false);
-   TEST_TT(void*, int, false);
-   TEST_TT(void*, double, false);
-   TEST_TT(void*, A, false);
-   TEST_TT(void*, B, false);
-   TEST_TT(bool*, bool, false);
-   TEST_TT(bool*, int, false);
-   TEST_TT(bool*, double, false);
-   TEST_TT(bool*, A, false);
-   TEST_TT(bool*, B, false);
-   TEST_TT(int*, bool, false);
-   TEST_TT(int*, int, false);
-   TEST_TT(int*, double, false);
-   TEST_TT(int*, A, false);
-   TEST_TT(int*, B, false);
-   TEST_TT(double*, bool, false);
-   TEST_TT(double*, int, false);
-   TEST_TT(double*, double, false);
-   TEST_TT(double*, A, false);
-   TEST_TT(double*, B, false);
-   TEST_TT(A*, bool, false);
-   TEST_TT(A*, int, false);
-   TEST_TT(A*, double, false);
-   TEST_TT(A*, A, false);
-   TEST_TT(A*, B, false);
-   TEST_TT(B*, bool, false);
-   TEST_TT(B*, int, false);
-   TEST_TT(B*, double, false);
-   TEST_TT(B*, A, false);
-   TEST_TT(B*, B, false);
-   TEST_TT(bool, void*, false);
-   TEST_TT(bool, bool*, false);
-   TEST_TT(bool, int*, false);
-   TEST_TT(bool, double*, false);
-   TEST_TT(bool, A*, false);
-   TEST_TT(bool, B*, false);
-   TEST_TT(int, void*, false);
-   TEST_TT(int, bool*, false);
-   TEST_TT(int, int*, false);
-   TEST_TT(int, double*, false);
-   TEST_TT(int, A*, false);
-   TEST_TT(int, B*, false);
-   TEST_TT(double, void*, false);
-   TEST_TT(double, bool*, false);
-   TEST_TT(double, int*, false);
-   TEST_TT(double, double*, false);
-   TEST_TT(double, A*, false);
-   TEST_TT(double, B*, false);
-   TEST_TT(A, void*, false);
-   TEST_TT(A, bool*, false);
-   TEST_TT(A, int*, false);
-   TEST_TT(A, double*, false);
-   TEST_TT(A, A*, false);
-   TEST_TT(A, B*, false);
-   TEST_TT(B, void*, false);
-   TEST_TT(B, bool*, false);
-   TEST_TT(B, int*, false);
-   TEST_TT(B, double*, false);
-   TEST_TT(B, A*, false);
-   TEST_TT(B, B*, false);
-   TEST_TT(void*, void*, true);
-   TEST_TT(void*, bool*, true);
-   TEST_TT(void*, int*, true);
-   TEST_TT(void*, double*, true);
-   TEST_TT(void*, A*, true);
-   TEST_TT(void*, B*, true);
-   TEST_TT(bool*, void*, true);
-   TEST_TT(bool*, bool*, true);
-   TEST_TT(bool*, int*, false);
-   TEST_TT(bool*, double*, false);
-   TEST_TT(bool*, A*, false);
-   TEST_TT(bool*, B*, false);
-   TEST_TT(int*, void*, true);
-   TEST_TT(int*, bool*, false);
-   TEST_TT(int*, int*, true);
-   TEST_TT(int*, double*, false);
-   TEST_TT(int*, A*, false);
-   TEST_TT(int*, B*, false);
-   TEST_TT(double*, void*, true);
-   TEST_TT(double*, bool*, false);
-   TEST_TT(double*, int*, false);
-   TEST_TT(double*, double*, true);
-   TEST_TT(double*, A*, false);
-   TEST_TT(double*, B*, false);
-   TEST_TT(A*, void*, true);
-   TEST_TT(A*, bool*, false);
-   TEST_TT(A*, int*, false);
-   TEST_TT(A*, double*, false);
-   TEST_TT(A*, A*, true);
-   TEST_TT(A*, B*, true);
-   TEST_TT(B*, void*, true);
-   TEST_TT(B*, bool*, false);
-   TEST_TT(B*, int*, false);
-   TEST_TT(B*, double*, false);
-   TEST_TT(B*, A*, true);
-   TEST_TT(B*, B*, true);
-   TEST_TT(C, void*, true);
-   TEST_TT(D, void*, false);
-   TEST_TT(void*, C, false);
-   TEST_TT(void*, D, true);
-   TEST_TT(C, D, true);
-}
-}

Deleted: sandbox/type_traits/libs/type_traits/test/has_dereference_operator_test.hpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_dereference_operator_test.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,101 +0,0 @@
-//  (C) Copyright Frederic Bron 2009-2011.
-//  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)
-
-namespace {
-
-void run2() {
-   // 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);
-
-   // 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);
-}
-}

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,1250 +0,0 @@
-//  (C) Copyright Frederic Bron 2009-2011.
-//  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)
-
-namespace {
-
-void run2() {
-   // test with only one template parameter
-   TEST_T(void, false);
-   TEST_T(bool, true);
-   TEST_T(char, true);
-   TEST_T(signed char, true);
-   TEST_T(short int, true);
-   TEST_T(int, true);
-   TEST_T(long int, true);
-   TEST_T(unsigned char, true);
-   TEST_T(unsigned short int, true);
-   TEST_T(unsigned int, true);
-   TEST_T(unsigned long int, true);
-   TEST_T(wchar_t, true);
-   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), true);
-   TEST_T(CV(int), true);
-   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), true);
-   TEST_T(CV(int), true);
-   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 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);
-   TEST_TT(bool, short int, true);
-   TEST_TT(bool, int, true);
-   TEST_TT(bool, long int, true);
-   TEST_TT(bool, unsigned char, true);
-   TEST_TT(bool, unsigned short int, true);
-   TEST_TT(bool, unsigned int, true);
-   TEST_TT(bool, unsigned long int, true);
-   TEST_TT(bool, wchar_t, true);
-   TEST_TT(bool, float, false);
-   TEST_TT(bool, double, false);
-   TEST_TT(bool, long double, false);
-   TEST_TT(char, bool, true);
-   TEST_TT(char, char, true);
-   TEST_TT(char, signed char, true);
-   TEST_TT(char, short int, true);
-   TEST_TT(char, int, true);
-   TEST_TT(char, long int, true);
-   TEST_TT(char, unsigned char, true);
-   TEST_TT(char, unsigned short int, true);
-   TEST_TT(char, unsigned int, true);
-   TEST_TT(char, unsigned long int, true);
-   TEST_TT(char, wchar_t, true);
-   TEST_TT(char, float, false);
-   TEST_TT(char, double, false);
-   TEST_TT(char, long double, false);
-   TEST_TT(signed char, bool, true);
-   TEST_TT(signed char, char, true);
-   TEST_TT(signed char, signed char, true);
-   TEST_TT(signed char, short int, true);
-   TEST_TT(signed char, int, true);
-   TEST_TT(signed char, long int, true);
-   TEST_TT(signed char, unsigned char, true);
-   TEST_TT(signed char, unsigned short int, true);
-   TEST_TT(signed char, unsigned int, true);
-   TEST_TT(signed char, unsigned long int, true);
-   TEST_TT(signed char, wchar_t, true);
-   TEST_TT(signed char, float, false);
-   TEST_TT(signed char, double, false);
-   TEST_TT(signed char, long double, false);
-   TEST_TT(short int, bool, true);
-   TEST_TT(short int, char, true);
-   TEST_TT(short int, signed char, true);
-   TEST_TT(short int, short int, true);
-   TEST_TT(short int, int, true);
-   TEST_TT(short int, long int, true);
-   TEST_TT(short int, unsigned char, true);
-   TEST_TT(short int, unsigned short int, true);
-   TEST_TT(short int, unsigned int, true);
-   TEST_TT(short int, unsigned long int, true);
-   TEST_TT(short int, wchar_t, true);
-   TEST_TT(short int, float, false);
-   TEST_TT(short int, double, false);
-   TEST_TT(short int, long double, false);
-   TEST_TT(int, bool, true);
-   TEST_TT(int, char, true);
-   TEST_TT(int, signed char, true);
-   TEST_TT(int, short int, true);
-   TEST_TT(int, int, true);
-   TEST_TT(int, long int, true);
-   TEST_TT(int, unsigned char, true);
-   TEST_TT(int, unsigned short int, true);
-   TEST_TT(int, unsigned int, true);
-   TEST_TT(int, unsigned long int, true);
-   TEST_TT(int, wchar_t, true);
-   TEST_TT(int, float, false);
-   TEST_TT(int, double, false);
-   TEST_TT(int, long double, false);
-   TEST_TT(long int, bool, true);
-   TEST_TT(long int, char, true);
-   TEST_TT(long int, signed char, true);
-   TEST_TT(long int, short int, true);
-   TEST_TT(long int, int, true);
-   TEST_TT(long int, long int, true);
-   TEST_TT(long int, unsigned char, true);
-   TEST_TT(long int, unsigned short int, true);
-   TEST_TT(long int, unsigned int, true);
-   TEST_TT(long int, unsigned long int, true);
-   TEST_TT(long int, wchar_t, true);
-   TEST_TT(long int, float, false);
-   TEST_TT(long int, double, false);
-   TEST_TT(long int, long double, false);
-   TEST_TT(unsigned char, bool, true);
-   TEST_TT(unsigned char, char, true);
-   TEST_TT(unsigned char, signed char, true);
-   TEST_TT(unsigned char, short int, true);
-   TEST_TT(unsigned char, int, true);
-   TEST_TT(unsigned char, long int, true);
-   TEST_TT(unsigned char, unsigned char, true);
-   TEST_TT(unsigned char, unsigned short int, true);
-   TEST_TT(unsigned char, unsigned int, true);
-   TEST_TT(unsigned char, unsigned long int, true);
-   TEST_TT(unsigned char, wchar_t, true);
-   TEST_TT(unsigned char, float, false);
-   TEST_TT(unsigned char, double, false);
-   TEST_TT(unsigned char, long double, false);
-   TEST_TT(unsigned short int, bool, true);
-   TEST_TT(unsigned short int, char, true);
-   TEST_TT(unsigned short int, signed char, true);
-   TEST_TT(unsigned short int, short int, true);
-   TEST_TT(unsigned short int, int, true);
-   TEST_TT(unsigned short int, long int, true);
-   TEST_TT(unsigned short int, unsigned char, true);
-   TEST_TT(unsigned short int, unsigned short int, true);
-   TEST_TT(unsigned short int, unsigned int, true);
-   TEST_TT(unsigned short int, unsigned long int, true);
-   TEST_TT(unsigned short int, wchar_t, true);
-   TEST_TT(unsigned short int, float, false);
-   TEST_TT(unsigned short int, double, false);
-   TEST_TT(unsigned short int, long double, false);
-   TEST_TT(unsigned int, bool, true);
-   TEST_TT(unsigned int, char, true);
-   TEST_TT(unsigned int, signed char, true);
-   TEST_TT(unsigned int, short int, true);
-   TEST_TT(unsigned int, int, true);
-   TEST_TT(unsigned int, long int, true);
-   TEST_TT(unsigned int, unsigned char, true);
-   TEST_TT(unsigned int, unsigned short int, true);
-   TEST_TT(unsigned int, unsigned int, true);
-   TEST_TT(unsigned int, unsigned long int, true);
-   TEST_TT(unsigned int, wchar_t, true);
-   TEST_TT(unsigned int, float, false);
-   TEST_TT(unsigned int, double, false);
-   TEST_TT(unsigned int, long double, false);
-   TEST_TT(unsigned long int, bool, true);
-   TEST_TT(unsigned long int, char, true);
-   TEST_TT(unsigned long int, signed char, true);
-   TEST_TT(unsigned long int, short int, true);
-   TEST_TT(unsigned long int, int, true);
-   TEST_TT(unsigned long int, long int, true);
-   TEST_TT(unsigned long int, unsigned char, true);
-   TEST_TT(unsigned long int, unsigned short int, true);
-   TEST_TT(unsigned long int, unsigned int, true);
-   TEST_TT(unsigned long int, unsigned long int, true);
-   TEST_TT(unsigned long int, wchar_t, true);
-   TEST_TT(unsigned long int, float, false);
-   TEST_TT(unsigned long int, double, false);
-   TEST_TT(unsigned long int, long double, false);
-   TEST_TT(wchar_t, bool, true);
-   TEST_TT(wchar_t, char, true);
-   TEST_TT(wchar_t, signed char, true);
-   TEST_TT(wchar_t, short int, true);
-   TEST_TT(wchar_t, int, true);
-   TEST_TT(wchar_t, long int, true);
-   TEST_TT(wchar_t, unsigned char, true);
-   TEST_TT(wchar_t, unsigned short int, true);
-   TEST_TT(wchar_t, unsigned int, true);
-   TEST_TT(wchar_t, unsigned long int, true);
-   TEST_TT(wchar_t, wchar_t, true);
-   TEST_TT(wchar_t, float, false);
-   TEST_TT(wchar_t, double, false);
-   TEST_TT(wchar_t, long double, false);
-   TEST_TT(float, bool, false);
-   TEST_TT(float, char, false);
-   TEST_TT(float, signed char, false);
-   TEST_TT(float, short int, false);
-   TEST_TT(float, int, false);
-   TEST_TT(float, long int, false);
-   TEST_TT(float, unsigned char, false);
-   TEST_TT(float, unsigned short int, false);
-   TEST_TT(float, unsigned int, false);
-   TEST_TT(float, unsigned long int, false);
-   TEST_TT(float, wchar_t, false);
-   TEST_TT(float, float, false);
-   TEST_TT(float, double, false);
-   TEST_TT(float, long double, false);
-   TEST_TT(double, bool, false);
-   TEST_TT(double, char, false);
-   TEST_TT(double, signed char, false);
-   TEST_TT(double, short int, false);
-   TEST_TT(double, int, false);
-   TEST_TT(double, long int, false);
-   TEST_TT(double, unsigned char, false);
-   TEST_TT(double, unsigned short int, false);
-   TEST_TT(double, unsigned int, false);
-   TEST_TT(double, unsigned long int, false);
-   TEST_TT(double, wchar_t, false);
-   TEST_TT(double, float, false);
-   TEST_TT(double, double, false);
-   TEST_TT(double, long double, false);
-   TEST_TT(long double, bool, false);
-   TEST_TT(long double, char, false);
-   TEST_TT(long double, signed char, false);
-   TEST_TT(long double, short int, false);
-   TEST_TT(long double, int, false);
-   TEST_TT(long double, long int, false);
-   TEST_TT(long double, unsigned char, false);
-   TEST_TT(long double, unsigned short int, false);
-   TEST_TT(long double, unsigned int, false);
-   TEST_TT(long double, unsigned long int, false);
-   TEST_TT(long double, wchar_t, false);
-   TEST_TT(long double, float, false);
-   TEST_TT(long double, double, false);
-   TEST_TT(long double, long double, false);
-   TEST_TT(bool, void, false);
-   TEST_TT(void, bool, false);
-   TEST_TT(char, void, false);
-   TEST_TT(void, char, false);
-   TEST_TT(signed char, void, false);
-   TEST_TT(void, signed char, false);
-   TEST_TT(short int, void, false);
-   TEST_TT(void, short int, false);
-   TEST_TT(int, void, false);
-   TEST_TT(void, int, false);
-   TEST_TT(long int, void, false);
-   TEST_TT(void, long int, false);
-   TEST_TT(unsigned char, void, false);
-   TEST_TT(void, unsigned char, false);
-   TEST_TT(unsigned short int, void, false);
-   TEST_TT(void, unsigned short int, false);
-   TEST_TT(unsigned int, void, false);
-   TEST_TT(void, unsigned int, false);
-   TEST_TT(unsigned long int, void, false);
-   TEST_TT(void, unsigned long int, false);
-   TEST_TT(wchar_t, void, false);
-   TEST_TT(void, wchar_t, false);
-   TEST_TT(float, void, false);
-   TEST_TT(void, float, false);
-   TEST_TT(double, void, false);
-   TEST_TT(void, double, false);
-   TEST_TT(long double, void, false);
-   TEST_TT(void, long double, false);
-
-// test with three template parameters
-   TEST_TTR(bool, bool, bool, true);
-   TEST_TTR(bool, char, bool, true);
-   TEST_TTR(bool, signed char, bool, true);
-   TEST_TTR(bool, short int, bool, true);
-   TEST_TTR(bool, int, bool, true);
-   TEST_TTR(bool, long int, bool, true);
-   TEST_TTR(bool, unsigned char, bool, true);
-   TEST_TTR(bool, unsigned short int, bool, true);
-   TEST_TTR(bool, unsigned int, bool, true);
-   TEST_TTR(bool, unsigned long int, bool, true);
-   TEST_TTR(bool, wchar_t, bool, true);
-   TEST_TTR(bool, float, bool, false);
-   TEST_TTR(bool, double, bool, false);
-   TEST_TTR(bool, long double, bool, false);
-   TEST_TTR(char, bool, bool, true);
-   TEST_TTR(char, char, bool, true);
-   TEST_TTR(char, signed char, bool, true);
-   TEST_TTR(char, short int, bool, true);
-   TEST_TTR(char, int, bool, true);
-   TEST_TTR(char, long int, bool, true);
-   TEST_TTR(char, unsigned char, bool, true);
-   TEST_TTR(char, unsigned short int, bool, true);
-   TEST_TTR(char, unsigned int, bool, true);
-   TEST_TTR(char, unsigned long int, bool, true);
-   TEST_TTR(char, wchar_t, bool, true);
-   TEST_TTR(char, float, bool, false);
-   TEST_TTR(char, double, bool, false);
-   TEST_TTR(char, long double, bool, false);
-   TEST_TTR(signed char, bool, bool, true);
-   TEST_TTR(signed char, char, bool, true);
-   TEST_TTR(signed char, signed char, bool, true);
-   TEST_TTR(signed char, short int, bool, true);
-   TEST_TTR(signed char, int, bool, true);
-   TEST_TTR(signed char, long int, bool, true);
-   TEST_TTR(signed char, unsigned char, bool, true);
-   TEST_TTR(signed char, unsigned short int, bool, true);
-   TEST_TTR(signed char, unsigned int, bool, true);
-   TEST_TTR(signed char, unsigned long int, bool, true);
-   TEST_TTR(signed char, wchar_t, bool, true);
-   TEST_TTR(signed char, float, bool, false);
-   TEST_TTR(signed char, double, bool, false);
-   TEST_TTR(signed char, long double, bool, false);
-   TEST_TTR(short int, bool, bool, true);
-   TEST_TTR(short int, char, bool, true);
-   TEST_TTR(short int, signed char, bool, true);
-   TEST_TTR(short int, short int, bool, true);
-   TEST_TTR(short int, int, bool, true);
-   TEST_TTR(short int, long int, bool, true);
-   TEST_TTR(short int, unsigned char, bool, true);
-   TEST_TTR(short int, unsigned short int, bool, true);
-   TEST_TTR(short int, unsigned int, bool, true);
-   TEST_TTR(short int, unsigned long int, bool, true);
-   TEST_TTR(short int, wchar_t, bool, true);
-   TEST_TTR(short int, float, bool, false);
-   TEST_TTR(short int, double, bool, false);
-   TEST_TTR(short int, long double, bool, false);
-   TEST_TTR(int, bool, bool, true);
-   TEST_TTR(int, char, bool, true);
-   TEST_TTR(int, signed char, bool, true);
-   TEST_TTR(int, short int, bool, true);
-   TEST_TTR(int, int, bool, true);
-   TEST_TTR(int, long int, bool, true);
-   TEST_TTR(int, unsigned char, bool, true);
-   TEST_TTR(int, unsigned short int, bool, true);
-   TEST_TTR(int, unsigned int, bool, true);
-   TEST_TTR(int, unsigned long int, bool, true);
-   TEST_TTR(int, wchar_t, bool, true);
-   TEST_TTR(int, float, bool, false);
-   TEST_TTR(int, double, bool, false);
-   TEST_TTR(int, long double, bool, false);
-   TEST_TTR(long int, bool, bool, true);
-   TEST_TTR(long int, char, bool, true);
-   TEST_TTR(long int, signed char, bool, true);
-   TEST_TTR(long int, short int, bool, true);
-   TEST_TTR(long int, int, bool, true);
-   TEST_TTR(long int, long int, bool, true);
-   TEST_TTR(long int, unsigned char, bool, true);
-   TEST_TTR(long int, unsigned short int, bool, true);
-   TEST_TTR(long int, unsigned int, bool, true);
-   TEST_TTR(long int, unsigned long int, bool, true);
-   TEST_TTR(long int, wchar_t, bool, true);
-   TEST_TTR(long int, float, bool, false);
-   TEST_TTR(long int, double, bool, false);
-   TEST_TTR(long int, long double, bool, false);
-   TEST_TTR(unsigned char, bool, bool, true);
-   TEST_TTR(unsigned char, char, bool, true);
-   TEST_TTR(unsigned char, signed char, bool, true);
-   TEST_TTR(unsigned char, short int, bool, true);
-   TEST_TTR(unsigned char, int, bool, true);
-   TEST_TTR(unsigned char, long int, bool, true);
-   TEST_TTR(unsigned char, unsigned char, bool, true);
-   TEST_TTR(unsigned char, unsigned short int, bool, true);
-   TEST_TTR(unsigned char, unsigned int, bool, true);
-   TEST_TTR(unsigned char, unsigned long int, bool, true);
-   TEST_TTR(unsigned char, wchar_t, bool, true);
-   TEST_TTR(unsigned char, float, bool, false);
-   TEST_TTR(unsigned char, double, bool, false);
-   TEST_TTR(unsigned char, long double, bool, false);
-   TEST_TTR(unsigned short int, bool, bool, true);
-   TEST_TTR(unsigned short int, char, bool, true);
-   TEST_TTR(unsigned short int, signed char, bool, true);
-   TEST_TTR(unsigned short int, short int, bool, true);
-   TEST_TTR(unsigned short int, int, bool, true);
-   TEST_TTR(unsigned short int, long int, bool, true);
-   TEST_TTR(unsigned short int, unsigned char, bool, true);
-   TEST_TTR(unsigned short int, unsigned short int, bool, true);
-   TEST_TTR(unsigned short int, unsigned int, bool, true);
-   TEST_TTR(unsigned short int, unsigned long int, bool, true);
-   TEST_TTR(unsigned short int, wchar_t, bool, true);
-   TEST_TTR(unsigned short int, float, bool, false);
-   TEST_TTR(unsigned short int, double, bool, false);
-   TEST_TTR(unsigned short int, long double, bool, false);
-   TEST_TTR(unsigned int, bool, bool, true);
-   TEST_TTR(unsigned int, char, bool, true);
-   TEST_TTR(unsigned int, signed char, bool, true);
-   TEST_TTR(unsigned int, short int, bool, true);
-   TEST_TTR(unsigned int, int, bool, true);
-   TEST_TTR(unsigned int, long int, bool, true);
-   TEST_TTR(unsigned int, unsigned char, bool, true);
-   TEST_TTR(unsigned int, unsigned short int, bool, true);
-   TEST_TTR(unsigned int, unsigned int, bool, true);
-   TEST_TTR(unsigned int, unsigned long int, bool, true);
-   TEST_TTR(unsigned int, wchar_t, bool, true);
-   TEST_TTR(unsigned int, float, bool, false);
-   TEST_TTR(unsigned int, double, bool, false);
-   TEST_TTR(unsigned int, long double, bool, false);
-   TEST_TTR(unsigned long int, bool, bool, true);
-   TEST_TTR(unsigned long int, char, bool, true);
-   TEST_TTR(unsigned long int, signed char, bool, true);
-   TEST_TTR(unsigned long int, short int, bool, true);
-   TEST_TTR(unsigned long int, int, bool, true);
-   TEST_TTR(unsigned long int, long int, bool, true);
-   TEST_TTR(unsigned long int, unsigned char, bool, true);
-   TEST_TTR(unsigned long int, unsigned short int, bool, true);
-   TEST_TTR(unsigned long int, unsigned int, bool, true);
-   TEST_TTR(unsigned long int, unsigned long int, bool, true);
-   TEST_TTR(unsigned long int, wchar_t, bool, true);
-   TEST_TTR(unsigned long int, float, bool, false);
-   TEST_TTR(unsigned long int, double, bool, false);
-   TEST_TTR(unsigned long int, long double, bool, false);
-   TEST_TTR(wchar_t, bool, bool, true);
-   TEST_TTR(wchar_t, char, bool, true);
-   TEST_TTR(wchar_t, signed char, bool, true);
-   TEST_TTR(wchar_t, short int, bool, true);
-   TEST_TTR(wchar_t, int, bool, true);
-   TEST_TTR(wchar_t, long int, bool, true);
-   TEST_TTR(wchar_t, unsigned char, bool, true);
-   TEST_TTR(wchar_t, unsigned short int, bool, true);
-   TEST_TTR(wchar_t, unsigned int, bool, true);
-   TEST_TTR(wchar_t, unsigned long int, bool, true);
-   TEST_TTR(wchar_t, wchar_t, bool, true);
-   TEST_TTR(wchar_t, float, bool, false);
-   TEST_TTR(wchar_t, double, bool, false);
-   TEST_TTR(wchar_t, long double, bool, false);
-   TEST_TTR(float, bool, bool, false);
-   TEST_TTR(float, char, bool, false);
-   TEST_TTR(float, signed char, bool, false);
-   TEST_TTR(float, short int, bool, false);
-   TEST_TTR(float, int, bool, false);
-   TEST_TTR(float, long int, bool, false);
-   TEST_TTR(float, unsigned char, bool, false);
-   TEST_TTR(float, unsigned short int, bool, false);
-   TEST_TTR(float, unsigned int, bool, false);
-   TEST_TTR(float, unsigned long int, bool, false);
-   TEST_TTR(float, wchar_t, bool, false);
-   TEST_TTR(float, float, bool, false);
-   TEST_TTR(float, double, bool, false);
-   TEST_TTR(float, long double, bool, false);
-   TEST_TTR(double, bool, bool, false);
-   TEST_TTR(double, char, bool, false);
-   TEST_TTR(double, signed char, bool, false);
-   TEST_TTR(double, short int, bool, false);
-   TEST_TTR(double, int, bool, false);
-   TEST_TTR(double, long int, bool, false);
-   TEST_TTR(double, unsigned char, bool, false);
-   TEST_TTR(double, unsigned short int, bool, false);
-   TEST_TTR(double, unsigned int, bool, false);
-   TEST_TTR(double, unsigned long int, bool, false);
-   TEST_TTR(double, wchar_t, bool, false);
-   TEST_TTR(double, float, bool, false);
-   TEST_TTR(double, double, bool, false);
-   TEST_TTR(double, long double, bool, false);
-   TEST_TTR(long double, bool, bool, false);
-   TEST_TTR(long double, char, bool, false);
-   TEST_TTR(long double, signed char, bool, false);
-   TEST_TTR(long double, short int, bool, false);
-   TEST_TTR(long double, int, bool, false);
-   TEST_TTR(long double, long int, bool, false);
-   TEST_TTR(long double, unsigned char, bool, false);
-   TEST_TTR(long double, unsigned short int, bool, false);
-   TEST_TTR(long double, unsigned int, bool, false);
-   TEST_TTR(long double, unsigned long int, bool, false);
-   TEST_TTR(long double, wchar_t, bool, false);
-   TEST_TTR(long double, float, bool, false);
-   TEST_TTR(long double, double, bool, false);
-   TEST_TTR(long double, long double, bool, false);
-   TEST_TTR(bool, bool, tag, false);
-   TEST_TTR(bool, char, tag, false);
-   TEST_TTR(bool, signed char, tag, false);
-   TEST_TTR(bool, short int, tag, false);
-   TEST_TTR(bool, int, tag, false);
-   TEST_TTR(bool, long int, tag, false);
-   TEST_TTR(bool, unsigned char, tag, false);
-   TEST_TTR(bool, unsigned short int, tag, false);
-   TEST_TTR(bool, unsigned int, tag, false);
-   TEST_TTR(bool, unsigned long int, tag, false);
-   TEST_TTR(bool, wchar_t, tag, false);
-   TEST_TTR(bool, float, tag, false);
-   TEST_TTR(bool, double, tag, false);
-   TEST_TTR(bool, long double, tag, false);
-   TEST_TTR(char, bool, tag, false);
-   TEST_TTR(char, char, tag, false);
-   TEST_TTR(char, signed char, tag, false);
-   TEST_TTR(char, short int, tag, false);
-   TEST_TTR(char, int, tag, false);
-   TEST_TTR(char, long int, tag, false);
-   TEST_TTR(char, unsigned char, tag, false);
-   TEST_TTR(char, unsigned short int, tag, false);
-   TEST_TTR(char, unsigned int, tag, false);
-   TEST_TTR(char, unsigned long int, tag, false);
-   TEST_TTR(char, wchar_t, tag, false);
-   TEST_TTR(char, float, tag, false);
-   TEST_TTR(char, double, tag, false);
-   TEST_TTR(char, long double, tag, false);
-   TEST_TTR(signed char, bool, tag, false);
-   TEST_TTR(signed char, char, tag, false);
-   TEST_TTR(signed char, signed char, tag, false);
-   TEST_TTR(signed char, short int, tag, false);
-   TEST_TTR(signed char, int, tag, false);
-   TEST_TTR(signed char, long int, tag, false);
-   TEST_TTR(signed char, unsigned char, tag, false);
-   TEST_TTR(signed char, unsigned short int, tag, false);
-   TEST_TTR(signed char, unsigned int, tag, false);
-   TEST_TTR(signed char, unsigned long int, tag, false);
-   TEST_TTR(signed char, wchar_t, tag, false);
-   TEST_TTR(signed char, float, tag, false);
-   TEST_TTR(signed char, double, tag, false);
-   TEST_TTR(signed char, long double, tag, false);
-   TEST_TTR(short int, bool, tag, false);
-   TEST_TTR(short int, char, tag, false);
-   TEST_TTR(short int, signed char, tag, false);
-   TEST_TTR(short int, short int, tag, false);
-   TEST_TTR(short int, int, tag, false);
-   TEST_TTR(short int, long int, tag, false);
-   TEST_TTR(short int, unsigned char, tag, false);
-   TEST_TTR(short int, unsigned short int, tag, false);
-   TEST_TTR(short int, unsigned int, tag, false);
-   TEST_TTR(short int, unsigned long int, tag, false);
-   TEST_TTR(short int, wchar_t, tag, false);
-   TEST_TTR(short int, float, tag, false);
-   TEST_TTR(short int, double, tag, false);
-   TEST_TTR(short int, long double, tag, false);
-   TEST_TTR(int, bool, tag, false);
-   TEST_TTR(int, char, tag, false);
-   TEST_TTR(int, signed char, tag, false);
-   TEST_TTR(int, short int, tag, false);
-   TEST_TTR(int, int, tag, false);
-   TEST_TTR(int, long int, tag, false);
-   TEST_TTR(int, unsigned char, tag, false);
-   TEST_TTR(int, unsigned short int, tag, false);
-   TEST_TTR(int, unsigned int, tag, false);
-   TEST_TTR(int, unsigned long int, tag, false);
-   TEST_TTR(int, wchar_t, tag, false);
-   TEST_TTR(int, float, tag, false);
-   TEST_TTR(int, double, tag, false);
-   TEST_TTR(int, long double, tag, false);
-   TEST_TTR(long int, bool, tag, false);
-   TEST_TTR(long int, char, tag, false);
-   TEST_TTR(long int, signed char, tag, false);
-   TEST_TTR(long int, short int, tag, false);
-   TEST_TTR(long int, int, tag, false);
-   TEST_TTR(long int, long int, tag, false);
-   TEST_TTR(long int, unsigned char, tag, false);
-   TEST_TTR(long int, unsigned short int, tag, false);
-   TEST_TTR(long int, unsigned int, tag, false);
-   TEST_TTR(long int, unsigned long int, tag, false);
-   TEST_TTR(long int, wchar_t, tag, false);
-   TEST_TTR(long int, float, tag, false);
-   TEST_TTR(long int, double, tag, false);
-   TEST_TTR(long int, long double, tag, false);
-   TEST_TTR(unsigned char, bool, tag, false);
-   TEST_TTR(unsigned char, char, tag, false);
-   TEST_TTR(unsigned char, signed char, tag, false);
-   TEST_TTR(unsigned char, short int, tag, false);
-   TEST_TTR(unsigned char, int, tag, false);
-   TEST_TTR(unsigned char, long int, tag, false);
-   TEST_TTR(unsigned char, unsigned char, tag, false);
-   TEST_TTR(unsigned char, unsigned short int, tag, false);
-   TEST_TTR(unsigned char, unsigned int, tag, false);
-   TEST_TTR(unsigned char, unsigned long int, tag, false);
-   TEST_TTR(unsigned char, wchar_t, tag, false);
-   TEST_TTR(unsigned char, float, tag, false);
-   TEST_TTR(unsigned char, double, tag, false);
-   TEST_TTR(unsigned char, long double, tag, false);
-   TEST_TTR(unsigned short int, bool, tag, false);
-   TEST_TTR(unsigned short int, char, tag, false);
-   TEST_TTR(unsigned short int, signed char, tag, false);
-   TEST_TTR(unsigned short int, short int, tag, false);
-   TEST_TTR(unsigned short int, int, tag, false);
-   TEST_TTR(unsigned short int, long int, tag, false);
-   TEST_TTR(unsigned short int, unsigned char, tag, false);
-   TEST_TTR(unsigned short int, unsigned short int, tag, false);
-   TEST_TTR(unsigned short int, unsigned int, tag, false);
-   TEST_TTR(unsigned short int, unsigned long int, tag, false);
-   TEST_TTR(unsigned short int, wchar_t, tag, false);
-   TEST_TTR(unsigned short int, float, tag, false);
-   TEST_TTR(unsigned short int, double, tag, false);
-   TEST_TTR(unsigned short int, long double, tag, false);
-   TEST_TTR(unsigned int, bool, tag, false);
-   TEST_TTR(unsigned int, char, tag, false);
-   TEST_TTR(unsigned int, signed char, tag, false);
-   TEST_TTR(unsigned int, short int, tag, false);
-   TEST_TTR(unsigned int, int, tag, false);
-   TEST_TTR(unsigned int, long int, tag, false);
-   TEST_TTR(unsigned int, unsigned char, tag, false);
-   TEST_TTR(unsigned int, unsigned short int, tag, false);
-   TEST_TTR(unsigned int, unsigned int, tag, false);
-   TEST_TTR(unsigned int, unsigned long int, tag, false);
-   TEST_TTR(unsigned int, wchar_t, tag, false);
-   TEST_TTR(unsigned int, float, tag, false);
-   TEST_TTR(unsigned int, double, tag, false);
-   TEST_TTR(unsigned int, long double, tag, false);
-   TEST_TTR(unsigned long int, bool, tag, false);
-   TEST_TTR(unsigned long int, char, tag, false);
-   TEST_TTR(unsigned long int, signed char, tag, false);
-   TEST_TTR(unsigned long int, short int, tag, false);
-   TEST_TTR(unsigned long int, int, tag, false);
-   TEST_TTR(unsigned long int, long int, tag, false);
-   TEST_TTR(unsigned long int, unsigned char, tag, false);
-   TEST_TTR(unsigned long int, unsigned short int, tag, false);
-   TEST_TTR(unsigned long int, unsigned int, tag, false);
-   TEST_TTR(unsigned long int, unsigned long int, tag, false);
-   TEST_TTR(unsigned long int, wchar_t, tag, false);
-   TEST_TTR(unsigned long int, float, tag, false);
-   TEST_TTR(unsigned long int, double, tag, false);
-   TEST_TTR(unsigned long int, long double, tag, false);
-   TEST_TTR(wchar_t, bool, tag, false);
-   TEST_TTR(wchar_t, char, tag, false);
-   TEST_TTR(wchar_t, signed char, tag, false);
-   TEST_TTR(wchar_t, short int, tag, false);
-   TEST_TTR(wchar_t, int, tag, false);
-   TEST_TTR(wchar_t, long int, tag, false);
-   TEST_TTR(wchar_t, unsigned char, tag, false);
-   TEST_TTR(wchar_t, unsigned short int, tag, false);
-   TEST_TTR(wchar_t, unsigned int, tag, false);
-   TEST_TTR(wchar_t, unsigned long int, tag, false);
-   TEST_TTR(wchar_t, wchar_t, tag, false);
-   TEST_TTR(wchar_t, float, tag, false);
-   TEST_TTR(wchar_t, double, tag, false);
-   TEST_TTR(wchar_t, long double, tag, false);
-   TEST_TTR(float, bool, tag, false);
-   TEST_TTR(float, char, tag, false);
-   TEST_TTR(float, signed char, tag, false);
-   TEST_TTR(float, short int, tag, false);
-   TEST_TTR(float, int, tag, false);
-   TEST_TTR(float, long int, tag, false);
-   TEST_TTR(float, unsigned char, tag, false);
-   TEST_TTR(float, unsigned short int, tag, false);
-   TEST_TTR(float, unsigned int, tag, false);
-   TEST_TTR(float, unsigned long int, tag, false);
-   TEST_TTR(float, wchar_t, tag, false);
-   TEST_TTR(float, float, tag, false);
-   TEST_TTR(float, double, tag, false);
-   TEST_TTR(float, long double, tag, false);
-   TEST_TTR(double, bool, tag, false);
-   TEST_TTR(double, char, tag, false);
-   TEST_TTR(double, signed char, tag, false);
-   TEST_TTR(double, short int, tag, false);
-   TEST_TTR(double, int, tag, false);
-   TEST_TTR(double, long int, tag, false);
-   TEST_TTR(double, unsigned char, tag, false);
-   TEST_TTR(double, unsigned short int, tag, false);
-   TEST_TTR(double, unsigned int, tag, false);
-   TEST_TTR(double, unsigned long int, tag, false);
-   TEST_TTR(double, wchar_t, tag, false);
-   TEST_TTR(double, float, tag, false);
-   TEST_TTR(double, double, tag, false);
-   TEST_TTR(double, long double, tag, false);
-   TEST_TTR(long double, bool, tag, false);
-   TEST_TTR(long double, char, tag, false);
-   TEST_TTR(long double, signed char, tag, false);
-   TEST_TTR(long double, short int, tag, false);
-   TEST_TTR(long double, int, tag, false);
-   TEST_TTR(long double, long int, tag, false);
-   TEST_TTR(long double, unsigned char, tag, false);
-   TEST_TTR(long double, unsigned short int, tag, false);
-   TEST_TTR(long double, unsigned int, tag, false);
-   TEST_TTR(long double, unsigned long int, tag, false);
-   TEST_TTR(long double, wchar_t, tag, false);
-   TEST_TTR(long double, float, tag, false);
-   TEST_TTR(long double, double, tag, false);
-   TEST_TTR(long double, long double, tag, false);
-#	undef CV1
-#	define CV1(T) const T
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), false);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), false);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, false);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), false);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), false);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, false);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const T&
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), false);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), false);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, false);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T&
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T&
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), false);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), false);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, false);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const T
-#	undef CV2
-#	define CV2(T) const T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), false);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), false);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, false);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const T&
-#	undef CV2
-#	define CV2(T) const T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), false);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), false);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, false);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T
-#	undef CV2
-#	define CV2(T) volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T&
-#	undef CV2
-#	define CV2(T) volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T
-#	undef CV2
-#	define CV2(T) const volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), false);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), false);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, false);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T&
-#	undef CV2
-#	define CV2(T) const volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), false);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), false);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, false);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-   // pointers
-   TEST_TT(void*, bool, false);
-   TEST_TT(void*, int, false);
-   TEST_TT(void*, double, false);
-   TEST_TT(void*, A, false);
-   TEST_TT(void*, B, false);
-   TEST_TT(bool*, bool, false);
-   TEST_TT(bool*, int, false);
-   TEST_TT(bool*, double, false);
-   TEST_TT(bool*, A, false);
-   TEST_TT(bool*, B, false);
-   TEST_TT(int*, bool, false);
-   TEST_TT(int*, int, false);
-   TEST_TT(int*, double, false);
-   TEST_TT(int*, A, false);
-   TEST_TT(int*, B, false);
-   TEST_TT(double*, bool, false);
-   TEST_TT(double*, int, false);
-   TEST_TT(double*, double, false);
-   TEST_TT(double*, A, false);
-   TEST_TT(double*, B, false);
-   TEST_TT(A*, bool, false);
-   TEST_TT(A*, int, false);
-   TEST_TT(A*, double, false);
-   TEST_TT(A*, A, false);
-   TEST_TT(A*, B, false);
-   TEST_TT(B*, bool, false);
-   TEST_TT(B*, int, false);
-   TEST_TT(B*, double, false);
-   TEST_TT(B*, A, false);
-   TEST_TT(B*, B, false);
-   TEST_TT(bool, void*, false);
-   TEST_TT(bool, bool*, false);
-   TEST_TT(bool, int*, false);
-   TEST_TT(bool, double*, false);
-   TEST_TT(bool, A*, false);
-   TEST_TT(bool, B*, false);
-   TEST_TT(int, void*, false);
-   TEST_TT(int, bool*, false);
-   TEST_TT(int, int*, false);
-   TEST_TT(int, double*, false);
-   TEST_TT(int, A*, false);
-   TEST_TT(int, B*, false);
-   TEST_TT(double, void*, false);
-   TEST_TT(double, bool*, false);
-   TEST_TT(double, int*, false);
-   TEST_TT(double, double*, false);
-   TEST_TT(double, A*, false);
-   TEST_TT(double, B*, false);
-   TEST_TT(A, void*, false);
-   TEST_TT(A, bool*, false);
-   TEST_TT(A, int*, false);
-   TEST_TT(A, double*, false);
-   TEST_TT(A, A*, false);
-   TEST_TT(A, B*, false);
-   TEST_TT(B, void*, false);
-   TEST_TT(B, bool*, false);
-   TEST_TT(B, int*, false);
-   TEST_TT(B, double*, false);
-   TEST_TT(B, A*, false);
-   TEST_TT(B, B*, false);
-   TEST_TT(void*, void*, false);
-   TEST_TT(void*, bool*, false);
-   TEST_TT(void*, int*, false);
-   TEST_TT(void*, double*, false);
-   TEST_TT(void*, A*, false);
-   TEST_TT(void*, B*, false);
-   TEST_TT(bool*, void*, false);
-   TEST_TT(bool*, bool*, false);
-   TEST_TT(bool*, int*, false);
-   TEST_TT(bool*, double*, false);
-   TEST_TT(bool*, A*, false);
-   TEST_TT(bool*, B*, false);
-   TEST_TT(int*, void*, false);
-   TEST_TT(int*, bool*, false);
-   TEST_TT(int*, int*, false);
-   TEST_TT(int*, double*, false);
-   TEST_TT(int*, A*, false);
-   TEST_TT(int*, B*, false);
-   TEST_TT(double*, void*, false);
-   TEST_TT(double*, bool*, false);
-   TEST_TT(double*, int*, false);
-   TEST_TT(double*, double*, false);
-   TEST_TT(double*, A*, false);
-   TEST_TT(double*, B*, false);
-   TEST_TT(A*, void*, false);
-   TEST_TT(A*, bool*, false);
-   TEST_TT(A*, int*, false);
-   TEST_TT(A*, double*, false);
-   TEST_TT(A*, A*, false);
-   TEST_TT(A*, B*, false);
-   TEST_TT(B*, void*, false);
-   TEST_TT(B*, bool*, false);
-   TEST_TT(B*, int*, false);
-   TEST_TT(B*, double*, false);
-   TEST_TT(B*, A*, false);
-   TEST_TT(B*, B*, false);
-   TEST_TT(C, void*, true);
-   TEST_TT(D, void*, false);
-   TEST_TT(void*, C, false);
-   TEST_TT(void*, D, true);
-   TEST_TT(C, D, true);
-}
-}

Deleted: sandbox/type_traits/libs/type_traits/test/has_integral_operator_test.hpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_integral_operator_test.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,1250 +0,0 @@
-//  (C) Copyright Frederic Bron 2009-2011.
-//  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)
-
-namespace {
-
-void run2() {
-   // test with only one template parameter
-   TEST_T(void, false);
-   TEST_T(bool, true);
-   TEST_T(char, true);
-   TEST_T(signed char, true);
-   TEST_T(short int, true);
-   TEST_T(int, true);
-   TEST_T(long int, true);
-   TEST_T(unsigned char, true);
-   TEST_T(unsigned short int, true);
-   TEST_T(unsigned int, true);
-   TEST_T(unsigned long int, true);
-   TEST_T(wchar_t, true);
-   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), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), false);
-#	undef CV
-#	define CV(T) volatile T
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), false);
-#	undef CV
-#	define CV(T) const volatile T
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), false);
-#	undef CV
-#	define CV(T) const T&
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), false);
-#	undef CV
-#	define CV(T) volatile T&
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), false);
-#	undef CV
-#	define CV(T) const volatile T&
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   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);
-   TEST_TT(bool, short int, true);
-   TEST_TT(bool, int, true);
-   TEST_TT(bool, long int, true);
-   TEST_TT(bool, unsigned char, true);
-   TEST_TT(bool, unsigned short int, true);
-   TEST_TT(bool, unsigned int, true);
-   TEST_TT(bool, unsigned long int, true);
-   TEST_TT(bool, wchar_t, true);
-   TEST_TT(bool, float, false);
-   TEST_TT(bool, double, false);
-   TEST_TT(bool, long double, false);
-   TEST_TT(char, bool, true);
-   TEST_TT(char, char, true);
-   TEST_TT(char, signed char, true);
-   TEST_TT(char, short int, true);
-   TEST_TT(char, int, true);
-   TEST_TT(char, long int, true);
-   TEST_TT(char, unsigned char, true);
-   TEST_TT(char, unsigned short int, true);
-   TEST_TT(char, unsigned int, true);
-   TEST_TT(char, unsigned long int, true);
-   TEST_TT(char, wchar_t, true);
-   TEST_TT(char, float, false);
-   TEST_TT(char, double, false);
-   TEST_TT(char, long double, false);
-   TEST_TT(signed char, bool, true);
-   TEST_TT(signed char, char, true);
-   TEST_TT(signed char, signed char, true);
-   TEST_TT(signed char, short int, true);
-   TEST_TT(signed char, int, true);
-   TEST_TT(signed char, long int, true);
-   TEST_TT(signed char, unsigned char, true);
-   TEST_TT(signed char, unsigned short int, true);
-   TEST_TT(signed char, unsigned int, true);
-   TEST_TT(signed char, unsigned long int, true);
-   TEST_TT(signed char, wchar_t, true);
-   TEST_TT(signed char, float, false);
-   TEST_TT(signed char, double, false);
-   TEST_TT(signed char, long double, false);
-   TEST_TT(short int, bool, true);
-   TEST_TT(short int, char, true);
-   TEST_TT(short int, signed char, true);
-   TEST_TT(short int, short int, true);
-   TEST_TT(short int, int, true);
-   TEST_TT(short int, long int, true);
-   TEST_TT(short int, unsigned char, true);
-   TEST_TT(short int, unsigned short int, true);
-   TEST_TT(short int, unsigned int, true);
-   TEST_TT(short int, unsigned long int, true);
-   TEST_TT(short int, wchar_t, true);
-   TEST_TT(short int, float, false);
-   TEST_TT(short int, double, false);
-   TEST_TT(short int, long double, false);
-   TEST_TT(int, bool, true);
-   TEST_TT(int, char, true);
-   TEST_TT(int, signed char, true);
-   TEST_TT(int, short int, true);
-   TEST_TT(int, int, true);
-   TEST_TT(int, long int, true);
-   TEST_TT(int, unsigned char, true);
-   TEST_TT(int, unsigned short int, true);
-   TEST_TT(int, unsigned int, true);
-   TEST_TT(int, unsigned long int, true);
-   TEST_TT(int, wchar_t, true);
-   TEST_TT(int, float, false);
-   TEST_TT(int, double, false);
-   TEST_TT(int, long double, false);
-   TEST_TT(long int, bool, true);
-   TEST_TT(long int, char, true);
-   TEST_TT(long int, signed char, true);
-   TEST_TT(long int, short int, true);
-   TEST_TT(long int, int, true);
-   TEST_TT(long int, long int, true);
-   TEST_TT(long int, unsigned char, true);
-   TEST_TT(long int, unsigned short int, true);
-   TEST_TT(long int, unsigned int, true);
-   TEST_TT(long int, unsigned long int, true);
-   TEST_TT(long int, wchar_t, true);
-   TEST_TT(long int, float, false);
-   TEST_TT(long int, double, false);
-   TEST_TT(long int, long double, false);
-   TEST_TT(unsigned char, bool, true);
-   TEST_TT(unsigned char, char, true);
-   TEST_TT(unsigned char, signed char, true);
-   TEST_TT(unsigned char, short int, true);
-   TEST_TT(unsigned char, int, true);
-   TEST_TT(unsigned char, long int, true);
-   TEST_TT(unsigned char, unsigned char, true);
-   TEST_TT(unsigned char, unsigned short int, true);
-   TEST_TT(unsigned char, unsigned int, true);
-   TEST_TT(unsigned char, unsigned long int, true);
-   TEST_TT(unsigned char, wchar_t, true);
-   TEST_TT(unsigned char, float, false);
-   TEST_TT(unsigned char, double, false);
-   TEST_TT(unsigned char, long double, false);
-   TEST_TT(unsigned short int, bool, true);
-   TEST_TT(unsigned short int, char, true);
-   TEST_TT(unsigned short int, signed char, true);
-   TEST_TT(unsigned short int, short int, true);
-   TEST_TT(unsigned short int, int, true);
-   TEST_TT(unsigned short int, long int, true);
-   TEST_TT(unsigned short int, unsigned char, true);
-   TEST_TT(unsigned short int, unsigned short int, true);
-   TEST_TT(unsigned short int, unsigned int, true);
-   TEST_TT(unsigned short int, unsigned long int, true);
-   TEST_TT(unsigned short int, wchar_t, true);
-   TEST_TT(unsigned short int, float, false);
-   TEST_TT(unsigned short int, double, false);
-   TEST_TT(unsigned short int, long double, false);
-   TEST_TT(unsigned int, bool, true);
-   TEST_TT(unsigned int, char, true);
-   TEST_TT(unsigned int, signed char, true);
-   TEST_TT(unsigned int, short int, true);
-   TEST_TT(unsigned int, int, true);
-   TEST_TT(unsigned int, long int, true);
-   TEST_TT(unsigned int, unsigned char, true);
-   TEST_TT(unsigned int, unsigned short int, true);
-   TEST_TT(unsigned int, unsigned int, true);
-   TEST_TT(unsigned int, unsigned long int, true);
-   TEST_TT(unsigned int, wchar_t, true);
-   TEST_TT(unsigned int, float, false);
-   TEST_TT(unsigned int, double, false);
-   TEST_TT(unsigned int, long double, false);
-   TEST_TT(unsigned long int, bool, true);
-   TEST_TT(unsigned long int, char, true);
-   TEST_TT(unsigned long int, signed char, true);
-   TEST_TT(unsigned long int, short int, true);
-   TEST_TT(unsigned long int, int, true);
-   TEST_TT(unsigned long int, long int, true);
-   TEST_TT(unsigned long int, unsigned char, true);
-   TEST_TT(unsigned long int, unsigned short int, true);
-   TEST_TT(unsigned long int, unsigned int, true);
-   TEST_TT(unsigned long int, unsigned long int, true);
-   TEST_TT(unsigned long int, wchar_t, true);
-   TEST_TT(unsigned long int, float, false);
-   TEST_TT(unsigned long int, double, false);
-   TEST_TT(unsigned long int, long double, false);
-   TEST_TT(wchar_t, bool, true);
-   TEST_TT(wchar_t, char, true);
-   TEST_TT(wchar_t, signed char, true);
-   TEST_TT(wchar_t, short int, true);
-   TEST_TT(wchar_t, int, true);
-   TEST_TT(wchar_t, long int, true);
-   TEST_TT(wchar_t, unsigned char, true);
-   TEST_TT(wchar_t, unsigned short int, true);
-   TEST_TT(wchar_t, unsigned int, true);
-   TEST_TT(wchar_t, unsigned long int, true);
-   TEST_TT(wchar_t, wchar_t, true);
-   TEST_TT(wchar_t, float, false);
-   TEST_TT(wchar_t, double, false);
-   TEST_TT(wchar_t, long double, false);
-   TEST_TT(float, bool, false);
-   TEST_TT(float, char, false);
-   TEST_TT(float, signed char, false);
-   TEST_TT(float, short int, false);
-   TEST_TT(float, int, false);
-   TEST_TT(float, long int, false);
-   TEST_TT(float, unsigned char, false);
-   TEST_TT(float, unsigned short int, false);
-   TEST_TT(float, unsigned int, false);
-   TEST_TT(float, unsigned long int, false);
-   TEST_TT(float, wchar_t, false);
-   TEST_TT(float, float, false);
-   TEST_TT(float, double, false);
-   TEST_TT(float, long double, false);
-   TEST_TT(double, bool, false);
-   TEST_TT(double, char, false);
-   TEST_TT(double, signed char, false);
-   TEST_TT(double, short int, false);
-   TEST_TT(double, int, false);
-   TEST_TT(double, long int, false);
-   TEST_TT(double, unsigned char, false);
-   TEST_TT(double, unsigned short int, false);
-   TEST_TT(double, unsigned int, false);
-   TEST_TT(double, unsigned long int, false);
-   TEST_TT(double, wchar_t, false);
-   TEST_TT(double, float, false);
-   TEST_TT(double, double, false);
-   TEST_TT(double, long double, false);
-   TEST_TT(long double, bool, false);
-   TEST_TT(long double, char, false);
-   TEST_TT(long double, signed char, false);
-   TEST_TT(long double, short int, false);
-   TEST_TT(long double, int, false);
-   TEST_TT(long double, long int, false);
-   TEST_TT(long double, unsigned char, false);
-   TEST_TT(long double, unsigned short int, false);
-   TEST_TT(long double, unsigned int, false);
-   TEST_TT(long double, unsigned long int, false);
-   TEST_TT(long double, wchar_t, false);
-   TEST_TT(long double, float, false);
-   TEST_TT(long double, double, false);
-   TEST_TT(long double, long double, false);
-   TEST_TT(bool, void, false);
-   TEST_TT(void, bool, false);
-   TEST_TT(char, void, false);
-   TEST_TT(void, char, false);
-   TEST_TT(signed char, void, false);
-   TEST_TT(void, signed char, false);
-   TEST_TT(short int, void, false);
-   TEST_TT(void, short int, false);
-   TEST_TT(int, void, false);
-   TEST_TT(void, int, false);
-   TEST_TT(long int, void, false);
-   TEST_TT(void, long int, false);
-   TEST_TT(unsigned char, void, false);
-   TEST_TT(void, unsigned char, false);
-   TEST_TT(unsigned short int, void, false);
-   TEST_TT(void, unsigned short int, false);
-   TEST_TT(unsigned int, void, false);
-   TEST_TT(void, unsigned int, false);
-   TEST_TT(unsigned long int, void, false);
-   TEST_TT(void, unsigned long int, false);
-   TEST_TT(wchar_t, void, false);
-   TEST_TT(void, wchar_t, false);
-   TEST_TT(float, void, false);
-   TEST_TT(void, float, false);
-   TEST_TT(double, void, false);
-   TEST_TT(void, double, false);
-   TEST_TT(long double, void, false);
-   TEST_TT(void, long double, false);
-
-// test with three template parameters
-   TEST_TTR(bool, bool, bool, true);
-   TEST_TTR(bool, char, bool, true);
-   TEST_TTR(bool, signed char, bool, true);
-   TEST_TTR(bool, short int, bool, true);
-   TEST_TTR(bool, int, bool, true);
-   TEST_TTR(bool, long int, bool, true);
-   TEST_TTR(bool, unsigned char, bool, true);
-   TEST_TTR(bool, unsigned short int, bool, true);
-   TEST_TTR(bool, unsigned int, bool, true);
-   TEST_TTR(bool, unsigned long int, bool, true);
-   TEST_TTR(bool, wchar_t, bool, true);
-   TEST_TTR(bool, float, bool, false);
-   TEST_TTR(bool, double, bool, false);
-   TEST_TTR(bool, long double, bool, false);
-   TEST_TTR(char, bool, bool, true);
-   TEST_TTR(char, char, bool, true);
-   TEST_TTR(char, signed char, bool, true);
-   TEST_TTR(char, short int, bool, true);
-   TEST_TTR(char, int, bool, true);
-   TEST_TTR(char, long int, bool, true);
-   TEST_TTR(char, unsigned char, bool, true);
-   TEST_TTR(char, unsigned short int, bool, true);
-   TEST_TTR(char, unsigned int, bool, true);
-   TEST_TTR(char, unsigned long int, bool, true);
-   TEST_TTR(char, wchar_t, bool, true);
-   TEST_TTR(char, float, bool, false);
-   TEST_TTR(char, double, bool, false);
-   TEST_TTR(char, long double, bool, false);
-   TEST_TTR(signed char, bool, bool, true);
-   TEST_TTR(signed char, char, bool, true);
-   TEST_TTR(signed char, signed char, bool, true);
-   TEST_TTR(signed char, short int, bool, true);
-   TEST_TTR(signed char, int, bool, true);
-   TEST_TTR(signed char, long int, bool, true);
-   TEST_TTR(signed char, unsigned char, bool, true);
-   TEST_TTR(signed char, unsigned short int, bool, true);
-   TEST_TTR(signed char, unsigned int, bool, true);
-   TEST_TTR(signed char, unsigned long int, bool, true);
-   TEST_TTR(signed char, wchar_t, bool, true);
-   TEST_TTR(signed char, float, bool, false);
-   TEST_TTR(signed char, double, bool, false);
-   TEST_TTR(signed char, long double, bool, false);
-   TEST_TTR(short int, bool, bool, true);
-   TEST_TTR(short int, char, bool, true);
-   TEST_TTR(short int, signed char, bool, true);
-   TEST_TTR(short int, short int, bool, true);
-   TEST_TTR(short int, int, bool, true);
-   TEST_TTR(short int, long int, bool, true);
-   TEST_TTR(short int, unsigned char, bool, true);
-   TEST_TTR(short int, unsigned short int, bool, true);
-   TEST_TTR(short int, unsigned int, bool, true);
-   TEST_TTR(short int, unsigned long int, bool, true);
-   TEST_TTR(short int, wchar_t, bool, true);
-   TEST_TTR(short int, float, bool, false);
-   TEST_TTR(short int, double, bool, false);
-   TEST_TTR(short int, long double, bool, false);
-   TEST_TTR(int, bool, bool, true);
-   TEST_TTR(int, char, bool, true);
-   TEST_TTR(int, signed char, bool, true);
-   TEST_TTR(int, short int, bool, true);
-   TEST_TTR(int, int, bool, true);
-   TEST_TTR(int, long int, bool, true);
-   TEST_TTR(int, unsigned char, bool, true);
-   TEST_TTR(int, unsigned short int, bool, true);
-   TEST_TTR(int, unsigned int, bool, true);
-   TEST_TTR(int, unsigned long int, bool, true);
-   TEST_TTR(int, wchar_t, bool, true);
-   TEST_TTR(int, float, bool, false);
-   TEST_TTR(int, double, bool, false);
-   TEST_TTR(int, long double, bool, false);
-   TEST_TTR(long int, bool, bool, true);
-   TEST_TTR(long int, char, bool, true);
-   TEST_TTR(long int, signed char, bool, true);
-   TEST_TTR(long int, short int, bool, true);
-   TEST_TTR(long int, int, bool, true);
-   TEST_TTR(long int, long int, bool, true);
-   TEST_TTR(long int, unsigned char, bool, true);
-   TEST_TTR(long int, unsigned short int, bool, true);
-   TEST_TTR(long int, unsigned int, bool, true);
-   TEST_TTR(long int, unsigned long int, bool, true);
-   TEST_TTR(long int, wchar_t, bool, true);
-   TEST_TTR(long int, float, bool, false);
-   TEST_TTR(long int, double, bool, false);
-   TEST_TTR(long int, long double, bool, false);
-   TEST_TTR(unsigned char, bool, bool, true);
-   TEST_TTR(unsigned char, char, bool, true);
-   TEST_TTR(unsigned char, signed char, bool, true);
-   TEST_TTR(unsigned char, short int, bool, true);
-   TEST_TTR(unsigned char, int, bool, true);
-   TEST_TTR(unsigned char, long int, bool, true);
-   TEST_TTR(unsigned char, unsigned char, bool, true);
-   TEST_TTR(unsigned char, unsigned short int, bool, true);
-   TEST_TTR(unsigned char, unsigned int, bool, true);
-   TEST_TTR(unsigned char, unsigned long int, bool, true);
-   TEST_TTR(unsigned char, wchar_t, bool, true);
-   TEST_TTR(unsigned char, float, bool, false);
-   TEST_TTR(unsigned char, double, bool, false);
-   TEST_TTR(unsigned char, long double, bool, false);
-   TEST_TTR(unsigned short int, bool, bool, true);
-   TEST_TTR(unsigned short int, char, bool, true);
-   TEST_TTR(unsigned short int, signed char, bool, true);
-   TEST_TTR(unsigned short int, short int, bool, true);
-   TEST_TTR(unsigned short int, int, bool, true);
-   TEST_TTR(unsigned short int, long int, bool, true);
-   TEST_TTR(unsigned short int, unsigned char, bool, true);
-   TEST_TTR(unsigned short int, unsigned short int, bool, true);
-   TEST_TTR(unsigned short int, unsigned int, bool, true);
-   TEST_TTR(unsigned short int, unsigned long int, bool, true);
-   TEST_TTR(unsigned short int, wchar_t, bool, true);
-   TEST_TTR(unsigned short int, float, bool, false);
-   TEST_TTR(unsigned short int, double, bool, false);
-   TEST_TTR(unsigned short int, long double, bool, false);
-   TEST_TTR(unsigned int, bool, bool, true);
-   TEST_TTR(unsigned int, char, bool, true);
-   TEST_TTR(unsigned int, signed char, bool, true);
-   TEST_TTR(unsigned int, short int, bool, true);
-   TEST_TTR(unsigned int, int, bool, true);
-   TEST_TTR(unsigned int, long int, bool, true);
-   TEST_TTR(unsigned int, unsigned char, bool, true);
-   TEST_TTR(unsigned int, unsigned short int, bool, true);
-   TEST_TTR(unsigned int, unsigned int, bool, true);
-   TEST_TTR(unsigned int, unsigned long int, bool, true);
-   TEST_TTR(unsigned int, wchar_t, bool, true);
-   TEST_TTR(unsigned int, float, bool, false);
-   TEST_TTR(unsigned int, double, bool, false);
-   TEST_TTR(unsigned int, long double, bool, false);
-   TEST_TTR(unsigned long int, bool, bool, true);
-   TEST_TTR(unsigned long int, char, bool, true);
-   TEST_TTR(unsigned long int, signed char, bool, true);
-   TEST_TTR(unsigned long int, short int, bool, true);
-   TEST_TTR(unsigned long int, int, bool, true);
-   TEST_TTR(unsigned long int, long int, bool, true);
-   TEST_TTR(unsigned long int, unsigned char, bool, true);
-   TEST_TTR(unsigned long int, unsigned short int, bool, true);
-   TEST_TTR(unsigned long int, unsigned int, bool, true);
-   TEST_TTR(unsigned long int, unsigned long int, bool, true);
-   TEST_TTR(unsigned long int, wchar_t, bool, true);
-   TEST_TTR(unsigned long int, float, bool, false);
-   TEST_TTR(unsigned long int, double, bool, false);
-   TEST_TTR(unsigned long int, long double, bool, false);
-   TEST_TTR(wchar_t, bool, bool, true);
-   TEST_TTR(wchar_t, char, bool, true);
-   TEST_TTR(wchar_t, signed char, bool, true);
-   TEST_TTR(wchar_t, short int, bool, true);
-   TEST_TTR(wchar_t, int, bool, true);
-   TEST_TTR(wchar_t, long int, bool, true);
-   TEST_TTR(wchar_t, unsigned char, bool, true);
-   TEST_TTR(wchar_t, unsigned short int, bool, true);
-   TEST_TTR(wchar_t, unsigned int, bool, true);
-   TEST_TTR(wchar_t, unsigned long int, bool, true);
-   TEST_TTR(wchar_t, wchar_t, bool, true);
-   TEST_TTR(wchar_t, float, bool, false);
-   TEST_TTR(wchar_t, double, bool, false);
-   TEST_TTR(wchar_t, long double, bool, false);
-   TEST_TTR(float, bool, bool, false);
-   TEST_TTR(float, char, bool, false);
-   TEST_TTR(float, signed char, bool, false);
-   TEST_TTR(float, short int, bool, false);
-   TEST_TTR(float, int, bool, false);
-   TEST_TTR(float, long int, bool, false);
-   TEST_TTR(float, unsigned char, bool, false);
-   TEST_TTR(float, unsigned short int, bool, false);
-   TEST_TTR(float, unsigned int, bool, false);
-   TEST_TTR(float, unsigned long int, bool, false);
-   TEST_TTR(float, wchar_t, bool, false);
-   TEST_TTR(float, float, bool, false);
-   TEST_TTR(float, double, bool, false);
-   TEST_TTR(float, long double, bool, false);
-   TEST_TTR(double, bool, bool, false);
-   TEST_TTR(double, char, bool, false);
-   TEST_TTR(double, signed char, bool, false);
-   TEST_TTR(double, short int, bool, false);
-   TEST_TTR(double, int, bool, false);
-   TEST_TTR(double, long int, bool, false);
-   TEST_TTR(double, unsigned char, bool, false);
-   TEST_TTR(double, unsigned short int, bool, false);
-   TEST_TTR(double, unsigned int, bool, false);
-   TEST_TTR(double, unsigned long int, bool, false);
-   TEST_TTR(double, wchar_t, bool, false);
-   TEST_TTR(double, float, bool, false);
-   TEST_TTR(double, double, bool, false);
-   TEST_TTR(double, long double, bool, false);
-   TEST_TTR(long double, bool, bool, false);
-   TEST_TTR(long double, char, bool, false);
-   TEST_TTR(long double, signed char, bool, false);
-   TEST_TTR(long double, short int, bool, false);
-   TEST_TTR(long double, int, bool, false);
-   TEST_TTR(long double, long int, bool, false);
-   TEST_TTR(long double, unsigned char, bool, false);
-   TEST_TTR(long double, unsigned short int, bool, false);
-   TEST_TTR(long double, unsigned int, bool, false);
-   TEST_TTR(long double, unsigned long int, bool, false);
-   TEST_TTR(long double, wchar_t, bool, false);
-   TEST_TTR(long double, float, bool, false);
-   TEST_TTR(long double, double, bool, false);
-   TEST_TTR(long double, long double, bool, false);
-   TEST_TTR(bool, bool, tag, false);
-   TEST_TTR(bool, char, tag, false);
-   TEST_TTR(bool, signed char, tag, false);
-   TEST_TTR(bool, short int, tag, false);
-   TEST_TTR(bool, int, tag, false);
-   TEST_TTR(bool, long int, tag, false);
-   TEST_TTR(bool, unsigned char, tag, false);
-   TEST_TTR(bool, unsigned short int, tag, false);
-   TEST_TTR(bool, unsigned int, tag, false);
-   TEST_TTR(bool, unsigned long int, tag, false);
-   TEST_TTR(bool, wchar_t, tag, false);
-   TEST_TTR(bool, float, tag, false);
-   TEST_TTR(bool, double, tag, false);
-   TEST_TTR(bool, long double, tag, false);
-   TEST_TTR(char, bool, tag, false);
-   TEST_TTR(char, char, tag, false);
-   TEST_TTR(char, signed char, tag, false);
-   TEST_TTR(char, short int, tag, false);
-   TEST_TTR(char, int, tag, false);
-   TEST_TTR(char, long int, tag, false);
-   TEST_TTR(char, unsigned char, tag, false);
-   TEST_TTR(char, unsigned short int, tag, false);
-   TEST_TTR(char, unsigned int, tag, false);
-   TEST_TTR(char, unsigned long int, tag, false);
-   TEST_TTR(char, wchar_t, tag, false);
-   TEST_TTR(char, float, tag, false);
-   TEST_TTR(char, double, tag, false);
-   TEST_TTR(char, long double, tag, false);
-   TEST_TTR(signed char, bool, tag, false);
-   TEST_TTR(signed char, char, tag, false);
-   TEST_TTR(signed char, signed char, tag, false);
-   TEST_TTR(signed char, short int, tag, false);
-   TEST_TTR(signed char, int, tag, false);
-   TEST_TTR(signed char, long int, tag, false);
-   TEST_TTR(signed char, unsigned char, tag, false);
-   TEST_TTR(signed char, unsigned short int, tag, false);
-   TEST_TTR(signed char, unsigned int, tag, false);
-   TEST_TTR(signed char, unsigned long int, tag, false);
-   TEST_TTR(signed char, wchar_t, tag, false);
-   TEST_TTR(signed char, float, tag, false);
-   TEST_TTR(signed char, double, tag, false);
-   TEST_TTR(signed char, long double, tag, false);
-   TEST_TTR(short int, bool, tag, false);
-   TEST_TTR(short int, char, tag, false);
-   TEST_TTR(short int, signed char, tag, false);
-   TEST_TTR(short int, short int, tag, false);
-   TEST_TTR(short int, int, tag, false);
-   TEST_TTR(short int, long int, tag, false);
-   TEST_TTR(short int, unsigned char, tag, false);
-   TEST_TTR(short int, unsigned short int, tag, false);
-   TEST_TTR(short int, unsigned int, tag, false);
-   TEST_TTR(short int, unsigned long int, tag, false);
-   TEST_TTR(short int, wchar_t, tag, false);
-   TEST_TTR(short int, float, tag, false);
-   TEST_TTR(short int, double, tag, false);
-   TEST_TTR(short int, long double, tag, false);
-   TEST_TTR(int, bool, tag, false);
-   TEST_TTR(int, char, tag, false);
-   TEST_TTR(int, signed char, tag, false);
-   TEST_TTR(int, short int, tag, false);
-   TEST_TTR(int, int, tag, false);
-   TEST_TTR(int, long int, tag, false);
-   TEST_TTR(int, unsigned char, tag, false);
-   TEST_TTR(int, unsigned short int, tag, false);
-   TEST_TTR(int, unsigned int, tag, false);
-   TEST_TTR(int, unsigned long int, tag, false);
-   TEST_TTR(int, wchar_t, tag, false);
-   TEST_TTR(int, float, tag, false);
-   TEST_TTR(int, double, tag, false);
-   TEST_TTR(int, long double, tag, false);
-   TEST_TTR(long int, bool, tag, false);
-   TEST_TTR(long int, char, tag, false);
-   TEST_TTR(long int, signed char, tag, false);
-   TEST_TTR(long int, short int, tag, false);
-   TEST_TTR(long int, int, tag, false);
-   TEST_TTR(long int, long int, tag, false);
-   TEST_TTR(long int, unsigned char, tag, false);
-   TEST_TTR(long int, unsigned short int, tag, false);
-   TEST_TTR(long int, unsigned int, tag, false);
-   TEST_TTR(long int, unsigned long int, tag, false);
-   TEST_TTR(long int, wchar_t, tag, false);
-   TEST_TTR(long int, float, tag, false);
-   TEST_TTR(long int, double, tag, false);
-   TEST_TTR(long int, long double, tag, false);
-   TEST_TTR(unsigned char, bool, tag, false);
-   TEST_TTR(unsigned char, char, tag, false);
-   TEST_TTR(unsigned char, signed char, tag, false);
-   TEST_TTR(unsigned char, short int, tag, false);
-   TEST_TTR(unsigned char, int, tag, false);
-   TEST_TTR(unsigned char, long int, tag, false);
-   TEST_TTR(unsigned char, unsigned char, tag, false);
-   TEST_TTR(unsigned char, unsigned short int, tag, false);
-   TEST_TTR(unsigned char, unsigned int, tag, false);
-   TEST_TTR(unsigned char, unsigned long int, tag, false);
-   TEST_TTR(unsigned char, wchar_t, tag, false);
-   TEST_TTR(unsigned char, float, tag, false);
-   TEST_TTR(unsigned char, double, tag, false);
-   TEST_TTR(unsigned char, long double, tag, false);
-   TEST_TTR(unsigned short int, bool, tag, false);
-   TEST_TTR(unsigned short int, char, tag, false);
-   TEST_TTR(unsigned short int, signed char, tag, false);
-   TEST_TTR(unsigned short int, short int, tag, false);
-   TEST_TTR(unsigned short int, int, tag, false);
-   TEST_TTR(unsigned short int, long int, tag, false);
-   TEST_TTR(unsigned short int, unsigned char, tag, false);
-   TEST_TTR(unsigned short int, unsigned short int, tag, false);
-   TEST_TTR(unsigned short int, unsigned int, tag, false);
-   TEST_TTR(unsigned short int, unsigned long int, tag, false);
-   TEST_TTR(unsigned short int, wchar_t, tag, false);
-   TEST_TTR(unsigned short int, float, tag, false);
-   TEST_TTR(unsigned short int, double, tag, false);
-   TEST_TTR(unsigned short int, long double, tag, false);
-   TEST_TTR(unsigned int, bool, tag, false);
-   TEST_TTR(unsigned int, char, tag, false);
-   TEST_TTR(unsigned int, signed char, tag, false);
-   TEST_TTR(unsigned int, short int, tag, false);
-   TEST_TTR(unsigned int, int, tag, false);
-   TEST_TTR(unsigned int, long int, tag, false);
-   TEST_TTR(unsigned int, unsigned char, tag, false);
-   TEST_TTR(unsigned int, unsigned short int, tag, false);
-   TEST_TTR(unsigned int, unsigned int, tag, false);
-   TEST_TTR(unsigned int, unsigned long int, tag, false);
-   TEST_TTR(unsigned int, wchar_t, tag, false);
-   TEST_TTR(unsigned int, float, tag, false);
-   TEST_TTR(unsigned int, double, tag, false);
-   TEST_TTR(unsigned int, long double, tag, false);
-   TEST_TTR(unsigned long int, bool, tag, false);
-   TEST_TTR(unsigned long int, char, tag, false);
-   TEST_TTR(unsigned long int, signed char, tag, false);
-   TEST_TTR(unsigned long int, short int, tag, false);
-   TEST_TTR(unsigned long int, int, tag, false);
-   TEST_TTR(unsigned long int, long int, tag, false);
-   TEST_TTR(unsigned long int, unsigned char, tag, false);
-   TEST_TTR(unsigned long int, unsigned short int, tag, false);
-   TEST_TTR(unsigned long int, unsigned int, tag, false);
-   TEST_TTR(unsigned long int, unsigned long int, tag, false);
-   TEST_TTR(unsigned long int, wchar_t, tag, false);
-   TEST_TTR(unsigned long int, float, tag, false);
-   TEST_TTR(unsigned long int, double, tag, false);
-   TEST_TTR(unsigned long int, long double, tag, false);
-   TEST_TTR(wchar_t, bool, tag, false);
-   TEST_TTR(wchar_t, char, tag, false);
-   TEST_TTR(wchar_t, signed char, tag, false);
-   TEST_TTR(wchar_t, short int, tag, false);
-   TEST_TTR(wchar_t, int, tag, false);
-   TEST_TTR(wchar_t, long int, tag, false);
-   TEST_TTR(wchar_t, unsigned char, tag, false);
-   TEST_TTR(wchar_t, unsigned short int, tag, false);
-   TEST_TTR(wchar_t, unsigned int, tag, false);
-   TEST_TTR(wchar_t, unsigned long int, tag, false);
-   TEST_TTR(wchar_t, wchar_t, tag, false);
-   TEST_TTR(wchar_t, float, tag, false);
-   TEST_TTR(wchar_t, double, tag, false);
-   TEST_TTR(wchar_t, long double, tag, false);
-   TEST_TTR(float, bool, tag, false);
-   TEST_TTR(float, char, tag, false);
-   TEST_TTR(float, signed char, tag, false);
-   TEST_TTR(float, short int, tag, false);
-   TEST_TTR(float, int, tag, false);
-   TEST_TTR(float, long int, tag, false);
-   TEST_TTR(float, unsigned char, tag, false);
-   TEST_TTR(float, unsigned short int, tag, false);
-   TEST_TTR(float, unsigned int, tag, false);
-   TEST_TTR(float, unsigned long int, tag, false);
-   TEST_TTR(float, wchar_t, tag, false);
-   TEST_TTR(float, float, tag, false);
-   TEST_TTR(float, double, tag, false);
-   TEST_TTR(float, long double, tag, false);
-   TEST_TTR(double, bool, tag, false);
-   TEST_TTR(double, char, tag, false);
-   TEST_TTR(double, signed char, tag, false);
-   TEST_TTR(double, short int, tag, false);
-   TEST_TTR(double, int, tag, false);
-   TEST_TTR(double, long int, tag, false);
-   TEST_TTR(double, unsigned char, tag, false);
-   TEST_TTR(double, unsigned short int, tag, false);
-   TEST_TTR(double, unsigned int, tag, false);
-   TEST_TTR(double, unsigned long int, tag, false);
-   TEST_TTR(double, wchar_t, tag, false);
-   TEST_TTR(double, float, tag, false);
-   TEST_TTR(double, double, tag, false);
-   TEST_TTR(double, long double, tag, false);
-   TEST_TTR(long double, bool, tag, false);
-   TEST_TTR(long double, char, tag, false);
-   TEST_TTR(long double, signed char, tag, false);
-   TEST_TTR(long double, short int, tag, false);
-   TEST_TTR(long double, int, tag, false);
-   TEST_TTR(long double, long int, tag, false);
-   TEST_TTR(long double, unsigned char, tag, false);
-   TEST_TTR(long double, unsigned short int, tag, false);
-   TEST_TTR(long double, unsigned int, tag, false);
-   TEST_TTR(long double, unsigned long int, tag, false);
-   TEST_TTR(long double, wchar_t, tag, false);
-   TEST_TTR(long double, float, tag, false);
-   TEST_TTR(long double, double, tag, false);
-   TEST_TTR(long double, long double, tag, false);
-#	undef CV1
-#	define CV1(T) const T
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const T&
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T&
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T&
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const T
-#	undef CV2
-#	define CV2(T) const T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const T&
-#	undef CV2
-#	define CV2(T) const T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T
-#	undef CV2
-#	define CV2(T) volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T&
-#	undef CV2
-#	define CV2(T) volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T
-#	undef CV2
-#	define CV2(T) const volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T&
-#	undef CV2
-#	define CV2(T) const volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-   // pointers
-   TEST_TT(void*, bool, false);
-   TEST_TT(void*, int, false);
-   TEST_TT(void*, double, false);
-   TEST_TT(void*, A, false);
-   TEST_TT(void*, B, false);
-   TEST_TT(bool*, bool, false);
-   TEST_TT(bool*, int, false);
-   TEST_TT(bool*, double, false);
-   TEST_TT(bool*, A, false);
-   TEST_TT(bool*, B, false);
-   TEST_TT(int*, bool, false);
-   TEST_TT(int*, int, false);
-   TEST_TT(int*, double, false);
-   TEST_TT(int*, A, false);
-   TEST_TT(int*, B, false);
-   TEST_TT(double*, bool, false);
-   TEST_TT(double*, int, false);
-   TEST_TT(double*, double, false);
-   TEST_TT(double*, A, false);
-   TEST_TT(double*, B, false);
-   TEST_TT(A*, bool, false);
-   TEST_TT(A*, int, false);
-   TEST_TT(A*, double, false);
-   TEST_TT(A*, A, false);
-   TEST_TT(A*, B, false);
-   TEST_TT(B*, bool, false);
-   TEST_TT(B*, int, false);
-   TEST_TT(B*, double, false);
-   TEST_TT(B*, A, false);
-   TEST_TT(B*, B, false);
-   TEST_TT(bool, void*, false);
-   TEST_TT(bool, bool*, false);
-   TEST_TT(bool, int*, false);
-   TEST_TT(bool, double*, false);
-   TEST_TT(bool, A*, false);
-   TEST_TT(bool, B*, false);
-   TEST_TT(int, void*, false);
-   TEST_TT(int, bool*, false);
-   TEST_TT(int, int*, false);
-   TEST_TT(int, double*, false);
-   TEST_TT(int, A*, false);
-   TEST_TT(int, B*, false);
-   TEST_TT(double, void*, false);
-   TEST_TT(double, bool*, false);
-   TEST_TT(double, int*, false);
-   TEST_TT(double, double*, false);
-   TEST_TT(double, A*, false);
-   TEST_TT(double, B*, false);
-   TEST_TT(A, void*, false);
-   TEST_TT(A, bool*, false);
-   TEST_TT(A, int*, false);
-   TEST_TT(A, double*, false);
-   TEST_TT(A, A*, false);
-   TEST_TT(A, B*, false);
-   TEST_TT(B, void*, false);
-   TEST_TT(B, bool*, false);
-   TEST_TT(B, int*, false);
-   TEST_TT(B, double*, false);
-   TEST_TT(B, A*, false);
-   TEST_TT(B, B*, false);
-   TEST_TT(void*, void*, false);
-   TEST_TT(void*, bool*, false);
-   TEST_TT(void*, int*, false);
-   TEST_TT(void*, double*, false);
-   TEST_TT(void*, A*, false);
-   TEST_TT(void*, B*, false);
-   TEST_TT(bool*, void*, false);
-   TEST_TT(bool*, bool*, false);
-   TEST_TT(bool*, int*, false);
-   TEST_TT(bool*, double*, false);
-   TEST_TT(bool*, A*, false);
-   TEST_TT(bool*, B*, false);
-   TEST_TT(int*, void*, false);
-   TEST_TT(int*, bool*, false);
-   TEST_TT(int*, int*, false);
-   TEST_TT(int*, double*, false);
-   TEST_TT(int*, A*, false);
-   TEST_TT(int*, B*, false);
-   TEST_TT(double*, void*, false);
-   TEST_TT(double*, bool*, false);
-   TEST_TT(double*, int*, false);
-   TEST_TT(double*, double*, false);
-   TEST_TT(double*, A*, false);
-   TEST_TT(double*, B*, false);
-   TEST_TT(A*, void*, false);
-   TEST_TT(A*, bool*, false);
-   TEST_TT(A*, int*, false);
-   TEST_TT(A*, double*, false);
-   TEST_TT(A*, A*, false);
-   TEST_TT(A*, B*, false);
-   TEST_TT(B*, void*, false);
-   TEST_TT(B*, bool*, false);
-   TEST_TT(B*, int*, false);
-   TEST_TT(B*, double*, false);
-   TEST_TT(B*, A*, false);
-   TEST_TT(B*, B*, false);
-   TEST_TT(C, void*, true);
-   TEST_TT(D, void*, false);
-   TEST_TT(void*, C, false);
-   TEST_TT(void*, D, true);
-   TEST_TT(C, D, true);
-}
-}

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,1250 +0,0 @@
-//  (C) Copyright Frederic Bron 2009-2011.
-//  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)
-
-namespace {
-
-void run2() {
-   // test with only one template parameter
-   TEST_T(void, false);
-   TEST_T(bool, true);
-   TEST_T(char, true);
-   TEST_T(signed char, true);
-   TEST_T(short int, true);
-   TEST_T(int, true);
-   TEST_T(long int, true);
-   TEST_T(unsigned char, true);
-   TEST_T(unsigned short int, true);
-   TEST_T(unsigned int, true);
-   TEST_T(unsigned long int, true);
-   TEST_T(wchar_t, true);
-   TEST_T(float, true);
-   TEST_T(double, true);
-   TEST_T(long double, true);
-   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), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	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), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	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 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);
-   TEST_TT(bool, short int, true);
-   TEST_TT(bool, int, true);
-   TEST_TT(bool, long int, true);
-   TEST_TT(bool, unsigned char, true);
-   TEST_TT(bool, unsigned short int, true);
-   TEST_TT(bool, unsigned int, true);
-   TEST_TT(bool, unsigned long int, true);
-   TEST_TT(bool, wchar_t, true);
-   TEST_TT(bool, float, true);
-   TEST_TT(bool, double, true);
-   TEST_TT(bool, long double, true);
-   TEST_TT(char, bool, true);
-   TEST_TT(char, char, true);
-   TEST_TT(char, signed char, true);
-   TEST_TT(char, short int, true);
-   TEST_TT(char, int, true);
-   TEST_TT(char, long int, true);
-   TEST_TT(char, unsigned char, true);
-   TEST_TT(char, unsigned short int, true);
-   TEST_TT(char, unsigned int, true);
-   TEST_TT(char, unsigned long int, true);
-   TEST_TT(char, wchar_t, true);
-   TEST_TT(char, float, true);
-   TEST_TT(char, double, true);
-   TEST_TT(char, long double, true);
-   TEST_TT(signed char, bool, true);
-   TEST_TT(signed char, char, true);
-   TEST_TT(signed char, signed char, true);
-   TEST_TT(signed char, short int, true);
-   TEST_TT(signed char, int, true);
-   TEST_TT(signed char, long int, true);
-   TEST_TT(signed char, unsigned char, true);
-   TEST_TT(signed char, unsigned short int, true);
-   TEST_TT(signed char, unsigned int, true);
-   TEST_TT(signed char, unsigned long int, true);
-   TEST_TT(signed char, wchar_t, true);
-   TEST_TT(signed char, float, true);
-   TEST_TT(signed char, double, true);
-   TEST_TT(signed char, long double, true);
-   TEST_TT(short int, bool, true);
-   TEST_TT(short int, char, true);
-   TEST_TT(short int, signed char, true);
-   TEST_TT(short int, short int, true);
-   TEST_TT(short int, int, true);
-   TEST_TT(short int, long int, true);
-   TEST_TT(short int, unsigned char, true);
-   TEST_TT(short int, unsigned short int, true);
-   TEST_TT(short int, unsigned int, true);
-   TEST_TT(short int, unsigned long int, true);
-   TEST_TT(short int, wchar_t, true);
-   TEST_TT(short int, float, true);
-   TEST_TT(short int, double, true);
-   TEST_TT(short int, long double, true);
-   TEST_TT(int, bool, true);
-   TEST_TT(int, char, true);
-   TEST_TT(int, signed char, true);
-   TEST_TT(int, short int, true);
-   TEST_TT(int, int, true);
-   TEST_TT(int, long int, true);
-   TEST_TT(int, unsigned char, true);
-   TEST_TT(int, unsigned short int, true);
-   TEST_TT(int, unsigned int, true);
-   TEST_TT(int, unsigned long int, true);
-   TEST_TT(int, wchar_t, true);
-   TEST_TT(int, float, true);
-   TEST_TT(int, double, true);
-   TEST_TT(int, long double, true);
-   TEST_TT(long int, bool, true);
-   TEST_TT(long int, char, true);
-   TEST_TT(long int, signed char, true);
-   TEST_TT(long int, short int, true);
-   TEST_TT(long int, int, true);
-   TEST_TT(long int, long int, true);
-   TEST_TT(long int, unsigned char, true);
-   TEST_TT(long int, unsigned short int, true);
-   TEST_TT(long int, unsigned int, true);
-   TEST_TT(long int, unsigned long int, true);
-   TEST_TT(long int, wchar_t, true);
-   TEST_TT(long int, float, true);
-   TEST_TT(long int, double, true);
-   TEST_TT(long int, long double, true);
-   TEST_TT(unsigned char, bool, true);
-   TEST_TT(unsigned char, char, true);
-   TEST_TT(unsigned char, signed char, true);
-   TEST_TT(unsigned char, short int, true);
-   TEST_TT(unsigned char, int, true);
-   TEST_TT(unsigned char, long int, true);
-   TEST_TT(unsigned char, unsigned char, true);
-   TEST_TT(unsigned char, unsigned short int, true);
-   TEST_TT(unsigned char, unsigned int, true);
-   TEST_TT(unsigned char, unsigned long int, true);
-   TEST_TT(unsigned char, wchar_t, true);
-   TEST_TT(unsigned char, float, true);
-   TEST_TT(unsigned char, double, true);
-   TEST_TT(unsigned char, long double, true);
-   TEST_TT(unsigned short int, bool, true);
-   TEST_TT(unsigned short int, char, true);
-   TEST_TT(unsigned short int, signed char, true);
-   TEST_TT(unsigned short int, short int, true);
-   TEST_TT(unsigned short int, int, true);
-   TEST_TT(unsigned short int, long int, true);
-   TEST_TT(unsigned short int, unsigned char, true);
-   TEST_TT(unsigned short int, unsigned short int, true);
-   TEST_TT(unsigned short int, unsigned int, true);
-   TEST_TT(unsigned short int, unsigned long int, true);
-   TEST_TT(unsigned short int, wchar_t, true);
-   TEST_TT(unsigned short int, float, true);
-   TEST_TT(unsigned short int, double, true);
-   TEST_TT(unsigned short int, long double, true);
-   TEST_TT(unsigned int, bool, true);
-   TEST_TT(unsigned int, char, true);
-   TEST_TT(unsigned int, signed char, true);
-   TEST_TT(unsigned int, short int, true);
-   TEST_TT(unsigned int, int, true);
-   TEST_TT(unsigned int, long int, true);
-   TEST_TT(unsigned int, unsigned char, true);
-   TEST_TT(unsigned int, unsigned short int, true);
-   TEST_TT(unsigned int, unsigned int, true);
-   TEST_TT(unsigned int, unsigned long int, true);
-   TEST_TT(unsigned int, wchar_t, true);
-   TEST_TT(unsigned int, float, true);
-   TEST_TT(unsigned int, double, true);
-   TEST_TT(unsigned int, long double, true);
-   TEST_TT(unsigned long int, bool, true);
-   TEST_TT(unsigned long int, char, true);
-   TEST_TT(unsigned long int, signed char, true);
-   TEST_TT(unsigned long int, short int, true);
-   TEST_TT(unsigned long int, int, true);
-   TEST_TT(unsigned long int, long int, true);
-   TEST_TT(unsigned long int, unsigned char, true);
-   TEST_TT(unsigned long int, unsigned short int, true);
-   TEST_TT(unsigned long int, unsigned int, true);
-   TEST_TT(unsigned long int, unsigned long int, true);
-   TEST_TT(unsigned long int, wchar_t, true);
-   TEST_TT(unsigned long int, float, true);
-   TEST_TT(unsigned long int, double, true);
-   TEST_TT(unsigned long int, long double, true);
-   TEST_TT(wchar_t, bool, true);
-   TEST_TT(wchar_t, char, true);
-   TEST_TT(wchar_t, signed char, true);
-   TEST_TT(wchar_t, short int, true);
-   TEST_TT(wchar_t, int, true);
-   TEST_TT(wchar_t, long int, true);
-   TEST_TT(wchar_t, unsigned char, true);
-   TEST_TT(wchar_t, unsigned short int, true);
-   TEST_TT(wchar_t, unsigned int, true);
-   TEST_TT(wchar_t, unsigned long int, true);
-   TEST_TT(wchar_t, wchar_t, true);
-   TEST_TT(wchar_t, float, true);
-   TEST_TT(wchar_t, double, true);
-   TEST_TT(wchar_t, long double, true);
-   TEST_TT(float, bool, true);
-   TEST_TT(float, char, true);
-   TEST_TT(float, signed char, true);
-   TEST_TT(float, short int, true);
-   TEST_TT(float, int, true);
-   TEST_TT(float, long int, true);
-   TEST_TT(float, unsigned char, true);
-   TEST_TT(float, unsigned short int, true);
-   TEST_TT(float, unsigned int, true);
-   TEST_TT(float, unsigned long int, true);
-   TEST_TT(float, wchar_t, true);
-   TEST_TT(float, float, true);
-   TEST_TT(float, double, true);
-   TEST_TT(float, long double, true);
-   TEST_TT(double, bool, true);
-   TEST_TT(double, char, true);
-   TEST_TT(double, signed char, true);
-   TEST_TT(double, short int, true);
-   TEST_TT(double, int, true);
-   TEST_TT(double, long int, true);
-   TEST_TT(double, unsigned char, true);
-   TEST_TT(double, unsigned short int, true);
-   TEST_TT(double, unsigned int, true);
-   TEST_TT(double, unsigned long int, true);
-   TEST_TT(double, wchar_t, true);
-   TEST_TT(double, float, true);
-   TEST_TT(double, double, true);
-   TEST_TT(double, long double, true);
-   TEST_TT(long double, bool, true);
-   TEST_TT(long double, char, true);
-   TEST_TT(long double, signed char, true);
-   TEST_TT(long double, short int, true);
-   TEST_TT(long double, int, true);
-   TEST_TT(long double, long int, true);
-   TEST_TT(long double, unsigned char, true);
-   TEST_TT(long double, unsigned short int, true);
-   TEST_TT(long double, unsigned int, true);
-   TEST_TT(long double, unsigned long int, true);
-   TEST_TT(long double, wchar_t, true);
-   TEST_TT(long double, float, true);
-   TEST_TT(long double, double, true);
-   TEST_TT(long double, long double, true);
-   TEST_TT(bool, void, false);
-   TEST_TT(void, bool, false);
-   TEST_TT(char, void, false);
-   TEST_TT(void, char, false);
-   TEST_TT(signed char, void, false);
-   TEST_TT(void, signed char, false);
-   TEST_TT(short int, void, false);
-   TEST_TT(void, short int, false);
-   TEST_TT(int, void, false);
-   TEST_TT(void, int, false);
-   TEST_TT(long int, void, false);
-   TEST_TT(void, long int, false);
-   TEST_TT(unsigned char, void, false);
-   TEST_TT(void, unsigned char, false);
-   TEST_TT(unsigned short int, void, false);
-   TEST_TT(void, unsigned short int, false);
-   TEST_TT(unsigned int, void, false);
-   TEST_TT(void, unsigned int, false);
-   TEST_TT(unsigned long int, void, false);
-   TEST_TT(void, unsigned long int, false);
-   TEST_TT(wchar_t, void, false);
-   TEST_TT(void, wchar_t, false);
-   TEST_TT(float, void, false);
-   TEST_TT(void, float, false);
-   TEST_TT(double, void, false);
-   TEST_TT(void, double, false);
-   TEST_TT(long double, void, false);
-   TEST_TT(void, long double, false);
-
-// test with three template parameters
-   TEST_TTR(bool, bool, bool, true);
-   TEST_TTR(bool, char, bool, true);
-   TEST_TTR(bool, signed char, bool, true);
-   TEST_TTR(bool, short int, bool, true);
-   TEST_TTR(bool, int, bool, true);
-   TEST_TTR(bool, long int, bool, true);
-   TEST_TTR(bool, unsigned char, bool, true);
-   TEST_TTR(bool, unsigned short int, bool, true);
-   TEST_TTR(bool, unsigned int, bool, true);
-   TEST_TTR(bool, unsigned long int, bool, true);
-   TEST_TTR(bool, wchar_t, bool, true);
-   TEST_TTR(bool, float, bool, true);
-   TEST_TTR(bool, double, bool, true);
-   TEST_TTR(bool, long double, bool, true);
-   TEST_TTR(char, bool, bool, true);
-   TEST_TTR(char, char, bool, true);
-   TEST_TTR(char, signed char, bool, true);
-   TEST_TTR(char, short int, bool, true);
-   TEST_TTR(char, int, bool, true);
-   TEST_TTR(char, long int, bool, true);
-   TEST_TTR(char, unsigned char, bool, true);
-   TEST_TTR(char, unsigned short int, bool, true);
-   TEST_TTR(char, unsigned int, bool, true);
-   TEST_TTR(char, unsigned long int, bool, true);
-   TEST_TTR(char, wchar_t, bool, true);
-   TEST_TTR(char, float, bool, true);
-   TEST_TTR(char, double, bool, true);
-   TEST_TTR(char, long double, bool, true);
-   TEST_TTR(signed char, bool, bool, true);
-   TEST_TTR(signed char, char, bool, true);
-   TEST_TTR(signed char, signed char, bool, true);
-   TEST_TTR(signed char, short int, bool, true);
-   TEST_TTR(signed char, int, bool, true);
-   TEST_TTR(signed char, long int, bool, true);
-   TEST_TTR(signed char, unsigned char, bool, true);
-   TEST_TTR(signed char, unsigned short int, bool, true);
-   TEST_TTR(signed char, unsigned int, bool, true);
-   TEST_TTR(signed char, unsigned long int, bool, true);
-   TEST_TTR(signed char, wchar_t, bool, true);
-   TEST_TTR(signed char, float, bool, true);
-   TEST_TTR(signed char, double, bool, true);
-   TEST_TTR(signed char, long double, bool, true);
-   TEST_TTR(short int, bool, bool, true);
-   TEST_TTR(short int, char, bool, true);
-   TEST_TTR(short int, signed char, bool, true);
-   TEST_TTR(short int, short int, bool, true);
-   TEST_TTR(short int, int, bool, true);
-   TEST_TTR(short int, long int, bool, true);
-   TEST_TTR(short int, unsigned char, bool, true);
-   TEST_TTR(short int, unsigned short int, bool, true);
-   TEST_TTR(short int, unsigned int, bool, true);
-   TEST_TTR(short int, unsigned long int, bool, true);
-   TEST_TTR(short int, wchar_t, bool, true);
-   TEST_TTR(short int, float, bool, true);
-   TEST_TTR(short int, double, bool, true);
-   TEST_TTR(short int, long double, bool, true);
-   TEST_TTR(int, bool, bool, true);
-   TEST_TTR(int, char, bool, true);
-   TEST_TTR(int, signed char, bool, true);
-   TEST_TTR(int, short int, bool, true);
-   TEST_TTR(int, int, bool, true);
-   TEST_TTR(int, long int, bool, true);
-   TEST_TTR(int, unsigned char, bool, true);
-   TEST_TTR(int, unsigned short int, bool, true);
-   TEST_TTR(int, unsigned int, bool, true);
-   TEST_TTR(int, unsigned long int, bool, true);
-   TEST_TTR(int, wchar_t, bool, true);
-   TEST_TTR(int, float, bool, true);
-   TEST_TTR(int, double, bool, true);
-   TEST_TTR(int, long double, bool, true);
-   TEST_TTR(long int, bool, bool, true);
-   TEST_TTR(long int, char, bool, true);
-   TEST_TTR(long int, signed char, bool, true);
-   TEST_TTR(long int, short int, bool, true);
-   TEST_TTR(long int, int, bool, true);
-   TEST_TTR(long int, long int, bool, true);
-   TEST_TTR(long int, unsigned char, bool, true);
-   TEST_TTR(long int, unsigned short int, bool, true);
-   TEST_TTR(long int, unsigned int, bool, true);
-   TEST_TTR(long int, unsigned long int, bool, true);
-   TEST_TTR(long int, wchar_t, bool, true);
-   TEST_TTR(long int, float, bool, true);
-   TEST_TTR(long int, double, bool, true);
-   TEST_TTR(long int, long double, bool, true);
-   TEST_TTR(unsigned char, bool, bool, true);
-   TEST_TTR(unsigned char, char, bool, true);
-   TEST_TTR(unsigned char, signed char, bool, true);
-   TEST_TTR(unsigned char, short int, bool, true);
-   TEST_TTR(unsigned char, int, bool, true);
-   TEST_TTR(unsigned char, long int, bool, true);
-   TEST_TTR(unsigned char, unsigned char, bool, true);
-   TEST_TTR(unsigned char, unsigned short int, bool, true);
-   TEST_TTR(unsigned char, unsigned int, bool, true);
-   TEST_TTR(unsigned char, unsigned long int, bool, true);
-   TEST_TTR(unsigned char, wchar_t, bool, true);
-   TEST_TTR(unsigned char, float, bool, true);
-   TEST_TTR(unsigned char, double, bool, true);
-   TEST_TTR(unsigned char, long double, bool, true);
-   TEST_TTR(unsigned short int, bool, bool, true);
-   TEST_TTR(unsigned short int, char, bool, true);
-   TEST_TTR(unsigned short int, signed char, bool, true);
-   TEST_TTR(unsigned short int, short int, bool, true);
-   TEST_TTR(unsigned short int, int, bool, true);
-   TEST_TTR(unsigned short int, long int, bool, true);
-   TEST_TTR(unsigned short int, unsigned char, bool, true);
-   TEST_TTR(unsigned short int, unsigned short int, bool, true);
-   TEST_TTR(unsigned short int, unsigned int, bool, true);
-   TEST_TTR(unsigned short int, unsigned long int, bool, true);
-   TEST_TTR(unsigned short int, wchar_t, bool, true);
-   TEST_TTR(unsigned short int, float, bool, true);
-   TEST_TTR(unsigned short int, double, bool, true);
-   TEST_TTR(unsigned short int, long double, bool, true);
-   TEST_TTR(unsigned int, bool, bool, true);
-   TEST_TTR(unsigned int, char, bool, true);
-   TEST_TTR(unsigned int, signed char, bool, true);
-   TEST_TTR(unsigned int, short int, bool, true);
-   TEST_TTR(unsigned int, int, bool, true);
-   TEST_TTR(unsigned int, long int, bool, true);
-   TEST_TTR(unsigned int, unsigned char, bool, true);
-   TEST_TTR(unsigned int, unsigned short int, bool, true);
-   TEST_TTR(unsigned int, unsigned int, bool, true);
-   TEST_TTR(unsigned int, unsigned long int, bool, true);
-   TEST_TTR(unsigned int, wchar_t, bool, true);
-   TEST_TTR(unsigned int, float, bool, true);
-   TEST_TTR(unsigned int, double, bool, true);
-   TEST_TTR(unsigned int, long double, bool, true);
-   TEST_TTR(unsigned long int, bool, bool, true);
-   TEST_TTR(unsigned long int, char, bool, true);
-   TEST_TTR(unsigned long int, signed char, bool, true);
-   TEST_TTR(unsigned long int, short int, bool, true);
-   TEST_TTR(unsigned long int, int, bool, true);
-   TEST_TTR(unsigned long int, long int, bool, true);
-   TEST_TTR(unsigned long int, unsigned char, bool, true);
-   TEST_TTR(unsigned long int, unsigned short int, bool, true);
-   TEST_TTR(unsigned long int, unsigned int, bool, true);
-   TEST_TTR(unsigned long int, unsigned long int, bool, true);
-   TEST_TTR(unsigned long int, wchar_t, bool, true);
-   TEST_TTR(unsigned long int, float, bool, true);
-   TEST_TTR(unsigned long int, double, bool, true);
-   TEST_TTR(unsigned long int, long double, bool, true);
-   TEST_TTR(wchar_t, bool, bool, true);
-   TEST_TTR(wchar_t, char, bool, true);
-   TEST_TTR(wchar_t, signed char, bool, true);
-   TEST_TTR(wchar_t, short int, bool, true);
-   TEST_TTR(wchar_t, int, bool, true);
-   TEST_TTR(wchar_t, long int, bool, true);
-   TEST_TTR(wchar_t, unsigned char, bool, true);
-   TEST_TTR(wchar_t, unsigned short int, bool, true);
-   TEST_TTR(wchar_t, unsigned int, bool, true);
-   TEST_TTR(wchar_t, unsigned long int, bool, true);
-   TEST_TTR(wchar_t, wchar_t, bool, true);
-   TEST_TTR(wchar_t, float, bool, true);
-   TEST_TTR(wchar_t, double, bool, true);
-   TEST_TTR(wchar_t, long double, bool, true);
-   TEST_TTR(float, bool, bool, true);
-   TEST_TTR(float, char, bool, true);
-   TEST_TTR(float, signed char, bool, true);
-   TEST_TTR(float, short int, bool, true);
-   TEST_TTR(float, int, bool, true);
-   TEST_TTR(float, long int, bool, true);
-   TEST_TTR(float, unsigned char, bool, true);
-   TEST_TTR(float, unsigned short int, bool, true);
-   TEST_TTR(float, unsigned int, bool, true);
-   TEST_TTR(float, unsigned long int, bool, true);
-   TEST_TTR(float, wchar_t, bool, true);
-   TEST_TTR(float, float, bool, true);
-   TEST_TTR(float, double, bool, true);
-   TEST_TTR(float, long double, bool, true);
-   TEST_TTR(double, bool, bool, true);
-   TEST_TTR(double, char, bool, true);
-   TEST_TTR(double, signed char, bool, true);
-   TEST_TTR(double, short int, bool, true);
-   TEST_TTR(double, int, bool, true);
-   TEST_TTR(double, long int, bool, true);
-   TEST_TTR(double, unsigned char, bool, true);
-   TEST_TTR(double, unsigned short int, bool, true);
-   TEST_TTR(double, unsigned int, bool, true);
-   TEST_TTR(double, unsigned long int, bool, true);
-   TEST_TTR(double, wchar_t, bool, true);
-   TEST_TTR(double, float, bool, true);
-   TEST_TTR(double, double, bool, true);
-   TEST_TTR(double, long double, bool, true);
-   TEST_TTR(long double, bool, bool, true);
-   TEST_TTR(long double, char, bool, true);
-   TEST_TTR(long double, signed char, bool, true);
-   TEST_TTR(long double, short int, bool, true);
-   TEST_TTR(long double, int, bool, true);
-   TEST_TTR(long double, long int, bool, true);
-   TEST_TTR(long double, unsigned char, bool, true);
-   TEST_TTR(long double, unsigned short int, bool, true);
-   TEST_TTR(long double, unsigned int, bool, true);
-   TEST_TTR(long double, unsigned long int, bool, true);
-   TEST_TTR(long double, wchar_t, bool, true);
-   TEST_TTR(long double, float, bool, true);
-   TEST_TTR(long double, double, bool, true);
-   TEST_TTR(long double, long double, bool, true);
-   TEST_TTR(bool, bool, tag, false);
-   TEST_TTR(bool, char, tag, false);
-   TEST_TTR(bool, signed char, tag, false);
-   TEST_TTR(bool, short int, tag, false);
-   TEST_TTR(bool, int, tag, false);
-   TEST_TTR(bool, long int, tag, false);
-   TEST_TTR(bool, unsigned char, tag, false);
-   TEST_TTR(bool, unsigned short int, tag, false);
-   TEST_TTR(bool, unsigned int, tag, false);
-   TEST_TTR(bool, unsigned long int, tag, false);
-   TEST_TTR(bool, wchar_t, tag, false);
-   TEST_TTR(bool, float, tag, false);
-   TEST_TTR(bool, double, tag, false);
-   TEST_TTR(bool, long double, tag, false);
-   TEST_TTR(char, bool, tag, false);
-   TEST_TTR(char, char, tag, false);
-   TEST_TTR(char, signed char, tag, false);
-   TEST_TTR(char, short int, tag, false);
-   TEST_TTR(char, int, tag, false);
-   TEST_TTR(char, long int, tag, false);
-   TEST_TTR(char, unsigned char, tag, false);
-   TEST_TTR(char, unsigned short int, tag, false);
-   TEST_TTR(char, unsigned int, tag, false);
-   TEST_TTR(char, unsigned long int, tag, false);
-   TEST_TTR(char, wchar_t, tag, false);
-   TEST_TTR(char, float, tag, false);
-   TEST_TTR(char, double, tag, false);
-   TEST_TTR(char, long double, tag, false);
-   TEST_TTR(signed char, bool, tag, false);
-   TEST_TTR(signed char, char, tag, false);
-   TEST_TTR(signed char, signed char, tag, false);
-   TEST_TTR(signed char, short int, tag, false);
-   TEST_TTR(signed char, int, tag, false);
-   TEST_TTR(signed char, long int, tag, false);
-   TEST_TTR(signed char, unsigned char, tag, false);
-   TEST_TTR(signed char, unsigned short int, tag, false);
-   TEST_TTR(signed char, unsigned int, tag, false);
-   TEST_TTR(signed char, unsigned long int, tag, false);
-   TEST_TTR(signed char, wchar_t, tag, false);
-   TEST_TTR(signed char, float, tag, false);
-   TEST_TTR(signed char, double, tag, false);
-   TEST_TTR(signed char, long double, tag, false);
-   TEST_TTR(short int, bool, tag, false);
-   TEST_TTR(short int, char, tag, false);
-   TEST_TTR(short int, signed char, tag, false);
-   TEST_TTR(short int, short int, tag, false);
-   TEST_TTR(short int, int, tag, false);
-   TEST_TTR(short int, long int, tag, false);
-   TEST_TTR(short int, unsigned char, tag, false);
-   TEST_TTR(short int, unsigned short int, tag, false);
-   TEST_TTR(short int, unsigned int, tag, false);
-   TEST_TTR(short int, unsigned long int, tag, false);
-   TEST_TTR(short int, wchar_t, tag, false);
-   TEST_TTR(short int, float, tag, false);
-   TEST_TTR(short int, double, tag, false);
-   TEST_TTR(short int, long double, tag, false);
-   TEST_TTR(int, bool, tag, false);
-   TEST_TTR(int, char, tag, false);
-   TEST_TTR(int, signed char, tag, false);
-   TEST_TTR(int, short int, tag, false);
-   TEST_TTR(int, int, tag, false);
-   TEST_TTR(int, long int, tag, false);
-   TEST_TTR(int, unsigned char, tag, false);
-   TEST_TTR(int, unsigned short int, tag, false);
-   TEST_TTR(int, unsigned int, tag, false);
-   TEST_TTR(int, unsigned long int, tag, false);
-   TEST_TTR(int, wchar_t, tag, false);
-   TEST_TTR(int, float, tag, false);
-   TEST_TTR(int, double, tag, false);
-   TEST_TTR(int, long double, tag, false);
-   TEST_TTR(long int, bool, tag, false);
-   TEST_TTR(long int, char, tag, false);
-   TEST_TTR(long int, signed char, tag, false);
-   TEST_TTR(long int, short int, tag, false);
-   TEST_TTR(long int, int, tag, false);
-   TEST_TTR(long int, long int, tag, false);
-   TEST_TTR(long int, unsigned char, tag, false);
-   TEST_TTR(long int, unsigned short int, tag, false);
-   TEST_TTR(long int, unsigned int, tag, false);
-   TEST_TTR(long int, unsigned long int, tag, false);
-   TEST_TTR(long int, wchar_t, tag, false);
-   TEST_TTR(long int, float, tag, false);
-   TEST_TTR(long int, double, tag, false);
-   TEST_TTR(long int, long double, tag, false);
-   TEST_TTR(unsigned char, bool, tag, false);
-   TEST_TTR(unsigned char, char, tag, false);
-   TEST_TTR(unsigned char, signed char, tag, false);
-   TEST_TTR(unsigned char, short int, tag, false);
-   TEST_TTR(unsigned char, int, tag, false);
-   TEST_TTR(unsigned char, long int, tag, false);
-   TEST_TTR(unsigned char, unsigned char, tag, false);
-   TEST_TTR(unsigned char, unsigned short int, tag, false);
-   TEST_TTR(unsigned char, unsigned int, tag, false);
-   TEST_TTR(unsigned char, unsigned long int, tag, false);
-   TEST_TTR(unsigned char, wchar_t, tag, false);
-   TEST_TTR(unsigned char, float, tag, false);
-   TEST_TTR(unsigned char, double, tag, false);
-   TEST_TTR(unsigned char, long double, tag, false);
-   TEST_TTR(unsigned short int, bool, tag, false);
-   TEST_TTR(unsigned short int, char, tag, false);
-   TEST_TTR(unsigned short int, signed char, tag, false);
-   TEST_TTR(unsigned short int, short int, tag, false);
-   TEST_TTR(unsigned short int, int, tag, false);
-   TEST_TTR(unsigned short int, long int, tag, false);
-   TEST_TTR(unsigned short int, unsigned char, tag, false);
-   TEST_TTR(unsigned short int, unsigned short int, tag, false);
-   TEST_TTR(unsigned short int, unsigned int, tag, false);
-   TEST_TTR(unsigned short int, unsigned long int, tag, false);
-   TEST_TTR(unsigned short int, wchar_t, tag, false);
-   TEST_TTR(unsigned short int, float, tag, false);
-   TEST_TTR(unsigned short int, double, tag, false);
-   TEST_TTR(unsigned short int, long double, tag, false);
-   TEST_TTR(unsigned int, bool, tag, false);
-   TEST_TTR(unsigned int, char, tag, false);
-   TEST_TTR(unsigned int, signed char, tag, false);
-   TEST_TTR(unsigned int, short int, tag, false);
-   TEST_TTR(unsigned int, int, tag, false);
-   TEST_TTR(unsigned int, long int, tag, false);
-   TEST_TTR(unsigned int, unsigned char, tag, false);
-   TEST_TTR(unsigned int, unsigned short int, tag, false);
-   TEST_TTR(unsigned int, unsigned int, tag, false);
-   TEST_TTR(unsigned int, unsigned long int, tag, false);
-   TEST_TTR(unsigned int, wchar_t, tag, false);
-   TEST_TTR(unsigned int, float, tag, false);
-   TEST_TTR(unsigned int, double, tag, false);
-   TEST_TTR(unsigned int, long double, tag, false);
-   TEST_TTR(unsigned long int, bool, tag, false);
-   TEST_TTR(unsigned long int, char, tag, false);
-   TEST_TTR(unsigned long int, signed char, tag, false);
-   TEST_TTR(unsigned long int, short int, tag, false);
-   TEST_TTR(unsigned long int, int, tag, false);
-   TEST_TTR(unsigned long int, long int, tag, false);
-   TEST_TTR(unsigned long int, unsigned char, tag, false);
-   TEST_TTR(unsigned long int, unsigned short int, tag, false);
-   TEST_TTR(unsigned long int, unsigned int, tag, false);
-   TEST_TTR(unsigned long int, unsigned long int, tag, false);
-   TEST_TTR(unsigned long int, wchar_t, tag, false);
-   TEST_TTR(unsigned long int, float, tag, false);
-   TEST_TTR(unsigned long int, double, tag, false);
-   TEST_TTR(unsigned long int, long double, tag, false);
-   TEST_TTR(wchar_t, bool, tag, false);
-   TEST_TTR(wchar_t, char, tag, false);
-   TEST_TTR(wchar_t, signed char, tag, false);
-   TEST_TTR(wchar_t, short int, tag, false);
-   TEST_TTR(wchar_t, int, tag, false);
-   TEST_TTR(wchar_t, long int, tag, false);
-   TEST_TTR(wchar_t, unsigned char, tag, false);
-   TEST_TTR(wchar_t, unsigned short int, tag, false);
-   TEST_TTR(wchar_t, unsigned int, tag, false);
-   TEST_TTR(wchar_t, unsigned long int, tag, false);
-   TEST_TTR(wchar_t, wchar_t, tag, false);
-   TEST_TTR(wchar_t, float, tag, false);
-   TEST_TTR(wchar_t, double, tag, false);
-   TEST_TTR(wchar_t, long double, tag, false);
-   TEST_TTR(float, bool, tag, false);
-   TEST_TTR(float, char, tag, false);
-   TEST_TTR(float, signed char, tag, false);
-   TEST_TTR(float, short int, tag, false);
-   TEST_TTR(float, int, tag, false);
-   TEST_TTR(float, long int, tag, false);
-   TEST_TTR(float, unsigned char, tag, false);
-   TEST_TTR(float, unsigned short int, tag, false);
-   TEST_TTR(float, unsigned int, tag, false);
-   TEST_TTR(float, unsigned long int, tag, false);
-   TEST_TTR(float, wchar_t, tag, false);
-   TEST_TTR(float, float, tag, false);
-   TEST_TTR(float, double, tag, false);
-   TEST_TTR(float, long double, tag, false);
-   TEST_TTR(double, bool, tag, false);
-   TEST_TTR(double, char, tag, false);
-   TEST_TTR(double, signed char, tag, false);
-   TEST_TTR(double, short int, tag, false);
-   TEST_TTR(double, int, tag, false);
-   TEST_TTR(double, long int, tag, false);
-   TEST_TTR(double, unsigned char, tag, false);
-   TEST_TTR(double, unsigned short int, tag, false);
-   TEST_TTR(double, unsigned int, tag, false);
-   TEST_TTR(double, unsigned long int, tag, false);
-   TEST_TTR(double, wchar_t, tag, false);
-   TEST_TTR(double, float, tag, false);
-   TEST_TTR(double, double, tag, false);
-   TEST_TTR(double, long double, tag, false);
-   TEST_TTR(long double, bool, tag, false);
-   TEST_TTR(long double, char, tag, false);
-   TEST_TTR(long double, signed char, tag, false);
-   TEST_TTR(long double, short int, tag, false);
-   TEST_TTR(long double, int, tag, false);
-   TEST_TTR(long double, long int, tag, false);
-   TEST_TTR(long double, unsigned char, tag, false);
-   TEST_TTR(long double, unsigned short int, tag, false);
-   TEST_TTR(long double, unsigned int, tag, false);
-   TEST_TTR(long double, unsigned long int, tag, false);
-   TEST_TTR(long double, wchar_t, tag, false);
-   TEST_TTR(long double, float, tag, false);
-   TEST_TTR(long double, double, tag, false);
-   TEST_TTR(long double, long double, tag, false);
-#	undef CV1
-#	define CV1(T) const T
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), false);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), false);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, false);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), false);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), false);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, false);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const T&
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), false);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), false);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, false);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T&
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T&
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), false);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), false);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, false);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const T
-#	undef CV2
-#	define CV2(T) const T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), false);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), false);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, false);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const T&
-#	undef CV2
-#	define CV2(T) const T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), false);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), false);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, false);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T
-#	undef CV2
-#	define CV2(T) volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T&
-#	undef CV2
-#	define CV2(T) volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T
-#	undef CV2
-#	define CV2(T) const volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), false);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), false);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, false);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T&
-#	undef CV2
-#	define CV2(T) const volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), false);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), false);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, false);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-   // pointers
-   TEST_TT(void*, bool, false);
-   TEST_TT(void*, int, false);
-   TEST_TT(void*, double, false);
-   TEST_TT(void*, A, false);
-   TEST_TT(void*, B, false);
-   TEST_TT(bool*, bool, true);
-   TEST_TT(bool*, int, true);
-   TEST_TT(bool*, double, false);
-   TEST_TT(bool*, A, false);
-   TEST_TT(bool*, B, false);
-   TEST_TT(int*, bool, true);
-   TEST_TT(int*, int, true);
-   TEST_TT(int*, double, false);
-   TEST_TT(int*, A, false);
-   TEST_TT(int*, B, false);
-   TEST_TT(double*, bool, true);
-   TEST_TT(double*, int, true);
-   TEST_TT(double*, double, false);
-   TEST_TT(double*, A, false);
-   TEST_TT(double*, B, false);
-   TEST_TT(A*, bool, true);
-   TEST_TT(A*, int, true);
-   TEST_TT(A*, double, false);
-   TEST_TT(A*, A, false);
-   TEST_TT(A*, B, false);
-   TEST_TT(B*, bool, true);
-   TEST_TT(B*, int, true);
-   TEST_TT(B*, double, false);
-   TEST_TT(B*, A, false);
-   TEST_TT(B*, B, false);
-   TEST_TT(bool, void*, false);
-   TEST_TT(bool, bool*, false);
-   TEST_TT(bool, int*, false);
-   TEST_TT(bool, double*, false);
-   TEST_TT(bool, A*, false);
-   TEST_TT(bool, B*, false);
-   TEST_TT(int, void*, false);
-   TEST_TT(int, bool*, false);
-   TEST_TT(int, int*, false);
-   TEST_TT(int, double*, false);
-   TEST_TT(int, A*, false);
-   TEST_TT(int, B*, false);
-   TEST_TT(double, void*, false);
-   TEST_TT(double, bool*, false);
-   TEST_TT(double, int*, false);
-   TEST_TT(double, double*, false);
-   TEST_TT(double, A*, false);
-   TEST_TT(double, B*, false);
-   TEST_TT(A, void*, false);
-   TEST_TT(A, bool*, false);
-   TEST_TT(A, int*, false);
-   TEST_TT(A, double*, false);
-   TEST_TT(A, A*, false);
-   TEST_TT(A, B*, false);
-   TEST_TT(B, void*, false);
-   TEST_TT(B, bool*, false);
-   TEST_TT(B, int*, false);
-   TEST_TT(B, double*, false);
-   TEST_TT(B, A*, false);
-   TEST_TT(B, B*, false);
-   TEST_TT(void*, void*, false);
-   TEST_TT(void*, bool*, false);
-   TEST_TT(void*, int*, false);
-   TEST_TT(void*, double*, false);
-   TEST_TT(void*, A*, false);
-   TEST_TT(void*, B*, false);
-   TEST_TT(bool*, void*, false);
-   TEST_TT(bool*, bool*, false);
-   TEST_TT(bool*, int*, false);
-   TEST_TT(bool*, double*, false);
-   TEST_TT(bool*, A*, false);
-   TEST_TT(bool*, B*, false);
-   TEST_TT(int*, void*, false);
-   TEST_TT(int*, bool*, false);
-   TEST_TT(int*, int*, false);
-   TEST_TT(int*, double*, false);
-   TEST_TT(int*, A*, false);
-   TEST_TT(int*, B*, false);
-   TEST_TT(double*, void*, false);
-   TEST_TT(double*, bool*, false);
-   TEST_TT(double*, int*, false);
-   TEST_TT(double*, double*, false);
-   TEST_TT(double*, A*, false);
-   TEST_TT(double*, B*, false);
-   TEST_TT(A*, void*, false);
-   TEST_TT(A*, bool*, false);
-   TEST_TT(A*, int*, false);
-   TEST_TT(A*, double*, false);
-   TEST_TT(A*, A*, false);
-   TEST_TT(A*, B*, false);
-   TEST_TT(B*, void*, false);
-   TEST_TT(B*, bool*, false);
-   TEST_TT(B*, int*, false);
-   TEST_TT(B*, double*, false);
-   TEST_TT(B*, A*, false);
-   TEST_TT(B*, B*, false);
-   TEST_TT(C, void*, true);
-   TEST_TT(D, void*, false);
-   TEST_TT(void*, C, false);
-   TEST_TT(void*, D, true);
-   TEST_TT(C, D, true);
-}
-}

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,1250 +0,0 @@
-//  (C) Copyright Frederic Bron 2009-2011.
-//  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)
-
-namespace {
-
-void run2() {
-   // test with only one template parameter
-   TEST_T(void, false);
-   TEST_T(bool, true);
-   TEST_T(char, true);
-   TEST_T(signed char, true);
-   TEST_T(short int, true);
-   TEST_T(int, true);
-   TEST_T(long int, true);
-   TEST_T(unsigned char, true);
-   TEST_T(unsigned short int, true);
-   TEST_T(unsigned int, true);
-   TEST_T(unsigned long int, true);
-   TEST_T(wchar_t, true);
-   TEST_T(float, true);
-   TEST_T(double, true);
-   TEST_T(long double, true);
-   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), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	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), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	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 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);
-   TEST_TT(bool, short int, true);
-   TEST_TT(bool, int, true);
-   TEST_TT(bool, long int, true);
-   TEST_TT(bool, unsigned char, true);
-   TEST_TT(bool, unsigned short int, true);
-   TEST_TT(bool, unsigned int, true);
-   TEST_TT(bool, unsigned long int, true);
-   TEST_TT(bool, wchar_t, true);
-   TEST_TT(bool, float, true);
-   TEST_TT(bool, double, true);
-   TEST_TT(bool, long double, true);
-   TEST_TT(char, bool, true);
-   TEST_TT(char, char, true);
-   TEST_TT(char, signed char, true);
-   TEST_TT(char, short int, true);
-   TEST_TT(char, int, true);
-   TEST_TT(char, long int, true);
-   TEST_TT(char, unsigned char, true);
-   TEST_TT(char, unsigned short int, true);
-   TEST_TT(char, unsigned int, true);
-   TEST_TT(char, unsigned long int, true);
-   TEST_TT(char, wchar_t, true);
-   TEST_TT(char, float, true);
-   TEST_TT(char, double, true);
-   TEST_TT(char, long double, true);
-   TEST_TT(signed char, bool, true);
-   TEST_TT(signed char, char, true);
-   TEST_TT(signed char, signed char, true);
-   TEST_TT(signed char, short int, true);
-   TEST_TT(signed char, int, true);
-   TEST_TT(signed char, long int, true);
-   TEST_TT(signed char, unsigned char, true);
-   TEST_TT(signed char, unsigned short int, true);
-   TEST_TT(signed char, unsigned int, true);
-   TEST_TT(signed char, unsigned long int, true);
-   TEST_TT(signed char, wchar_t, true);
-   TEST_TT(signed char, float, true);
-   TEST_TT(signed char, double, true);
-   TEST_TT(signed char, long double, true);
-   TEST_TT(short int, bool, true);
-   TEST_TT(short int, char, true);
-   TEST_TT(short int, signed char, true);
-   TEST_TT(short int, short int, true);
-   TEST_TT(short int, int, true);
-   TEST_TT(short int, long int, true);
-   TEST_TT(short int, unsigned char, true);
-   TEST_TT(short int, unsigned short int, true);
-   TEST_TT(short int, unsigned int, true);
-   TEST_TT(short int, unsigned long int, true);
-   TEST_TT(short int, wchar_t, true);
-   TEST_TT(short int, float, true);
-   TEST_TT(short int, double, true);
-   TEST_TT(short int, long double, true);
-   TEST_TT(int, bool, true);
-   TEST_TT(int, char, true);
-   TEST_TT(int, signed char, true);
-   TEST_TT(int, short int, true);
-   TEST_TT(int, int, true);
-   TEST_TT(int, long int, true);
-   TEST_TT(int, unsigned char, true);
-   TEST_TT(int, unsigned short int, true);
-   TEST_TT(int, unsigned int, true);
-   TEST_TT(int, unsigned long int, true);
-   TEST_TT(int, wchar_t, true);
-   TEST_TT(int, float, true);
-   TEST_TT(int, double, true);
-   TEST_TT(int, long double, true);
-   TEST_TT(long int, bool, true);
-   TEST_TT(long int, char, true);
-   TEST_TT(long int, signed char, true);
-   TEST_TT(long int, short int, true);
-   TEST_TT(long int, int, true);
-   TEST_TT(long int, long int, true);
-   TEST_TT(long int, unsigned char, true);
-   TEST_TT(long int, unsigned short int, true);
-   TEST_TT(long int, unsigned int, true);
-   TEST_TT(long int, unsigned long int, true);
-   TEST_TT(long int, wchar_t, true);
-   TEST_TT(long int, float, true);
-   TEST_TT(long int, double, true);
-   TEST_TT(long int, long double, true);
-   TEST_TT(unsigned char, bool, true);
-   TEST_TT(unsigned char, char, true);
-   TEST_TT(unsigned char, signed char, true);
-   TEST_TT(unsigned char, short int, true);
-   TEST_TT(unsigned char, int, true);
-   TEST_TT(unsigned char, long int, true);
-   TEST_TT(unsigned char, unsigned char, true);
-   TEST_TT(unsigned char, unsigned short int, true);
-   TEST_TT(unsigned char, unsigned int, true);
-   TEST_TT(unsigned char, unsigned long int, true);
-   TEST_TT(unsigned char, wchar_t, true);
-   TEST_TT(unsigned char, float, true);
-   TEST_TT(unsigned char, double, true);
-   TEST_TT(unsigned char, long double, true);
-   TEST_TT(unsigned short int, bool, true);
-   TEST_TT(unsigned short int, char, true);
-   TEST_TT(unsigned short int, signed char, true);
-   TEST_TT(unsigned short int, short int, true);
-   TEST_TT(unsigned short int, int, true);
-   TEST_TT(unsigned short int, long int, true);
-   TEST_TT(unsigned short int, unsigned char, true);
-   TEST_TT(unsigned short int, unsigned short int, true);
-   TEST_TT(unsigned short int, unsigned int, true);
-   TEST_TT(unsigned short int, unsigned long int, true);
-   TEST_TT(unsigned short int, wchar_t, true);
-   TEST_TT(unsigned short int, float, true);
-   TEST_TT(unsigned short int, double, true);
-   TEST_TT(unsigned short int, long double, true);
-   TEST_TT(unsigned int, bool, true);
-   TEST_TT(unsigned int, char, true);
-   TEST_TT(unsigned int, signed char, true);
-   TEST_TT(unsigned int, short int, true);
-   TEST_TT(unsigned int, int, true);
-   TEST_TT(unsigned int, long int, true);
-   TEST_TT(unsigned int, unsigned char, true);
-   TEST_TT(unsigned int, unsigned short int, true);
-   TEST_TT(unsigned int, unsigned int, true);
-   TEST_TT(unsigned int, unsigned long int, true);
-   TEST_TT(unsigned int, wchar_t, true);
-   TEST_TT(unsigned int, float, true);
-   TEST_TT(unsigned int, double, true);
-   TEST_TT(unsigned int, long double, true);
-   TEST_TT(unsigned long int, bool, true);
-   TEST_TT(unsigned long int, char, true);
-   TEST_TT(unsigned long int, signed char, true);
-   TEST_TT(unsigned long int, short int, true);
-   TEST_TT(unsigned long int, int, true);
-   TEST_TT(unsigned long int, long int, true);
-   TEST_TT(unsigned long int, unsigned char, true);
-   TEST_TT(unsigned long int, unsigned short int, true);
-   TEST_TT(unsigned long int, unsigned int, true);
-   TEST_TT(unsigned long int, unsigned long int, true);
-   TEST_TT(unsigned long int, wchar_t, true);
-   TEST_TT(unsigned long int, float, true);
-   TEST_TT(unsigned long int, double, true);
-   TEST_TT(unsigned long int, long double, true);
-   TEST_TT(wchar_t, bool, true);
-   TEST_TT(wchar_t, char, true);
-   TEST_TT(wchar_t, signed char, true);
-   TEST_TT(wchar_t, short int, true);
-   TEST_TT(wchar_t, int, true);
-   TEST_TT(wchar_t, long int, true);
-   TEST_TT(wchar_t, unsigned char, true);
-   TEST_TT(wchar_t, unsigned short int, true);
-   TEST_TT(wchar_t, unsigned int, true);
-   TEST_TT(wchar_t, unsigned long int, true);
-   TEST_TT(wchar_t, wchar_t, true);
-   TEST_TT(wchar_t, float, true);
-   TEST_TT(wchar_t, double, true);
-   TEST_TT(wchar_t, long double, true);
-   TEST_TT(float, bool, true);
-   TEST_TT(float, char, true);
-   TEST_TT(float, signed char, true);
-   TEST_TT(float, short int, true);
-   TEST_TT(float, int, true);
-   TEST_TT(float, long int, true);
-   TEST_TT(float, unsigned char, true);
-   TEST_TT(float, unsigned short int, true);
-   TEST_TT(float, unsigned int, true);
-   TEST_TT(float, unsigned long int, true);
-   TEST_TT(float, wchar_t, true);
-   TEST_TT(float, float, true);
-   TEST_TT(float, double, true);
-   TEST_TT(float, long double, true);
-   TEST_TT(double, bool, true);
-   TEST_TT(double, char, true);
-   TEST_TT(double, signed char, true);
-   TEST_TT(double, short int, true);
-   TEST_TT(double, int, true);
-   TEST_TT(double, long int, true);
-   TEST_TT(double, unsigned char, true);
-   TEST_TT(double, unsigned short int, true);
-   TEST_TT(double, unsigned int, true);
-   TEST_TT(double, unsigned long int, true);
-   TEST_TT(double, wchar_t, true);
-   TEST_TT(double, float, true);
-   TEST_TT(double, double, true);
-   TEST_TT(double, long double, true);
-   TEST_TT(long double, bool, true);
-   TEST_TT(long double, char, true);
-   TEST_TT(long double, signed char, true);
-   TEST_TT(long double, short int, true);
-   TEST_TT(long double, int, true);
-   TEST_TT(long double, long int, true);
-   TEST_TT(long double, unsigned char, true);
-   TEST_TT(long double, unsigned short int, true);
-   TEST_TT(long double, unsigned int, true);
-   TEST_TT(long double, unsigned long int, true);
-   TEST_TT(long double, wchar_t, true);
-   TEST_TT(long double, float, true);
-   TEST_TT(long double, double, true);
-   TEST_TT(long double, long double, true);
-   TEST_TT(bool, void, false);
-   TEST_TT(void, bool, false);
-   TEST_TT(char, void, false);
-   TEST_TT(void, char, false);
-   TEST_TT(signed char, void, false);
-   TEST_TT(void, signed char, false);
-   TEST_TT(short int, void, false);
-   TEST_TT(void, short int, false);
-   TEST_TT(int, void, false);
-   TEST_TT(void, int, false);
-   TEST_TT(long int, void, false);
-   TEST_TT(void, long int, false);
-   TEST_TT(unsigned char, void, false);
-   TEST_TT(void, unsigned char, false);
-   TEST_TT(unsigned short int, void, false);
-   TEST_TT(void, unsigned short int, false);
-   TEST_TT(unsigned int, void, false);
-   TEST_TT(void, unsigned int, false);
-   TEST_TT(unsigned long int, void, false);
-   TEST_TT(void, unsigned long int, false);
-   TEST_TT(wchar_t, void, false);
-   TEST_TT(void, wchar_t, false);
-   TEST_TT(float, void, false);
-   TEST_TT(void, float, false);
-   TEST_TT(double, void, false);
-   TEST_TT(void, double, false);
-   TEST_TT(long double, void, false);
-   TEST_TT(void, long double, false);
-
-// test with three template parameters
-   TEST_TTR(bool, bool, bool, true);
-   TEST_TTR(bool, char, bool, true);
-   TEST_TTR(bool, signed char, bool, true);
-   TEST_TTR(bool, short int, bool, true);
-   TEST_TTR(bool, int, bool, true);
-   TEST_TTR(bool, long int, bool, true);
-   TEST_TTR(bool, unsigned char, bool, true);
-   TEST_TTR(bool, unsigned short int, bool, true);
-   TEST_TTR(bool, unsigned int, bool, true);
-   TEST_TTR(bool, unsigned long int, bool, true);
-   TEST_TTR(bool, wchar_t, bool, true);
-   TEST_TTR(bool, float, bool, true);
-   TEST_TTR(bool, double, bool, true);
-   TEST_TTR(bool, long double, bool, true);
-   TEST_TTR(char, bool, bool, true);
-   TEST_TTR(char, char, bool, true);
-   TEST_TTR(char, signed char, bool, true);
-   TEST_TTR(char, short int, bool, true);
-   TEST_TTR(char, int, bool, true);
-   TEST_TTR(char, long int, bool, true);
-   TEST_TTR(char, unsigned char, bool, true);
-   TEST_TTR(char, unsigned short int, bool, true);
-   TEST_TTR(char, unsigned int, bool, true);
-   TEST_TTR(char, unsigned long int, bool, true);
-   TEST_TTR(char, wchar_t, bool, true);
-   TEST_TTR(char, float, bool, true);
-   TEST_TTR(char, double, bool, true);
-   TEST_TTR(char, long double, bool, true);
-   TEST_TTR(signed char, bool, bool, true);
-   TEST_TTR(signed char, char, bool, true);
-   TEST_TTR(signed char, signed char, bool, true);
-   TEST_TTR(signed char, short int, bool, true);
-   TEST_TTR(signed char, int, bool, true);
-   TEST_TTR(signed char, long int, bool, true);
-   TEST_TTR(signed char, unsigned char, bool, true);
-   TEST_TTR(signed char, unsigned short int, bool, true);
-   TEST_TTR(signed char, unsigned int, bool, true);
-   TEST_TTR(signed char, unsigned long int, bool, true);
-   TEST_TTR(signed char, wchar_t, bool, true);
-   TEST_TTR(signed char, float, bool, true);
-   TEST_TTR(signed char, double, bool, true);
-   TEST_TTR(signed char, long double, bool, true);
-   TEST_TTR(short int, bool, bool, true);
-   TEST_TTR(short int, char, bool, true);
-   TEST_TTR(short int, signed char, bool, true);
-   TEST_TTR(short int, short int, bool, true);
-   TEST_TTR(short int, int, bool, true);
-   TEST_TTR(short int, long int, bool, true);
-   TEST_TTR(short int, unsigned char, bool, true);
-   TEST_TTR(short int, unsigned short int, bool, true);
-   TEST_TTR(short int, unsigned int, bool, true);
-   TEST_TTR(short int, unsigned long int, bool, true);
-   TEST_TTR(short int, wchar_t, bool, true);
-   TEST_TTR(short int, float, bool, true);
-   TEST_TTR(short int, double, bool, true);
-   TEST_TTR(short int, long double, bool, true);
-   TEST_TTR(int, bool, bool, true);
-   TEST_TTR(int, char, bool, true);
-   TEST_TTR(int, signed char, bool, true);
-   TEST_TTR(int, short int, bool, true);
-   TEST_TTR(int, int, bool, true);
-   TEST_TTR(int, long int, bool, true);
-   TEST_TTR(int, unsigned char, bool, true);
-   TEST_TTR(int, unsigned short int, bool, true);
-   TEST_TTR(int, unsigned int, bool, true);
-   TEST_TTR(int, unsigned long int, bool, true);
-   TEST_TTR(int, wchar_t, bool, true);
-   TEST_TTR(int, float, bool, true);
-   TEST_TTR(int, double, bool, true);
-   TEST_TTR(int, long double, bool, true);
-   TEST_TTR(long int, bool, bool, true);
-   TEST_TTR(long int, char, bool, true);
-   TEST_TTR(long int, signed char, bool, true);
-   TEST_TTR(long int, short int, bool, true);
-   TEST_TTR(long int, int, bool, true);
-   TEST_TTR(long int, long int, bool, true);
-   TEST_TTR(long int, unsigned char, bool, true);
-   TEST_TTR(long int, unsigned short int, bool, true);
-   TEST_TTR(long int, unsigned int, bool, true);
-   TEST_TTR(long int, unsigned long int, bool, true);
-   TEST_TTR(long int, wchar_t, bool, true);
-   TEST_TTR(long int, float, bool, true);
-   TEST_TTR(long int, double, bool, true);
-   TEST_TTR(long int, long double, bool, true);
-   TEST_TTR(unsigned char, bool, bool, true);
-   TEST_TTR(unsigned char, char, bool, true);
-   TEST_TTR(unsigned char, signed char, bool, true);
-   TEST_TTR(unsigned char, short int, bool, true);
-   TEST_TTR(unsigned char, int, bool, true);
-   TEST_TTR(unsigned char, long int, bool, true);
-   TEST_TTR(unsigned char, unsigned char, bool, true);
-   TEST_TTR(unsigned char, unsigned short int, bool, true);
-   TEST_TTR(unsigned char, unsigned int, bool, true);
-   TEST_TTR(unsigned char, unsigned long int, bool, true);
-   TEST_TTR(unsigned char, wchar_t, bool, true);
-   TEST_TTR(unsigned char, float, bool, true);
-   TEST_TTR(unsigned char, double, bool, true);
-   TEST_TTR(unsigned char, long double, bool, true);
-   TEST_TTR(unsigned short int, bool, bool, true);
-   TEST_TTR(unsigned short int, char, bool, true);
-   TEST_TTR(unsigned short int, signed char, bool, true);
-   TEST_TTR(unsigned short int, short int, bool, true);
-   TEST_TTR(unsigned short int, int, bool, true);
-   TEST_TTR(unsigned short int, long int, bool, true);
-   TEST_TTR(unsigned short int, unsigned char, bool, true);
-   TEST_TTR(unsigned short int, unsigned short int, bool, true);
-   TEST_TTR(unsigned short int, unsigned int, bool, true);
-   TEST_TTR(unsigned short int, unsigned long int, bool, true);
-   TEST_TTR(unsigned short int, wchar_t, bool, true);
-   TEST_TTR(unsigned short int, float, bool, true);
-   TEST_TTR(unsigned short int, double, bool, true);
-   TEST_TTR(unsigned short int, long double, bool, true);
-   TEST_TTR(unsigned int, bool, bool, true);
-   TEST_TTR(unsigned int, char, bool, true);
-   TEST_TTR(unsigned int, signed char, bool, true);
-   TEST_TTR(unsigned int, short int, bool, true);
-   TEST_TTR(unsigned int, int, bool, true);
-   TEST_TTR(unsigned int, long int, bool, true);
-   TEST_TTR(unsigned int, unsigned char, bool, true);
-   TEST_TTR(unsigned int, unsigned short int, bool, true);
-   TEST_TTR(unsigned int, unsigned int, bool, true);
-   TEST_TTR(unsigned int, unsigned long int, bool, true);
-   TEST_TTR(unsigned int, wchar_t, bool, true);
-   TEST_TTR(unsigned int, float, bool, true);
-   TEST_TTR(unsigned int, double, bool, true);
-   TEST_TTR(unsigned int, long double, bool, true);
-   TEST_TTR(unsigned long int, bool, bool, true);
-   TEST_TTR(unsigned long int, char, bool, true);
-   TEST_TTR(unsigned long int, signed char, bool, true);
-   TEST_TTR(unsigned long int, short int, bool, true);
-   TEST_TTR(unsigned long int, int, bool, true);
-   TEST_TTR(unsigned long int, long int, bool, true);
-   TEST_TTR(unsigned long int, unsigned char, bool, true);
-   TEST_TTR(unsigned long int, unsigned short int, bool, true);
-   TEST_TTR(unsigned long int, unsigned int, bool, true);
-   TEST_TTR(unsigned long int, unsigned long int, bool, true);
-   TEST_TTR(unsigned long int, wchar_t, bool, true);
-   TEST_TTR(unsigned long int, float, bool, true);
-   TEST_TTR(unsigned long int, double, bool, true);
-   TEST_TTR(unsigned long int, long double, bool, true);
-   TEST_TTR(wchar_t, bool, bool, true);
-   TEST_TTR(wchar_t, char, bool, true);
-   TEST_TTR(wchar_t, signed char, bool, true);
-   TEST_TTR(wchar_t, short int, bool, true);
-   TEST_TTR(wchar_t, int, bool, true);
-   TEST_TTR(wchar_t, long int, bool, true);
-   TEST_TTR(wchar_t, unsigned char, bool, true);
-   TEST_TTR(wchar_t, unsigned short int, bool, true);
-   TEST_TTR(wchar_t, unsigned int, bool, true);
-   TEST_TTR(wchar_t, unsigned long int, bool, true);
-   TEST_TTR(wchar_t, wchar_t, bool, true);
-   TEST_TTR(wchar_t, float, bool, true);
-   TEST_TTR(wchar_t, double, bool, true);
-   TEST_TTR(wchar_t, long double, bool, true);
-   TEST_TTR(float, bool, bool, true);
-   TEST_TTR(float, char, bool, true);
-   TEST_TTR(float, signed char, bool, true);
-   TEST_TTR(float, short int, bool, true);
-   TEST_TTR(float, int, bool, true);
-   TEST_TTR(float, long int, bool, true);
-   TEST_TTR(float, unsigned char, bool, true);
-   TEST_TTR(float, unsigned short int, bool, true);
-   TEST_TTR(float, unsigned int, bool, true);
-   TEST_TTR(float, unsigned long int, bool, true);
-   TEST_TTR(float, wchar_t, bool, true);
-   TEST_TTR(float, float, bool, true);
-   TEST_TTR(float, double, bool, true);
-   TEST_TTR(float, long double, bool, true);
-   TEST_TTR(double, bool, bool, true);
-   TEST_TTR(double, char, bool, true);
-   TEST_TTR(double, signed char, bool, true);
-   TEST_TTR(double, short int, bool, true);
-   TEST_TTR(double, int, bool, true);
-   TEST_TTR(double, long int, bool, true);
-   TEST_TTR(double, unsigned char, bool, true);
-   TEST_TTR(double, unsigned short int, bool, true);
-   TEST_TTR(double, unsigned int, bool, true);
-   TEST_TTR(double, unsigned long int, bool, true);
-   TEST_TTR(double, wchar_t, bool, true);
-   TEST_TTR(double, float, bool, true);
-   TEST_TTR(double, double, bool, true);
-   TEST_TTR(double, long double, bool, true);
-   TEST_TTR(long double, bool, bool, true);
-   TEST_TTR(long double, char, bool, true);
-   TEST_TTR(long double, signed char, bool, true);
-   TEST_TTR(long double, short int, bool, true);
-   TEST_TTR(long double, int, bool, true);
-   TEST_TTR(long double, long int, bool, true);
-   TEST_TTR(long double, unsigned char, bool, true);
-   TEST_TTR(long double, unsigned short int, bool, true);
-   TEST_TTR(long double, unsigned int, bool, true);
-   TEST_TTR(long double, unsigned long int, bool, true);
-   TEST_TTR(long double, wchar_t, bool, true);
-   TEST_TTR(long double, float, bool, true);
-   TEST_TTR(long double, double, bool, true);
-   TEST_TTR(long double, long double, bool, true);
-   TEST_TTR(bool, bool, tag, false);
-   TEST_TTR(bool, char, tag, false);
-   TEST_TTR(bool, signed char, tag, false);
-   TEST_TTR(bool, short int, tag, false);
-   TEST_TTR(bool, int, tag, false);
-   TEST_TTR(bool, long int, tag, false);
-   TEST_TTR(bool, unsigned char, tag, false);
-   TEST_TTR(bool, unsigned short int, tag, false);
-   TEST_TTR(bool, unsigned int, tag, false);
-   TEST_TTR(bool, unsigned long int, tag, false);
-   TEST_TTR(bool, wchar_t, tag, false);
-   TEST_TTR(bool, float, tag, false);
-   TEST_TTR(bool, double, tag, false);
-   TEST_TTR(bool, long double, tag, false);
-   TEST_TTR(char, bool, tag, false);
-   TEST_TTR(char, char, tag, false);
-   TEST_TTR(char, signed char, tag, false);
-   TEST_TTR(char, short int, tag, false);
-   TEST_TTR(char, int, tag, false);
-   TEST_TTR(char, long int, tag, false);
-   TEST_TTR(char, unsigned char, tag, false);
-   TEST_TTR(char, unsigned short int, tag, false);
-   TEST_TTR(char, unsigned int, tag, false);
-   TEST_TTR(char, unsigned long int, tag, false);
-   TEST_TTR(char, wchar_t, tag, false);
-   TEST_TTR(char, float, tag, false);
-   TEST_TTR(char, double, tag, false);
-   TEST_TTR(char, long double, tag, false);
-   TEST_TTR(signed char, bool, tag, false);
-   TEST_TTR(signed char, char, tag, false);
-   TEST_TTR(signed char, signed char, tag, false);
-   TEST_TTR(signed char, short int, tag, false);
-   TEST_TTR(signed char, int, tag, false);
-   TEST_TTR(signed char, long int, tag, false);
-   TEST_TTR(signed char, unsigned char, tag, false);
-   TEST_TTR(signed char, unsigned short int, tag, false);
-   TEST_TTR(signed char, unsigned int, tag, false);
-   TEST_TTR(signed char, unsigned long int, tag, false);
-   TEST_TTR(signed char, wchar_t, tag, false);
-   TEST_TTR(signed char, float, tag, false);
-   TEST_TTR(signed char, double, tag, false);
-   TEST_TTR(signed char, long double, tag, false);
-   TEST_TTR(short int, bool, tag, false);
-   TEST_TTR(short int, char, tag, false);
-   TEST_TTR(short int, signed char, tag, false);
-   TEST_TTR(short int, short int, tag, false);
-   TEST_TTR(short int, int, tag, false);
-   TEST_TTR(short int, long int, tag, false);
-   TEST_TTR(short int, unsigned char, tag, false);
-   TEST_TTR(short int, unsigned short int, tag, false);
-   TEST_TTR(short int, unsigned int, tag, false);
-   TEST_TTR(short int, unsigned long int, tag, false);
-   TEST_TTR(short int, wchar_t, tag, false);
-   TEST_TTR(short int, float, tag, false);
-   TEST_TTR(short int, double, tag, false);
-   TEST_TTR(short int, long double, tag, false);
-   TEST_TTR(int, bool, tag, false);
-   TEST_TTR(int, char, tag, false);
-   TEST_TTR(int, signed char, tag, false);
-   TEST_TTR(int, short int, tag, false);
-   TEST_TTR(int, int, tag, false);
-   TEST_TTR(int, long int, tag, false);
-   TEST_TTR(int, unsigned char, tag, false);
-   TEST_TTR(int, unsigned short int, tag, false);
-   TEST_TTR(int, unsigned int, tag, false);
-   TEST_TTR(int, unsigned long int, tag, false);
-   TEST_TTR(int, wchar_t, tag, false);
-   TEST_TTR(int, float, tag, false);
-   TEST_TTR(int, double, tag, false);
-   TEST_TTR(int, long double, tag, false);
-   TEST_TTR(long int, bool, tag, false);
-   TEST_TTR(long int, char, tag, false);
-   TEST_TTR(long int, signed char, tag, false);
-   TEST_TTR(long int, short int, tag, false);
-   TEST_TTR(long int, int, tag, false);
-   TEST_TTR(long int, long int, tag, false);
-   TEST_TTR(long int, unsigned char, tag, false);
-   TEST_TTR(long int, unsigned short int, tag, false);
-   TEST_TTR(long int, unsigned int, tag, false);
-   TEST_TTR(long int, unsigned long int, tag, false);
-   TEST_TTR(long int, wchar_t, tag, false);
-   TEST_TTR(long int, float, tag, false);
-   TEST_TTR(long int, double, tag, false);
-   TEST_TTR(long int, long double, tag, false);
-   TEST_TTR(unsigned char, bool, tag, false);
-   TEST_TTR(unsigned char, char, tag, false);
-   TEST_TTR(unsigned char, signed char, tag, false);
-   TEST_TTR(unsigned char, short int, tag, false);
-   TEST_TTR(unsigned char, int, tag, false);
-   TEST_TTR(unsigned char, long int, tag, false);
-   TEST_TTR(unsigned char, unsigned char, tag, false);
-   TEST_TTR(unsigned char, unsigned short int, tag, false);
-   TEST_TTR(unsigned char, unsigned int, tag, false);
-   TEST_TTR(unsigned char, unsigned long int, tag, false);
-   TEST_TTR(unsigned char, wchar_t, tag, false);
-   TEST_TTR(unsigned char, float, tag, false);
-   TEST_TTR(unsigned char, double, tag, false);
-   TEST_TTR(unsigned char, long double, tag, false);
-   TEST_TTR(unsigned short int, bool, tag, false);
-   TEST_TTR(unsigned short int, char, tag, false);
-   TEST_TTR(unsigned short int, signed char, tag, false);
-   TEST_TTR(unsigned short int, short int, tag, false);
-   TEST_TTR(unsigned short int, int, tag, false);
-   TEST_TTR(unsigned short int, long int, tag, false);
-   TEST_TTR(unsigned short int, unsigned char, tag, false);
-   TEST_TTR(unsigned short int, unsigned short int, tag, false);
-   TEST_TTR(unsigned short int, unsigned int, tag, false);
-   TEST_TTR(unsigned short int, unsigned long int, tag, false);
-   TEST_TTR(unsigned short int, wchar_t, tag, false);
-   TEST_TTR(unsigned short int, float, tag, false);
-   TEST_TTR(unsigned short int, double, tag, false);
-   TEST_TTR(unsigned short int, long double, tag, false);
-   TEST_TTR(unsigned int, bool, tag, false);
-   TEST_TTR(unsigned int, char, tag, false);
-   TEST_TTR(unsigned int, signed char, tag, false);
-   TEST_TTR(unsigned int, short int, tag, false);
-   TEST_TTR(unsigned int, int, tag, false);
-   TEST_TTR(unsigned int, long int, tag, false);
-   TEST_TTR(unsigned int, unsigned char, tag, false);
-   TEST_TTR(unsigned int, unsigned short int, tag, false);
-   TEST_TTR(unsigned int, unsigned int, tag, false);
-   TEST_TTR(unsigned int, unsigned long int, tag, false);
-   TEST_TTR(unsigned int, wchar_t, tag, false);
-   TEST_TTR(unsigned int, float, tag, false);
-   TEST_TTR(unsigned int, double, tag, false);
-   TEST_TTR(unsigned int, long double, tag, false);
-   TEST_TTR(unsigned long int, bool, tag, false);
-   TEST_TTR(unsigned long int, char, tag, false);
-   TEST_TTR(unsigned long int, signed char, tag, false);
-   TEST_TTR(unsigned long int, short int, tag, false);
-   TEST_TTR(unsigned long int, int, tag, false);
-   TEST_TTR(unsigned long int, long int, tag, false);
-   TEST_TTR(unsigned long int, unsigned char, tag, false);
-   TEST_TTR(unsigned long int, unsigned short int, tag, false);
-   TEST_TTR(unsigned long int, unsigned int, tag, false);
-   TEST_TTR(unsigned long int, unsigned long int, tag, false);
-   TEST_TTR(unsigned long int, wchar_t, tag, false);
-   TEST_TTR(unsigned long int, float, tag, false);
-   TEST_TTR(unsigned long int, double, tag, false);
-   TEST_TTR(unsigned long int, long double, tag, false);
-   TEST_TTR(wchar_t, bool, tag, false);
-   TEST_TTR(wchar_t, char, tag, false);
-   TEST_TTR(wchar_t, signed char, tag, false);
-   TEST_TTR(wchar_t, short int, tag, false);
-   TEST_TTR(wchar_t, int, tag, false);
-   TEST_TTR(wchar_t, long int, tag, false);
-   TEST_TTR(wchar_t, unsigned char, tag, false);
-   TEST_TTR(wchar_t, unsigned short int, tag, false);
-   TEST_TTR(wchar_t, unsigned int, tag, false);
-   TEST_TTR(wchar_t, unsigned long int, tag, false);
-   TEST_TTR(wchar_t, wchar_t, tag, false);
-   TEST_TTR(wchar_t, float, tag, false);
-   TEST_TTR(wchar_t, double, tag, false);
-   TEST_TTR(wchar_t, long double, tag, false);
-   TEST_TTR(float, bool, tag, false);
-   TEST_TTR(float, char, tag, false);
-   TEST_TTR(float, signed char, tag, false);
-   TEST_TTR(float, short int, tag, false);
-   TEST_TTR(float, int, tag, false);
-   TEST_TTR(float, long int, tag, false);
-   TEST_TTR(float, unsigned char, tag, false);
-   TEST_TTR(float, unsigned short int, tag, false);
-   TEST_TTR(float, unsigned int, tag, false);
-   TEST_TTR(float, unsigned long int, tag, false);
-   TEST_TTR(float, wchar_t, tag, false);
-   TEST_TTR(float, float, tag, false);
-   TEST_TTR(float, double, tag, false);
-   TEST_TTR(float, long double, tag, false);
-   TEST_TTR(double, bool, tag, false);
-   TEST_TTR(double, char, tag, false);
-   TEST_TTR(double, signed char, tag, false);
-   TEST_TTR(double, short int, tag, false);
-   TEST_TTR(double, int, tag, false);
-   TEST_TTR(double, long int, tag, false);
-   TEST_TTR(double, unsigned char, tag, false);
-   TEST_TTR(double, unsigned short int, tag, false);
-   TEST_TTR(double, unsigned int, tag, false);
-   TEST_TTR(double, unsigned long int, tag, false);
-   TEST_TTR(double, wchar_t, tag, false);
-   TEST_TTR(double, float, tag, false);
-   TEST_TTR(double, double, tag, false);
-   TEST_TTR(double, long double, tag, false);
-   TEST_TTR(long double, bool, tag, false);
-   TEST_TTR(long double, char, tag, false);
-   TEST_TTR(long double, signed char, tag, false);
-   TEST_TTR(long double, short int, tag, false);
-   TEST_TTR(long double, int, tag, false);
-   TEST_TTR(long double, long int, tag, false);
-   TEST_TTR(long double, unsigned char, tag, false);
-   TEST_TTR(long double, unsigned short int, tag, false);
-   TEST_TTR(long double, unsigned int, tag, false);
-   TEST_TTR(long double, unsigned long int, tag, false);
-   TEST_TTR(long double, wchar_t, tag, false);
-   TEST_TTR(long double, float, tag, false);
-   TEST_TTR(long double, double, tag, false);
-   TEST_TTR(long double, long double, tag, false);
-#	undef CV1
-#	define CV1(T) const T
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), false);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), false);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, false);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), false);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), false);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, false);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const T&
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), false);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), false);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, false);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T&
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T&
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), false);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), false);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, false);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const T
-#	undef CV2
-#	define CV2(T) const T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), false);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), false);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, false);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const T&
-#	undef CV2
-#	define CV2(T) const T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), false);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), false);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, false);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T
-#	undef CV2
-#	define CV2(T) volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T&
-#	undef CV2
-#	define CV2(T) volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T
-#	undef CV2
-#	define CV2(T) const volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), false);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), false);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, false);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T&
-#	undef CV2
-#	define CV2(T) const volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), false);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), false);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, false);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-   // pointers
-   TEST_TT(void*, bool, false);
-   TEST_TT(void*, int, false);
-   TEST_TT(void*, double, false);
-   TEST_TT(void*, A, false);
-   TEST_TT(void*, B, false);
-   TEST_TT(bool*, bool, false);
-   TEST_TT(bool*, int, false);
-   TEST_TT(bool*, double, false);
-   TEST_TT(bool*, A, false);
-   TEST_TT(bool*, B, false);
-   TEST_TT(int*, bool, false);
-   TEST_TT(int*, int, false);
-   TEST_TT(int*, double, false);
-   TEST_TT(int*, A, false);
-   TEST_TT(int*, B, false);
-   TEST_TT(double*, bool, false);
-   TEST_TT(double*, int, false);
-   TEST_TT(double*, double, false);
-   TEST_TT(double*, A, false);
-   TEST_TT(double*, B, false);
-   TEST_TT(A*, bool, false);
-   TEST_TT(A*, int, false);
-   TEST_TT(A*, double, false);
-   TEST_TT(A*, A, false);
-   TEST_TT(A*, B, false);
-   TEST_TT(B*, bool, false);
-   TEST_TT(B*, int, false);
-   TEST_TT(B*, double, false);
-   TEST_TT(B*, A, false);
-   TEST_TT(B*, B, false);
-   TEST_TT(bool, void*, false);
-   TEST_TT(bool, bool*, false);
-   TEST_TT(bool, int*, false);
-   TEST_TT(bool, double*, false);
-   TEST_TT(bool, A*, false);
-   TEST_TT(bool, B*, false);
-   TEST_TT(int, void*, false);
-   TEST_TT(int, bool*, false);
-   TEST_TT(int, int*, false);
-   TEST_TT(int, double*, false);
-   TEST_TT(int, A*, false);
-   TEST_TT(int, B*, false);
-   TEST_TT(double, void*, false);
-   TEST_TT(double, bool*, false);
-   TEST_TT(double, int*, false);
-   TEST_TT(double, double*, false);
-   TEST_TT(double, A*, false);
-   TEST_TT(double, B*, false);
-   TEST_TT(A, void*, false);
-   TEST_TT(A, bool*, false);
-   TEST_TT(A, int*, false);
-   TEST_TT(A, double*, false);
-   TEST_TT(A, A*, false);
-   TEST_TT(A, B*, false);
-   TEST_TT(B, void*, false);
-   TEST_TT(B, bool*, false);
-   TEST_TT(B, int*, false);
-   TEST_TT(B, double*, false);
-   TEST_TT(B, A*, false);
-   TEST_TT(B, B*, false);
-   TEST_TT(void*, void*, false);
-   TEST_TT(void*, bool*, false);
-   TEST_TT(void*, int*, false);
-   TEST_TT(void*, double*, false);
-   TEST_TT(void*, A*, false);
-   TEST_TT(void*, B*, false);
-   TEST_TT(bool*, void*, false);
-   TEST_TT(bool*, bool*, false);
-   TEST_TT(bool*, int*, false);
-   TEST_TT(bool*, double*, false);
-   TEST_TT(bool*, A*, false);
-   TEST_TT(bool*, B*, false);
-   TEST_TT(int*, void*, false);
-   TEST_TT(int*, bool*, false);
-   TEST_TT(int*, int*, false);
-   TEST_TT(int*, double*, false);
-   TEST_TT(int*, A*, false);
-   TEST_TT(int*, B*, false);
-   TEST_TT(double*, void*, false);
-   TEST_TT(double*, bool*, false);
-   TEST_TT(double*, int*, false);
-   TEST_TT(double*, double*, false);
-   TEST_TT(double*, A*, false);
-   TEST_TT(double*, B*, false);
-   TEST_TT(A*, void*, false);
-   TEST_TT(A*, bool*, false);
-   TEST_TT(A*, int*, false);
-   TEST_TT(A*, double*, false);
-   TEST_TT(A*, A*, false);
-   TEST_TT(A*, B*, false);
-   TEST_TT(B*, void*, false);
-   TEST_TT(B*, bool*, false);
-   TEST_TT(B*, int*, false);
-   TEST_TT(B*, double*, false);
-   TEST_TT(B*, A*, false);
-   TEST_TT(B*, B*, false);
-   TEST_TT(C, void*, true);
-   TEST_TT(D, void*, false);
-   TEST_TT(void*, C, false);
-   TEST_TT(void*, D, true);
-   TEST_TT(C, D, true);
-}
-}

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,1250 +0,0 @@
-//  (C) Copyright Frederic Bron 2009-2011.
-//  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)
-
-namespace {
-
-void run2() {
-   // test with only one template parameter
-   TEST_T(void, false);
-   TEST_T(bool, true);
-   TEST_T(char, true);
-   TEST_T(signed char, true);
-   TEST_T(short int, true);
-   TEST_T(int, true);
-   TEST_T(long int, true);
-   TEST_T(unsigned char, true);
-   TEST_T(unsigned short int, true);
-   TEST_T(unsigned int, true);
-   TEST_T(unsigned long int, true);
-   TEST_T(wchar_t, true);
-   TEST_T(float, true);
-   TEST_T(double, true);
-   TEST_T(long double, true);
-   TEST_T(void, false);
-#	undef CV
-#	define CV(T) const T
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	undef CV
-#	define CV(T) volatile T
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	undef CV
-#	define CV(T) const volatile T
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	undef CV
-#	define CV(T) const T&
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	undef CV
-#	define CV(T) volatile T&
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	undef CV
-#	define CV(T) const volatile T&
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   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);
-   TEST_TT(bool, short int, true);
-   TEST_TT(bool, int, true);
-   TEST_TT(bool, long int, true);
-   TEST_TT(bool, unsigned char, true);
-   TEST_TT(bool, unsigned short int, true);
-   TEST_TT(bool, unsigned int, true);
-   TEST_TT(bool, unsigned long int, true);
-   TEST_TT(bool, wchar_t, true);
-   TEST_TT(bool, float, true);
-   TEST_TT(bool, double, true);
-   TEST_TT(bool, long double, true);
-   TEST_TT(char, bool, true);
-   TEST_TT(char, char, true);
-   TEST_TT(char, signed char, true);
-   TEST_TT(char, short int, true);
-   TEST_TT(char, int, true);
-   TEST_TT(char, long int, true);
-   TEST_TT(char, unsigned char, true);
-   TEST_TT(char, unsigned short int, true);
-   TEST_TT(char, unsigned int, true);
-   TEST_TT(char, unsigned long int, true);
-   TEST_TT(char, wchar_t, true);
-   TEST_TT(char, float, true);
-   TEST_TT(char, double, true);
-   TEST_TT(char, long double, true);
-   TEST_TT(signed char, bool, true);
-   TEST_TT(signed char, char, true);
-   TEST_TT(signed char, signed char, true);
-   TEST_TT(signed char, short int, true);
-   TEST_TT(signed char, int, true);
-   TEST_TT(signed char, long int, true);
-   TEST_TT(signed char, unsigned char, true);
-   TEST_TT(signed char, unsigned short int, true);
-   TEST_TT(signed char, unsigned int, true);
-   TEST_TT(signed char, unsigned long int, true);
-   TEST_TT(signed char, wchar_t, true);
-   TEST_TT(signed char, float, true);
-   TEST_TT(signed char, double, true);
-   TEST_TT(signed char, long double, true);
-   TEST_TT(short int, bool, true);
-   TEST_TT(short int, char, true);
-   TEST_TT(short int, signed char, true);
-   TEST_TT(short int, short int, true);
-   TEST_TT(short int, int, true);
-   TEST_TT(short int, long int, true);
-   TEST_TT(short int, unsigned char, true);
-   TEST_TT(short int, unsigned short int, true);
-   TEST_TT(short int, unsigned int, true);
-   TEST_TT(short int, unsigned long int, true);
-   TEST_TT(short int, wchar_t, true);
-   TEST_TT(short int, float, true);
-   TEST_TT(short int, double, true);
-   TEST_TT(short int, long double, true);
-   TEST_TT(int, bool, true);
-   TEST_TT(int, char, true);
-   TEST_TT(int, signed char, true);
-   TEST_TT(int, short int, true);
-   TEST_TT(int, int, true);
-   TEST_TT(int, long int, true);
-   TEST_TT(int, unsigned char, true);
-   TEST_TT(int, unsigned short int, true);
-   TEST_TT(int, unsigned int, true);
-   TEST_TT(int, unsigned long int, true);
-   TEST_TT(int, wchar_t, true);
-   TEST_TT(int, float, true);
-   TEST_TT(int, double, true);
-   TEST_TT(int, long double, true);
-   TEST_TT(long int, bool, true);
-   TEST_TT(long int, char, true);
-   TEST_TT(long int, signed char, true);
-   TEST_TT(long int, short int, true);
-   TEST_TT(long int, int, true);
-   TEST_TT(long int, long int, true);
-   TEST_TT(long int, unsigned char, true);
-   TEST_TT(long int, unsigned short int, true);
-   TEST_TT(long int, unsigned int, true);
-   TEST_TT(long int, unsigned long int, true);
-   TEST_TT(long int, wchar_t, true);
-   TEST_TT(long int, float, true);
-   TEST_TT(long int, double, true);
-   TEST_TT(long int, long double, true);
-   TEST_TT(unsigned char, bool, true);
-   TEST_TT(unsigned char, char, true);
-   TEST_TT(unsigned char, signed char, true);
-   TEST_TT(unsigned char, short int, true);
-   TEST_TT(unsigned char, int, true);
-   TEST_TT(unsigned char, long int, true);
-   TEST_TT(unsigned char, unsigned char, true);
-   TEST_TT(unsigned char, unsigned short int, true);
-   TEST_TT(unsigned char, unsigned int, true);
-   TEST_TT(unsigned char, unsigned long int, true);
-   TEST_TT(unsigned char, wchar_t, true);
-   TEST_TT(unsigned char, float, true);
-   TEST_TT(unsigned char, double, true);
-   TEST_TT(unsigned char, long double, true);
-   TEST_TT(unsigned short int, bool, true);
-   TEST_TT(unsigned short int, char, true);
-   TEST_TT(unsigned short int, signed char, true);
-   TEST_TT(unsigned short int, short int, true);
-   TEST_TT(unsigned short int, int, true);
-   TEST_TT(unsigned short int, long int, true);
-   TEST_TT(unsigned short int, unsigned char, true);
-   TEST_TT(unsigned short int, unsigned short int, true);
-   TEST_TT(unsigned short int, unsigned int, true);
-   TEST_TT(unsigned short int, unsigned long int, true);
-   TEST_TT(unsigned short int, wchar_t, true);
-   TEST_TT(unsigned short int, float, true);
-   TEST_TT(unsigned short int, double, true);
-   TEST_TT(unsigned short int, long double, true);
-   TEST_TT(unsigned int, bool, true);
-   TEST_TT(unsigned int, char, true);
-   TEST_TT(unsigned int, signed char, true);
-   TEST_TT(unsigned int, short int, true);
-   TEST_TT(unsigned int, int, true);
-   TEST_TT(unsigned int, long int, true);
-   TEST_TT(unsigned int, unsigned char, true);
-   TEST_TT(unsigned int, unsigned short int, true);
-   TEST_TT(unsigned int, unsigned int, true);
-   TEST_TT(unsigned int, unsigned long int, true);
-   TEST_TT(unsigned int, wchar_t, true);
-   TEST_TT(unsigned int, float, true);
-   TEST_TT(unsigned int, double, true);
-   TEST_TT(unsigned int, long double, true);
-   TEST_TT(unsigned long int, bool, true);
-   TEST_TT(unsigned long int, char, true);
-   TEST_TT(unsigned long int, signed char, true);
-   TEST_TT(unsigned long int, short int, true);
-   TEST_TT(unsigned long int, int, true);
-   TEST_TT(unsigned long int, long int, true);
-   TEST_TT(unsigned long int, unsigned char, true);
-   TEST_TT(unsigned long int, unsigned short int, true);
-   TEST_TT(unsigned long int, unsigned int, true);
-   TEST_TT(unsigned long int, unsigned long int, true);
-   TEST_TT(unsigned long int, wchar_t, true);
-   TEST_TT(unsigned long int, float, true);
-   TEST_TT(unsigned long int, double, true);
-   TEST_TT(unsigned long int, long double, true);
-   TEST_TT(wchar_t, bool, true);
-   TEST_TT(wchar_t, char, true);
-   TEST_TT(wchar_t, signed char, true);
-   TEST_TT(wchar_t, short int, true);
-   TEST_TT(wchar_t, int, true);
-   TEST_TT(wchar_t, long int, true);
-   TEST_TT(wchar_t, unsigned char, true);
-   TEST_TT(wchar_t, unsigned short int, true);
-   TEST_TT(wchar_t, unsigned int, true);
-   TEST_TT(wchar_t, unsigned long int, true);
-   TEST_TT(wchar_t, wchar_t, true);
-   TEST_TT(wchar_t, float, true);
-   TEST_TT(wchar_t, double, true);
-   TEST_TT(wchar_t, long double, true);
-   TEST_TT(float, bool, true);
-   TEST_TT(float, char, true);
-   TEST_TT(float, signed char, true);
-   TEST_TT(float, short int, true);
-   TEST_TT(float, int, true);
-   TEST_TT(float, long int, true);
-   TEST_TT(float, unsigned char, true);
-   TEST_TT(float, unsigned short int, true);
-   TEST_TT(float, unsigned int, true);
-   TEST_TT(float, unsigned long int, true);
-   TEST_TT(float, wchar_t, true);
-   TEST_TT(float, float, true);
-   TEST_TT(float, double, true);
-   TEST_TT(float, long double, true);
-   TEST_TT(double, bool, true);
-   TEST_TT(double, char, true);
-   TEST_TT(double, signed char, true);
-   TEST_TT(double, short int, true);
-   TEST_TT(double, int, true);
-   TEST_TT(double, long int, true);
-   TEST_TT(double, unsigned char, true);
-   TEST_TT(double, unsigned short int, true);
-   TEST_TT(double, unsigned int, true);
-   TEST_TT(double, unsigned long int, true);
-   TEST_TT(double, wchar_t, true);
-   TEST_TT(double, float, true);
-   TEST_TT(double, double, true);
-   TEST_TT(double, long double, true);
-   TEST_TT(long double, bool, true);
-   TEST_TT(long double, char, true);
-   TEST_TT(long double, signed char, true);
-   TEST_TT(long double, short int, true);
-   TEST_TT(long double, int, true);
-   TEST_TT(long double, long int, true);
-   TEST_TT(long double, unsigned char, true);
-   TEST_TT(long double, unsigned short int, true);
-   TEST_TT(long double, unsigned int, true);
-   TEST_TT(long double, unsigned long int, true);
-   TEST_TT(long double, wchar_t, true);
-   TEST_TT(long double, float, true);
-   TEST_TT(long double, double, true);
-   TEST_TT(long double, long double, true);
-   TEST_TT(bool, void, false);
-   TEST_TT(void, bool, false);
-   TEST_TT(char, void, false);
-   TEST_TT(void, char, false);
-   TEST_TT(signed char, void, false);
-   TEST_TT(void, signed char, false);
-   TEST_TT(short int, void, false);
-   TEST_TT(void, short int, false);
-   TEST_TT(int, void, false);
-   TEST_TT(void, int, false);
-   TEST_TT(long int, void, false);
-   TEST_TT(void, long int, false);
-   TEST_TT(unsigned char, void, false);
-   TEST_TT(void, unsigned char, false);
-   TEST_TT(unsigned short int, void, false);
-   TEST_TT(void, unsigned short int, false);
-   TEST_TT(unsigned int, void, false);
-   TEST_TT(void, unsigned int, false);
-   TEST_TT(unsigned long int, void, false);
-   TEST_TT(void, unsigned long int, false);
-   TEST_TT(wchar_t, void, false);
-   TEST_TT(void, wchar_t, false);
-   TEST_TT(float, void, false);
-   TEST_TT(void, float, false);
-   TEST_TT(double, void, false);
-   TEST_TT(void, double, false);
-   TEST_TT(long double, void, false);
-   TEST_TT(void, long double, false);
-
-// test with three template parameters
-   TEST_TTR(bool, bool, bool, true);
-   TEST_TTR(bool, char, bool, true);
-   TEST_TTR(bool, signed char, bool, true);
-   TEST_TTR(bool, short int, bool, true);
-   TEST_TTR(bool, int, bool, true);
-   TEST_TTR(bool, long int, bool, true);
-   TEST_TTR(bool, unsigned char, bool, true);
-   TEST_TTR(bool, unsigned short int, bool, true);
-   TEST_TTR(bool, unsigned int, bool, true);
-   TEST_TTR(bool, unsigned long int, bool, true);
-   TEST_TTR(bool, wchar_t, bool, true);
-   TEST_TTR(bool, float, bool, true);
-   TEST_TTR(bool, double, bool, true);
-   TEST_TTR(bool, long double, bool, true);
-   TEST_TTR(char, bool, bool, true);
-   TEST_TTR(char, char, bool, true);
-   TEST_TTR(char, signed char, bool, true);
-   TEST_TTR(char, short int, bool, true);
-   TEST_TTR(char, int, bool, true);
-   TEST_TTR(char, long int, bool, true);
-   TEST_TTR(char, unsigned char, bool, true);
-   TEST_TTR(char, unsigned short int, bool, true);
-   TEST_TTR(char, unsigned int, bool, true);
-   TEST_TTR(char, unsigned long int, bool, true);
-   TEST_TTR(char, wchar_t, bool, true);
-   TEST_TTR(char, float, bool, true);
-   TEST_TTR(char, double, bool, true);
-   TEST_TTR(char, long double, bool, true);
-   TEST_TTR(signed char, bool, bool, true);
-   TEST_TTR(signed char, char, bool, true);
-   TEST_TTR(signed char, signed char, bool, true);
-   TEST_TTR(signed char, short int, bool, true);
-   TEST_TTR(signed char, int, bool, true);
-   TEST_TTR(signed char, long int, bool, true);
-   TEST_TTR(signed char, unsigned char, bool, true);
-   TEST_TTR(signed char, unsigned short int, bool, true);
-   TEST_TTR(signed char, unsigned int, bool, true);
-   TEST_TTR(signed char, unsigned long int, bool, true);
-   TEST_TTR(signed char, wchar_t, bool, true);
-   TEST_TTR(signed char, float, bool, true);
-   TEST_TTR(signed char, double, bool, true);
-   TEST_TTR(signed char, long double, bool, true);
-   TEST_TTR(short int, bool, bool, true);
-   TEST_TTR(short int, char, bool, true);
-   TEST_TTR(short int, signed char, bool, true);
-   TEST_TTR(short int, short int, bool, true);
-   TEST_TTR(short int, int, bool, true);
-   TEST_TTR(short int, long int, bool, true);
-   TEST_TTR(short int, unsigned char, bool, true);
-   TEST_TTR(short int, unsigned short int, bool, true);
-   TEST_TTR(short int, unsigned int, bool, true);
-   TEST_TTR(short int, unsigned long int, bool, true);
-   TEST_TTR(short int, wchar_t, bool, true);
-   TEST_TTR(short int, float, bool, true);
-   TEST_TTR(short int, double, bool, true);
-   TEST_TTR(short int, long double, bool, true);
-   TEST_TTR(int, bool, bool, true);
-   TEST_TTR(int, char, bool, true);
-   TEST_TTR(int, signed char, bool, true);
-   TEST_TTR(int, short int, bool, true);
-   TEST_TTR(int, int, bool, true);
-   TEST_TTR(int, long int, bool, true);
-   TEST_TTR(int, unsigned char, bool, true);
-   TEST_TTR(int, unsigned short int, bool, true);
-   TEST_TTR(int, unsigned int, bool, true);
-   TEST_TTR(int, unsigned long int, bool, true);
-   TEST_TTR(int, wchar_t, bool, true);
-   TEST_TTR(int, float, bool, true);
-   TEST_TTR(int, double, bool, true);
-   TEST_TTR(int, long double, bool, true);
-   TEST_TTR(long int, bool, bool, true);
-   TEST_TTR(long int, char, bool, true);
-   TEST_TTR(long int, signed char, bool, true);
-   TEST_TTR(long int, short int, bool, true);
-   TEST_TTR(long int, int, bool, true);
-   TEST_TTR(long int, long int, bool, true);
-   TEST_TTR(long int, unsigned char, bool, true);
-   TEST_TTR(long int, unsigned short int, bool, true);
-   TEST_TTR(long int, unsigned int, bool, true);
-   TEST_TTR(long int, unsigned long int, bool, true);
-   TEST_TTR(long int, wchar_t, bool, true);
-   TEST_TTR(long int, float, bool, true);
-   TEST_TTR(long int, double, bool, true);
-   TEST_TTR(long int, long double, bool, true);
-   TEST_TTR(unsigned char, bool, bool, true);
-   TEST_TTR(unsigned char, char, bool, true);
-   TEST_TTR(unsigned char, signed char, bool, true);
-   TEST_TTR(unsigned char, short int, bool, true);
-   TEST_TTR(unsigned char, int, bool, true);
-   TEST_TTR(unsigned char, long int, bool, true);
-   TEST_TTR(unsigned char, unsigned char, bool, true);
-   TEST_TTR(unsigned char, unsigned short int, bool, true);
-   TEST_TTR(unsigned char, unsigned int, bool, true);
-   TEST_TTR(unsigned char, unsigned long int, bool, true);
-   TEST_TTR(unsigned char, wchar_t, bool, true);
-   TEST_TTR(unsigned char, float, bool, true);
-   TEST_TTR(unsigned char, double, bool, true);
-   TEST_TTR(unsigned char, long double, bool, true);
-   TEST_TTR(unsigned short int, bool, bool, true);
-   TEST_TTR(unsigned short int, char, bool, true);
-   TEST_TTR(unsigned short int, signed char, bool, true);
-   TEST_TTR(unsigned short int, short int, bool, true);
-   TEST_TTR(unsigned short int, int, bool, true);
-   TEST_TTR(unsigned short int, long int, bool, true);
-   TEST_TTR(unsigned short int, unsigned char, bool, true);
-   TEST_TTR(unsigned short int, unsigned short int, bool, true);
-   TEST_TTR(unsigned short int, unsigned int, bool, true);
-   TEST_TTR(unsigned short int, unsigned long int, bool, true);
-   TEST_TTR(unsigned short int, wchar_t, bool, true);
-   TEST_TTR(unsigned short int, float, bool, true);
-   TEST_TTR(unsigned short int, double, bool, true);
-   TEST_TTR(unsigned short int, long double, bool, true);
-   TEST_TTR(unsigned int, bool, bool, true);
-   TEST_TTR(unsigned int, char, bool, true);
-   TEST_TTR(unsigned int, signed char, bool, true);
-   TEST_TTR(unsigned int, short int, bool, true);
-   TEST_TTR(unsigned int, int, bool, true);
-   TEST_TTR(unsigned int, long int, bool, true);
-   TEST_TTR(unsigned int, unsigned char, bool, true);
-   TEST_TTR(unsigned int, unsigned short int, bool, true);
-   TEST_TTR(unsigned int, unsigned int, bool, true);
-   TEST_TTR(unsigned int, unsigned long int, bool, true);
-   TEST_TTR(unsigned int, wchar_t, bool, true);
-   TEST_TTR(unsigned int, float, bool, true);
-   TEST_TTR(unsigned int, double, bool, true);
-   TEST_TTR(unsigned int, long double, bool, true);
-   TEST_TTR(unsigned long int, bool, bool, true);
-   TEST_TTR(unsigned long int, char, bool, true);
-   TEST_TTR(unsigned long int, signed char, bool, true);
-   TEST_TTR(unsigned long int, short int, bool, true);
-   TEST_TTR(unsigned long int, int, bool, true);
-   TEST_TTR(unsigned long int, long int, bool, true);
-   TEST_TTR(unsigned long int, unsigned char, bool, true);
-   TEST_TTR(unsigned long int, unsigned short int, bool, true);
-   TEST_TTR(unsigned long int, unsigned int, bool, true);
-   TEST_TTR(unsigned long int, unsigned long int, bool, true);
-   TEST_TTR(unsigned long int, wchar_t, bool, true);
-   TEST_TTR(unsigned long int, float, bool, true);
-   TEST_TTR(unsigned long int, double, bool, true);
-   TEST_TTR(unsigned long int, long double, bool, true);
-   TEST_TTR(wchar_t, bool, bool, true);
-   TEST_TTR(wchar_t, char, bool, true);
-   TEST_TTR(wchar_t, signed char, bool, true);
-   TEST_TTR(wchar_t, short int, bool, true);
-   TEST_TTR(wchar_t, int, bool, true);
-   TEST_TTR(wchar_t, long int, bool, true);
-   TEST_TTR(wchar_t, unsigned char, bool, true);
-   TEST_TTR(wchar_t, unsigned short int, bool, true);
-   TEST_TTR(wchar_t, unsigned int, bool, true);
-   TEST_TTR(wchar_t, unsigned long int, bool, true);
-   TEST_TTR(wchar_t, wchar_t, bool, true);
-   TEST_TTR(wchar_t, float, bool, true);
-   TEST_TTR(wchar_t, double, bool, true);
-   TEST_TTR(wchar_t, long double, bool, true);
-   TEST_TTR(float, bool, bool, true);
-   TEST_TTR(float, char, bool, true);
-   TEST_TTR(float, signed char, bool, true);
-   TEST_TTR(float, short int, bool, true);
-   TEST_TTR(float, int, bool, true);
-   TEST_TTR(float, long int, bool, true);
-   TEST_TTR(float, unsigned char, bool, true);
-   TEST_TTR(float, unsigned short int, bool, true);
-   TEST_TTR(float, unsigned int, bool, true);
-   TEST_TTR(float, unsigned long int, bool, true);
-   TEST_TTR(float, wchar_t, bool, true);
-   TEST_TTR(float, float, bool, true);
-   TEST_TTR(float, double, bool, true);
-   TEST_TTR(float, long double, bool, true);
-   TEST_TTR(double, bool, bool, true);
-   TEST_TTR(double, char, bool, true);
-   TEST_TTR(double, signed char, bool, true);
-   TEST_TTR(double, short int, bool, true);
-   TEST_TTR(double, int, bool, true);
-   TEST_TTR(double, long int, bool, true);
-   TEST_TTR(double, unsigned char, bool, true);
-   TEST_TTR(double, unsigned short int, bool, true);
-   TEST_TTR(double, unsigned int, bool, true);
-   TEST_TTR(double, unsigned long int, bool, true);
-   TEST_TTR(double, wchar_t, bool, true);
-   TEST_TTR(double, float, bool, true);
-   TEST_TTR(double, double, bool, true);
-   TEST_TTR(double, long double, bool, true);
-   TEST_TTR(long double, bool, bool, true);
-   TEST_TTR(long double, char, bool, true);
-   TEST_TTR(long double, signed char, bool, true);
-   TEST_TTR(long double, short int, bool, true);
-   TEST_TTR(long double, int, bool, true);
-   TEST_TTR(long double, long int, bool, true);
-   TEST_TTR(long double, unsigned char, bool, true);
-   TEST_TTR(long double, unsigned short int, bool, true);
-   TEST_TTR(long double, unsigned int, bool, true);
-   TEST_TTR(long double, unsigned long int, bool, true);
-   TEST_TTR(long double, wchar_t, bool, true);
-   TEST_TTR(long double, float, bool, true);
-   TEST_TTR(long double, double, bool, true);
-   TEST_TTR(long double, long double, bool, true);
-   TEST_TTR(bool, bool, tag, false);
-   TEST_TTR(bool, char, tag, false);
-   TEST_TTR(bool, signed char, tag, false);
-   TEST_TTR(bool, short int, tag, false);
-   TEST_TTR(bool, int, tag, false);
-   TEST_TTR(bool, long int, tag, false);
-   TEST_TTR(bool, unsigned char, tag, false);
-   TEST_TTR(bool, unsigned short int, tag, false);
-   TEST_TTR(bool, unsigned int, tag, false);
-   TEST_TTR(bool, unsigned long int, tag, false);
-   TEST_TTR(bool, wchar_t, tag, false);
-   TEST_TTR(bool, float, tag, false);
-   TEST_TTR(bool, double, tag, false);
-   TEST_TTR(bool, long double, tag, false);
-   TEST_TTR(char, bool, tag, false);
-   TEST_TTR(char, char, tag, false);
-   TEST_TTR(char, signed char, tag, false);
-   TEST_TTR(char, short int, tag, false);
-   TEST_TTR(char, int, tag, false);
-   TEST_TTR(char, long int, tag, false);
-   TEST_TTR(char, unsigned char, tag, false);
-   TEST_TTR(char, unsigned short int, tag, false);
-   TEST_TTR(char, unsigned int, tag, false);
-   TEST_TTR(char, unsigned long int, tag, false);
-   TEST_TTR(char, wchar_t, tag, false);
-   TEST_TTR(char, float, tag, false);
-   TEST_TTR(char, double, tag, false);
-   TEST_TTR(char, long double, tag, false);
-   TEST_TTR(signed char, bool, tag, false);
-   TEST_TTR(signed char, char, tag, false);
-   TEST_TTR(signed char, signed char, tag, false);
-   TEST_TTR(signed char, short int, tag, false);
-   TEST_TTR(signed char, int, tag, false);
-   TEST_TTR(signed char, long int, tag, false);
-   TEST_TTR(signed char, unsigned char, tag, false);
-   TEST_TTR(signed char, unsigned short int, tag, false);
-   TEST_TTR(signed char, unsigned int, tag, false);
-   TEST_TTR(signed char, unsigned long int, tag, false);
-   TEST_TTR(signed char, wchar_t, tag, false);
-   TEST_TTR(signed char, float, tag, false);
-   TEST_TTR(signed char, double, tag, false);
-   TEST_TTR(signed char, long double, tag, false);
-   TEST_TTR(short int, bool, tag, false);
-   TEST_TTR(short int, char, tag, false);
-   TEST_TTR(short int, signed char, tag, false);
-   TEST_TTR(short int, short int, tag, false);
-   TEST_TTR(short int, int, tag, false);
-   TEST_TTR(short int, long int, tag, false);
-   TEST_TTR(short int, unsigned char, tag, false);
-   TEST_TTR(short int, unsigned short int, tag, false);
-   TEST_TTR(short int, unsigned int, tag, false);
-   TEST_TTR(short int, unsigned long int, tag, false);
-   TEST_TTR(short int, wchar_t, tag, false);
-   TEST_TTR(short int, float, tag, false);
-   TEST_TTR(short int, double, tag, false);
-   TEST_TTR(short int, long double, tag, false);
-   TEST_TTR(int, bool, tag, false);
-   TEST_TTR(int, char, tag, false);
-   TEST_TTR(int, signed char, tag, false);
-   TEST_TTR(int, short int, tag, false);
-   TEST_TTR(int, int, tag, false);
-   TEST_TTR(int, long int, tag, false);
-   TEST_TTR(int, unsigned char, tag, false);
-   TEST_TTR(int, unsigned short int, tag, false);
-   TEST_TTR(int, unsigned int, tag, false);
-   TEST_TTR(int, unsigned long int, tag, false);
-   TEST_TTR(int, wchar_t, tag, false);
-   TEST_TTR(int, float, tag, false);
-   TEST_TTR(int, double, tag, false);
-   TEST_TTR(int, long double, tag, false);
-   TEST_TTR(long int, bool, tag, false);
-   TEST_TTR(long int, char, tag, false);
-   TEST_TTR(long int, signed char, tag, false);
-   TEST_TTR(long int, short int, tag, false);
-   TEST_TTR(long int, int, tag, false);
-   TEST_TTR(long int, long int, tag, false);
-   TEST_TTR(long int, unsigned char, tag, false);
-   TEST_TTR(long int, unsigned short int, tag, false);
-   TEST_TTR(long int, unsigned int, tag, false);
-   TEST_TTR(long int, unsigned long int, tag, false);
-   TEST_TTR(long int, wchar_t, tag, false);
-   TEST_TTR(long int, float, tag, false);
-   TEST_TTR(long int, double, tag, false);
-   TEST_TTR(long int, long double, tag, false);
-   TEST_TTR(unsigned char, bool, tag, false);
-   TEST_TTR(unsigned char, char, tag, false);
-   TEST_TTR(unsigned char, signed char, tag, false);
-   TEST_TTR(unsigned char, short int, tag, false);
-   TEST_TTR(unsigned char, int, tag, false);
-   TEST_TTR(unsigned char, long int, tag, false);
-   TEST_TTR(unsigned char, unsigned char, tag, false);
-   TEST_TTR(unsigned char, unsigned short int, tag, false);
-   TEST_TTR(unsigned char, unsigned int, tag, false);
-   TEST_TTR(unsigned char, unsigned long int, tag, false);
-   TEST_TTR(unsigned char, wchar_t, tag, false);
-   TEST_TTR(unsigned char, float, tag, false);
-   TEST_TTR(unsigned char, double, tag, false);
-   TEST_TTR(unsigned char, long double, tag, false);
-   TEST_TTR(unsigned short int, bool, tag, false);
-   TEST_TTR(unsigned short int, char, tag, false);
-   TEST_TTR(unsigned short int, signed char, tag, false);
-   TEST_TTR(unsigned short int, short int, tag, false);
-   TEST_TTR(unsigned short int, int, tag, false);
-   TEST_TTR(unsigned short int, long int, tag, false);
-   TEST_TTR(unsigned short int, unsigned char, tag, false);
-   TEST_TTR(unsigned short int, unsigned short int, tag, false);
-   TEST_TTR(unsigned short int, unsigned int, tag, false);
-   TEST_TTR(unsigned short int, unsigned long int, tag, false);
-   TEST_TTR(unsigned short int, wchar_t, tag, false);
-   TEST_TTR(unsigned short int, float, tag, false);
-   TEST_TTR(unsigned short int, double, tag, false);
-   TEST_TTR(unsigned short int, long double, tag, false);
-   TEST_TTR(unsigned int, bool, tag, false);
-   TEST_TTR(unsigned int, char, tag, false);
-   TEST_TTR(unsigned int, signed char, tag, false);
-   TEST_TTR(unsigned int, short int, tag, false);
-   TEST_TTR(unsigned int, int, tag, false);
-   TEST_TTR(unsigned int, long int, tag, false);
-   TEST_TTR(unsigned int, unsigned char, tag, false);
-   TEST_TTR(unsigned int, unsigned short int, tag, false);
-   TEST_TTR(unsigned int, unsigned int, tag, false);
-   TEST_TTR(unsigned int, unsigned long int, tag, false);
-   TEST_TTR(unsigned int, wchar_t, tag, false);
-   TEST_TTR(unsigned int, float, tag, false);
-   TEST_TTR(unsigned int, double, tag, false);
-   TEST_TTR(unsigned int, long double, tag, false);
-   TEST_TTR(unsigned long int, bool, tag, false);
-   TEST_TTR(unsigned long int, char, tag, false);
-   TEST_TTR(unsigned long int, signed char, tag, false);
-   TEST_TTR(unsigned long int, short int, tag, false);
-   TEST_TTR(unsigned long int, int, tag, false);
-   TEST_TTR(unsigned long int, long int, tag, false);
-   TEST_TTR(unsigned long int, unsigned char, tag, false);
-   TEST_TTR(unsigned long int, unsigned short int, tag, false);
-   TEST_TTR(unsigned long int, unsigned int, tag, false);
-   TEST_TTR(unsigned long int, unsigned long int, tag, false);
-   TEST_TTR(unsigned long int, wchar_t, tag, false);
-   TEST_TTR(unsigned long int, float, tag, false);
-   TEST_TTR(unsigned long int, double, tag, false);
-   TEST_TTR(unsigned long int, long double, tag, false);
-   TEST_TTR(wchar_t, bool, tag, false);
-   TEST_TTR(wchar_t, char, tag, false);
-   TEST_TTR(wchar_t, signed char, tag, false);
-   TEST_TTR(wchar_t, short int, tag, false);
-   TEST_TTR(wchar_t, int, tag, false);
-   TEST_TTR(wchar_t, long int, tag, false);
-   TEST_TTR(wchar_t, unsigned char, tag, false);
-   TEST_TTR(wchar_t, unsigned short int, tag, false);
-   TEST_TTR(wchar_t, unsigned int, tag, false);
-   TEST_TTR(wchar_t, unsigned long int, tag, false);
-   TEST_TTR(wchar_t, wchar_t, tag, false);
-   TEST_TTR(wchar_t, float, tag, false);
-   TEST_TTR(wchar_t, double, tag, false);
-   TEST_TTR(wchar_t, long double, tag, false);
-   TEST_TTR(float, bool, tag, false);
-   TEST_TTR(float, char, tag, false);
-   TEST_TTR(float, signed char, tag, false);
-   TEST_TTR(float, short int, tag, false);
-   TEST_TTR(float, int, tag, false);
-   TEST_TTR(float, long int, tag, false);
-   TEST_TTR(float, unsigned char, tag, false);
-   TEST_TTR(float, unsigned short int, tag, false);
-   TEST_TTR(float, unsigned int, tag, false);
-   TEST_TTR(float, unsigned long int, tag, false);
-   TEST_TTR(float, wchar_t, tag, false);
-   TEST_TTR(float, float, tag, false);
-   TEST_TTR(float, double, tag, false);
-   TEST_TTR(float, long double, tag, false);
-   TEST_TTR(double, bool, tag, false);
-   TEST_TTR(double, char, tag, false);
-   TEST_TTR(double, signed char, tag, false);
-   TEST_TTR(double, short int, tag, false);
-   TEST_TTR(double, int, tag, false);
-   TEST_TTR(double, long int, tag, false);
-   TEST_TTR(double, unsigned char, tag, false);
-   TEST_TTR(double, unsigned short int, tag, false);
-   TEST_TTR(double, unsigned int, tag, false);
-   TEST_TTR(double, unsigned long int, tag, false);
-   TEST_TTR(double, wchar_t, tag, false);
-   TEST_TTR(double, float, tag, false);
-   TEST_TTR(double, double, tag, false);
-   TEST_TTR(double, long double, tag, false);
-   TEST_TTR(long double, bool, tag, false);
-   TEST_TTR(long double, char, tag, false);
-   TEST_TTR(long double, signed char, tag, false);
-   TEST_TTR(long double, short int, tag, false);
-   TEST_TTR(long double, int, tag, false);
-   TEST_TTR(long double, long int, tag, false);
-   TEST_TTR(long double, unsigned char, tag, false);
-   TEST_TTR(long double, unsigned short int, tag, false);
-   TEST_TTR(long double, unsigned int, tag, false);
-   TEST_TTR(long double, unsigned long int, tag, false);
-   TEST_TTR(long double, wchar_t, tag, false);
-   TEST_TTR(long double, float, tag, false);
-   TEST_TTR(long double, double, tag, false);
-   TEST_TTR(long double, long double, tag, false);
-#	undef CV1
-#	define CV1(T) const T
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const T&
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T&
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T&
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const T
-#	undef CV2
-#	define CV2(T) const T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const T&
-#	undef CV2
-#	define CV2(T) const T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T
-#	undef CV2
-#	define CV2(T) volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T&
-#	undef CV2
-#	define CV2(T) volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T
-#	undef CV2
-#	define CV2(T) const volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T&
-#	undef CV2
-#	define CV2(T) const volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-   // pointers
-   TEST_TT(void*, bool, false);
-   TEST_TT(void*, int, false);
-   TEST_TT(void*, double, false);
-   TEST_TT(void*, A, false);
-   TEST_TT(void*, B, false);
-   TEST_TT(bool*, bool, false);
-   TEST_TT(bool*, int, false);
-   TEST_TT(bool*, double, false);
-   TEST_TT(bool*, A, false);
-   TEST_TT(bool*, B, false);
-   TEST_TT(int*, bool, false);
-   TEST_TT(int*, int, false);
-   TEST_TT(int*, double, false);
-   TEST_TT(int*, A, false);
-   TEST_TT(int*, B, false);
-   TEST_TT(double*, bool, false);
-   TEST_TT(double*, int, false);
-   TEST_TT(double*, double, false);
-   TEST_TT(double*, A, false);
-   TEST_TT(double*, B, false);
-   TEST_TT(A*, bool, false);
-   TEST_TT(A*, int, false);
-   TEST_TT(A*, double, false);
-   TEST_TT(A*, A, false);
-   TEST_TT(A*, B, false);
-   TEST_TT(B*, bool, false);
-   TEST_TT(B*, int, false);
-   TEST_TT(B*, double, false);
-   TEST_TT(B*, A, false);
-   TEST_TT(B*, B, false);
-   TEST_TT(bool, void*, false);
-   TEST_TT(bool, bool*, false);
-   TEST_TT(bool, int*, false);
-   TEST_TT(bool, double*, false);
-   TEST_TT(bool, A*, false);
-   TEST_TT(bool, B*, false);
-   TEST_TT(int, void*, false);
-   TEST_TT(int, bool*, false);
-   TEST_TT(int, int*, false);
-   TEST_TT(int, double*, false);
-   TEST_TT(int, A*, false);
-   TEST_TT(int, B*, false);
-   TEST_TT(double, void*, false);
-   TEST_TT(double, bool*, false);
-   TEST_TT(double, int*, false);
-   TEST_TT(double, double*, false);
-   TEST_TT(double, A*, false);
-   TEST_TT(double, B*, false);
-   TEST_TT(A, void*, false);
-   TEST_TT(A, bool*, false);
-   TEST_TT(A, int*, false);
-   TEST_TT(A, double*, false);
-   TEST_TT(A, A*, false);
-   TEST_TT(A, B*, false);
-   TEST_TT(B, void*, false);
-   TEST_TT(B, bool*, false);
-   TEST_TT(B, int*, false);
-   TEST_TT(B, double*, false);
-   TEST_TT(B, A*, false);
-   TEST_TT(B, B*, false);
-   TEST_TT(void*, void*, false);
-   TEST_TT(void*, bool*, false);
-   TEST_TT(void*, int*, false);
-   TEST_TT(void*, double*, false);
-   TEST_TT(void*, A*, false);
-   TEST_TT(void*, B*, false);
-   TEST_TT(bool*, void*, false);
-   TEST_TT(bool*, bool*, false);
-   TEST_TT(bool*, int*, false);
-   TEST_TT(bool*, double*, false);
-   TEST_TT(bool*, A*, false);
-   TEST_TT(bool*, B*, false);
-   TEST_TT(int*, void*, false);
-   TEST_TT(int*, bool*, false);
-   TEST_TT(int*, int*, false);
-   TEST_TT(int*, double*, false);
-   TEST_TT(int*, A*, false);
-   TEST_TT(int*, B*, false);
-   TEST_TT(double*, void*, false);
-   TEST_TT(double*, bool*, false);
-   TEST_TT(double*, int*, false);
-   TEST_TT(double*, double*, false);
-   TEST_TT(double*, A*, false);
-   TEST_TT(double*, B*, false);
-   TEST_TT(A*, void*, false);
-   TEST_TT(A*, bool*, false);
-   TEST_TT(A*, int*, false);
-   TEST_TT(A*, double*, false);
-   TEST_TT(A*, A*, false);
-   TEST_TT(A*, B*, false);
-   TEST_TT(B*, void*, false);
-   TEST_TT(B*, bool*, false);
-   TEST_TT(B*, int*, false);
-   TEST_TT(B*, double*, false);
-   TEST_TT(B*, A*, false);
-   TEST_TT(B*, B*, false);
-   TEST_TT(C, void*, true);
-   TEST_TT(D, void*, false);
-   TEST_TT(void*, C, false);
-   TEST_TT(void*, D, true);
-   TEST_TT(C, D, true);
-}
-}

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_bit_and_equal_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_bit_and_equal_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,33 +0,0 @@
-//  (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_bit_and_equal.hpp>
-#endif
-
-#define BOOST_TT_TRAIT_NAME has_operator_bit_and_equal
-#define BOOST_TT_TRAIT_OP &=
-
-#include "has_binary_operator_test.hpp"
-#include "has_integral_no_constlhs_operator_test.hpp"
-
-namespace {
-void specific() {
-   /* nothing specific */
-}
-}
-
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_bit_and_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_bit_and_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,33 +0,0 @@
-//  (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_bit_and.hpp>
-#endif
-
-#define BOOST_TT_TRAIT_NAME has_operator_bit_and
-#define BOOST_TT_TRAIT_OP &
-
-#include "has_binary_operator_test.hpp"
-#include "has_integral_operator_test.hpp"
-
-namespace {
-void specific() {
-   /* nothing specific */
-}
-}
-
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_bit_or_equal_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_bit_or_equal_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,33 +0,0 @@
-//  (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_bit_or_equal.hpp>
-#endif
-
-#define BOOST_TT_TRAIT_NAME has_operator_bit_or_equal
-#define BOOST_TT_TRAIT_OP |=
-
-#include "has_binary_operator_test.hpp"
-#include "has_integral_no_constlhs_operator_test.hpp"
-
-namespace {
-void specific() {
-   /* nothing specific */
-}
-}
-
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_bit_or_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_bit_or_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,33 +0,0 @@
-//  (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_bit_or.hpp>
-#endif
-
-#define BOOST_TT_TRAIT_NAME has_operator_bit_or
-#define BOOST_TT_TRAIT_OP |
-
-#include "has_binary_operator_test.hpp"
-#include "has_integral_operator_test.hpp"
-
-namespace {
-void specific() {
-   /* nothing specific */
-}
-}
-
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_bit_xor_equal_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_bit_xor_equal_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,33 +0,0 @@
-//  (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_bit_xor_equal.hpp>
-#endif
-
-#define BOOST_TT_TRAIT_NAME has_operator_bit_xor_equal
-#define BOOST_TT_TRAIT_OP ^=
-
-#include "has_binary_operator_test.hpp"
-#include "has_integral_no_constlhs_operator_test.hpp"
-
-namespace {
-void specific() {
-   /* nothing specific */
-}
-}
-
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_bit_xor_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_bit_xor_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,33 +0,0 @@
-//  (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_bit_xor.hpp>
-#endif
-
-#define BOOST_TT_TRAIT_NAME has_operator_bit_xor
-#define BOOST_TT_TRAIT_OP ^
-
-#include "has_binary_operator_test.hpp"
-#include "has_integral_operator_test.hpp"
-
-namespace {
-void specific() {
-   /* nothing specific */
-}
-}
-
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_complement_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_complement_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,33 +0,0 @@
-//  (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_complement.hpp>
-#endif
-
-#define BOOST_TT_TRAIT_NAME has_operator_complement
-#define BOOST_TT_TRAIT_OP ~
-
-#include "has_prefix_operator_test.hpp"
-#include "has_prefix_complement_operator_test.hpp"
-
-namespace {
-void specific() {
-   /* nothing specific */
-}
-}
-
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_dereference_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_dereference_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,33 +0,0 @@
-//  (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_prefix_operator_test.hpp"
-#include "has_dereference_operator_test.hpp"
-
-namespace {
-void specific() {
-   /* nothing specific */
-}
-}
-
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_divides_equal_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_divides_equal_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,33 +0,0 @@
-//  (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_divides_equal.hpp>
-#endif
-
-#define BOOST_TT_TRAIT_NAME has_operator_divides_equal
-#define BOOST_TT_TRAIT_OP /=
-
-#include "has_binary_operator_test.hpp"
-#include "has_no_pointer_no_constlhs_operator_test.hpp"
-
-namespace {
-void specific() {
-   /* nothing specific */
-}
-}
-
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_divides_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_divides_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,33 +0,0 @@
-//  (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_divides.hpp>
-#endif
-
-#define BOOST_TT_TRAIT_NAME has_operator_divides
-#define BOOST_TT_TRAIT_OP /
-
-#include "has_binary_operator_test.hpp"
-#include "has_no_pointer_operator_test.hpp"
-
-namespace {
-void specific() {
-   /* nothing specific */
-}
-}
-
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_equal_to_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_equal_to_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,33 +0,0 @@
-//  (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_equal_to.hpp>
-#endif
-
-#define BOOST_TT_TRAIT_NAME has_operator_equal_to
-#define BOOST_TT_TRAIT_OP ==
-
-#include "has_binary_operator_test.hpp"
-#include "has_comparison_operator_test.hpp"
-
-namespace {
-void specific() {
-   /* nothing specific */
-}
-}
-
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_greater_equal_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_greater_equal_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,33 +0,0 @@
-//  (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_greater_equal.hpp>
-#endif
-
-#define BOOST_TT_TRAIT_NAME has_operator_greater_equal
-#define BOOST_TT_TRAIT_OP >=
-
-#include "has_binary_operator_test.hpp"
-#include "has_comparison_operator_test.hpp"
-
-namespace {
-void specific() {
-   /* nothing specific */
-}
-}
-
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_greater_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_greater_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,33 +0,0 @@
-//  (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_greater.hpp>
-#endif
-
-#define BOOST_TT_TRAIT_NAME has_operator_greater
-#define BOOST_TT_TRAIT_OP >
-
-#include "has_binary_operator_test.hpp"
-#include "has_comparison_operator_test.hpp"
-
-namespace {
-void specific() {
-   /* nothing specific */
-}
-}
-
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_left_shift_equal_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_left_shift_equal_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,33 +0,0 @@
-//  (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_left_shift_equal.hpp>
-#endif
-
-#define BOOST_TT_TRAIT_NAME has_operator_left_shift_equal
-#define BOOST_TT_TRAIT_OP <<=
-
-#include "has_binary_operator_test.hpp"
-#include "has_integral_no_constlhs_operator_test.hpp"
-
-namespace {
-void specific() {
-   /* nothing specific */
-}
-}
-
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_left_shift_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_left_shift_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,56 +0,0 @@
-//  (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_left_shift.hpp>
-#endif
-
-#define BOOST_TT_TRAIT_NAME has_operator_left_shift
-#define BOOST_TT_TRAIT_OP <<
-
-#include "has_binary_operator_test.hpp"
-#include "has_integral_operator_test.hpp"
-
-#include <ostream>
-#include <string>
-
-#define TEST_SPECIFIC(T) TEST_TTR(std::ostream&, T, std::ostream&, true)
-namespace {
-
-void specific() {
-   TEST_SPECIFIC(long);
-   TEST_SPECIFIC(unsigned long);
-   TEST_SPECIFIC(bool);
-   TEST_SPECIFIC(short);
-   TEST_SPECIFIC(unsigned short);
-   TEST_SPECIFIC(int);
-   TEST_SPECIFIC(unsigned int);
-   TEST_SPECIFIC(double);
-   TEST_SPECIFIC(float);
-   TEST_SPECIFIC(void*);
-   TEST_SPECIFIC(char);
-   TEST_SPECIFIC(signed char);
-   TEST_SPECIFIC(unsigned char);
-   TEST_SPECIFIC(const char*);
-   TEST_SPECIFIC(char*);
-   TEST_SPECIFIC(const signed char*);
-   TEST_SPECIFIC(signed char*);
-   TEST_SPECIFIC(const unsigned char*);
-   TEST_SPECIFIC(unsigned char*);
-   TEST_SPECIFIC(std::string);
-}
-}
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_less_equal_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_less_equal_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,33 +0,0 @@
-//  (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_less_equal.hpp>
-#endif
-
-#define BOOST_TT_TRAIT_NAME has_operator_less_equal
-#define BOOST_TT_TRAIT_OP <=
-
-#include "has_binary_operator_test.hpp"
-#include "has_comparison_operator_test.hpp"
-
-namespace {
-void specific() {
-   /* nothing specific */
-}
-}
-
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_less_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_less_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,33 +0,0 @@
-//  (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_less.hpp>
-#endif
-
-#define BOOST_TT_TRAIT_NAME has_operator_less
-#define BOOST_TT_TRAIT_OP <
-
-#include "has_binary_operator_test.hpp"
-#include "has_comparison_operator_test.hpp"
-
-namespace {
-void specific() {
-   /* nothing specific */
-}
-}
-
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_logical_and_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_logical_and_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,33 +0,0 @@
-//  (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_logical_and.hpp>
-#endif
-
-#define BOOST_TT_TRAIT_NAME has_operator_logical_and
-#define BOOST_TT_TRAIT_OP &&
-
-#include "has_binary_operator_test.hpp"
-#include "has_binary_logical_operator_test.hpp"
-
-namespace {
-void specific() {
-   /* nothing specific */
-}
-}
-
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_logical_not_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_logical_not_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,35 +0,0 @@
-//  (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_logical_not.hpp>
-#endif
-
-#define BOOST_TT_TRAIT_NAME has_operator_logical_not
-#define BOOST_TT_TRAIT_OP !
-
-#include "has_prefix_operator_test.hpp"
-#include "has_prefix_plus_not_operator_test.hpp"
-
-#include <iostream>
-
-namespace {
-void specific() {
-   TEST_TR(std::ostream, bool, true);
-   TEST_TR(std::istream, bool, true);
-}
-}
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_logical_or_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_logical_or_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,33 +0,0 @@
-//  (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_logical_or.hpp>
-#endif
-
-#define BOOST_TT_TRAIT_NAME has_operator_logical_or
-#define BOOST_TT_TRAIT_OP ||
-
-#include "has_binary_operator_test.hpp"
-#include "has_binary_logical_operator_test.hpp"
-
-namespace {
-void specific() {
-   /* nothing specific */
-}
-}
-
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_minus_equal_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_minus_equal_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,33 +0,0 @@
-//  (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_minus_equal.hpp>
-#endif
-
-#define BOOST_TT_TRAIT_NAME has_operator_minus_equal
-#define BOOST_TT_TRAIT_OP -=
-
-#include "has_binary_operator_test.hpp"
-#include "has_minus_equal_operator_test.hpp"
-
-namespace {
-void specific() {
-   /* nothing specific */
-}
-}
-
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_minus_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_minus_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,33 +0,0 @@
-//  (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_minus.hpp>
-#endif
-
-#define BOOST_TT_TRAIT_NAME has_operator_minus
-#define BOOST_TT_TRAIT_OP -
-
-#include "has_binary_operator_test.hpp"
-#include "has_binary_minus_operator_test.hpp"
-
-namespace {
-void specific() {
-   /* nothing specific */
-}
-}
-
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_modulus_equal_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_modulus_equal_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,33 +0,0 @@
-//  (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_modulus_equal.hpp>
-#endif
-
-#define BOOST_TT_TRAIT_NAME has_operator_modulus_equal
-#define BOOST_TT_TRAIT_OP %=
-
-#include "has_binary_operator_test.hpp"
-#include "has_integral_no_constlhs_operator_test.hpp"
-
-namespace {
-void specific() {
-   /* nothing specific */
-}
-}
-
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_modulus_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_modulus_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,33 +0,0 @@
-//  (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_modulus.hpp>
-#endif
-
-#define BOOST_TT_TRAIT_NAME has_operator_modulus
-#define BOOST_TT_TRAIT_OP %
-
-#include "has_binary_operator_test.hpp"
-#include "has_integral_operator_test.hpp"
-
-namespace {
-void specific() {
-   /* nothing specific */
-}
-}
-
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_multiplies_equal_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_multiplies_equal_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,33 +0,0 @@
-//  (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_multiplies_equal.hpp>
-#endif
-
-#define BOOST_TT_TRAIT_NAME has_operator_multiplies_equal
-#define BOOST_TT_TRAIT_OP *=
-
-#include "has_binary_operator_test.hpp"
-#include "has_no_pointer_no_constlhs_operator_test.hpp"
-
-namespace {
-void specific() {
-   /* nothing specific */
-}
-}
-
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_multiplies_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_multiplies_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,33 +0,0 @@
-//  (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_multiplies.hpp>
-#endif
-
-#define BOOST_TT_TRAIT_NAME has_operator_multiplies
-#define BOOST_TT_TRAIT_OP *
-
-#include "has_binary_operator_test.hpp"
-#include "has_no_pointer_operator_test.hpp"
-
-namespace {
-void specific() {
-   /* nothing specific */
-}
-}
-
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_not_equal_to_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_not_equal_to_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,33 +0,0 @@
-//  (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_not_equal_to.hpp>
-#endif
-
-#define BOOST_TT_TRAIT_NAME has_operator_not_equal_to
-#define BOOST_TT_TRAIT_OP !=
-
-#include "has_binary_operator_test.hpp"
-#include "has_comparison_operator_test.hpp"
-
-namespace {
-void specific() {
-   /* nothing specific */
-}
-}
-
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_plus_equal_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_plus_equal_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,33 +0,0 @@
-//  (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_plus_equal.hpp>
-#endif
-
-#define BOOST_TT_TRAIT_NAME has_operator_plus_equal
-#define BOOST_TT_TRAIT_OP +=
-
-#include "has_binary_operator_test.hpp"
-#include "has_plus_equal_operator_test.hpp"
-
-namespace {
-void specific() {
-   /* nothing specific */
-}
-}
-
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_plus_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_plus_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,33 +0,0 @@
-//  (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_plus.hpp>
-#endif
-
-#define BOOST_TT_TRAIT_NAME has_operator_plus
-#define BOOST_TT_TRAIT_OP +
-
-#include "has_binary_operator_test.hpp"
-#include "has_binary_plus_operator_test.hpp"
-
-namespace {
-void specific() {
-   /* nothing specific */
-}
-}
-
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_postfix_decrement_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_postfix_decrement_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,33 +0,0 @@
-//  (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_postfix_decrement.hpp>
-#endif
-
-#define BOOST_TT_TRAIT_NAME has_operator_postfix_decrement
-#define BOOST_TT_TRAIT_OP --
-
-#include "has_postfix_operator_test.hpp"
-#include "has_postfix_decrement_operator_test.hpp"
-
-namespace {
-void specific() {
-   /* nothing specific */
-}
-}
-
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_postfix_increment_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_postfix_increment_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,33 +0,0 @@
-//  (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_postfix_increment.hpp>
-#endif
-
-#define BOOST_TT_TRAIT_NAME has_operator_postfix_increment
-#define BOOST_TT_TRAIT_OP ++
-
-#include "has_postfix_operator_test.hpp"
-#include "has_postfix_increment_operator_test.hpp"
-
-namespace {
-void specific() {
-   /* nothing specific */
-}
-}
-
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_prefix_decrement_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_prefix_decrement_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,33 +0,0 @@
-//  (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_prefix_decrement.hpp>
-#endif
-
-#define BOOST_TT_TRAIT_NAME has_operator_prefix_decrement
-#define BOOST_TT_TRAIT_OP --
-
-#include "has_prefix_operator_test.hpp"
-#include "has_prefix_decrement_operator_test.hpp"
-
-namespace {
-void specific() {
-   /* nothing specific */
-}
-}
-
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_prefix_increment_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_prefix_increment_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,33 +0,0 @@
-//  (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_prefix_increment.hpp>
-#endif
-
-#define BOOST_TT_TRAIT_NAME has_operator_prefix_increment
-#define BOOST_TT_TRAIT_OP ++
-
-#include "has_prefix_operator_test.hpp"
-#include "has_prefix_increment_operator_test.hpp"
-
-namespace {
-void specific() {
-   /* nothing specific */
-}
-}
-
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_right_shift_equal_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_right_shift_equal_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,33 +0,0 @@
-//  (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_right_shift_equal.hpp>
-#endif
-
-#define BOOST_TT_TRAIT_NAME has_operator_right_shift_equal
-#define BOOST_TT_TRAIT_OP >>=
-
-#include "has_binary_operator_test.hpp"
-#include "has_integral_no_constlhs_operator_test.hpp"
-
-namespace {
-void specific() {
-   /* nothing specific */
-}
-}
-
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_right_shift_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_right_shift_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,53 +0,0 @@
-//  (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_right_shift.hpp>
-#endif
-
-#define BOOST_TT_TRAIT_NAME has_operator_right_shift
-#define BOOST_TT_TRAIT_OP >>
-
-#include "has_binary_operator_test.hpp"
-#include "has_integral_operator_test.hpp"
-
-#include <istream>
-#include <string>
-
-#define TEST_SPECIFIC(T) TEST_TTR(std::istream&, T, std::istream&, true)
-namespace {
-
-void specific() {
-   TEST_SPECIFIC(bool&);
-   TEST_SPECIFIC(short&);
-   TEST_SPECIFIC(unsigned short&);
-   TEST_SPECIFIC(int&);
-   TEST_SPECIFIC(unsigned int&);
-   TEST_SPECIFIC(long&);
-   TEST_SPECIFIC(unsigned long&);
-   TEST_SPECIFIC(float&);
-   TEST_SPECIFIC(double&);
-   TEST_SPECIFIC(void*&);
-   TEST_SPECIFIC(char&);
-   TEST_SPECIFIC(signed char&);
-   TEST_SPECIFIC(unsigned char&);
-   TEST_SPECIFIC(char*);
-   TEST_SPECIFIC(signed char*);
-   TEST_SPECIFIC(unsigned char*);
-   TEST_SPECIFIC(std::string&);
-}
-}
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_unary_minus_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_unary_minus_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,33 +0,0 @@
-//  (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_unary_minus.hpp>
-#endif
-
-#define BOOST_TT_TRAIT_NAME has_operator_unary_minus
-#define BOOST_TT_TRAIT_OP -
-
-#include "has_prefix_operator_test.hpp"
-#include "has_prefix_minus_operator_test.hpp"
-
-namespace {
-void specific() {
-   /* nothing specific */
-}
-}
-
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/has_operator_unary_plus_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_operator_unary_plus_test.cpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,33 +0,0 @@
-//  (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_unary_plus.hpp>
-#endif
-
-#define BOOST_TT_TRAIT_NAME has_operator_unary_plus
-#define BOOST_TT_TRAIT_OP +
-
-#include "has_prefix_operator_test.hpp"
-#include "has_prefix_plus_not_operator_test.hpp"
-
-namespace {
-void specific() {
-   /* nothing specific */
-}
-}
-
-
-
-TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
-   run1();
-   run2();
-   specific();
-TT_TEST_END

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,1250 +0,0 @@
-//  (C) Copyright Frederic Bron 2009-2011.
-//  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)
-
-namespace {
-
-void run2() {
-   // test with only one template parameter
-   TEST_T(void, false);
-   TEST_T(bool, true);
-   TEST_T(char, true);
-   TEST_T(signed char, true);
-   TEST_T(short int, true);
-   TEST_T(int, true);
-   TEST_T(long int, true);
-   TEST_T(unsigned char, true);
-   TEST_T(unsigned short int, true);
-   TEST_T(unsigned int, true);
-   TEST_T(unsigned long int, true);
-   TEST_T(wchar_t, true);
-   TEST_T(float, true);
-   TEST_T(double, true);
-   TEST_T(long double, true);
-   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), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	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), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	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 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);
-   TEST_TT(bool, short int, true);
-   TEST_TT(bool, int, true);
-   TEST_TT(bool, long int, true);
-   TEST_TT(bool, unsigned char, true);
-   TEST_TT(bool, unsigned short int, true);
-   TEST_TT(bool, unsigned int, true);
-   TEST_TT(bool, unsigned long int, true);
-   TEST_TT(bool, wchar_t, true);
-   TEST_TT(bool, float, true);
-   TEST_TT(bool, double, true);
-   TEST_TT(bool, long double, true);
-   TEST_TT(char, bool, true);
-   TEST_TT(char, char, true);
-   TEST_TT(char, signed char, true);
-   TEST_TT(char, short int, true);
-   TEST_TT(char, int, true);
-   TEST_TT(char, long int, true);
-   TEST_TT(char, unsigned char, true);
-   TEST_TT(char, unsigned short int, true);
-   TEST_TT(char, unsigned int, true);
-   TEST_TT(char, unsigned long int, true);
-   TEST_TT(char, wchar_t, true);
-   TEST_TT(char, float, true);
-   TEST_TT(char, double, true);
-   TEST_TT(char, long double, true);
-   TEST_TT(signed char, bool, true);
-   TEST_TT(signed char, char, true);
-   TEST_TT(signed char, signed char, true);
-   TEST_TT(signed char, short int, true);
-   TEST_TT(signed char, int, true);
-   TEST_TT(signed char, long int, true);
-   TEST_TT(signed char, unsigned char, true);
-   TEST_TT(signed char, unsigned short int, true);
-   TEST_TT(signed char, unsigned int, true);
-   TEST_TT(signed char, unsigned long int, true);
-   TEST_TT(signed char, wchar_t, true);
-   TEST_TT(signed char, float, true);
-   TEST_TT(signed char, double, true);
-   TEST_TT(signed char, long double, true);
-   TEST_TT(short int, bool, true);
-   TEST_TT(short int, char, true);
-   TEST_TT(short int, signed char, true);
-   TEST_TT(short int, short int, true);
-   TEST_TT(short int, int, true);
-   TEST_TT(short int, long int, true);
-   TEST_TT(short int, unsigned char, true);
-   TEST_TT(short int, unsigned short int, true);
-   TEST_TT(short int, unsigned int, true);
-   TEST_TT(short int, unsigned long int, true);
-   TEST_TT(short int, wchar_t, true);
-   TEST_TT(short int, float, true);
-   TEST_TT(short int, double, true);
-   TEST_TT(short int, long double, true);
-   TEST_TT(int, bool, true);
-   TEST_TT(int, char, true);
-   TEST_TT(int, signed char, true);
-   TEST_TT(int, short int, true);
-   TEST_TT(int, int, true);
-   TEST_TT(int, long int, true);
-   TEST_TT(int, unsigned char, true);
-   TEST_TT(int, unsigned short int, true);
-   TEST_TT(int, unsigned int, true);
-   TEST_TT(int, unsigned long int, true);
-   TEST_TT(int, wchar_t, true);
-   TEST_TT(int, float, true);
-   TEST_TT(int, double, true);
-   TEST_TT(int, long double, true);
-   TEST_TT(long int, bool, true);
-   TEST_TT(long int, char, true);
-   TEST_TT(long int, signed char, true);
-   TEST_TT(long int, short int, true);
-   TEST_TT(long int, int, true);
-   TEST_TT(long int, long int, true);
-   TEST_TT(long int, unsigned char, true);
-   TEST_TT(long int, unsigned short int, true);
-   TEST_TT(long int, unsigned int, true);
-   TEST_TT(long int, unsigned long int, true);
-   TEST_TT(long int, wchar_t, true);
-   TEST_TT(long int, float, true);
-   TEST_TT(long int, double, true);
-   TEST_TT(long int, long double, true);
-   TEST_TT(unsigned char, bool, true);
-   TEST_TT(unsigned char, char, true);
-   TEST_TT(unsigned char, signed char, true);
-   TEST_TT(unsigned char, short int, true);
-   TEST_TT(unsigned char, int, true);
-   TEST_TT(unsigned char, long int, true);
-   TEST_TT(unsigned char, unsigned char, true);
-   TEST_TT(unsigned char, unsigned short int, true);
-   TEST_TT(unsigned char, unsigned int, true);
-   TEST_TT(unsigned char, unsigned long int, true);
-   TEST_TT(unsigned char, wchar_t, true);
-   TEST_TT(unsigned char, float, true);
-   TEST_TT(unsigned char, double, true);
-   TEST_TT(unsigned char, long double, true);
-   TEST_TT(unsigned short int, bool, true);
-   TEST_TT(unsigned short int, char, true);
-   TEST_TT(unsigned short int, signed char, true);
-   TEST_TT(unsigned short int, short int, true);
-   TEST_TT(unsigned short int, int, true);
-   TEST_TT(unsigned short int, long int, true);
-   TEST_TT(unsigned short int, unsigned char, true);
-   TEST_TT(unsigned short int, unsigned short int, true);
-   TEST_TT(unsigned short int, unsigned int, true);
-   TEST_TT(unsigned short int, unsigned long int, true);
-   TEST_TT(unsigned short int, wchar_t, true);
-   TEST_TT(unsigned short int, float, true);
-   TEST_TT(unsigned short int, double, true);
-   TEST_TT(unsigned short int, long double, true);
-   TEST_TT(unsigned int, bool, true);
-   TEST_TT(unsigned int, char, true);
-   TEST_TT(unsigned int, signed char, true);
-   TEST_TT(unsigned int, short int, true);
-   TEST_TT(unsigned int, int, true);
-   TEST_TT(unsigned int, long int, true);
-   TEST_TT(unsigned int, unsigned char, true);
-   TEST_TT(unsigned int, unsigned short int, true);
-   TEST_TT(unsigned int, unsigned int, true);
-   TEST_TT(unsigned int, unsigned long int, true);
-   TEST_TT(unsigned int, wchar_t, true);
-   TEST_TT(unsigned int, float, true);
-   TEST_TT(unsigned int, double, true);
-   TEST_TT(unsigned int, long double, true);
-   TEST_TT(unsigned long int, bool, true);
-   TEST_TT(unsigned long int, char, true);
-   TEST_TT(unsigned long int, signed char, true);
-   TEST_TT(unsigned long int, short int, true);
-   TEST_TT(unsigned long int, int, true);
-   TEST_TT(unsigned long int, long int, true);
-   TEST_TT(unsigned long int, unsigned char, true);
-   TEST_TT(unsigned long int, unsigned short int, true);
-   TEST_TT(unsigned long int, unsigned int, true);
-   TEST_TT(unsigned long int, unsigned long int, true);
-   TEST_TT(unsigned long int, wchar_t, true);
-   TEST_TT(unsigned long int, float, true);
-   TEST_TT(unsigned long int, double, true);
-   TEST_TT(unsigned long int, long double, true);
-   TEST_TT(wchar_t, bool, true);
-   TEST_TT(wchar_t, char, true);
-   TEST_TT(wchar_t, signed char, true);
-   TEST_TT(wchar_t, short int, true);
-   TEST_TT(wchar_t, int, true);
-   TEST_TT(wchar_t, long int, true);
-   TEST_TT(wchar_t, unsigned char, true);
-   TEST_TT(wchar_t, unsigned short int, true);
-   TEST_TT(wchar_t, unsigned int, true);
-   TEST_TT(wchar_t, unsigned long int, true);
-   TEST_TT(wchar_t, wchar_t, true);
-   TEST_TT(wchar_t, float, true);
-   TEST_TT(wchar_t, double, true);
-   TEST_TT(wchar_t, long double, true);
-   TEST_TT(float, bool, true);
-   TEST_TT(float, char, true);
-   TEST_TT(float, signed char, true);
-   TEST_TT(float, short int, true);
-   TEST_TT(float, int, true);
-   TEST_TT(float, long int, true);
-   TEST_TT(float, unsigned char, true);
-   TEST_TT(float, unsigned short int, true);
-   TEST_TT(float, unsigned int, true);
-   TEST_TT(float, unsigned long int, true);
-   TEST_TT(float, wchar_t, true);
-   TEST_TT(float, float, true);
-   TEST_TT(float, double, true);
-   TEST_TT(float, long double, true);
-   TEST_TT(double, bool, true);
-   TEST_TT(double, char, true);
-   TEST_TT(double, signed char, true);
-   TEST_TT(double, short int, true);
-   TEST_TT(double, int, true);
-   TEST_TT(double, long int, true);
-   TEST_TT(double, unsigned char, true);
-   TEST_TT(double, unsigned short int, true);
-   TEST_TT(double, unsigned int, true);
-   TEST_TT(double, unsigned long int, true);
-   TEST_TT(double, wchar_t, true);
-   TEST_TT(double, float, true);
-   TEST_TT(double, double, true);
-   TEST_TT(double, long double, true);
-   TEST_TT(long double, bool, true);
-   TEST_TT(long double, char, true);
-   TEST_TT(long double, signed char, true);
-   TEST_TT(long double, short int, true);
-   TEST_TT(long double, int, true);
-   TEST_TT(long double, long int, true);
-   TEST_TT(long double, unsigned char, true);
-   TEST_TT(long double, unsigned short int, true);
-   TEST_TT(long double, unsigned int, true);
-   TEST_TT(long double, unsigned long int, true);
-   TEST_TT(long double, wchar_t, true);
-   TEST_TT(long double, float, true);
-   TEST_TT(long double, double, true);
-   TEST_TT(long double, long double, true);
-   TEST_TT(bool, void, false);
-   TEST_TT(void, bool, false);
-   TEST_TT(char, void, false);
-   TEST_TT(void, char, false);
-   TEST_TT(signed char, void, false);
-   TEST_TT(void, signed char, false);
-   TEST_TT(short int, void, false);
-   TEST_TT(void, short int, false);
-   TEST_TT(int, void, false);
-   TEST_TT(void, int, false);
-   TEST_TT(long int, void, false);
-   TEST_TT(void, long int, false);
-   TEST_TT(unsigned char, void, false);
-   TEST_TT(void, unsigned char, false);
-   TEST_TT(unsigned short int, void, false);
-   TEST_TT(void, unsigned short int, false);
-   TEST_TT(unsigned int, void, false);
-   TEST_TT(void, unsigned int, false);
-   TEST_TT(unsigned long int, void, false);
-   TEST_TT(void, unsigned long int, false);
-   TEST_TT(wchar_t, void, false);
-   TEST_TT(void, wchar_t, false);
-   TEST_TT(float, void, false);
-   TEST_TT(void, float, false);
-   TEST_TT(double, void, false);
-   TEST_TT(void, double, false);
-   TEST_TT(long double, void, false);
-   TEST_TT(void, long double, false);
-
-// test with three template parameters
-   TEST_TTR(bool, bool, bool, true);
-   TEST_TTR(bool, char, bool, true);
-   TEST_TTR(bool, signed char, bool, true);
-   TEST_TTR(bool, short int, bool, true);
-   TEST_TTR(bool, int, bool, true);
-   TEST_TTR(bool, long int, bool, true);
-   TEST_TTR(bool, unsigned char, bool, true);
-   TEST_TTR(bool, unsigned short int, bool, true);
-   TEST_TTR(bool, unsigned int, bool, true);
-   TEST_TTR(bool, unsigned long int, bool, true);
-   TEST_TTR(bool, wchar_t, bool, true);
-   TEST_TTR(bool, float, bool, true);
-   TEST_TTR(bool, double, bool, true);
-   TEST_TTR(bool, long double, bool, true);
-   TEST_TTR(char, bool, bool, true);
-   TEST_TTR(char, char, bool, true);
-   TEST_TTR(char, signed char, bool, true);
-   TEST_TTR(char, short int, bool, true);
-   TEST_TTR(char, int, bool, true);
-   TEST_TTR(char, long int, bool, true);
-   TEST_TTR(char, unsigned char, bool, true);
-   TEST_TTR(char, unsigned short int, bool, true);
-   TEST_TTR(char, unsigned int, bool, true);
-   TEST_TTR(char, unsigned long int, bool, true);
-   TEST_TTR(char, wchar_t, bool, true);
-   TEST_TTR(char, float, bool, true);
-   TEST_TTR(char, double, bool, true);
-   TEST_TTR(char, long double, bool, true);
-   TEST_TTR(signed char, bool, bool, true);
-   TEST_TTR(signed char, char, bool, true);
-   TEST_TTR(signed char, signed char, bool, true);
-   TEST_TTR(signed char, short int, bool, true);
-   TEST_TTR(signed char, int, bool, true);
-   TEST_TTR(signed char, long int, bool, true);
-   TEST_TTR(signed char, unsigned char, bool, true);
-   TEST_TTR(signed char, unsigned short int, bool, true);
-   TEST_TTR(signed char, unsigned int, bool, true);
-   TEST_TTR(signed char, unsigned long int, bool, true);
-   TEST_TTR(signed char, wchar_t, bool, true);
-   TEST_TTR(signed char, float, bool, true);
-   TEST_TTR(signed char, double, bool, true);
-   TEST_TTR(signed char, long double, bool, true);
-   TEST_TTR(short int, bool, bool, true);
-   TEST_TTR(short int, char, bool, true);
-   TEST_TTR(short int, signed char, bool, true);
-   TEST_TTR(short int, short int, bool, true);
-   TEST_TTR(short int, int, bool, true);
-   TEST_TTR(short int, long int, bool, true);
-   TEST_TTR(short int, unsigned char, bool, true);
-   TEST_TTR(short int, unsigned short int, bool, true);
-   TEST_TTR(short int, unsigned int, bool, true);
-   TEST_TTR(short int, unsigned long int, bool, true);
-   TEST_TTR(short int, wchar_t, bool, true);
-   TEST_TTR(short int, float, bool, true);
-   TEST_TTR(short int, double, bool, true);
-   TEST_TTR(short int, long double, bool, true);
-   TEST_TTR(int, bool, bool, true);
-   TEST_TTR(int, char, bool, true);
-   TEST_TTR(int, signed char, bool, true);
-   TEST_TTR(int, short int, bool, true);
-   TEST_TTR(int, int, bool, true);
-   TEST_TTR(int, long int, bool, true);
-   TEST_TTR(int, unsigned char, bool, true);
-   TEST_TTR(int, unsigned short int, bool, true);
-   TEST_TTR(int, unsigned int, bool, true);
-   TEST_TTR(int, unsigned long int, bool, true);
-   TEST_TTR(int, wchar_t, bool, true);
-   TEST_TTR(int, float, bool, true);
-   TEST_TTR(int, double, bool, true);
-   TEST_TTR(int, long double, bool, true);
-   TEST_TTR(long int, bool, bool, true);
-   TEST_TTR(long int, char, bool, true);
-   TEST_TTR(long int, signed char, bool, true);
-   TEST_TTR(long int, short int, bool, true);
-   TEST_TTR(long int, int, bool, true);
-   TEST_TTR(long int, long int, bool, true);
-   TEST_TTR(long int, unsigned char, bool, true);
-   TEST_TTR(long int, unsigned short int, bool, true);
-   TEST_TTR(long int, unsigned int, bool, true);
-   TEST_TTR(long int, unsigned long int, bool, true);
-   TEST_TTR(long int, wchar_t, bool, true);
-   TEST_TTR(long int, float, bool, true);
-   TEST_TTR(long int, double, bool, true);
-   TEST_TTR(long int, long double, bool, true);
-   TEST_TTR(unsigned char, bool, bool, true);
-   TEST_TTR(unsigned char, char, bool, true);
-   TEST_TTR(unsigned char, signed char, bool, true);
-   TEST_TTR(unsigned char, short int, bool, true);
-   TEST_TTR(unsigned char, int, bool, true);
-   TEST_TTR(unsigned char, long int, bool, true);
-   TEST_TTR(unsigned char, unsigned char, bool, true);
-   TEST_TTR(unsigned char, unsigned short int, bool, true);
-   TEST_TTR(unsigned char, unsigned int, bool, true);
-   TEST_TTR(unsigned char, unsigned long int, bool, true);
-   TEST_TTR(unsigned char, wchar_t, bool, true);
-   TEST_TTR(unsigned char, float, bool, true);
-   TEST_TTR(unsigned char, double, bool, true);
-   TEST_TTR(unsigned char, long double, bool, true);
-   TEST_TTR(unsigned short int, bool, bool, true);
-   TEST_TTR(unsigned short int, char, bool, true);
-   TEST_TTR(unsigned short int, signed char, bool, true);
-   TEST_TTR(unsigned short int, short int, bool, true);
-   TEST_TTR(unsigned short int, int, bool, true);
-   TEST_TTR(unsigned short int, long int, bool, true);
-   TEST_TTR(unsigned short int, unsigned char, bool, true);
-   TEST_TTR(unsigned short int, unsigned short int, bool, true);
-   TEST_TTR(unsigned short int, unsigned int, bool, true);
-   TEST_TTR(unsigned short int, unsigned long int, bool, true);
-   TEST_TTR(unsigned short int, wchar_t, bool, true);
-   TEST_TTR(unsigned short int, float, bool, true);
-   TEST_TTR(unsigned short int, double, bool, true);
-   TEST_TTR(unsigned short int, long double, bool, true);
-   TEST_TTR(unsigned int, bool, bool, true);
-   TEST_TTR(unsigned int, char, bool, true);
-   TEST_TTR(unsigned int, signed char, bool, true);
-   TEST_TTR(unsigned int, short int, bool, true);
-   TEST_TTR(unsigned int, int, bool, true);
-   TEST_TTR(unsigned int, long int, bool, true);
-   TEST_TTR(unsigned int, unsigned char, bool, true);
-   TEST_TTR(unsigned int, unsigned short int, bool, true);
-   TEST_TTR(unsigned int, unsigned int, bool, true);
-   TEST_TTR(unsigned int, unsigned long int, bool, true);
-   TEST_TTR(unsigned int, wchar_t, bool, true);
-   TEST_TTR(unsigned int, float, bool, true);
-   TEST_TTR(unsigned int, double, bool, true);
-   TEST_TTR(unsigned int, long double, bool, true);
-   TEST_TTR(unsigned long int, bool, bool, true);
-   TEST_TTR(unsigned long int, char, bool, true);
-   TEST_TTR(unsigned long int, signed char, bool, true);
-   TEST_TTR(unsigned long int, short int, bool, true);
-   TEST_TTR(unsigned long int, int, bool, true);
-   TEST_TTR(unsigned long int, long int, bool, true);
-   TEST_TTR(unsigned long int, unsigned char, bool, true);
-   TEST_TTR(unsigned long int, unsigned short int, bool, true);
-   TEST_TTR(unsigned long int, unsigned int, bool, true);
-   TEST_TTR(unsigned long int, unsigned long int, bool, true);
-   TEST_TTR(unsigned long int, wchar_t, bool, true);
-   TEST_TTR(unsigned long int, float, bool, true);
-   TEST_TTR(unsigned long int, double, bool, true);
-   TEST_TTR(unsigned long int, long double, bool, true);
-   TEST_TTR(wchar_t, bool, bool, true);
-   TEST_TTR(wchar_t, char, bool, true);
-   TEST_TTR(wchar_t, signed char, bool, true);
-   TEST_TTR(wchar_t, short int, bool, true);
-   TEST_TTR(wchar_t, int, bool, true);
-   TEST_TTR(wchar_t, long int, bool, true);
-   TEST_TTR(wchar_t, unsigned char, bool, true);
-   TEST_TTR(wchar_t, unsigned short int, bool, true);
-   TEST_TTR(wchar_t, unsigned int, bool, true);
-   TEST_TTR(wchar_t, unsigned long int, bool, true);
-   TEST_TTR(wchar_t, wchar_t, bool, true);
-   TEST_TTR(wchar_t, float, bool, true);
-   TEST_TTR(wchar_t, double, bool, true);
-   TEST_TTR(wchar_t, long double, bool, true);
-   TEST_TTR(float, bool, bool, true);
-   TEST_TTR(float, char, bool, true);
-   TEST_TTR(float, signed char, bool, true);
-   TEST_TTR(float, short int, bool, true);
-   TEST_TTR(float, int, bool, true);
-   TEST_TTR(float, long int, bool, true);
-   TEST_TTR(float, unsigned char, bool, true);
-   TEST_TTR(float, unsigned short int, bool, true);
-   TEST_TTR(float, unsigned int, bool, true);
-   TEST_TTR(float, unsigned long int, bool, true);
-   TEST_TTR(float, wchar_t, bool, true);
-   TEST_TTR(float, float, bool, true);
-   TEST_TTR(float, double, bool, true);
-   TEST_TTR(float, long double, bool, true);
-   TEST_TTR(double, bool, bool, true);
-   TEST_TTR(double, char, bool, true);
-   TEST_TTR(double, signed char, bool, true);
-   TEST_TTR(double, short int, bool, true);
-   TEST_TTR(double, int, bool, true);
-   TEST_TTR(double, long int, bool, true);
-   TEST_TTR(double, unsigned char, bool, true);
-   TEST_TTR(double, unsigned short int, bool, true);
-   TEST_TTR(double, unsigned int, bool, true);
-   TEST_TTR(double, unsigned long int, bool, true);
-   TEST_TTR(double, wchar_t, bool, true);
-   TEST_TTR(double, float, bool, true);
-   TEST_TTR(double, double, bool, true);
-   TEST_TTR(double, long double, bool, true);
-   TEST_TTR(long double, bool, bool, true);
-   TEST_TTR(long double, char, bool, true);
-   TEST_TTR(long double, signed char, bool, true);
-   TEST_TTR(long double, short int, bool, true);
-   TEST_TTR(long double, int, bool, true);
-   TEST_TTR(long double, long int, bool, true);
-   TEST_TTR(long double, unsigned char, bool, true);
-   TEST_TTR(long double, unsigned short int, bool, true);
-   TEST_TTR(long double, unsigned int, bool, true);
-   TEST_TTR(long double, unsigned long int, bool, true);
-   TEST_TTR(long double, wchar_t, bool, true);
-   TEST_TTR(long double, float, bool, true);
-   TEST_TTR(long double, double, bool, true);
-   TEST_TTR(long double, long double, bool, true);
-   TEST_TTR(bool, bool, tag, false);
-   TEST_TTR(bool, char, tag, false);
-   TEST_TTR(bool, signed char, tag, false);
-   TEST_TTR(bool, short int, tag, false);
-   TEST_TTR(bool, int, tag, false);
-   TEST_TTR(bool, long int, tag, false);
-   TEST_TTR(bool, unsigned char, tag, false);
-   TEST_TTR(bool, unsigned short int, tag, false);
-   TEST_TTR(bool, unsigned int, tag, false);
-   TEST_TTR(bool, unsigned long int, tag, false);
-   TEST_TTR(bool, wchar_t, tag, false);
-   TEST_TTR(bool, float, tag, false);
-   TEST_TTR(bool, double, tag, false);
-   TEST_TTR(bool, long double, tag, false);
-   TEST_TTR(char, bool, tag, false);
-   TEST_TTR(char, char, tag, false);
-   TEST_TTR(char, signed char, tag, false);
-   TEST_TTR(char, short int, tag, false);
-   TEST_TTR(char, int, tag, false);
-   TEST_TTR(char, long int, tag, false);
-   TEST_TTR(char, unsigned char, tag, false);
-   TEST_TTR(char, unsigned short int, tag, false);
-   TEST_TTR(char, unsigned int, tag, false);
-   TEST_TTR(char, unsigned long int, tag, false);
-   TEST_TTR(char, wchar_t, tag, false);
-   TEST_TTR(char, float, tag, false);
-   TEST_TTR(char, double, tag, false);
-   TEST_TTR(char, long double, tag, false);
-   TEST_TTR(signed char, bool, tag, false);
-   TEST_TTR(signed char, char, tag, false);
-   TEST_TTR(signed char, signed char, tag, false);
-   TEST_TTR(signed char, short int, tag, false);
-   TEST_TTR(signed char, int, tag, false);
-   TEST_TTR(signed char, long int, tag, false);
-   TEST_TTR(signed char, unsigned char, tag, false);
-   TEST_TTR(signed char, unsigned short int, tag, false);
-   TEST_TTR(signed char, unsigned int, tag, false);
-   TEST_TTR(signed char, unsigned long int, tag, false);
-   TEST_TTR(signed char, wchar_t, tag, false);
-   TEST_TTR(signed char, float, tag, false);
-   TEST_TTR(signed char, double, tag, false);
-   TEST_TTR(signed char, long double, tag, false);
-   TEST_TTR(short int, bool, tag, false);
-   TEST_TTR(short int, char, tag, false);
-   TEST_TTR(short int, signed char, tag, false);
-   TEST_TTR(short int, short int, tag, false);
-   TEST_TTR(short int, int, tag, false);
-   TEST_TTR(short int, long int, tag, false);
-   TEST_TTR(short int, unsigned char, tag, false);
-   TEST_TTR(short int, unsigned short int, tag, false);
-   TEST_TTR(short int, unsigned int, tag, false);
-   TEST_TTR(short int, unsigned long int, tag, false);
-   TEST_TTR(short int, wchar_t, tag, false);
-   TEST_TTR(short int, float, tag, false);
-   TEST_TTR(short int, double, tag, false);
-   TEST_TTR(short int, long double, tag, false);
-   TEST_TTR(int, bool, tag, false);
-   TEST_TTR(int, char, tag, false);
-   TEST_TTR(int, signed char, tag, false);
-   TEST_TTR(int, short int, tag, false);
-   TEST_TTR(int, int, tag, false);
-   TEST_TTR(int, long int, tag, false);
-   TEST_TTR(int, unsigned char, tag, false);
-   TEST_TTR(int, unsigned short int, tag, false);
-   TEST_TTR(int, unsigned int, tag, false);
-   TEST_TTR(int, unsigned long int, tag, false);
-   TEST_TTR(int, wchar_t, tag, false);
-   TEST_TTR(int, float, tag, false);
-   TEST_TTR(int, double, tag, false);
-   TEST_TTR(int, long double, tag, false);
-   TEST_TTR(long int, bool, tag, false);
-   TEST_TTR(long int, char, tag, false);
-   TEST_TTR(long int, signed char, tag, false);
-   TEST_TTR(long int, short int, tag, false);
-   TEST_TTR(long int, int, tag, false);
-   TEST_TTR(long int, long int, tag, false);
-   TEST_TTR(long int, unsigned char, tag, false);
-   TEST_TTR(long int, unsigned short int, tag, false);
-   TEST_TTR(long int, unsigned int, tag, false);
-   TEST_TTR(long int, unsigned long int, tag, false);
-   TEST_TTR(long int, wchar_t, tag, false);
-   TEST_TTR(long int, float, tag, false);
-   TEST_TTR(long int, double, tag, false);
-   TEST_TTR(long int, long double, tag, false);
-   TEST_TTR(unsigned char, bool, tag, false);
-   TEST_TTR(unsigned char, char, tag, false);
-   TEST_TTR(unsigned char, signed char, tag, false);
-   TEST_TTR(unsigned char, short int, tag, false);
-   TEST_TTR(unsigned char, int, tag, false);
-   TEST_TTR(unsigned char, long int, tag, false);
-   TEST_TTR(unsigned char, unsigned char, tag, false);
-   TEST_TTR(unsigned char, unsigned short int, tag, false);
-   TEST_TTR(unsigned char, unsigned int, tag, false);
-   TEST_TTR(unsigned char, unsigned long int, tag, false);
-   TEST_TTR(unsigned char, wchar_t, tag, false);
-   TEST_TTR(unsigned char, float, tag, false);
-   TEST_TTR(unsigned char, double, tag, false);
-   TEST_TTR(unsigned char, long double, tag, false);
-   TEST_TTR(unsigned short int, bool, tag, false);
-   TEST_TTR(unsigned short int, char, tag, false);
-   TEST_TTR(unsigned short int, signed char, tag, false);
-   TEST_TTR(unsigned short int, short int, tag, false);
-   TEST_TTR(unsigned short int, int, tag, false);
-   TEST_TTR(unsigned short int, long int, tag, false);
-   TEST_TTR(unsigned short int, unsigned char, tag, false);
-   TEST_TTR(unsigned short int, unsigned short int, tag, false);
-   TEST_TTR(unsigned short int, unsigned int, tag, false);
-   TEST_TTR(unsigned short int, unsigned long int, tag, false);
-   TEST_TTR(unsigned short int, wchar_t, tag, false);
-   TEST_TTR(unsigned short int, float, tag, false);
-   TEST_TTR(unsigned short int, double, tag, false);
-   TEST_TTR(unsigned short int, long double, tag, false);
-   TEST_TTR(unsigned int, bool, tag, false);
-   TEST_TTR(unsigned int, char, tag, false);
-   TEST_TTR(unsigned int, signed char, tag, false);
-   TEST_TTR(unsigned int, short int, tag, false);
-   TEST_TTR(unsigned int, int, tag, false);
-   TEST_TTR(unsigned int, long int, tag, false);
-   TEST_TTR(unsigned int, unsigned char, tag, false);
-   TEST_TTR(unsigned int, unsigned short int, tag, false);
-   TEST_TTR(unsigned int, unsigned int, tag, false);
-   TEST_TTR(unsigned int, unsigned long int, tag, false);
-   TEST_TTR(unsigned int, wchar_t, tag, false);
-   TEST_TTR(unsigned int, float, tag, false);
-   TEST_TTR(unsigned int, double, tag, false);
-   TEST_TTR(unsigned int, long double, tag, false);
-   TEST_TTR(unsigned long int, bool, tag, false);
-   TEST_TTR(unsigned long int, char, tag, false);
-   TEST_TTR(unsigned long int, signed char, tag, false);
-   TEST_TTR(unsigned long int, short int, tag, false);
-   TEST_TTR(unsigned long int, int, tag, false);
-   TEST_TTR(unsigned long int, long int, tag, false);
-   TEST_TTR(unsigned long int, unsigned char, tag, false);
-   TEST_TTR(unsigned long int, unsigned short int, tag, false);
-   TEST_TTR(unsigned long int, unsigned int, tag, false);
-   TEST_TTR(unsigned long int, unsigned long int, tag, false);
-   TEST_TTR(unsigned long int, wchar_t, tag, false);
-   TEST_TTR(unsigned long int, float, tag, false);
-   TEST_TTR(unsigned long int, double, tag, false);
-   TEST_TTR(unsigned long int, long double, tag, false);
-   TEST_TTR(wchar_t, bool, tag, false);
-   TEST_TTR(wchar_t, char, tag, false);
-   TEST_TTR(wchar_t, signed char, tag, false);
-   TEST_TTR(wchar_t, short int, tag, false);
-   TEST_TTR(wchar_t, int, tag, false);
-   TEST_TTR(wchar_t, long int, tag, false);
-   TEST_TTR(wchar_t, unsigned char, tag, false);
-   TEST_TTR(wchar_t, unsigned short int, tag, false);
-   TEST_TTR(wchar_t, unsigned int, tag, false);
-   TEST_TTR(wchar_t, unsigned long int, tag, false);
-   TEST_TTR(wchar_t, wchar_t, tag, false);
-   TEST_TTR(wchar_t, float, tag, false);
-   TEST_TTR(wchar_t, double, tag, false);
-   TEST_TTR(wchar_t, long double, tag, false);
-   TEST_TTR(float, bool, tag, false);
-   TEST_TTR(float, char, tag, false);
-   TEST_TTR(float, signed char, tag, false);
-   TEST_TTR(float, short int, tag, false);
-   TEST_TTR(float, int, tag, false);
-   TEST_TTR(float, long int, tag, false);
-   TEST_TTR(float, unsigned char, tag, false);
-   TEST_TTR(float, unsigned short int, tag, false);
-   TEST_TTR(float, unsigned int, tag, false);
-   TEST_TTR(float, unsigned long int, tag, false);
-   TEST_TTR(float, wchar_t, tag, false);
-   TEST_TTR(float, float, tag, false);
-   TEST_TTR(float, double, tag, false);
-   TEST_TTR(float, long double, tag, false);
-   TEST_TTR(double, bool, tag, false);
-   TEST_TTR(double, char, tag, false);
-   TEST_TTR(double, signed char, tag, false);
-   TEST_TTR(double, short int, tag, false);
-   TEST_TTR(double, int, tag, false);
-   TEST_TTR(double, long int, tag, false);
-   TEST_TTR(double, unsigned char, tag, false);
-   TEST_TTR(double, unsigned short int, tag, false);
-   TEST_TTR(double, unsigned int, tag, false);
-   TEST_TTR(double, unsigned long int, tag, false);
-   TEST_TTR(double, wchar_t, tag, false);
-   TEST_TTR(double, float, tag, false);
-   TEST_TTR(double, double, tag, false);
-   TEST_TTR(double, long double, tag, false);
-   TEST_TTR(long double, bool, tag, false);
-   TEST_TTR(long double, char, tag, false);
-   TEST_TTR(long double, signed char, tag, false);
-   TEST_TTR(long double, short int, tag, false);
-   TEST_TTR(long double, int, tag, false);
-   TEST_TTR(long double, long int, tag, false);
-   TEST_TTR(long double, unsigned char, tag, false);
-   TEST_TTR(long double, unsigned short int, tag, false);
-   TEST_TTR(long double, unsigned int, tag, false);
-   TEST_TTR(long double, unsigned long int, tag, false);
-   TEST_TTR(long double, wchar_t, tag, false);
-   TEST_TTR(long double, float, tag, false);
-   TEST_TTR(long double, double, tag, false);
-   TEST_TTR(long double, long double, tag, false);
-#	undef CV1
-#	define CV1(T) const T
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), false);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), false);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, false);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), false);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), false);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, false);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const T&
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), false);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), false);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, false);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T&
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T&
-#	undef CV2
-#	define CV2(T) T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), false);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), false);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, false);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) T
-#	undef CV2
-#	define CV2(T) const volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const T
-#	undef CV2
-#	define CV2(T) const T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), false);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), false);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, false);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const T&
-#	undef CV2
-#	define CV2(T) const T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), false);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), false);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, false);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T
-#	undef CV2
-#	define CV2(T) volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) volatile T&
-#	undef CV2
-#	define CV2(T) volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), true);
-   TEST_TT(CV1(bool), CV2(double), true);
-   TEST_TT(CV1(int), CV2(bool), true);
-   TEST_TT(CV1(int), CV2(double), true);
-   TEST_TT(CV1(double), CV2(bool), true);
-   TEST_TT(CV1(double), CV2(int), true);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(double), bool, true);
-   TEST_TTR(CV1(int), CV2(bool), bool, true);
-   TEST_TTR(CV1(int), CV2(double), bool, true);
-   TEST_TTR(CV1(double), CV2(bool), bool, true);
-   TEST_TTR(CV1(double), CV2(int), bool, true);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T
-#	undef CV2
-#	define CV2(T) const volatile T
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), false);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), false);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, false);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-#	undef CV1
-#	define CV1(T) const volatile T&
-#	undef CV2
-#	define CV2(T) const volatile T&
-   // test with only two template parameters
-   TEST_TT(CV1(bool), CV2(int), false);
-   TEST_TT(CV1(bool), CV2(double), false);
-   TEST_TT(CV1(int), CV2(bool), false);
-   TEST_TT(CV1(int), CV2(double), false);
-   TEST_TT(CV1(double), CV2(bool), false);
-   TEST_TT(CV1(double), CV2(int), false);
-
-   // test with three template parameters
-   TEST_TTR(CV1(bool), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(double), bool, false);
-   TEST_TTR(CV1(int), CV2(bool), bool, false);
-   TEST_TTR(CV1(int), CV2(double), bool, false);
-   TEST_TTR(CV1(double), CV2(bool), bool, false);
-   TEST_TTR(CV1(double), CV2(int), bool, false);
-   TEST_TTR(CV1(bool), CV2(int), tag, false);
-   TEST_TTR(CV1(bool), CV2(double), tag, false);
-   TEST_TTR(CV1(int), CV2(bool), tag, false);
-   TEST_TTR(CV1(int), CV2(double), tag, false);
-   TEST_TTR(CV1(double), CV2(bool), tag, false);
-   TEST_TTR(CV1(double), CV2(int), tag, false);
-
-   // pointers
-   TEST_TT(void*, bool, false);
-   TEST_TT(void*, int, false);
-   TEST_TT(void*, double, false);
-   TEST_TT(void*, A, false);
-   TEST_TT(void*, B, false);
-   TEST_TT(bool*, bool, true);
-   TEST_TT(bool*, int, true);
-   TEST_TT(bool*, double, false);
-   TEST_TT(bool*, A, false);
-   TEST_TT(bool*, B, false);
-   TEST_TT(int*, bool, true);
-   TEST_TT(int*, int, true);
-   TEST_TT(int*, double, false);
-   TEST_TT(int*, A, false);
-   TEST_TT(int*, B, false);
-   TEST_TT(double*, bool, true);
-   TEST_TT(double*, int, true);
-   TEST_TT(double*, double, false);
-   TEST_TT(double*, A, false);
-   TEST_TT(double*, B, false);
-   TEST_TT(A*, bool, true);
-   TEST_TT(A*, int, true);
-   TEST_TT(A*, double, false);
-   TEST_TT(A*, A, false);
-   TEST_TT(A*, B, false);
-   TEST_TT(B*, bool, true);
-   TEST_TT(B*, int, true);
-   TEST_TT(B*, double, false);
-   TEST_TT(B*, A, false);
-   TEST_TT(B*, B, false);
-   TEST_TT(bool, void*, false);
-   TEST_TT(bool, bool*, true);
-   TEST_TT(bool, int*, true);
-   TEST_TT(bool, double*, true);
-   TEST_TT(bool, A*, true);
-   TEST_TT(bool, B*, true);
-   TEST_TT(int, void*, false);
-   TEST_TT(int, bool*, false);
-   TEST_TT(int, int*, false);
-   TEST_TT(int, double*, false);
-   TEST_TT(int, A*, false);
-   TEST_TT(int, B*, false);
-   TEST_TT(double, void*, false);
-   TEST_TT(double, bool*, false);
-   TEST_TT(double, int*, false);
-   TEST_TT(double, double*, false);
-   TEST_TT(double, A*, false);
-   TEST_TT(double, B*, false);
-   TEST_TT(A, void*, false);
-   TEST_TT(A, bool*, false);
-   TEST_TT(A, int*, false);
-   TEST_TT(A, double*, false);
-   TEST_TT(A, A*, false);
-   TEST_TT(A, B*, false);
-   TEST_TT(B, void*, false);
-   TEST_TT(B, bool*, false);
-   TEST_TT(B, int*, false);
-   TEST_TT(B, double*, false);
-   TEST_TT(B, A*, false);
-   TEST_TT(B, B*, false);
-   TEST_TT(void*, void*, false);
-   TEST_TT(void*, bool*, false);
-   TEST_TT(void*, int*, false);
-   TEST_TT(void*, double*, false);
-   TEST_TT(void*, A*, false);
-   TEST_TT(void*, B*, false);
-   TEST_TT(bool*, void*, false);
-   TEST_TT(bool*, bool*, false);
-   TEST_TT(bool*, int*, false);
-   TEST_TT(bool*, double*, false);
-   TEST_TT(bool*, A*, false);
-   TEST_TT(bool*, B*, false);
-   TEST_TT(int*, void*, false);
-   TEST_TT(int*, bool*, false);
-   TEST_TT(int*, int*, false);
-   TEST_TT(int*, double*, false);
-   TEST_TT(int*, A*, false);
-   TEST_TT(int*, B*, false);
-   TEST_TT(double*, void*, false);
-   TEST_TT(double*, bool*, false);
-   TEST_TT(double*, int*, false);
-   TEST_TT(double*, double*, false);
-   TEST_TT(double*, A*, false);
-   TEST_TT(double*, B*, false);
-   TEST_TT(A*, void*, false);
-   TEST_TT(A*, bool*, false);
-   TEST_TT(A*, int*, false);
-   TEST_TT(A*, double*, false);
-   TEST_TT(A*, A*, false);
-   TEST_TT(A*, B*, false);
-   TEST_TT(B*, void*, false);
-   TEST_TT(B*, bool*, false);
-   TEST_TT(B*, int*, false);
-   TEST_TT(B*, double*, false);
-   TEST_TT(B*, A*, false);
-   TEST_TT(B*, B*, false);
-   TEST_TT(C, void*, true);
-   TEST_TT(D, void*, false);
-   TEST_TT(void*, C, false);
-   TEST_TT(void*, D, true);
-   TEST_TT(C, D, true);
-}
-}

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,97 +0,0 @@
-//  (C) Copyright Frederic Bron 2009-2011.
-//  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)
-
-namespace {
-
-void run2() {
-   // test with only one template parameter
-   TEST_T(void, false);
-   TEST_T(bool, false);
-   TEST_T(char, true);
-   TEST_T(signed char, true);
-   TEST_T(short int, true);
-   TEST_T(int, true);
-   TEST_T(long int, true);
-   TEST_T(unsigned char, true);
-   TEST_T(unsigned short int, true);
-   TEST_T(unsigned int, true);
-   TEST_T(unsigned long int, true);
-   TEST_T(wchar_t, true);
-   TEST_T(float, true);
-   TEST_T(double, true);
-   TEST_T(long double, true);
-   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), true);
-   TEST_T(CV(double), true);
-#	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), true);
-   TEST_T(CV(double), true);
-#	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, true);
-   TEST_TR(signed char, bool, true);
-   TEST_TR(short int, bool, true);
-   TEST_TR(int, bool, true);
-   TEST_TR(long int, bool, true);
-   TEST_TR(unsigned char, bool, true);
-   TEST_TR(unsigned short int, bool, true);
-   TEST_TR(unsigned int, bool, true);
-   TEST_TR(unsigned long int, bool, true);
-   TEST_TR(wchar_t, bool, true);
-   TEST_TR(float, bool, true);
-   TEST_TR(double, bool, true);
-   TEST_TR(long double, bool, true);
-   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);
-
-   // 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);
-}
-}

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,97 +0,0 @@
-//  (C) Copyright Frederic Bron 2009-2011.
-//  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)
-
-namespace {
-
-void run2() {
-   // test with only one template parameter
-   TEST_T(void, false);
-   TEST_T(bool, true);
-   TEST_T(char, true);
-   TEST_T(signed char, true);
-   TEST_T(short int, true);
-   TEST_T(int, true);
-   TEST_T(long int, true);
-   TEST_T(unsigned char, true);
-   TEST_T(unsigned short int, true);
-   TEST_T(unsigned int, true);
-   TEST_T(unsigned long int, true);
-   TEST_T(wchar_t, true);
-   TEST_T(float, true);
-   TEST_T(double, true);
-   TEST_T(long double, true);
-   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), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	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), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	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, true);
-   TEST_TR(char, bool, true);
-   TEST_TR(signed char, bool, true);
-   TEST_TR(short int, bool, true);
-   TEST_TR(int, bool, true);
-   TEST_TR(long int, bool, true);
-   TEST_TR(unsigned char, bool, true);
-   TEST_TR(unsigned short int, bool, true);
-   TEST_TR(unsigned int, bool, true);
-   TEST_TR(unsigned long int, bool, true);
-   TEST_TR(wchar_t, bool, true);
-   TEST_TR(float, bool, true);
-   TEST_TR(double, bool, true);
-   TEST_TR(long double, bool, true);
-   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);
-
-   // 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);
-}
-}

Deleted: sandbox/type_traits/libs/type_traits/test/has_postfix_operator_test.hpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_postfix_operator_test.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,114 +0,0 @@
-//  (C) Copyright Frederic Bron 2009-2011.
-//  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)
-
-// 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 without { };
-
-struct ret { };
-
-struct internal { ret operator BOOST_TT_TRAIT_OP (int) const; };
-
-struct external { };
-ret operator BOOST_TT_TRAIT_OP (const external&, int);
-
-struct comma1_ret { };
-struct ret_with_comma1 { comma1_ret operator,(int); };
-
-struct internal_comma1 { ret_with_comma1 operator BOOST_TT_TRAIT_OP (int) const; };
-
-struct external_comma1 { };
-ret_with_comma1 operator BOOST_TT_TRAIT_OP (const external_comma1&, int);
-
-struct ret_with_comma2 { void operator,(int); };
-
-struct internal_comma2 { ret_with_comma2 operator BOOST_TT_TRAIT_OP (int) const; };
-
-struct external_comma2 { };
-ret_with_comma2 operator BOOST_TT_TRAIT_OP (const external_comma2&, int);
-
-struct returns_int { int operator BOOST_TT_TRAIT_OP (int); };
-
-struct returns_void { void operator BOOST_TT_TRAIT_OP (int); };
-
-struct returns_void_star { void *operator BOOST_TT_TRAIT_OP (int); };
-
-struct returns_double { double operator BOOST_TT_TRAIT_OP (int); };
-
-struct ret1 { };
-struct convertible_to_ret1 { operator ret1 () const; };
-struct returns_convertible_to_ret1 { convertible_to_ret1 operator BOOST_TT_TRAIT_OP (int); };
-
-struct convertible_to_ret2 { };
-struct ret2 { ret2(const convertible_to_ret2); };
-struct returns_convertible_to_ret2 { convertible_to_ret2 operator BOOST_TT_TRAIT_OP (int); };
-
-class Base1 { };
-class Derived1 : public Base1 { };
-
-bool operator BOOST_TT_TRAIT_OP (const Base1&, int) { 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&, int) { return true; }
-
-struct tag { };
-
-//class internal_private { ret operator BOOST_TT_TRAIT_OP (int) const; };
-
-void run1() {
-   TEST_T(without, false);
-   TEST_T(internal, true);
-   TEST_T(external, true);
-   TEST_T(internal_comma1, true);
-   TEST_T(external_comma1, true);
-   TEST_T(internal_comma2, true);
-   TEST_T(external_comma2, true);
-   TEST_T(returns_int, true);
-   TEST_T(returns_void, true);
-   TEST_T(returns_void_star, true);
-   TEST_T(returns_double, true);
-   TEST_T(returns_convertible_to_ret1, true);
-   TEST_T(returns_convertible_to_ret2, 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(internal_comma1, bool, false);
-   TEST_TR(internal_comma1, ret_with_comma1, true);
-   TEST_TR(internal_comma2, bool, false);
-   TEST_TR(internal_comma2, ret_with_comma2, true);
-   TEST_TR(external, bool, false);
-   TEST_TR(external, ret, true);
-   TEST_TR(returns_int, bool, true);
-   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_convertible_to_ret1, ret1, true);
-   TEST_TR(returns_convertible_to_ret2, ret2, true);
-   TEST_TR(Base1, bool, true);
-   TEST_TR(Derived1, bool, true);
-   TEST_TR(Base2, bool, false);
-   TEST_TR(Derived2, bool, true);
-// compile time error
-// TEST_T(internal_private, false);
-}
-
-}

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,97 +0,0 @@
-//  (C) Copyright Frederic Bron 2009-2011.
-//  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)
-
-namespace {
-
-void run2() {
-   // test with only one template parameter
-   TEST_T(void, false);
-   TEST_T(bool, true);
-   TEST_T(char, true);
-   TEST_T(signed char, true);
-   TEST_T(short int, true);
-   TEST_T(int, true);
-   TEST_T(long int, true);
-   TEST_T(unsigned char, true);
-   TEST_T(unsigned short int, true);
-   TEST_T(unsigned int, true);
-   TEST_T(unsigned long int, true);
-   TEST_T(wchar_t, true);
-   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), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), false);
-#	undef CV
-#	define CV(T) volatile T
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), false);
-#	undef CV
-#	define CV(T) const volatile T
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), false);
-#	undef CV
-#	define CV(T) const T&
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), false);
-#	undef CV
-#	define CV(T) volatile T&
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), false);
-#	undef CV
-#	define CV(T) const volatile T&
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), false);
-
-   // test with three template parameters
-   TEST_TR(bool, bool, true);
-   TEST_TR(char, bool, true);
-   TEST_TR(signed char, bool, true);
-   TEST_TR(short int, bool, true);
-   TEST_TR(int, bool, true);
-   TEST_TR(long int, bool, true);
-   TEST_TR(unsigned char, bool, true);
-   TEST_TR(unsigned short int, bool, true);
-   TEST_TR(unsigned int, bool, true);
-   TEST_TR(unsigned long int, bool, true);
-   TEST_TR(wchar_t, bool, true);
-   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);
-
-   // pointers
-   TEST_T(void*, false);
-   TEST_T(bool*, false);
-   TEST_T(char*, false);
-   TEST_T(int*, false);
-   TEST_T(long*, false);
-   TEST_T(wchar_t*, false);
-   TEST_T(double*, false);
-   TEST_T(without*, false);
-}
-}

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,97 +0,0 @@
-//  (C) Copyright Frederic Bron 2009-2011.
-//  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)
-
-namespace {
-
-void run2() {
-   // test with only one template parameter
-   TEST_T(void, false);
-   TEST_T(bool, false);
-   TEST_T(char, true);
-   TEST_T(signed char, true);
-   TEST_T(short int, true);
-   TEST_T(int, true);
-   TEST_T(long int, true);
-   TEST_T(unsigned char, true);
-   TEST_T(unsigned short int, true);
-   TEST_T(unsigned int, true);
-   TEST_T(unsigned long int, true);
-   TEST_T(wchar_t, true);
-   TEST_T(float, true);
-   TEST_T(double, true);
-   TEST_T(long double, true);
-   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), true);
-   TEST_T(CV(double), true);
-#	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), true);
-   TEST_T(CV(double), true);
-#	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, true);
-   TEST_TR(signed char, bool, true);
-   TEST_TR(short int, bool, true);
-   TEST_TR(int, bool, true);
-   TEST_TR(long int, bool, true);
-   TEST_TR(unsigned char, bool, true);
-   TEST_TR(unsigned short int, bool, true);
-   TEST_TR(unsigned int, bool, true);
-   TEST_TR(unsigned long int, bool, true);
-   TEST_TR(wchar_t, bool, true);
-   TEST_TR(float, bool, true);
-   TEST_TR(double, bool, true);
-   TEST_TR(long double, bool, true);
-   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);
-
-   // 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);
-}
-}

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,97 +0,0 @@
-//  (C) Copyright Frederic Bron 2009-2011.
-//  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)
-
-namespace {
-
-void run2() {
-   // test with only one template parameter
-   TEST_T(void, false);
-   TEST_T(bool, true);
-   TEST_T(char, true);
-   TEST_T(signed char, true);
-   TEST_T(short int, true);
-   TEST_T(int, true);
-   TEST_T(long int, true);
-   TEST_T(unsigned char, true);
-   TEST_T(unsigned short int, true);
-   TEST_T(unsigned int, true);
-   TEST_T(unsigned long int, true);
-   TEST_T(wchar_t, true);
-   TEST_T(float, true);
-   TEST_T(double, true);
-   TEST_T(long double, true);
-   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), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	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), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	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, true);
-   TEST_TR(char, bool, true);
-   TEST_TR(signed char, bool, true);
-   TEST_TR(short int, bool, true);
-   TEST_TR(int, bool, true);
-   TEST_TR(long int, bool, true);
-   TEST_TR(unsigned char, bool, true);
-   TEST_TR(unsigned short int, bool, true);
-   TEST_TR(unsigned int, bool, true);
-   TEST_TR(unsigned long int, bool, true);
-   TEST_TR(wchar_t, bool, true);
-   TEST_TR(float, bool, true);
-   TEST_TR(double, bool, true);
-   TEST_TR(long double, bool, true);
-   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);
-
-   // 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);
-}
-}

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,97 +0,0 @@
-//  (C) Copyright Frederic Bron 2009-2011.
-//  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)
-
-namespace {
-
-void run2() {
-   // test with only one template parameter
-   TEST_T(void, false);
-   TEST_T(bool, true);
-   TEST_T(char, true);
-   TEST_T(signed char, true);
-   TEST_T(short int, true);
-   TEST_T(int, true);
-   TEST_T(long int, true);
-   TEST_T(unsigned char, true);
-   TEST_T(unsigned short int, true);
-   TEST_T(unsigned int, true);
-   TEST_T(unsigned long int, true);
-   TEST_T(wchar_t, true);
-   TEST_T(float, true);
-   TEST_T(double, true);
-   TEST_T(long double, true);
-   TEST_T(void, false);
-#	undef CV
-#	define CV(T) const T
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	undef CV
-#	define CV(T) volatile T
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	undef CV
-#	define CV(T) const volatile T
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	undef CV
-#	define CV(T) const T&
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	undef CV
-#	define CV(T) volatile T&
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	undef CV
-#	define CV(T) const volatile T&
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-
-   // test with three template parameters
-   TEST_TR(bool, bool, true);
-   TEST_TR(char, bool, true);
-   TEST_TR(signed char, bool, true);
-   TEST_TR(short int, bool, true);
-   TEST_TR(int, bool, true);
-   TEST_TR(long int, bool, true);
-   TEST_TR(unsigned char, bool, true);
-   TEST_TR(unsigned short int, bool, true);
-   TEST_TR(unsigned int, bool, true);
-   TEST_TR(unsigned long int, bool, true);
-   TEST_TR(wchar_t, bool, true);
-   TEST_TR(float, bool, true);
-   TEST_TR(double, bool, true);
-   TEST_TR(long double, bool, true);
-   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);
-
-   // pointers
-   TEST_T(void*, false);
-   TEST_T(bool*, false);
-   TEST_T(char*, false);
-   TEST_T(int*, false);
-   TEST_T(long*, false);
-   TEST_T(wchar_t*, false);
-   TEST_T(double*, false);
-   TEST_T(without*, false);
-}
-}

Deleted: sandbox/type_traits/libs/type_traits/test/has_prefix_operator_test.hpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/has_prefix_operator_test.hpp	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,112 +0,0 @@
-//  (C) Copyright Frederic Bron 2009-2011.
-//  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)
-
-// 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 without { };
-
-struct ret { };
-
-struct internal { ret operator BOOST_TT_TRAIT_OP () const; };
-
-struct external { };
-ret operator BOOST_TT_TRAIT_OP (const external&);
-
-struct comma1_ret { };
-struct ret_with_comma1 { comma1_ret operator,(int); };
-
-struct internal_comma1 { ret_with_comma1 operator BOOST_TT_TRAIT_OP () const; };
-
-struct external_comma1 { };
-ret_with_comma1 operator BOOST_TT_TRAIT_OP (const external_comma1&);
-
-struct ret_with_comma2 { void operator,(int); };
-
-struct internal_comma2 { ret_with_comma2 operator BOOST_TT_TRAIT_OP () const; };
-
-struct external_comma2 { };
-ret_with_comma2 operator BOOST_TT_TRAIT_OP (const external_comma2&);
-
-struct returns_int { int operator BOOST_TT_TRAIT_OP (); };
-
-struct returns_void { void operator BOOST_TT_TRAIT_OP (); };
-
-struct returns_void_star { void *operator BOOST_TT_TRAIT_OP (); };
-
-struct returns_double { double operator BOOST_TT_TRAIT_OP (); };
-
-struct ret1 { };
-struct convertible_to_ret1 { operator ret1 () const; };
-struct returns_convertible_to_ret1 { convertible_to_ret1 operator BOOST_TT_TRAIT_OP (); };
-
-struct convertible_to_ret2 { };
-struct ret2 { ret2(const convertible_to_ret2); };
-struct returns_convertible_to_ret2 { convertible_to_ret2 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 { };
-
-//class internal_private { ret operator BOOST_TT_TRAIT_OP () const; };
-
-void run1() {
-   TEST_T(without, false);
-   TEST_T(internal, true);
-   TEST_T(external, true);
-   TEST_T(internal_comma1, true);
-   TEST_T(external_comma1, true);
-   TEST_T(internal_comma2, true);
-   TEST_T(external_comma2, true);
-   TEST_T(returns_int, true);
-   TEST_T(returns_void, true);
-   TEST_T(returns_void_star, true);
-   TEST_T(returns_double, true);
-   TEST_T(returns_convertible_to_ret1, true);
-   TEST_T(returns_convertible_to_ret2, 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_comma1, bool, false);
-   TEST_TR(internal_comma1, ret_with_comma1, true);
-   TEST_TR(internal_comma2, bool, false);
-   TEST_TR(internal_comma2, ret_with_comma2, true);
-   TEST_TR(external, bool, false);
-   TEST_TR(external, ret, true);
-   TEST_TR(returns_int, bool, true);
-   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_convertible_to_ret1, ret1, true);
-   TEST_TR(returns_convertible_to_ret2, ret2, true);
-   TEST_TR(Base1, bool, true);
-   TEST_TR(Derived1, bool, true);
-   TEST_TR(Base2, bool, false);
-   TEST_TR(Derived2, bool, true);
-// compile time error
-// TEST_T(internal_private, false);
-}
-
-}

Deleted: 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	2011-04-19 17:59:57 EDT (Tue, 19 Apr 2011)
+++ (empty file)
@@ -1,97 +0,0 @@
-//  (C) Copyright Frederic Bron 2009-2011.
-//  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)
-
-namespace {
-
-void run2() {
-   // test with only one template parameter
-   TEST_T(void, false);
-   TEST_T(bool, true);
-   TEST_T(char, true);
-   TEST_T(signed char, true);
-   TEST_T(short int, true);
-   TEST_T(int, true);
-   TEST_T(long int, true);
-   TEST_T(unsigned char, true);
-   TEST_T(unsigned short int, true);
-   TEST_T(unsigned int, true);
-   TEST_T(unsigned long int, true);
-   TEST_T(wchar_t, true);
-   TEST_T(float, true);
-   TEST_T(double, true);
-   TEST_T(long double, true);
-   TEST_T(void, false);
-#	undef CV
-#	define CV(T) const T
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	undef CV
-#	define CV(T) volatile T
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	undef CV
-#	define CV(T) const volatile T
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	undef CV
-#	define CV(T) const T&
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	undef CV
-#	define CV(T) volatile T&
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-#	undef CV
-#	define CV(T) const volatile T&
-   TEST_T(CV(bool), true);
-   TEST_T(CV(int), true);
-   TEST_T(CV(double), true);
-
-   // test with three template parameters
-   TEST_TR(bool, bool, true);
-   TEST_TR(char, bool, true);
-   TEST_TR(signed char, bool, true);
-   TEST_TR(short int, bool, true);
-   TEST_TR(int, bool, true);
-   TEST_TR(long int, bool, true);
-   TEST_TR(unsigned char, bool, true);
-   TEST_TR(unsigned short int, bool, true);
-   TEST_TR(unsigned int, bool, true);
-   TEST_TR(unsigned long int, bool, true);
-   TEST_TR(wchar_t, bool, true);
-   TEST_TR(float, bool, true);
-   TEST_TR(double, bool, true);
-   TEST_TR(long double, bool, true);
-   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);
-
-   // pointers
-   TEST_T(void*, true);
-   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);
-}
-}