Boost logo

Boost-Commit :

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