Fix some more gcc-4.5/6 testing errors.

Also suppress one new msvc warning (from 14.1 update 6).

.travis.yml

@@ -30,6 +30,26 @@ matrix:
     - os: linux
       env: TOOLSET=gcc COMPILER=g++ CXXSTD=03
 
+    - os: linux
+      compiler: g++-4.4
+      env: TOOLSET=gcc COMPILER=g++-4.4 CXXSTD=98,0x
+      addons:
+        apt:
+          packages:
+            - g++-4.4
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-4.6
+      env: TOOLSET=gcc COMPILER=g++-4.6 CXXSTD=03,0x
+      addons:
+        apt:
+          packages:
+            - g++-4.6
+          sources:
+            - ubuntu-toolchain-r-test
+
     - os: linux
       env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=03,11
       addons:
@@ -170,6 +190,17 @@ matrix:
             - ubuntu-toolchain-r-test
             - llvm-toolchain-trusty-4.0
 
+    - os: linux
+      compiler: clang++-5.0
+      env: TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-5.0
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-5.0
+
     - os: osx
       env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
       osx_image: xcode8.3

appveyor.yml

@@ -59,7 +59,7 @@ install:
   - git submodule update --init libs/throw_exception
   - git submodule update --init libs/type_index
   - git submodule update --init libs/utility
-  - git submodule update --init libs/functional
+  - git submodule update --init libs/container_hash
   - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\type_traits
   - bootstrap
   - b2 headers

doc/credits.qbk

@@ -18,8 +18,8 @@ current maintainer of the library.
 This version of type traits library is based on contributions by 
 Adobe Systems Inc, David Abrahams, Steve Cleary, 
 Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat Marcus, 
-Itay Maman, John Maddock, Thorsten Ottosen, Robert Ramey, Jeremy Siek
-and Antony Polukhin.
+Itay Maman, John Maddock, Thorsten Ottosen, Robert Ramey, Jeremy Siek,
+Antony Polukhin and Glen Fernandes.
 
 Mat Marcus and Jesse Jones invented, and 
 [@http://opensource.adobe.com/project4/project.shtml published a paper describing], 

doc/detected.qbk

@@ -0,0 +1,40 @@
+[/
+Copyright 2018 Glen Joseph Fernandes
+<glenjofe -at- gmail.com>
+
+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:detected detected]
+
+    template<template<class...> class Op, class... Args>
+    using detected_t = __below;
+
+__alias `Op<Args...>` if it is a valid template-id, otherwise
+`boost::nonesuch`.
+
+__std_paper [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4502.pdf N4502]
+
+__compat Requires C++11 variadic templates and C++11 template aliases.
+
+__header `#include <boost/type_traits/detected.hpp>`
+
+__examples
+
+Suppose you wish to determine whether a type has a `size()` const-member function, then given the meta-functions:
+
+   template <class T>
+   using size_member_tester = decltype(std::declval<const T&>().size());
+
+   template <class T>
+   using size_member_t = boost::detected_t<size_member_tester, T >;
+
+
+Then the type `size_member_t<T>` is an alias for `size_member_tester<T>` if the operation is valid, and an alias for
+`boost::nonesuch` otherwise.
+
+See also: __is_detected, __is_detected_convertible, __is_detected_exact.
+
+[endsect]

doc/detected_or.qbk

@@ -0,0 +1,45 @@
+[/
+Copyright 2018 Glen Joseph Fernandes
+<glenjofe -at- gmail.com>
+
+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:detected_or detected_or]
+
+    template<class Default, template<class...> class Op, class... Args>
+    using detected_or = __below;
+
+    template<class Default, template<class...> class Op, class... Args>
+    using detected_or_t = typename detected_or<Default, Op, Args...>::type;
+
+__alias An unspecified type with two public member type definitions:
+
+* `value_t` is __true_type if `Op<Args...>` is a valid template-id, otherwise
+  __false_type
+* `type` is `Op<Args...>` if it is a valid template-id, otherwise `Default`
+
+__std_paper [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4502.pdf N4502]
+
+__compat Requires C++11 variadic templates and C++11 template aliases.
+
+__header `#include <boost/type_traits/detected_or.hpp>`
+
+__examples
+
+Suppose we wish to declare a type that represents the difference between two values of type T, it should be
+T::difference_type if such a type exists, or std::ptrdiff_t otherwise:
+
+    template<class T>
+    using difference_t = typename T::difference_type;
+
+    template<class T>
+    using difference_type = boost::detected_or_t<std::ptrdiff_t, difference_t, T>;
+
+Now the type `difference_type<T>` gives us what we need.
+
+See also: __is_detected, __is_detected_convertible, __is_detected_exact.
+
+[endsect]

doc/has_bit_and.qbk

@@ -46,62 +46,7 @@ __examples
 
 [has_binary_operator_compat]
 
-[*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_bit_and<Lhs>` will produce a compiler error.
-For this reason `has_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_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 ambiguous overload.
-``
-struct A { };
-void operator&(const A&, const A&);
-struct B { operator A(); };
-boost::has_bit_and<A>::value; // this is fine
-boost::has_bit_and<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator&` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_bit_and.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator&(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_bit_and< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g&g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_bit_and< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b&b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_bit_and..&..A..contains<T>..const ]
 
 [endsect]
 

doc/has_bit_and_assign.qbk

@@ -46,62 +46,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*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_bit_and_assign<Lhs>` will produce a compiler error.
-For this reason `has_bit_and_assign` cannot be used to determine whether a type has a public `operator&=` or not.
-``
-struct A { private: void operator&=(const A&); };
-boost::has_bit_and_assign<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::has_bit_and_assign<A>::value; // this is fine
-boost::has_bit_and_assign<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator&=` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_bit_and_assign.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator&=(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_bit_and_assign< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g&=g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_bit_and_assign< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b&=b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_bit_and_assign..&=..A&..contains<T>&..[/Nothing]]
 
 [endsect]
 

doc/has_bit_or.qbk

@@ -46,62 +46,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*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_bit_or<Lhs>` will produce a compiler error.
-For this reason `has_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_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 ambiguous overload.
-``
-struct A { };
-void operator|(const A&, const A&);
-struct B { operator A(); };
-boost::has_bit_or<A>::value; // this is fine
-boost::has_bit_or<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator|` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_bit_or.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator|(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_bit_or< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g|g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_bit_or< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b|b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_bit_or..|..A..contains<T>..const ]
 
 [endsect]
 

doc/has_bit_or_assign.qbk

@@ -46,62 +46,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*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_bit_or_assign<Lhs>` will produce a compiler error.
-For this reason `has_bit_or_assign` cannot be used to determine whether a type has a public `operator|=` or not.
-``
-struct A { private: void operator|=(const A&); };
-boost::has_bit_or_assign<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::has_bit_or_assign<A>::value; // this is fine
-boost::has_bit_or_assign<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator|=` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_bit_or_assign.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator|=(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_bit_or_assign< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g|=g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_bit_or_assign< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b|=b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_bit_or_assign..|=..A&..contains<T>&..[/Nothing]]
 
 [endsect]
 

doc/has_bit_xor.qbk

@@ -46,62 +46,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*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_bit_xor<Lhs>` will produce a compiler error.
-For this reason `has_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_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 ambiguous overload.
-``
-struct A { };
-void operator^(const A&, const A&);
-struct B { operator A(); };
-boost::has_bit_xor<A>::value; // this is fine
-boost::has_bit_xor<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator^` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_bit_xor.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator^(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_bit_xor< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g^g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_bit_xor< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b^b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_bit_xor..^..A..contains<T>..const ]
 
 [endsect]
 

doc/has_bit_xor_assign.qbk

@@ -46,62 +46,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*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_bit_xor_assign<Lhs>` will produce a compiler error.
-For this reason `has_bit_xor_assign` cannot be used to determine whether a type has a public `operator^=` or not.
-``
-struct A { private: void operator^=(const A&); };
-boost::has_bit_xor_assign<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::has_bit_xor_assign<A>::value; // this is fine
-boost::has_bit_xor_assign<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator^=` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_bit_xor_assign.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator^=(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_bit_xor_assign< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g^=g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_bit_xor_assign< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b^=b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_bit_xor_assign..^=..A&..contains<T>&..[/Nothing]]
 
 [endsect]
 

doc/has_divides.qbk

@@ -48,62 +48,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*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_divides<Lhs>` will produce a compiler error.
-For this reason `has_divides` cannot be used to determine whether a type has a public `operator/` or not.
-``
-struct A { private: void operator/(const A&); };
-boost::has_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 ambiguous overload.
-``
-struct A { };
-void operator/(const A&, const A&);
-struct B { operator A(); };
-boost::has_divides<A>::value; // this is fine
-boost::has_divides<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator/` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_divides.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator/(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_divides< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g/g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_divides< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b/b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_divides../..A..contains<T>..const ]
 
 [endsect]
 

doc/has_divides_assign.qbk

@@ -48,62 +48,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*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_divides_assign<Lhs>` will produce a compiler error.
-For this reason `has_divides_assign` cannot be used to determine whether a type has a public `operator/=` or not.
-``
-struct A { private: void operator/=(const A&); };
-boost::has_divides_assign<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::has_divides_assign<A>::value; // this is fine
-boost::has_divides_assign<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator/=` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_divides_assign.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator/=(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_divides_assign< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g/=g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_divides_assign< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b/=b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_divides_assign../=..A&..contains<T>&..[/Nothing]]
 
 [endsect]
 

doc/has_equal_to.qbk

@@ -48,62 +48,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*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_equal_to<Lhs>` will produce a compiler error.
-For this reason `has_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_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 ambiguous overload.
-``
-struct A { };
-void operator==(const A&, const A&);
-struct B { operator A(); };
-boost::has_equal_to<A>::value; // this is fine
-boost::has_equal_to<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator==` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_equal_to.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator==(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_equal_to< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g==g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_equal_to< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b==b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_equal_to..==..bool..bool..const ]
 
 [endsect]
 

doc/has_greater.qbk

@@ -48,62 +48,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*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_greater<Lhs>` will produce a compiler error.
-For this reason `has_greater` cannot be used to determine whether a type has a public `operator>` or not.
-``
-struct A { private: void operator>(const A&); };
-boost::has_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::has_greater<A>::value; // this is fine
-boost::has_greater<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator>` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_greater.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator>(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_greater< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g>g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_greater< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b>b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_greater..>..bool..bool..const ]
 
 [endsect]
 

doc/has_greater_equal.qbk

@@ -48,62 +48,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*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_greater_equal<Lhs>` will produce a compiler error.
-For this reason `has_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_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::has_greater_equal<A>::value; // this is fine
-boost::has_greater_equal<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator>=` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_greater_equal.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator>=(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_greater_equal< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g>=g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_greater_equal< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b>=b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_greater_equal..>=..bool..bool..const ]
 
 [endsect]
 

doc/has_left_shift.qbk

@@ -49,62 +49,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*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_left_shift<Lhs>` will produce a compiler error.
-For this reason `has_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_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::has_left_shift<A>::value; // this is fine
-boost::has_left_shift<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator<<` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_left_shift.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator<<(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_left_shift< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g<<g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_left_shift< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b<<b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_left_shift..<<..A..contains<T>..const ]
 
 [endsect]
 

doc/has_left_shift_assign.qbk

@@ -46,62 +46,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*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_left_shift_assign<Lhs>` will produce a compiler error.
-For this reason `has_left_shift_assign` cannot be used to determine whether a type has a public `operator<<=` or not.
-``
-struct A { private: void operator<<=(const A&); };
-boost::has_left_shift_assign<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::has_left_shift_assign<A>::value; // this is fine
-boost::has_left_shift_assign<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator<<=` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_left_shift_assign.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator<<=(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_left_shift_assign< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g<<=g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_left_shift_assign< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b<<=b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_left_shift_assign..<<=..A&..contains<T>&..[/]]
 
 [endsect]
 

doc/has_less.qbk

@@ -48,62 +48,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*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_less<Lhs>` will produce a compiler error.
-For this reason `has_less` cannot be used to determine whether a type has a public `operator<` or not.
-``
-struct A { private: void operator<(const A&); };
-boost::has_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::has_less<A>::value; // this is fine
-boost::has_less<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator<` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_less.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator<(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_less< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g<g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_less< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b<b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_less..<..bool..bool..const ]
 
 [endsect]
 

doc/has_less_equal.qbk

@@ -48,62 +48,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*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_less_equal<Lhs>` will produce a compiler error.
-For this reason `has_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_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::has_less_equal<A>::value; // this is fine
-boost::has_less_equal<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator<=` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_less_equal.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator<=(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_less_equal< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g<=g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_less_equal< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b<=b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_less_equal..<=..bool..bool..const ]
 
 [endsect]
 

doc/has_logical_and.qbk

@@ -46,63 +46,8 @@ __examples
 
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
+[binary_operator_known_issues has_logical_and..&&..bool..bool..const ]
 
-[*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_logical_and<Lhs>` will produce a compiler error.
-For this reason `has_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_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 ambiguous overload.
-``
-struct A { };
-void operator&&(const A&, const A&);
-struct B { operator A(); };
-boost::has_logical_and<A>::value; // this is fine
-boost::has_logical_and<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator&&` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_logical_and.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator&&(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_logical_and< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g&&g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_logical_and< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b&&b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
 
 [endsect]
 

doc/has_logical_or.qbk

@@ -47,62 +47,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*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_logical_or<Lhs>` will produce a compiler error.
-For this reason `has_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_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 ambiguous overload.
-``
-struct A { };
-void operator||(const A&, const A&);
-struct B { operator A(); };
-boost::has_logical_or<A>::value; // this is fine
-boost::has_logical_or<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator||` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_logical_or.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator||(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_logical_or< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g||g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_logical_or< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b||b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_logical_or..||..bool..bool..const ]
 
 [endsect]
 

doc/has_minus.qbk

@@ -48,62 +48,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*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_minus<Lhs>` will produce a compiler error.
-For this reason `has_minus` cannot be used to determine whether a type has a public `operator-` or not.
-``
-struct A { private: void operator-(const A&); };
-boost::has_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 ambiguous overload.
-``
-struct A { };
-void operator-(const A&, const A&);
-struct B { operator A(); };
-boost::has_minus<A>::value; // this is fine
-boost::has_minus<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator-` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_minus.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator-(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_minus< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g-g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_minus< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b-b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_minus..-..A..contains<T>..const ]
 
 [endsect]
 

doc/has_minus_assign.qbk

@@ -48,62 +48,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*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_minus_assign<Lhs>` will produce a compiler error.
-For this reason `has_minus_assign` cannot be used to determine whether a type has a public `operator-=` or not.
-``
-struct A { private: void operator-=(const A&); };
-boost::has_minus_assign<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::has_minus_assign<A>::value; // this is fine
-boost::has_minus_assign<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator-=` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_minus_assign.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator-=(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_minus_assign< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g-=g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_minus_assign< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b-=b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_minus_assign..-=..A&..contains<T>&..[/]]
 
 [endsect]
 

doc/has_modulus.qbk

@@ -46,62 +46,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*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_modulus<Lhs>` will produce a compiler error.
-For this reason `has_modulus` cannot be used to determine whether a type has a public `operator%` or not.
-``
-struct A { private: void operator%(const A&); };
-boost::has_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::has_modulus<A>::value; // this is fine
-boost::has_modulus<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator%` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_modulus.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator%(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_modulus< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g%g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_modulus< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b%b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_modulus..%..A..contains<T>..const ]
 
 [endsect]
 

doc/has_modulus_assign.qbk

@@ -46,62 +46,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*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_modulus_assign<Lhs>` will produce a compiler error.
-For this reason `has_modulus_assign` cannot be used to determine whether a type has a public `operator%=` or not.
-``
-struct A { private: void operator%=(const A&); };
-boost::has_modulus_assign<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::has_modulus_assign<A>::value; // this is fine
-boost::has_modulus_assign<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator%=` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_modulus_assign.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator%=(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_modulus_assign< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g%=g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_modulus_assign< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b%=b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_modulus_assign..%=..A&..contains<T>&..[/]]
 
 [endsect]
 

doc/has_multiplies.qbk

@@ -48,62 +48,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*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_multiplies<Lhs>` will produce a compiler error.
-For this reason `has_multiplies` cannot be used to determine whether a type has a public `operator*` or not.
-``
-struct A { private: void operator*(const A&); };
-boost::has_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 ambiguous overload.
-``
-struct A { };
-void operator*(const A&, const A&);
-struct B { operator A(); };
-boost::has_multiplies<A>::value; // this is fine
-boost::has_multiplies<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator*` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_multiplies.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator*(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_multiplies< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g*g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_multiplies< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b*b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_multiplies..*..A..contains<T>..const ]
 
 [endsect]
 

doc/has_multiplies_assign.qbk

@@ -48,62 +48,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*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_multiplies_assign<Lhs>` will produce a compiler error.
-For this reason `has_multiplies_assign` cannot be used to determine whether a type has a public `operator*=` or not.
-``
-struct A { private: void operator*=(const A&); };
-boost::has_multiplies_assign<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::has_multiplies_assign<A>::value; // this is fine
-boost::has_multiplies_assign<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator*=` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_multiplies_assign.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator*=(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_multiplies_assign< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g*=g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_multiplies_assign< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b*=b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_multiplies_assign..*=..A&..contains<T>&..[/]]
 
 [endsect]
 

doc/has_not_equal_to.qbk

@@ -48,62 +48,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*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_not_equal_to<Lhs>` will produce a compiler error.
-For this reason `has_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_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 ambiguous overload.
-``
-struct A { };
-void operator!=(const A&, const A&);
-struct B { operator A(); };
-boost::has_not_equal_to<A>::value; // this is fine
-boost::has_not_equal_to<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator!=` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_not_equal_to.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator!=(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_not_equal_to< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g!=g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_not_equal_to< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b!=b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_not_equal_to..!=..bool..bool..const ]
 
 [endsect]
 

doc/has_plus.qbk

@@ -48,62 +48,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*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_plus<Lhs>` will produce a compiler error.
-For this reason `has_plus` cannot be used to determine whether a type has a public `operator+` or not.
-``
-struct A { private: void operator+(const A&); };
-boost::has_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 ambiguous overload.
-``
-struct A { };
-void operator+(const A&, const A&);
-struct B { operator A(); };
-boost::has_plus<A>::value; // this is fine
-boost::has_plus<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator+` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_plus.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator+(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_plus< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g+g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_plus< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b+b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_plus..+..A..contains<T>..const ]
 
 [endsect]
 

doc/has_plus_assign.qbk

@@ -48,62 +48,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*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_plus_assign<Lhs>` will produce a compiler error.
-For this reason `has_plus_assign` cannot be used to determine whether a type has a public `operator+=` or not.
-``
-struct A { private: void operator+=(const A&); };
-boost::has_plus_assign<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::has_plus_assign<A>::value; // this is fine
-boost::has_plus_assign<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator+=` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_plus_assign.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator+=(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_plus_assign< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g+=g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_plus_assign< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b+=b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_plus_assign..+=..A&..contains<T>&..const ]
 
 [endsect]
 

doc/has_right_shift.qbk

@@ -49,62 +49,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*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_right_shift<Lhs>` will produce a compiler error.
-For this reason `has_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_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::has_right_shift<A>::value; // this is fine
-boost::has_right_shift<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator>>` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_right_shift.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator>>(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_right_shift< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g>>g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_right_shift< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b>>b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_right_shift..>>..A..contains<T>..const ]
 
 [endsect]
 

doc/has_right_shift_assign.qbk

@@ -46,62 +46,7 @@ __examples
 
 [*See also:] [link boost_typetraits.category.value_traits.operators Operator Type Traits]
 
-[*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_right_shift_assign<Lhs>` will produce a compiler error.
-For this reason `has_right_shift_assign` cannot be used to determine whether a type has a public `operator>>=` or not.
-``
-struct A { private: void operator>>=(const A&); };
-boost::has_right_shift_assign<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::has_right_shift_assign<A>::value; // this is fine
-boost::has_right_shift_assign<B>::value; // error: ambiguous overload
-``
-
-* There is an issue when applying this trait to template classes.
-If `operator>>=` is defined but does not bind for a given template type,
-it is still detected by the trait which returns `true` instead of `false`.
-Example:
-``
-#include <boost/type_traits/has_right_shift_assign.hpp>
-#include <iostream>
-
-template <class T>
-struct contains { T data; };
-
-template <class T>
-bool operator>>=(const contains<T> &lhs, const contains<T> &rhs) {
-	return f(lhs.data, rhs.data);
-}
-
-class bad { };
-class good { };
-bool f(const good&, const good&) { }
-
-int main() {
-	std::cout<<std::boolalpha;
-	// works fine for contains<good>
-	std::cout<<boost::has_right_shift_assign< contains< good > >::value<<'\n'; // true
-	contains<good> g;
-	g>>=g; // ok
-	// does not work for contains<bad>
-	std::cout<<boost::has_right_shift_assign< contains< bad > >::value<<'\n'; // true, should be false
-	contains<bad> b;
-	b>>=b; // compile time error
-	return 0;
-}
-``
-
-* `volatile` qualifier is not properly handled and would lead to undefined behavior
+[binary_operator_known_issues has_right_shift_assign..>>=..A&..contains<T>&..[/]]
 
 [endsect]
 

doc/history.qbk

@@ -7,6 +7,17 @@
 
 [section:history History]
 
+[h4 Boost 1.67.0]
+
+* Added new traits __detected, __detected_or, __is_detected, __is_detected_convertible, __is_detected_exact, __is_complete.
+* Added greatly improved code for detecting binary operators.
+* Add assertions for completeness to traits which require complete types as arguments: this prevents various traits from giving eroneous results from incomplete types.
+* Fix minor issue with mpl compatibility, see [@https://svn.boost.org/trac/boost/ticket/12212 #12212].
+* Add macro to indicate when is_constructible is fully implemented, see [@https://svn.boost.org/trac/boost/ticket/12003 #12003].
+* Update __is_function and __is_member_function_pointer to work correctly with C++17 noexcept specifications.
+* Add workaround for __is_default_constructible and `std::pair`.
+* Added fallback for __is_nothrow_swappable on pre-C++11 compilers.
+
 [h4 Boost 1.64.0]
 
 * Added new trait __make_void.
@@ -16,7 +27,7 @@
 * Refactored traits to depend only on Boost.Config.  Greatly simplified code to improve readability and remove workarounds for old compilers no longer supported.
 * Fix __decay to follow C++11 semantics, see [@https://svn.boost.org/trac/boost/ticket/7760 #7760].
 * Added a number of new traits __is_assignable, __is_default_constructible, __is_constructible and __is_destructible required to fix bugs in a number of other traits,
-see for example [@https://svn.boost.org/trac/boost/ticket/7760 #11324].
+see for example [@https://svn.boost.org/trac/boost/ticket/11324 #11324].
 
 [h4 Boost 1.58.0]
 

doc/html/boost_typetraits/category/value_traits/properties.html

@@ -96,6 +96,9 @@
 <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="keyword">struct</span> <a class="link" href="../../reference/is_default_constructible.html" title="is_default_constructible">is_default_constructible</a><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">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <a class="link" href="../../reference/is_list_constructible.html" title="is_list_constructible">is_list_constructible</a><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="keyword">struct</span> <a class="link" href="../../reference/is_destructible.html" title="is_destructible">is_destructible</a><span class="special">;</span>
 

doc/html/boost_typetraits/credits.html

@@ -39,7 +39,7 @@
       This version of type traits library is based on contributions by Adobe Systems
       Inc, David Abrahams, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant,
       Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Thorsten Ottosen, Robert
-      Ramey, Jeremy Siek and Antony Polukhin.
+      Ramey, Jeremy Siek, Antony Polukhin and Glen Fernandes.
     </p>
 <p>
       Mat Marcus and Jesse Jones invented, and <a href="http://opensource.adobe.com/project4/project.shtml" target="_top">published

doc/html/boost_typetraits/history.html

@@ -28,6 +28,49 @@
 </h2></div></div></div>
 <h5>
 <a name="boost_typetraits.history.h0"></a>
+      <span class="phrase"><a name="boost_typetraits.history.boost_1_67_0"></a></span><a class="link" href="history.html#boost_typetraits.history.boost_1_67_0">Boost
+      1.67.0</a>
+    </h5>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
+          Added new traits <a class="link" href="reference/detected.html" title="detected">detected</a>,
+          <a class="link" href="reference/detected_or.html" title="detected_or">detected_or</a>,
+          <a class="link" href="reference/is_detected.html" title="is_detected">is_detected</a>,
+          <a class="link" href="reference/is_detected_convertible.html" title="is_detected_convertible">is_detected_convertible</a>,
+          <a class="link" href="reference/is_detected_exact.html" title="is_detected_exact">is_detected_exact</a>,
+          <a class="link" href="reference/is_complete.html" title="is_complete">is_complete</a>.
+        </li>
+<li class="listitem">
+          Added greatly improved code for detecting binary operators.
+        </li>
+<li class="listitem">
+          Add assertions for completeness to traits which require complete types
+          as arguments: this prevents various traits from giving eroneous results
+          from incomplete types.
+        </li>
+<li class="listitem">
+          Fix minor issue with mpl compatibility, see <a href="https://svn.boost.org/trac/boost/ticket/12212" target="_top">#12212</a>.
+        </li>
+<li class="listitem">
+          Add macro to indicate when is_constructible is fully implemented, see
+          <a href="https://svn.boost.org/trac/boost/ticket/12003" target="_top">#12003</a>.
+        </li>
+<li class="listitem">
+          Update <a class="link" href="reference/is_function.html" title="is_function">is_function</a>
+          and <a class="link" href="reference/is_member_function_pointer.html" title="is_member_function_pointer">is_member_function_pointer</a>
+          to work correctly with C++17 noexcept specifications.
+        </li>
+<li class="listitem">
+          Add workaround for <a class="link" href="reference/is_default_constructible.html" title="is_default_constructible">is_default_constructible</a>
+          and <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span></code>.
+        </li>
+<li class="listitem">
+          Added fallback for <a class="link" href="reference/is_nothrow_swappable.html" title="is_nothrow_swappable">is_nothrow_swappable</a>
+          on pre-C++11 compilers.
+        </li>
+</ul></div>
+<h5>
+<a name="boost_typetraits.history.h1"></a>
       <span class="phrase"><a name="boost_typetraits.history.boost_1_64_0"></a></span><a class="link" href="history.html#boost_typetraits.history.boost_1_64_0">Boost
       1.64.0</a>
     </h5>
@@ -35,7 +78,7 @@
           Added new trait <a class="link" href="reference/make_void.html" title="make_void">make_void</a>.
         </li></ul></div>
 <h5>
-<a name="boost_typetraits.history.h1"></a>
+<a name="boost_typetraits.history.h2"></a>
       <span class="phrase"><a name="boost_typetraits.history.boost_1_60_0"></a></span><a class="link" href="history.html#boost_typetraits.history.boost_1_60_0">Boost
       1.60.0</a>
     </h5>
@@ -54,11 +97,11 @@
           <a class="link" href="reference/is_default_constructible.html" title="is_default_constructible">is_default_constructible</a>,
           <a class="link" href="reference/is_constructible.html" title="is_constructible">is_constructible</a>
           and <a class="link" href="reference/is_destructible.html" title="is_destructible">is_destructible</a>
-          required to fix bugs in a number of other traits, see for example <a href="https://svn.boost.org/trac/boost/ticket/7760" target="_top">#11324</a>.
+          required to fix bugs in a number of other traits, see for example <a href="https://svn.boost.org/trac/boost/ticket/11324" target="_top">#11324</a>.
         </li>
 </ul></div>
 <h5>
-<a name="boost_typetraits.history.h2"></a>
+<a name="boost_typetraits.history.h3"></a>
       <span class="phrase"><a name="boost_typetraits.history.boost_1_58_0"></a></span><a class="link" href="history.html#boost_typetraits.history.boost_1_58_0">Boost
       1.58.0</a>
     </h5>
@@ -73,7 +116,7 @@
         </li>
 </ul></div>
 <h5>
-<a name="boost_typetraits.history.h3"></a>
+<a name="boost_typetraits.history.h4"></a>
       <span class="phrase"><a name="boost_typetraits.history.boost_1_57_0"></a></span><a class="link" href="history.html#boost_typetraits.history.boost_1_57_0">Boost
       1.57.0</a>
     </h5>
@@ -87,7 +130,7 @@
         </li>
 </ul></div>
 <h5>
-<a name="boost_typetraits.history.h4"></a>
+<a name="boost_typetraits.history.h5"></a>
       <span class="phrase"><a name="boost_typetraits.history.boost_1_56_0"></a></span><a class="link" href="history.html#boost_typetraits.history.boost_1_56_0">Boost
       1.56.0</a>
     </h5>
@@ -96,7 +139,7 @@
           <a href="https://svn.boost.org/trac/boost/ticket/9474" target="_top">#9474</a>.
         </li></ul></div>
 <h5>
-<a name="boost_typetraits.history.h5"></a>
+<a name="boost_typetraits.history.h6"></a>
       <span class="phrase"><a name="boost_typetraits.history.boost_1_55_0"></a></span><a class="link" href="history.html#boost_typetraits.history.boost_1_55_0">Boost
       1.55.0</a>
     </h5>
@@ -104,7 +147,7 @@
           Added new trait <a class="link" href="reference/is_copy_constructible.html" title="is_copy_constructible">is_copy_constructible</a>.
         </li></ul></div>
 <h5>
-<a name="boost_typetraits.history.h6"></a>
+<a name="boost_typetraits.history.h7"></a>
       <span class="phrase"><a name="boost_typetraits.history.boost_1_54_0"></a></span><a class="link" href="history.html#boost_typetraits.history.boost_1_54_0">Boost
       1.54.0</a>
     </h5>
@@ -115,7 +158,7 @@
           <a class="link" href="reference/has_trivial_move_constructor.html" title="has_trivial_move_constructor">has_trivial_move_constructor</a>.
         </li></ul></div>
 <h5>
-<a name="boost_typetraits.history.h7"></a>
+<a name="boost_typetraits.history.h8"></a>
       <span class="phrase"><a name="boost_typetraits.history.boost_1_47_0"></a></span><a class="link" href="history.html#boost_typetraits.history.boost_1_47_0">Boost
       1.47.0</a>
     </h5>
@@ -130,7 +173,7 @@
         </li>
 </ul></div>
 <h5>
-<a name="boost_typetraits.history.h8"></a>
+<a name="boost_typetraits.history.h9"></a>
       <span class="phrase"><a name="boost_typetraits.history.boost_1_45_0"></a></span><a class="link" href="history.html#boost_typetraits.history.boost_1_45_0">Boost
       1.45.0</a>
     </h5>
@@ -147,7 +190,7 @@
         </li>
 </ul></div>
 <h5>
-<a name="boost_typetraits.history.h9"></a>
+<a name="boost_typetraits.history.h10"></a>
       <span class="phrase"><a name="boost_typetraits.history.boost_1_44_0"></a></span><a class="link" href="history.html#boost_typetraits.history.boost_1_44_0">Boost
       1.44.0</a>
     </h5>
@@ -164,7 +207,7 @@
         </li>
 </ul></div>
 <h5>
-<a name="boost_typetraits.history.h10"></a>
+<a name="boost_typetraits.history.h11"></a>
       <span class="phrase"><a name="boost_typetraits.history.boost_1_42_0"></a></span><a class="link" href="history.html#boost_typetraits.history.boost_1_42_0">Boost
       1.42.0</a>
     </h5>

doc/html/boost_typetraits/reference.html

@@ -41,6 +41,8 @@
 <dt><span class="section"><a href="reference/copy_cv.html">copy_cv</a></span></dt>
 <dt><span class="section"><a href="reference/decay.html">decay</a></span></dt>
 <dt><span class="section"><a href="reference/declval.html">declval</a></span></dt>
+<dt><span class="section"><a href="reference/detected.html">detected</a></span></dt>
+<dt><span class="section"><a href="reference/detected_or.html">detected_or</a></span></dt>
 <dt><span class="section"><a href="reference/extent.html">extent</a></span></dt>
 <dt><span class="section"><a href="reference/floating_point_promotion.html">floating_point_promotion</a></span></dt>
 <dt><span class="section"><a href="reference/function_traits.html">function_traits</a></span></dt>
@@ -106,6 +108,7 @@
 <dt><span class="section"><a href="reference/is_assignable.html">is_assignable</a></span></dt>
 <dt><span class="section"><a href="reference/is_base_of.html">is_base_of</a></span></dt>
 <dt><span class="section"><a href="reference/is_class.html">is_class</a></span></dt>
+<dt><span class="section"><a href="reference/is_complete.html">is_complete</a></span></dt>
 <dt><span class="section"><a href="reference/is_complex.html">is_complex</a></span></dt>
 <dt><span class="section"><a href="reference/is_compound.html">is_compound</a></span></dt>
 <dt><span class="section"><a href="reference/is_const.html">is_const</a></span></dt>
@@ -115,6 +118,9 @@
 <dt><span class="section"><a href="reference/is_copy_constructible.html">is_copy_constructible</a></span></dt>
 <dt><span class="section"><a href="reference/is_default_constructible.html">is_default_constructible</a></span></dt>
 <dt><span class="section"><a href="reference/is_destructible.html">is_destructible</a></span></dt>
+<dt><span class="section"><a href="reference/is_detected.html">is_detected</a></span></dt>
+<dt><span class="section"><a href="reference/is_detected_convertible.html">is_detected_convertible</a></span></dt>
+<dt><span class="section"><a href="reference/is_detected_exact.html">is_detected_exact</a></span></dt>
 <dt><span class="section"><a href="reference/is_empty.html">is_empty</a></span></dt>
 <dt><span class="section"><a href="reference/is_enum.html">is_enum</a></span></dt>
 <dt><span class="section"><a href="reference/is_final.html">is_final</a></span></dt>
@@ -122,12 +128,14 @@
 <dt><span class="section"><a href="reference/is_function.html">is_function</a></span></dt>
 <dt><span class="section"><a href="reference/is_fundamental.html">is_fundamental</a></span></dt>
 <dt><span class="section"><a href="reference/is_integral.html">is_integral</a></span></dt>
+<dt><span class="section"><a href="reference/is_list_constructible.html">is_list_constructible</a></span></dt>
 <dt><span class="section"><a href="reference/is_lvalue_reference.html">is_lvalue_reference</a></span></dt>
 <dt><span class="section"><a href="reference/is_member_function_pointer.html">is_member_function_pointer</a></span></dt>
 <dt><span class="section"><a href="reference/is_member_object_pointer.html">is_member_object_pointer</a></span></dt>
 <dt><span class="section"><a href="reference/is_member_pointer.html">is_member_pointer</a></span></dt>
 <dt><span class="section"><a href="reference/is_nothrow_move_assignable.html">is_nothrow_move_assignable</a></span></dt>
 <dt><span class="section"><a href="reference/is_nothrow_move_constructible.html">is_nothrow_move_constructible</a></span></dt>
+<dt><span class="section"><a href="reference/is_nothrow_swappable.html">is_nothrow_swappable</a></span></dt>
 <dt><span class="section"><a href="reference/is_object.html">is_object</a></span></dt>
 <dt><span class="section"><a href="reference/is_pod.html">is_pod</a></span></dt>
 <dt><span class="section"><a href="reference/is_pointer.html">is_pointer</a></span></dt>
@@ -146,11 +154,13 @@
 <dt><span class="section"><a href="reference/make_signed.html">make_signed</a></span></dt>
 <dt><span class="section"><a href="reference/make_unsigned.html">make_unsigned</a></span></dt>
 <dt><span class="section"><a href="reference/make_void.html">make_void</a></span></dt>
+<dt><span class="section"><a href="reference/nonesuch.html">nonesuch</a></span></dt>
 <dt><span class="section"><a href="reference/promote.html">promote</a></span></dt>
 <dt><span class="section"><a href="reference/rank.html">rank</a></span></dt>
 <dt><span class="section"><a href="reference/remove_all_extents.html">remove_all_extents</a></span></dt>
 <dt><span class="section"><a href="reference/remove_const.html">remove_const</a></span></dt>
 <dt><span class="section"><a href="reference/remove_cv.html">remove_cv</a></span></dt>
+<dt><span class="section"><a href="reference/remove_cv_ref.html">remove_cv_ref</a></span></dt>
 <dt><span class="section"><a href="reference/remove_extent.html">remove_extent</a></span></dt>
 <dt><span class="section"><a href="reference/remove_pointer.html">remove_pointer</a></span></dt>
 <dt><span class="section"><a href="reference/remove_reference.html">remove_reference</a></span></dt>

doc/html/boost_typetraits/reference/declval.html

@@ -7,7 +7,7 @@
 <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="decay.html" title="decay">
-<link rel="next" href="extent.html" title="extent">
+<link rel="next" href="detected.html" title="detected">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -20,7 +20,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="decay.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="extent.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="decay.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="detected.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
@@ -60,7 +60,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="decay.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="extent.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="decay.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="detected.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

doc/html/boost_typetraits/reference/detected.html

@@ -0,0 +1,88 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>detected</title>
+<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
+<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="declval.html" title="declval">
+<link rel="next" href="detected_or.html" title="detected_or">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="declval.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="detected_or.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.reference.detected"></a><a class="link" href="detected.html" title="detected">detected</a>
+</h3></div></div></div>
+<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...&gt;</span> <span class="keyword">class</span> <span class="identifier">Op</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span>
+<span class="keyword">using</span> <span class="identifier">detected_t</span> <span class="special">=</span> <em class="replaceable"><code>see-below</code></em><span class="special">;</span>
+</pre>
+<p>
+        <span class="bold"><strong>Aliases:</strong></span> <code class="computeroutput"><span class="identifier">Op</span><span class="special">&lt;</span><span class="identifier">Args</span><span class="special">...&gt;</span></code> if it is a valid template-id, otherwise
+        <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">nonesuch</span></code>.
+      </p>
+<p>
+        <span class="bold"><strong>C++ Standard Paper:</strong></span> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4502.pdf" target="_top">N4502</a>
+      </p>
+<p>
+        <span class="bold"><strong>Compiler Compatibility:</strong></span> Requires C++11 variadic
+        templates and C++11 template aliases.
+      </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">detected</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>
+<p>
+        Suppose you wish to determine whether a type has a <code class="computeroutput"><span class="identifier">size</span><span class="special">()</span></code> const-member function, then given the meta-functions:
+      </p>
+<pre class="programlisting"><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="keyword">using</span> <span class="identifier">size_member_tester</span> <span class="special">=</span> <span class="keyword">decltype</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">declval</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;&gt;().</span><span class="identifier">size</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="keyword">using</span> <span class="identifier">size_member_t</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">detected_t</span><span class="special">&lt;</span><span class="identifier">size_member_tester</span><span class="special">,</span> <span class="identifier">T</span> <span class="special">&gt;;</span>
+</pre>
+<p>
+        Then the type <code class="computeroutput"><span class="identifier">size_member_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
+        is an alias for <code class="computeroutput"><span class="identifier">size_member_tester</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
+        if the operation is valid, and an alias for <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">nonesuch</span></code>
+        otherwise.
+      </p>
+<p>
+        See also: <a class="link" href="is_detected.html" title="is_detected">is_detected</a>,
+        <a class="link" href="is_detected_convertible.html" title="is_detected_convertible">is_detected_convertible</a>,
+        <a class="link" href="is_detected_exact.html" title="is_detected_exact">is_detected_exact</a>.
+      </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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="declval.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="detected_or.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

doc/html/boost_typetraits/reference/detected_or.html

@@ -0,0 +1,102 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>detected_or</title>
+<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
+<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="detected.html" title="detected">
+<link rel="next" href="extent.html" title="extent">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="detected.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="extent.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.reference.detected_or"></a><a class="link" href="detected_or.html" title="detected_or">detected_or</a>
+</h3></div></div></div>
+<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Default</span><span class="special">,</span> <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...&gt;</span> <span class="keyword">class</span> <span class="identifier">Op</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span>
+<span class="keyword">using</span> <span class="identifier">detected_or</span> <span class="special">=</span> <em class="replaceable"><code>see-below</code></em><span class="special">;</span>
+
+<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Default</span><span class="special">,</span> <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...&gt;</span> <span class="keyword">class</span> <span class="identifier">Op</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span>
+<span class="keyword">using</span> <span class="identifier">detected_or_t</span> <span class="special">=</span> <span class="keyword">typename</span> <span class="identifier">detected_or</span><span class="special">&lt;</span><span class="identifier">Default</span><span class="special">,</span> <span class="identifier">Op</span><span class="special">,</span> <span class="identifier">Args</span><span class="special">...&gt;::</span><span class="identifier">type</span><span class="special">;</span>
+</pre>
+<p>
+        <span class="bold"><strong>Aliases:</strong></span> An unspecified type with two public
+        member type definitions:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
+            <code class="computeroutput"><span class="identifier">value_t</span></code> is <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>
+            if <code class="computeroutput"><span class="identifier">Op</span><span class="special">&lt;</span><span class="identifier">Args</span><span class="special">...&gt;</span></code>
+            is a valid template-id, otherwise <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>
+          </li>
+<li class="listitem">
+            <code class="computeroutput"><span class="identifier">type</span></code> is <code class="computeroutput"><span class="identifier">Op</span><span class="special">&lt;</span><span class="identifier">Args</span><span class="special">...&gt;</span></code>
+            if it is a valid template-id, otherwise <code class="computeroutput"><span class="identifier">Default</span></code>
+          </li>
+</ul></div>
+<p>
+        <span class="bold"><strong>C++ Standard Paper:</strong></span> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4502.pdf" target="_top">N4502</a>
+      </p>
+<p>
+        <span class="bold"><strong>Compiler Compatibility:</strong></span> Requires C++11 variadic
+        templates and C++11 template aliases.
+      </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">detected_or</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>
+<p>
+        Suppose we wish to declare a type that represents the difference between
+        two values of type T, it should be T::difference_type if such a type exists,
+        or std::ptrdiff_t otherwise:
+      </p>
+<pre class="programlisting"><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="keyword">using</span> <span class="identifier">difference_t</span> <span class="special">=</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">::</span><span class="identifier">difference_type</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="keyword">using</span> <span class="identifier">difference_type</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">detected_or_t</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ptrdiff_t</span><span class="special">,</span> <span class="identifier">difference_t</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;;</span>
+</pre>
+<p>
+        Now the type <code class="computeroutput"><span class="identifier">difference_type</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
+        gives us what we need.
+      </p>
+<p>
+        See also: <a class="link" href="is_detected.html" title="is_detected">is_detected</a>,
+        <a class="link" href="is_detected_convertible.html" title="is_detected_convertible">is_detected_convertible</a>,
+        <a class="link" href="is_detected_exact.html" title="is_detected_exact">is_detected_exact</a>.
+      </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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="detected.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="extent.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

doc/html/boost_typetraits/reference/extent.html

@@ -6,7 +6,7 @@
 <meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
 <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="declval.html" title="declval">
+<link rel="prev" href="detected_or.html" title="detected_or">
 <link rel="next" href="floating_point_promotion.html" title="floating_point_promotion">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -20,7 +20,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="declval.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="floating_point_promotion.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="detected_or.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="floating_point_promotion.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
@@ -107,7 +107,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="declval.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="floating_point_promotion.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="detected_or.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="floating_point_promotion.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

doc/html/boost_typetraits/reference/has_bit_and.html

@@ -107,68 +107,82 @@
 <p>
         <span class="bold"><strong>Known issues:</strong></span>
       </p>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
-            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;</span></code>
-            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
-            then instantiating <code class="computeroutput"><span class="identifier">has_bit_and</span><span class="special">&lt;</span><span class="identifier">Lhs</span><span class="special">&gt;</span></code> will produce a compiler error. For
-            this reason <code class="computeroutput"><span class="identifier">has_bit_and</span></code>
-            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;</span></code>
-            or not.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&amp;(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_and</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator&amp;(const A&amp;) is private</span>
-</pre>
-          </li>
-<li class="listitem">
-            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.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&amp;(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_and</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_and</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span>
-</pre>
-          </li>
-<li class="listitem">
-            There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;</span></code>
-            is defined but does not bind for a given template type, it is still detected
-            by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code>
-            instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example:
-<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_bit_and</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<p>
+        For modern compilers (those that support arbitrary SFINAE-expressions and
+        decltype/declval) this trait offers near perfect detection. In this situation
+        the macro <code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        will be defined after including <code class="literal">&lt;boost/type_traits/has_bit_and.hpp&gt;</code>.
+        Please note however, that detection is based on function signature only,
+        in the case that the operator is a function template then has_bit_and cannot
+        perform introspection of the template function body to ensure that the type
+        meets all of the conceptual requirements of the actual code.
+      </p>
+<p>
+        Example:
+      </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>has_bit_and<span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</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="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span>
+<span class="keyword">struct</span> <span class="identifier">contains</span>
+<span class="special">{</span>
+   <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span>
+   <span class="identifier">contains</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">d</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">data</span><span class="special">(</span><span class="identifier">d</span><span class="special">)</span> <span class="special">{}</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="keyword">bool</span> <span class="keyword">operator</span><span class="special">&amp;(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
-	<span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
+contains&lt;T&gt; <span class="keyword">operator</span> &amp; <span class="special">(</span>const <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
+    <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
 <span class="special">}</span>
 
 <span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span>
 <span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="special">}</span>
+<span class="identifier">good</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="comment">/*something*/</span><span class="special">;</span> <span class="special">}</span>
 
 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
-	<span class="comment">// works fine for contains&lt;good&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_and</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
-	<span class="identifier">g</span><span class="special">&amp;</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
-	<span class="comment">// does not work for contains&lt;bad&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_and</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
-	<span class="identifier">b</span><span class="special">&amp;</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
-	<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
+    <span class="comment">// works fine for contains&lt;good&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_bit_and<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
+    <span class="identifier">g</span><span class="special">&amp;</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
+    <span class="comment">// does not work for contains&lt;bad&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_bit_and<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
+    <span class="identifier">b</span><span class="special">&amp;</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
+    <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
 <span class="special">}</span>
 </pre>
-          </li>
-<li class="listitem">
+<p>
+        For older compilers (<code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        not defined) then there are a number of issues:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span></code>&amp;
+            is public or not: if <code class="computeroutput"><span class="keyword">operator</span></code>&amp;
+            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
+            then instantiating <code class="literal">has_bit_and&lt;Lhs&gt;</code> will produce
+            a compiler error. For this reason <code class="literal">has_bit_and</code> cannot
+            be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span></code>&amp;
+            or not.
+          </li></ul></div>
+<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> A <span class="keyword">operator</span> &amp; <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>has_bit_and<span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator &amp; (const A&amp;) is private</span>
+</pre>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            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.
+          </li></ul></div>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+A <span class="keyword">operator</span> &amp; <span class="special">(</span>const <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>has_bit_and<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>has_bit_and<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
             <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not
             properly handled and would lead to undefined behavior
-          </li>
-</ul></div>
+          </li></ul></div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>

doc/html/boost_typetraits/reference/has_bit_and_assign.html

@@ -107,68 +107,81 @@
 <p>
         <span class="bold"><strong>Known issues:</strong></span>
       </p>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
-            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;=</span></code>
-            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
-            then instantiating <code class="computeroutput"><span class="identifier">has_bit_and_assign</span><span class="special">&lt;</span><span class="identifier">Lhs</span><span class="special">&gt;</span></code> will produce a compiler error. For
-            this reason <code class="computeroutput"><span class="identifier">has_bit_and_assign</span></code>
-            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;=</span></code>
-            or not.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&amp;=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_and_assign</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator&amp;=(const A&amp;) is private</span>
-</pre>
-          </li>
-<li class="listitem">
-            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.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&amp;=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_and_assign</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_bit_and_assign</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>
-          </li>
-<li class="listitem">
-            There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;=</span></code>
-            is defined but does not bind for a given template type, it is still detected
-            by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code>
-            instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example:
-<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_bit_and_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<p>
+        For modern compilers (those that support arbitrary SFINAE-expressions and
+        decltype/declval) this trait offers near perfect detection. In this situation
+        the macro <code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        will be defined after including <code class="literal">&lt;boost/type_traits/has_bit_and_assign.hpp&gt;</code>.
+        Please note however, that detection is based on function signature only,
+        in the case that the operator is a function template then has_bit_and_assign
+        cannot perform introspection of the template function body to ensure that
+        the type meets all of the conceptual requirements of the actual code.
+      </p>
+<p>
+        Example:
+      </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>has_bit_and_assign<span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</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="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span>
+<span class="keyword">struct</span> <span class="identifier">contains</span>
+<span class="special">{</span>
+   <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span>
+   <span class="identifier">contains</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">d</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">data</span><span class="special">(</span><span class="identifier">d</span><span class="special">)</span> <span class="special">{}</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="keyword">bool</span> <span class="keyword">operator</span><span class="special">&amp;=(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
-	<span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
+contains&lt;T&gt;&amp; <span class="keyword">operator</span> &amp;= <span class="special">(</span><span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
+    <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
 <span class="special">}</span>
 
 <span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span>
 <span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="special">}</span>
+<span class="identifier">good</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="comment">/*something*/</span><span class="special">;</span> <span class="special">}</span>
 
 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
-	<span class="comment">// works fine for contains&lt;good&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_and_assign</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
-	<span class="identifier">g</span><span class="special">&amp;=</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
-	<span class="comment">// does not work for contains&lt;bad&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_and_assign</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
-	<span class="identifier">b</span><span class="special">&amp;=</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
-	<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
+    <span class="comment">// works fine for contains&lt;good&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_bit_and_assign<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
+    <span class="identifier">g</span><span class="special">&amp;</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
+    <span class="comment">// does not work for contains&lt;bad&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_bit_and_assign<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
+    <span class="identifier">b</span><span class="special">&amp;</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
+    <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
 <span class="special">}</span>
 </pre>
-          </li>
-<li class="listitem">
+<p>
+        For older compilers (<code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        not defined) then there are a number of issues:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span></code>&amp;=
+            is public or not: if <code class="computeroutput"><span class="keyword">operator</span></code>&amp;=
+            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
+            then instantiating <code class="literal">has_bit_and_assign&lt;Lhs&gt;</code> will
+            produce a compiler error. For this reason <code class="literal">has_bit_and_assign</code>
+            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span></code>&amp;= or not.
+          </li></ul></div>
+<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> A&amp; <span class="keyword">operator</span> &amp;= <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>has_bit_and_assign<span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator &amp;= (const A&amp;) is private</span>
+</pre>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            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.
+          </li></ul></div>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+A&amp; <span class="keyword">operator</span> &amp;= <span class="special">(</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>has_bit_and_assign<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>has_bit_and_assign<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
             <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not
             properly handled and would lead to undefined behavior
-          </li>
-</ul></div>
+          </li></ul></div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>

doc/html/boost_typetraits/reference/has_bit_or.html

@@ -107,66 +107,82 @@
 <p>
         <span class="bold"><strong>Known issues:</strong></span>
       </p>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
-            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">|</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">|</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_bit_or</span><span class="special">&lt;</span><span class="identifier">Lhs</span><span class="special">&gt;</span></code>
-            will produce a compiler error. For this reason <code class="computeroutput"><span class="identifier">has_bit_or</span></code>
-            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">|</span></code>
-            or not.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">|(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_or</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator|(const A&amp;) is private</span>
-</pre>
-          </li>
-<li class="listitem">
-            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.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">|(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_or</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_or</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span>
-</pre>
-          </li>
-<li class="listitem">
-            There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">|</span></code>
-            is defined but does not bind for a given template type, it is still detected
-            by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code>
-            instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example:
-<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_bit_or</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<p>
+        For modern compilers (those that support arbitrary SFINAE-expressions and
+        decltype/declval) this trait offers near perfect detection. In this situation
+        the macro <code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        will be defined after including <code class="literal">&lt;boost/type_traits/has_bit_or.hpp&gt;</code>.
+        Please note however, that detection is based on function signature only,
+        in the case that the operator is a function template then has_bit_or cannot
+        perform introspection of the template function body to ensure that the type
+        meets all of the conceptual requirements of the actual code.
+      </p>
+<p>
+        Example:
+      </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>has_bit_or<span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</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="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span>
+<span class="keyword">struct</span> <span class="identifier">contains</span>
+<span class="special">{</span>
+   <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span>
+   <span class="identifier">contains</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">d</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">data</span><span class="special">(</span><span class="identifier">d</span><span class="special">)</span> <span class="special">{}</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="keyword">bool</span> <span class="keyword">operator</span><span class="special">|(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
-	<span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
+contains&lt;T&gt; <span class="keyword">operator</span> | <span class="special">(</span>const <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
+    <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
 <span class="special">}</span>
 
 <span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span>
 <span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="special">}</span>
+<span class="identifier">good</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="comment">/*something*/</span><span class="special">;</span> <span class="special">}</span>
 
 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
-	<span class="comment">// works fine for contains&lt;good&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_or</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
-	<span class="identifier">g</span><span class="special">|</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
-	<span class="comment">// does not work for contains&lt;bad&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_or</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
-	<span class="identifier">b</span><span class="special">|</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
-	<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
+    <span class="comment">// works fine for contains&lt;good&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_bit_or<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
+    <span class="identifier">g</span><span class="special">&amp;</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
+    <span class="comment">// does not work for contains&lt;bad&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_bit_or<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
+    <span class="identifier">b</span><span class="special">&amp;</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
+    <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
 <span class="special">}</span>
 </pre>
-          </li>
-<li class="listitem">
+<p>
+        For older compilers (<code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        not defined) then there are a number of issues:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span></code>|
+            is public or not: if <code class="computeroutput"><span class="keyword">operator</span></code>|
+            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
+            then instantiating <code class="literal">has_bit_or&lt;Lhs&gt;</code> will produce
+            a compiler error. For this reason <code class="literal">has_bit_or</code> cannot
+            be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span></code>|
+            or not.
+          </li></ul></div>
+<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> A <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>has_bit_or<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            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.
+          </li></ul></div>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+A <span class="keyword">operator</span> | <span class="special">(</span>const <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>has_bit_or<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>has_bit_or<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
             <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not
             properly handled and would lead to undefined behavior
-          </li>
-</ul></div>
+          </li></ul></div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>

doc/html/boost_typetraits/reference/has_bit_or_assign.html

@@ -107,68 +107,81 @@
 <p>
         <span class="bold"><strong>Known issues:</strong></span>
       </p>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
-            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">|=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">|=</span></code>
-            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
-            then instantiating <code class="computeroutput"><span class="identifier">has_bit_or_assign</span><span class="special">&lt;</span><span class="identifier">Lhs</span><span class="special">&gt;</span></code> will produce a compiler error. For
-            this reason <code class="computeroutput"><span class="identifier">has_bit_or_assign</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.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">|=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_or_assign</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>
-          </li>
-<li class="listitem">
-            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.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">|=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_or_assign</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_bit_or_assign</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>
-          </li>
-<li class="listitem">
-            There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">|=</span></code>
-            is defined but does not bind for a given template type, it is still detected
-            by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code>
-            instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example:
-<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_bit_or_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<p>
+        For modern compilers (those that support arbitrary SFINAE-expressions and
+        decltype/declval) this trait offers near perfect detection. In this situation
+        the macro <code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        will be defined after including <code class="literal">&lt;boost/type_traits/has_bit_or_assign.hpp&gt;</code>.
+        Please note however, that detection is based on function signature only,
+        in the case that the operator is a function template then has_bit_or_assign
+        cannot perform introspection of the template function body to ensure that
+        the type meets all of the conceptual requirements of the actual code.
+      </p>
+<p>
+        Example:
+      </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>has_bit_or_assign<span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</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="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span>
+<span class="keyword">struct</span> <span class="identifier">contains</span>
+<span class="special">{</span>
+   <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span>
+   <span class="identifier">contains</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">d</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">data</span><span class="special">(</span><span class="identifier">d</span><span class="special">)</span> <span class="special">{}</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="keyword">bool</span> <span class="keyword">operator</span><span class="special">|=(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
-	<span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
+contains&lt;T&gt;&amp; <span class="keyword">operator</span> |= <span class="special">(</span><span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
+    <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
 <span class="special">}</span>
 
 <span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span>
 <span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="special">}</span>
+<span class="identifier">good</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="comment">/*something*/</span><span class="special">;</span> <span class="special">}</span>
 
 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
-	<span class="comment">// works fine for contains&lt;good&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_or_assign</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
-	<span class="identifier">g</span><span class="special">|=</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
-	<span class="comment">// does not work for contains&lt;bad&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_or_assign</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
-	<span class="identifier">b</span><span class="special">|=</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
-	<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
+    <span class="comment">// works fine for contains&lt;good&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_bit_or_assign<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
+    <span class="identifier">g</span><span class="special">&amp;</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
+    <span class="comment">// does not work for contains&lt;bad&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_bit_or_assign<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
+    <span class="identifier">b</span><span class="special">&amp;</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
+    <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
 <span class="special">}</span>
 </pre>
-          </li>
-<li class="listitem">
+<p>
+        For older compilers (<code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        not defined) then there are a number of issues:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span></code>|=
+            is public or not: if <code class="computeroutput"><span class="keyword">operator</span></code>|=
+            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
+            then instantiating <code class="literal">has_bit_or_assign&lt;Lhs&gt;</code> will
+            produce a compiler error. For this reason <code class="literal">has_bit_or_assign</code>
+            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span></code>|= or not.
+          </li></ul></div>
+<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> A&amp; <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>has_bit_or_assign<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            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.
+          </li></ul></div>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+A&amp; <span class="keyword">operator</span> |= <span class="special">(</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>has_bit_or_assign<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>has_bit_or_assign<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
             <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not
             properly handled and would lead to undefined behavior
-          </li>
-</ul></div>
+          </li></ul></div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>

doc/html/boost_typetraits/reference/has_bit_xor.html

@@ -107,66 +107,82 @@
 <p>
         <span class="bold"><strong>Known issues:</strong></span>
       </p>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
-            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">^</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">^</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_bit_xor</span><span class="special">&lt;</span><span class="identifier">Lhs</span><span class="special">&gt;</span></code>
-            will produce a compiler error. For this reason <code class="computeroutput"><span class="identifier">has_bit_xor</span></code>
-            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">^</span></code>
-            or not.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">^(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_xor</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator^(const A&amp;) is private</span>
-</pre>
-          </li>
-<li class="listitem">
-            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.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">^(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_xor</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_xor</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span>
-</pre>
-          </li>
-<li class="listitem">
-            There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">^</span></code>
-            is defined but does not bind for a given template type, it is still detected
-            by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code>
-            instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example:
-<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_bit_xor</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<p>
+        For modern compilers (those that support arbitrary SFINAE-expressions and
+        decltype/declval) this trait offers near perfect detection. In this situation
+        the macro <code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        will be defined after including <code class="literal">&lt;boost/type_traits/has_bit_xor.hpp&gt;</code>.
+        Please note however, that detection is based on function signature only,
+        in the case that the operator is a function template then has_bit_xor cannot
+        perform introspection of the template function body to ensure that the type
+        meets all of the conceptual requirements of the actual code.
+      </p>
+<p>
+        Example:
+      </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>has_bit_xor<span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</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="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span>
+<span class="keyword">struct</span> <span class="identifier">contains</span>
+<span class="special">{</span>
+   <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span>
+   <span class="identifier">contains</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">d</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">data</span><span class="special">(</span><span class="identifier">d</span><span class="special">)</span> <span class="special">{}</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="keyword">bool</span> <span class="keyword">operator</span><span class="special">^(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
-	<span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
+contains&lt;T&gt; <span class="keyword">operator</span> ^ <span class="special">(</span>const <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
+    <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
 <span class="special">}</span>
 
 <span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span>
 <span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="special">}</span>
+<span class="identifier">good</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="comment">/*something*/</span><span class="special">;</span> <span class="special">}</span>
 
 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
-	<span class="comment">// works fine for contains&lt;good&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_xor</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
-	<span class="identifier">g</span><span class="special">^</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
-	<span class="comment">// does not work for contains&lt;bad&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_xor</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
-	<span class="identifier">b</span><span class="special">^</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
-	<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
+    <span class="comment">// works fine for contains&lt;good&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_bit_xor<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
+    <span class="identifier">g</span><span class="special">&amp;</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
+    <span class="comment">// does not work for contains&lt;bad&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_bit_xor<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
+    <span class="identifier">b</span><span class="special">&amp;</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
+    <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
 <span class="special">}</span>
 </pre>
-          </li>
-<li class="listitem">
+<p>
+        For older compilers (<code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        not defined) then there are a number of issues:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span></code>^
+            is public or not: if <code class="computeroutput"><span class="keyword">operator</span></code>^
+            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
+            then instantiating <code class="literal">has_bit_xor&lt;Lhs&gt;</code> will produce
+            a compiler error. For this reason <code class="literal">has_bit_xor</code> cannot
+            be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span></code>^
+            or not.
+          </li></ul></div>
+<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> A <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>has_bit_xor<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            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.
+          </li></ul></div>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+A <span class="keyword">operator</span> ^ <span class="special">(</span>const <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>has_bit_xor<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>has_bit_xor<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
             <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not
             properly handled and would lead to undefined behavior
-          </li>
-</ul></div>
+          </li></ul></div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>

doc/html/boost_typetraits/reference/has_bit_xor_assign.html

@@ -107,68 +107,81 @@
 <p>
         <span class="bold"><strong>Known issues:</strong></span>
       </p>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
-            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">^=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">^=</span></code>
-            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
-            then instantiating <code class="computeroutput"><span class="identifier">has_bit_xor_assign</span><span class="special">&lt;</span><span class="identifier">Lhs</span><span class="special">&gt;</span></code> will produce a compiler error. For
-            this reason <code class="computeroutput"><span class="identifier">has_bit_xor_assign</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.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">^=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_xor_assign</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>
-          </li>
-<li class="listitem">
-            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.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">^=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_xor_assign</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_bit_xor_assign</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>
-          </li>
-<li class="listitem">
-            There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">^=</span></code>
-            is defined but does not bind for a given template type, it is still detected
-            by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code>
-            instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example:
-<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_bit_xor_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<p>
+        For modern compilers (those that support arbitrary SFINAE-expressions and
+        decltype/declval) this trait offers near perfect detection. In this situation
+        the macro <code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        will be defined after including <code class="literal">&lt;boost/type_traits/has_bit_xor_assign.hpp&gt;</code>.
+        Please note however, that detection is based on function signature only,
+        in the case that the operator is a function template then has_bit_xor_assign
+        cannot perform introspection of the template function body to ensure that
+        the type meets all of the conceptual requirements of the actual code.
+      </p>
+<p>
+        Example:
+      </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>has_bit_xor_assign<span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</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="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span>
+<span class="keyword">struct</span> <span class="identifier">contains</span>
+<span class="special">{</span>
+   <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span>
+   <span class="identifier">contains</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">d</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">data</span><span class="special">(</span><span class="identifier">d</span><span class="special">)</span> <span class="special">{}</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="keyword">bool</span> <span class="keyword">operator</span><span class="special">^=(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
-	<span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
+contains&lt;T&gt;&amp; <span class="keyword">operator</span> ^= <span class="special">(</span><span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
+    <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
 <span class="special">}</span>
 
 <span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span>
 <span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="special">}</span>
+<span class="identifier">good</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="comment">/*something*/</span><span class="special">;</span> <span class="special">}</span>
 
 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
-	<span class="comment">// works fine for contains&lt;good&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_xor_assign</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
-	<span class="identifier">g</span><span class="special">^=</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
-	<span class="comment">// does not work for contains&lt;bad&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_bit_xor_assign</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
-	<span class="identifier">b</span><span class="special">^=</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
-	<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
+    <span class="comment">// works fine for contains&lt;good&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_bit_xor_assign<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
+    <span class="identifier">g</span><span class="special">&amp;</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
+    <span class="comment">// does not work for contains&lt;bad&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_bit_xor_assign<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
+    <span class="identifier">b</span><span class="special">&amp;</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
+    <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
 <span class="special">}</span>
 </pre>
-          </li>
-<li class="listitem">
+<p>
+        For older compilers (<code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        not defined) then there are a number of issues:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span></code>^=
+            is public or not: if <code class="computeroutput"><span class="keyword">operator</span></code>^=
+            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
+            then instantiating <code class="literal">has_bit_xor_assign&lt;Lhs&gt;</code> will
+            produce a compiler error. For this reason <code class="literal">has_bit_xor_assign</code>
+            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span></code>^= or not.
+          </li></ul></div>
+<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> A&amp; <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>has_bit_xor_assign<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            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.
+          </li></ul></div>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+A&amp; <span class="keyword">operator</span> ^= <span class="special">(</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>has_bit_xor_assign<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>has_bit_xor_assign<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
             <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not
             properly handled and would lead to undefined behavior
-          </li>
-</ul></div>
+          </li></ul></div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>

doc/html/boost_typetraits/reference/has_divides.html

@@ -113,66 +113,82 @@
 <p>
         <span class="bold"><strong>Known issues:</strong></span>
       </p>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
-            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">/</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">/</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_divides</span><span class="special">&lt;</span><span class="identifier">Lhs</span><span class="special">&gt;</span></code>
-            will produce a compiler error. For this reason <code class="computeroutput"><span class="identifier">has_divides</span></code>
-            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">/</span></code>
-            or not.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">/(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_divides</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator/(const A&amp;) is private</span>
-</pre>
-          </li>
-<li class="listitem">
-            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.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">/(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_divides</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_divides</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span>
-</pre>
-          </li>
-<li class="listitem">
-            There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">/</span></code>
-            is defined but does not bind for a given template type, it is still detected
-            by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code>
-            instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example:
-<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_divides</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<p>
+        For modern compilers (those that support arbitrary SFINAE-expressions and
+        decltype/declval) this trait offers near perfect detection. In this situation
+        the macro <code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        will be defined after including <code class="literal">&lt;boost/type_traits/has_divides.hpp&gt;</code>.
+        Please note however, that detection is based on function signature only,
+        in the case that the operator is a function template then has_divides cannot
+        perform introspection of the template function body to ensure that the type
+        meets all of the conceptual requirements of the actual code.
+      </p>
+<p>
+        Example:
+      </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>has_divides<span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</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="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span>
+<span class="keyword">struct</span> <span class="identifier">contains</span>
+<span class="special">{</span>
+   <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span>
+   <span class="identifier">contains</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">d</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">data</span><span class="special">(</span><span class="identifier">d</span><span class="special">)</span> <span class="special">{}</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="keyword">bool</span> <span class="keyword">operator</span><span class="special">/(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
-	<span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
+contains&lt;T&gt; <span class="keyword">operator</span> / <span class="special">(</span>const <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
+    <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
 <span class="special">}</span>
 
 <span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span>
 <span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="special">}</span>
+<span class="identifier">good</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="comment">/*something*/</span><span class="special">;</span> <span class="special">}</span>
 
 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
-	<span class="comment">// works fine for contains&lt;good&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_divides</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
-	<span class="identifier">g</span><span class="special">/</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
-	<span class="comment">// does not work for contains&lt;bad&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_divides</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
-	<span class="identifier">b</span><span class="special">/</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
-	<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
+    <span class="comment">// works fine for contains&lt;good&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_divides<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
+    <span class="identifier">g</span><span class="special">&amp;</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
+    <span class="comment">// does not work for contains&lt;bad&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_divides<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
+    <span class="identifier">b</span><span class="special">&amp;</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
+    <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
 <span class="special">}</span>
 </pre>
-          </li>
-<li class="listitem">
+<p>
+        For older compilers (<code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        not defined) then there are a number of issues:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span></code>/
+            is public or not: if <code class="computeroutput"><span class="keyword">operator</span></code>/
+            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
+            then instantiating <code class="literal">has_divides&lt;Lhs&gt;</code> will produce
+            a compiler error. For this reason <code class="literal">has_divides</code> cannot
+            be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span></code>/
+            or not.
+          </li></ul></div>
+<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> A <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>has_divides<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            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.
+          </li></ul></div>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+A <span class="keyword">operator</span> / <span class="special">(</span>const <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>has_divides<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>has_divides<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
             <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not
             properly handled and would lead to undefined behavior
-          </li>
-</ul></div>
+          </li></ul></div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>

doc/html/boost_typetraits/reference/has_divides_assign.html

@@ -113,68 +113,81 @@
 <p>
         <span class="bold"><strong>Known issues:</strong></span>
       </p>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
-            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">/=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">/=</span></code>
-            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
-            then instantiating <code class="computeroutput"><span class="identifier">has_divides_assign</span><span class="special">&lt;</span><span class="identifier">Lhs</span><span class="special">&gt;</span></code> will produce a compiler error. For
-            this reason <code class="computeroutput"><span class="identifier">has_divides_assign</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.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">/=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_divides_assign</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>
-          </li>
-<li class="listitem">
-            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.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">/=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_divides_assign</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_divides_assign</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>
-          </li>
-<li class="listitem">
-            There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">/=</span></code>
-            is defined but does not bind for a given template type, it is still detected
-            by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code>
-            instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example:
-<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_divides_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<p>
+        For modern compilers (those that support arbitrary SFINAE-expressions and
+        decltype/declval) this trait offers near perfect detection. In this situation
+        the macro <code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        will be defined after including <code class="literal">&lt;boost/type_traits/has_divides_assign.hpp&gt;</code>.
+        Please note however, that detection is based on function signature only,
+        in the case that the operator is a function template then has_divides_assign
+        cannot perform introspection of the template function body to ensure that
+        the type meets all of the conceptual requirements of the actual code.
+      </p>
+<p>
+        Example:
+      </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>has_divides_assign<span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</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="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span>
+<span class="keyword">struct</span> <span class="identifier">contains</span>
+<span class="special">{</span>
+   <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span>
+   <span class="identifier">contains</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">d</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">data</span><span class="special">(</span><span class="identifier">d</span><span class="special">)</span> <span class="special">{}</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="keyword">bool</span> <span class="keyword">operator</span><span class="special">/=(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
-	<span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
+contains&lt;T&gt;&amp; <span class="keyword">operator</span> /= <span class="special">(</span><span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
+    <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
 <span class="special">}</span>
 
 <span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span>
 <span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="special">}</span>
+<span class="identifier">good</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="comment">/*something*/</span><span class="special">;</span> <span class="special">}</span>
 
 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
-	<span class="comment">// works fine for contains&lt;good&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_divides_assign</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
-	<span class="identifier">g</span><span class="special">/=</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
-	<span class="comment">// does not work for contains&lt;bad&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_divides_assign</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
-	<span class="identifier">b</span><span class="special">/=</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
-	<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
+    <span class="comment">// works fine for contains&lt;good&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_divides_assign<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
+    <span class="identifier">g</span><span class="special">&amp;</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
+    <span class="comment">// does not work for contains&lt;bad&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_divides_assign<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
+    <span class="identifier">b</span><span class="special">&amp;</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
+    <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
 <span class="special">}</span>
 </pre>
-          </li>
-<li class="listitem">
+<p>
+        For older compilers (<code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        not defined) then there are a number of issues:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span></code>/=
+            is public or not: if <code class="computeroutput"><span class="keyword">operator</span></code>/=
+            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
+            then instantiating <code class="literal">has_divides_assign&lt;Lhs&gt;</code> will
+            produce a compiler error. For this reason <code class="literal">has_divides_assign</code>
+            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span></code>/= or not.
+          </li></ul></div>
+<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> A&amp; <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>has_divides_assign<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            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.
+          </li></ul></div>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+A&amp; <span class="keyword">operator</span> /= <span class="special">(</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>has_divides_assign<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>has_divides_assign<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
             <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not
             properly handled and would lead to undefined behavior
-          </li>
-</ul></div>
+          </li></ul></div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>

doc/html/boost_typetraits/reference/has_equal_to.html

@@ -112,68 +112,82 @@
 <p>
         <span class="bold"><strong>Known issues:</strong></span>
       </p>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
-            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code>
-            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
-            then instantiating <code class="computeroutput"><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">Lhs</span><span class="special">&gt;</span></code> will produce a compiler error. For
-            this reason <code class="computeroutput"><span class="identifier">has_equal_to</span></code>
-            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code>
-            or not.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator==(const A&amp;) is private</span>
-</pre>
-          </li>
-<li class="listitem">
-            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.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span>
-</pre>
-          </li>
-<li class="listitem">
-            There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code>
-            is defined but does not bind for a given template type, it is still detected
-            by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code>
-            instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example:
-<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_equal_to</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<p>
+        For modern compilers (those that support arbitrary SFINAE-expressions and
+        decltype/declval) this trait offers near perfect detection. In this situation
+        the macro <code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        will be defined after including <code class="literal">&lt;boost/type_traits/has_equal_to.hpp&gt;</code>.
+        Please note however, that detection is based on function signature only,
+        in the case that the operator is a function template then has_equal_to cannot
+        perform introspection of the template function body to ensure that the type
+        meets all of the conceptual requirements of the actual code.
+      </p>
+<p>
+        Example:
+      </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>has_equal_to<span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</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="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span>
+<span class="keyword">struct</span> <span class="identifier">contains</span>
+<span class="special">{</span>
+   <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span>
+   <span class="identifier">contains</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">d</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">data</span><span class="special">(</span><span class="identifier">d</span><span class="special">)</span> <span class="special">{}</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="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
-	<span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
+bool <span class="keyword">operator</span> == <span class="special">(</span>const <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
+    <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
 <span class="special">}</span>
 
 <span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span>
 <span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="special">}</span>
+<span class="identifier">good</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="comment">/*something*/</span><span class="special">;</span> <span class="special">}</span>
 
 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
-	<span class="comment">// works fine for contains&lt;good&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
-	<span class="identifier">g</span><span class="special">==</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
-	<span class="comment">// does not work for contains&lt;bad&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
-	<span class="identifier">b</span><span class="special">==</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
-	<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
+    <span class="comment">// works fine for contains&lt;good&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_equal_to<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
+    <span class="identifier">g</span><span class="special">&amp;</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
+    <span class="comment">// does not work for contains&lt;bad&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_equal_to<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
+    <span class="identifier">b</span><span class="special">&amp;</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
+    <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
 <span class="special">}</span>
 </pre>
-          </li>
-<li class="listitem">
+<p>
+        For older compilers (<code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        not defined) then there are a number of issues:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span></code>==
+            is public or not: if <code class="computeroutput"><span class="keyword">operator</span></code>==
+            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
+            then instantiating <code class="literal">has_equal_to&lt;Lhs&gt;</code> will produce
+            a compiler error. For this reason <code class="literal">has_equal_to</code> cannot
+            be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span></code>==
+            or not.
+          </li></ul></div>
+<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> bool <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>has_equal_to<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            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.
+          </li></ul></div>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+bool <span class="keyword">operator</span> == <span class="special">(</span>const <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>has_equal_to<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>has_equal_to<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
             <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not
             properly handled and would lead to undefined behavior
-          </li>
-</ul></div>
+          </li></ul></div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>

doc/html/boost_typetraits/reference/has_greater.html

@@ -112,68 +112,82 @@
 <p>
         <span class="bold"><strong>Known issues:</strong></span>
       </p>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
-            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;</span></code>
-            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
-            then instantiating <code class="computeroutput"><span class="identifier">has_greater</span><span class="special">&lt;</span><span class="identifier">Lhs</span><span class="special">&gt;</span></code> will produce a compiler error. For
-            this reason <code class="computeroutput"><span class="identifier">has_greater</span></code>
-            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;</span></code>
-            or not.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&gt;(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_greater</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator&gt;(const A&amp;) is private</span>
-</pre>
-          </li>
-<li class="listitem">
-            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.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&gt;(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_greater</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_greater</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span>
-</pre>
-          </li>
-<li class="listitem">
-            There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;</span></code>
-            is defined but does not bind for a given template type, it is still detected
-            by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code>
-            instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example:
-<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_greater</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<p>
+        For modern compilers (those that support arbitrary SFINAE-expressions and
+        decltype/declval) this trait offers near perfect detection. In this situation
+        the macro <code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        will be defined after including <code class="literal">&lt;boost/type_traits/has_greater.hpp&gt;</code>.
+        Please note however, that detection is based on function signature only,
+        in the case that the operator is a function template then has_greater cannot
+        perform introspection of the template function body to ensure that the type
+        meets all of the conceptual requirements of the actual code.
+      </p>
+<p>
+        Example:
+      </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>has_greater<span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</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="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span>
+<span class="keyword">struct</span> <span class="identifier">contains</span>
+<span class="special">{</span>
+   <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span>
+   <span class="identifier">contains</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">d</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">data</span><span class="special">(</span><span class="identifier">d</span><span class="special">)</span> <span class="special">{}</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="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
-	<span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
+bool <span class="keyword">operator</span> &gt; <span class="special">(</span>const <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
+    <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
 <span class="special">}</span>
 
 <span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span>
 <span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="special">}</span>
+<span class="identifier">good</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="comment">/*something*/</span><span class="special">;</span> <span class="special">}</span>
 
 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
-	<span class="comment">// works fine for contains&lt;good&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_greater</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
-	<span class="identifier">g</span><span class="special">&gt;</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
-	<span class="comment">// does not work for contains&lt;bad&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_greater</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
-	<span class="identifier">b</span><span class="special">&gt;</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
-	<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
+    <span class="comment">// works fine for contains&lt;good&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_greater<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
+    <span class="identifier">g</span><span class="special">&amp;</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
+    <span class="comment">// does not work for contains&lt;bad&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_greater<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
+    <span class="identifier">b</span><span class="special">&amp;</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
+    <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
 <span class="special">}</span>
 </pre>
-          </li>
-<li class="listitem">
+<p>
+        For older compilers (<code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        not defined) then there are a number of issues:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span></code>&gt;
+            is public or not: if <code class="computeroutput"><span class="keyword">operator</span></code>&gt;
+            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
+            then instantiating <code class="literal">has_greater&lt;Lhs&gt;</code> will produce
+            a compiler error. For this reason <code class="literal">has_greater</code> cannot
+            be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span></code>&gt;
+            or not.
+          </li></ul></div>
+<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> bool <span class="keyword">operator</span> &gt; <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>has_greater<span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator &gt; (const A&amp;) is private</span>
+</pre>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            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.
+          </li></ul></div>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+bool <span class="keyword">operator</span> &gt; <span class="special">(</span>const <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>has_greater<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>has_greater<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
             <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not
             properly handled and would lead to undefined behavior
-          </li>
-</ul></div>
+          </li></ul></div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>

doc/html/boost_typetraits/reference/has_greater_equal.html

@@ -112,68 +112,81 @@
 <p>
         <span class="bold"><strong>Known issues:</strong></span>
       </p>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
-            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;=</span></code>
-            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
-            then instantiating <code class="computeroutput"><span class="identifier">has_greater_equal</span><span class="special">&lt;</span><span class="identifier">Lhs</span><span class="special">&gt;</span></code> will produce a compiler error. For
-            this reason <code class="computeroutput"><span class="identifier">has_greater_equal</span></code>
-            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;=</span></code>
-            or not.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&gt;=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_greater_equal</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator&gt;=(const A&amp;) is private</span>
-</pre>
-          </li>
-<li class="listitem">
-            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.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&gt;=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_greater_equal</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_greater_equal</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span>
-</pre>
-          </li>
-<li class="listitem">
-            There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;=</span></code>
-            is defined but does not bind for a given template type, it is still detected
-            by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code>
-            instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example:
-<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_greater_equal</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<p>
+        For modern compilers (those that support arbitrary SFINAE-expressions and
+        decltype/declval) this trait offers near perfect detection. In this situation
+        the macro <code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        will be defined after including <code class="literal">&lt;boost/type_traits/has_greater_equal.hpp&gt;</code>.
+        Please note however, that detection is based on function signature only,
+        in the case that the operator is a function template then has_greater_equal
+        cannot perform introspection of the template function body to ensure that
+        the type meets all of the conceptual requirements of the actual code.
+      </p>
+<p>
+        Example:
+      </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>has_greater_equal<span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</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="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span>
+<span class="keyword">struct</span> <span class="identifier">contains</span>
+<span class="special">{</span>
+   <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span>
+   <span class="identifier">contains</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">d</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">data</span><span class="special">(</span><span class="identifier">d</span><span class="special">)</span> <span class="special">{}</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="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;=(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
-	<span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
+bool <span class="keyword">operator</span> &gt;= <span class="special">(</span>const <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
+    <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
 <span class="special">}</span>
 
 <span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span>
 <span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="special">}</span>
+<span class="identifier">good</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="comment">/*something*/</span><span class="special">;</span> <span class="special">}</span>
 
 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
-	<span class="comment">// works fine for contains&lt;good&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_greater_equal</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
-	<span class="identifier">g</span><span class="special">&gt;=</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
-	<span class="comment">// does not work for contains&lt;bad&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_greater_equal</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
-	<span class="identifier">b</span><span class="special">&gt;=</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
-	<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
+    <span class="comment">// works fine for contains&lt;good&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_greater_equal<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
+    <span class="identifier">g</span><span class="special">&amp;</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
+    <span class="comment">// does not work for contains&lt;bad&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_greater_equal<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
+    <span class="identifier">b</span><span class="special">&amp;</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
+    <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
 <span class="special">}</span>
 </pre>
-          </li>
-<li class="listitem">
+<p>
+        For older compilers (<code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        not defined) then there are a number of issues:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span></code>&gt;=
+            is public or not: if <code class="computeroutput"><span class="keyword">operator</span></code>&gt;=
+            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
+            then instantiating <code class="literal">has_greater_equal&lt;Lhs&gt;</code> will
+            produce a compiler error. For this reason <code class="literal">has_greater_equal</code>
+            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span></code>&gt;= or not.
+          </li></ul></div>
+<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> bool <span class="keyword">operator</span> &gt;= <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>has_greater_equal<span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator &gt;= (const A&amp;) is private</span>
+</pre>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            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.
+          </li></ul></div>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+bool <span class="keyword">operator</span> &gt;= <span class="special">(</span>const <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>has_greater_equal<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>has_greater_equal<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
             <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not
             properly handled and would lead to undefined behavior
-          </li>
-</ul></div>
+          </li></ul></div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>

doc/html/boost_typetraits/reference/has_left_shift.html

@@ -119,68 +119,81 @@
 <p>
         <span class="bold"><strong>Known issues:</strong></span>
       </p>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
-            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></code>
-            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
-            then instantiating <code class="computeroutput"><span class="identifier">has_left_shift</span><span class="special">&lt;</span><span class="identifier">Lhs</span><span class="special">&gt;</span></code> will produce a compiler error. For
-            this reason <code class="computeroutput"><span class="identifier">has_left_shift</span></code>
-            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></code>
-            or not.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&lt;&lt;(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_left_shift</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator&lt;&lt;(const A&amp;) is private</span>
-</pre>
-          </li>
-<li class="listitem">
-            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.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&lt;&lt;(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_left_shift</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_left_shift</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span>
-</pre>
-          </li>
-<li class="listitem">
-            There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;</span></code>
-            is defined but does not bind for a given template type, it is still detected
-            by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code>
-            instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example:
-<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_left_shift</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<p>
+        For modern compilers (those that support arbitrary SFINAE-expressions and
+        decltype/declval) this trait offers near perfect detection. In this situation
+        the macro <code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        will be defined after including <code class="literal">&lt;boost/type_traits/has_left_shift.hpp&gt;</code>.
+        Please note however, that detection is based on function signature only,
+        in the case that the operator is a function template then has_left_shift
+        cannot perform introspection of the template function body to ensure that
+        the type meets all of the conceptual requirements of the actual code.
+      </p>
+<p>
+        Example:
+      </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>has_left_shift<span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</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="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span>
+<span class="keyword">struct</span> <span class="identifier">contains</span>
+<span class="special">{</span>
+   <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span>
+   <span class="identifier">contains</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">d</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">data</span><span class="special">(</span><span class="identifier">d</span><span class="special">)</span> <span class="special">{}</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="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;&lt;(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
-	<span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
+contains&lt;T&gt; <span class="keyword">operator</span> &lt;&lt; <span class="special">(</span>const <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
+    <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
 <span class="special">}</span>
 
 <span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span>
 <span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="special">}</span>
+<span class="identifier">good</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="comment">/*something*/</span><span class="special">;</span> <span class="special">}</span>
 
 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
-	<span class="comment">// works fine for contains&lt;good&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_left_shift</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
-	<span class="identifier">g</span><span class="special">&lt;&lt;</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
-	<span class="comment">// does not work for contains&lt;bad&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_left_shift</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
-	<span class="identifier">b</span><span class="special">&lt;&lt;</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
-	<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
+    <span class="comment">// works fine for contains&lt;good&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_left_shift<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
+    <span class="identifier">g</span><span class="special">&amp;</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
+    <span class="comment">// does not work for contains&lt;bad&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_left_shift<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
+    <span class="identifier">b</span><span class="special">&amp;</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
+    <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
 <span class="special">}</span>
 </pre>
-          </li>
-<li class="listitem">
+<p>
+        For older compilers (<code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        not defined) then there are a number of issues:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span></code>&lt;&lt;
+            is public or not: if <code class="computeroutput"><span class="keyword">operator</span></code>&lt;&lt;
+            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
+            then instantiating <code class="literal">has_left_shift&lt;Lhs&gt;</code> will
+            produce a compiler error. For this reason <code class="literal">has_left_shift</code>
+            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span></code>&lt;&lt; or not.
+          </li></ul></div>
+<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> A <span class="keyword">operator</span> &lt;&lt; <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>has_left_shift<span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator &lt;&lt; (const A&amp;) is private</span>
+</pre>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            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.
+          </li></ul></div>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+A <span class="keyword">operator</span> &lt;&lt; <span class="special">(</span>const <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>has_left_shift<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>has_left_shift<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
             <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not
             properly handled and would lead to undefined behavior
-          </li>
-</ul></div>
+          </li></ul></div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>

doc/html/boost_typetraits/reference/has_left_shift_assign.html

@@ -107,68 +107,81 @@
 <p>
         <span class="bold"><strong>Known issues:</strong></span>
       </p>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
-            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;=</span></code>
-            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
-            then instantiating <code class="computeroutput"><span class="identifier">has_left_shift_assign</span><span class="special">&lt;</span><span class="identifier">Lhs</span><span class="special">&gt;</span></code> will produce a compiler error. For
-            this reason <code class="computeroutput"><span class="identifier">has_left_shift_assign</span></code>
-            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;=</span></code>
-            or not.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&lt;&lt;=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_left_shift_assign</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator&lt;&lt;=(const A&amp;) is private</span>
-</pre>
-          </li>
-<li class="listitem">
-            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.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&lt;&lt;=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_left_shift_assign</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_left_shift_assign</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>
-          </li>
-<li class="listitem">
-            There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;&lt;=</span></code>
-            is defined but does not bind for a given template type, it is still detected
-            by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code>
-            instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example:
-<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_left_shift_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<p>
+        For modern compilers (those that support arbitrary SFINAE-expressions and
+        decltype/declval) this trait offers near perfect detection. In this situation
+        the macro <code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        will be defined after including <code class="literal">&lt;boost/type_traits/has_left_shift_assign.hpp&gt;</code>.
+        Please note however, that detection is based on function signature only,
+        in the case that the operator is a function template then has_left_shift_assign
+        cannot perform introspection of the template function body to ensure that
+        the type meets all of the conceptual requirements of the actual code.
+      </p>
+<p>
+        Example:
+      </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>has_left_shift_assign<span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</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="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span>
+<span class="keyword">struct</span> <span class="identifier">contains</span>
+<span class="special">{</span>
+   <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span>
+   <span class="identifier">contains</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">d</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">data</span><span class="special">(</span><span class="identifier">d</span><span class="special">)</span> <span class="special">{}</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="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;&lt;=(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
-	<span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
+contains&lt;T&gt;&amp; <span class="keyword">operator</span> &lt;&lt;= <span class="special">(</span><span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
+    <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
 <span class="special">}</span>
 
 <span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span>
 <span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="special">}</span>
+<span class="identifier">good</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="comment">/*something*/</span><span class="special">;</span> <span class="special">}</span>
 
 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
-	<span class="comment">// works fine for contains&lt;good&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_left_shift_assign</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
-	<span class="identifier">g</span><span class="special">&lt;&lt;=</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
-	<span class="comment">// does not work for contains&lt;bad&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_left_shift_assign</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
-	<span class="identifier">b</span><span class="special">&lt;&lt;=</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
-	<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
+    <span class="comment">// works fine for contains&lt;good&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_left_shift_assign<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
+    <span class="identifier">g</span><span class="special">&amp;</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
+    <span class="comment">// does not work for contains&lt;bad&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_left_shift_assign<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
+    <span class="identifier">b</span><span class="special">&amp;</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
+    <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
 <span class="special">}</span>
 </pre>
-          </li>
-<li class="listitem">
+<p>
+        For older compilers (<code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        not defined) then there are a number of issues:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span></code>&lt;&lt;=
+            is public or not: if <code class="computeroutput"><span class="keyword">operator</span></code>&lt;&lt;=
+            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
+            then instantiating <code class="literal">has_left_shift_assign&lt;Lhs&gt;</code>
+            will produce a compiler error. For this reason <code class="literal">has_left_shift_assign</code>
+            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span></code>&lt;&lt;= or not.
+          </li></ul></div>
+<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> A&amp; <span class="keyword">operator</span> &lt;&lt;= <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>has_left_shift_assign<span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator &lt;&lt;= (const A&amp;) is private</span>
+</pre>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            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.
+          </li></ul></div>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+A&amp; <span class="keyword">operator</span> &lt;&lt;= <span class="special">(</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>has_left_shift_assign<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>has_left_shift_assign<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
             <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not
             properly handled and would lead to undefined behavior
-          </li>
-</ul></div>
+          </li></ul></div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>

doc/html/boost_typetraits/reference/has_less.html

@@ -112,68 +112,82 @@
 <p>
         <span class="bold"><strong>Known issues:</strong></span>
       </p>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
-            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;</span></code>
-            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
-            then instantiating <code class="computeroutput"><span class="identifier">has_less</span><span class="special">&lt;</span><span class="identifier">Lhs</span><span class="special">&gt;</span></code> will produce a compiler error. For
-            this reason <code class="computeroutput"><span class="identifier">has_less</span></code>
-            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;</span></code>
-            or not.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&lt;(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_less</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator&lt;(const A&amp;) is private</span>
-</pre>
-          </li>
-<li class="listitem">
-            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.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&lt;(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_less</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_less</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span>
-</pre>
-          </li>
-<li class="listitem">
-            There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;</span></code>
-            is defined but does not bind for a given template type, it is still detected
-            by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code>
-            instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example:
-<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_less</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<p>
+        For modern compilers (those that support arbitrary SFINAE-expressions and
+        decltype/declval) this trait offers near perfect detection. In this situation
+        the macro <code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        will be defined after including <code class="literal">&lt;boost/type_traits/has_less.hpp&gt;</code>.
+        Please note however, that detection is based on function signature only,
+        in the case that the operator is a function template then has_less cannot
+        perform introspection of the template function body to ensure that the type
+        meets all of the conceptual requirements of the actual code.
+      </p>
+<p>
+        Example:
+      </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>has_less<span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</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="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span>
+<span class="keyword">struct</span> <span class="identifier">contains</span>
+<span class="special">{</span>
+   <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span>
+   <span class="identifier">contains</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">d</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">data</span><span class="special">(</span><span class="identifier">d</span><span class="special">)</span> <span class="special">{}</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="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
-	<span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
+bool <span class="keyword">operator</span> &lt; <span class="special">(</span>const <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
+    <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
 <span class="special">}</span>
 
 <span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span>
 <span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="special">}</span>
+<span class="identifier">good</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="comment">/*something*/</span><span class="special">;</span> <span class="special">}</span>
 
 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
-	<span class="comment">// works fine for contains&lt;good&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_less</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
-	<span class="identifier">g</span><span class="special">&lt;</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
-	<span class="comment">// does not work for contains&lt;bad&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_less</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
-	<span class="identifier">b</span><span class="special">&lt;</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
-	<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
+    <span class="comment">// works fine for contains&lt;good&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_less<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
+    <span class="identifier">g</span><span class="special">&amp;</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
+    <span class="comment">// does not work for contains&lt;bad&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_less<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
+    <span class="identifier">b</span><span class="special">&amp;</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
+    <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
 <span class="special">}</span>
 </pre>
-          </li>
-<li class="listitem">
+<p>
+        For older compilers (<code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        not defined) then there are a number of issues:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span></code>&lt;
+            is public or not: if <code class="computeroutput"><span class="keyword">operator</span></code>&lt;
+            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
+            then instantiating <code class="literal">has_less&lt;Lhs&gt;</code> will produce
+            a compiler error. For this reason <code class="literal">has_less</code> cannot
+            be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span></code>&lt;
+            or not.
+          </li></ul></div>
+<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> bool <span class="keyword">operator</span> &lt; <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>has_less<span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator &lt; (const A&amp;) is private</span>
+</pre>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            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.
+          </li></ul></div>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+bool <span class="keyword">operator</span> &lt; <span class="special">(</span>const <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>has_less<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>has_less<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
             <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not
             properly handled and would lead to undefined behavior
-          </li>
-</ul></div>
+          </li></ul></div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>

doc/html/boost_typetraits/reference/has_less_equal.html

@@ -112,68 +112,81 @@
 <p>
         <span class="bold"><strong>Known issues:</strong></span>
       </p>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
-            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;=</span></code>
-            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
-            then instantiating <code class="computeroutput"><span class="identifier">has_less_equal</span><span class="special">&lt;</span><span class="identifier">Lhs</span><span class="special">&gt;</span></code> will produce a compiler error. For
-            this reason <code class="computeroutput"><span class="identifier">has_less_equal</span></code>
-            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;=</span></code>
-            or not.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&lt;=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_less_equal</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator&lt;=(const A&amp;) is private</span>
-</pre>
-          </li>
-<li class="listitem">
-            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.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&lt;=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_less_equal</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_less_equal</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span>
-</pre>
-          </li>
-<li class="listitem">
-            There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;=</span></code>
-            is defined but does not bind for a given template type, it is still detected
-            by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code>
-            instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example:
-<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_less_equal</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<p>
+        For modern compilers (those that support arbitrary SFINAE-expressions and
+        decltype/declval) this trait offers near perfect detection. In this situation
+        the macro <code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        will be defined after including <code class="literal">&lt;boost/type_traits/has_less_equal.hpp&gt;</code>.
+        Please note however, that detection is based on function signature only,
+        in the case that the operator is a function template then has_less_equal
+        cannot perform introspection of the template function body to ensure that
+        the type meets all of the conceptual requirements of the actual code.
+      </p>
+<p>
+        Example:
+      </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>has_less_equal<span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</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="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span>
+<span class="keyword">struct</span> <span class="identifier">contains</span>
+<span class="special">{</span>
+   <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span>
+   <span class="identifier">contains</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">d</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">data</span><span class="special">(</span><span class="identifier">d</span><span class="special">)</span> <span class="special">{}</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="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;=(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
-	<span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
+bool <span class="keyword">operator</span> &lt;= <span class="special">(</span>const <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
+    <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
 <span class="special">}</span>
 
 <span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span>
 <span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="special">}</span>
+<span class="identifier">good</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="comment">/*something*/</span><span class="special">;</span> <span class="special">}</span>
 
 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
-	<span class="comment">// works fine for contains&lt;good&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_less_equal</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
-	<span class="identifier">g</span><span class="special">&lt;=</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
-	<span class="comment">// does not work for contains&lt;bad&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_less_equal</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
-	<span class="identifier">b</span><span class="special">&lt;=</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
-	<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
+    <span class="comment">// works fine for contains&lt;good&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_less_equal<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
+    <span class="identifier">g</span><span class="special">&amp;</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
+    <span class="comment">// does not work for contains&lt;bad&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_less_equal<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
+    <span class="identifier">b</span><span class="special">&amp;</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
+    <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
 <span class="special">}</span>
 </pre>
-          </li>
-<li class="listitem">
+<p>
+        For older compilers (<code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        not defined) then there are a number of issues:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span></code>&lt;=
+            is public or not: if <code class="computeroutput"><span class="keyword">operator</span></code>&lt;=
+            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
+            then instantiating <code class="literal">has_less_equal&lt;Lhs&gt;</code> will
+            produce a compiler error. For this reason <code class="literal">has_less_equal</code>
+            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span></code>&lt;= or not.
+          </li></ul></div>
+<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> bool <span class="keyword">operator</span> &lt;= <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>has_less_equal<span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator &lt;= (const A&amp;) is private</span>
+</pre>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            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.
+          </li></ul></div>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+bool <span class="keyword">operator</span> &lt;= <span class="special">(</span>const <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>has_less_equal<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>has_less_equal<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
             <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not
             properly handled and would lead to undefined behavior
-          </li>
-</ul></div>
+          </li></ul></div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>

doc/html/boost_typetraits/reference/has_logical_and.html

@@ -110,68 +110,81 @@
 <p>
         <span class="bold"><strong>Known issues:</strong></span>
       </p>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
-            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;&amp;</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;&amp;</span></code>
-            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
-            then instantiating <code class="computeroutput"><span class="identifier">has_logical_and</span><span class="special">&lt;</span><span class="identifier">Lhs</span><span class="special">&gt;</span></code> will produce a compiler error. For
-            this reason <code class="computeroutput"><span class="identifier">has_logical_and</span></code>
-            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;&amp;</span></code>
-            or not.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&amp;&amp;(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_logical_and</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator&amp;&amp;(const A&amp;) is private</span>
-</pre>
-          </li>
-<li class="listitem">
-            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.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&amp;&amp;(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_logical_and</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_logical_and</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span>
-</pre>
-          </li>
-<li class="listitem">
-            There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">&amp;&amp;</span></code>
-            is defined but does not bind for a given template type, it is still detected
-            by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code>
-            instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example:
-<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_logical_and</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<p>
+        For modern compilers (those that support arbitrary SFINAE-expressions and
+        decltype/declval) this trait offers near perfect detection. In this situation
+        the macro <code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        will be defined after including <code class="literal">&lt;boost/type_traits/has_logical_and.hpp&gt;</code>.
+        Please note however, that detection is based on function signature only,
+        in the case that the operator is a function template then has_logical_and
+        cannot perform introspection of the template function body to ensure that
+        the type meets all of the conceptual requirements of the actual code.
+      </p>
+<p>
+        Example:
+      </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>has_logical_and<span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</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="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span>
+<span class="keyword">struct</span> <span class="identifier">contains</span>
+<span class="special">{</span>
+   <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span>
+   <span class="identifier">contains</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">d</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">data</span><span class="special">(</span><span class="identifier">d</span><span class="special">)</span> <span class="special">{}</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="keyword">bool</span> <span class="keyword">operator</span><span class="special">&amp;&amp;(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
-	<span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
+bool <span class="keyword">operator</span> &amp;&amp; <span class="special">(</span>const <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
+    <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
 <span class="special">}</span>
 
 <span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span>
 <span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="special">}</span>
+<span class="identifier">good</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="comment">/*something*/</span><span class="special">;</span> <span class="special">}</span>
 
 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
-	<span class="comment">// works fine for contains&lt;good&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_logical_and</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
-	<span class="identifier">g</span><span class="special">&amp;&amp;</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
-	<span class="comment">// does not work for contains&lt;bad&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_logical_and</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
-	<span class="identifier">b</span><span class="special">&amp;&amp;</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
-	<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
+    <span class="comment">// works fine for contains&lt;good&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_logical_and<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
+    <span class="identifier">g</span><span class="special">&amp;</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
+    <span class="comment">// does not work for contains&lt;bad&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_logical_and<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
+    <span class="identifier">b</span><span class="special">&amp;</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
+    <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
 <span class="special">}</span>
 </pre>
-          </li>
-<li class="listitem">
+<p>
+        For older compilers (<code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        not defined) then there are a number of issues:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span></code>&amp;&amp;
+            is public or not: if <code class="computeroutput"><span class="keyword">operator</span></code>&amp;&amp;
+            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
+            then instantiating <code class="literal">has_logical_and&lt;Lhs&gt;</code> will
+            produce a compiler error. For this reason <code class="literal">has_logical_and</code>
+            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span></code>&amp;&amp; or not.
+          </li></ul></div>
+<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> bool <span class="keyword">operator</span> &amp;&amp; <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>has_logical_and<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            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.
+          </li></ul></div>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+bool <span class="keyword">operator</span> &amp;&amp; <span class="special">(</span>const <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>has_logical_and<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>has_logical_and<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
             <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not
             properly handled and would lead to undefined behavior
-          </li>
-</ul></div>
+          </li></ul></div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>

doc/html/boost_typetraits/reference/has_logical_or.html

@@ -110,68 +110,81 @@
 <p>
         <span class="bold"><strong>Known issues:</strong></span>
       </p>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
-            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">||</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">||</span></code>
-            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
-            then instantiating <code class="computeroutput"><span class="identifier">has_logical_or</span><span class="special">&lt;</span><span class="identifier">Lhs</span><span class="special">&gt;</span></code> will produce a compiler error. For
-            this reason <code class="computeroutput"><span class="identifier">has_logical_or</span></code>
-            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">||</span></code>
-            or not.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">||(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_logical_or</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator||(const A&amp;) is private</span>
-</pre>
-          </li>
-<li class="listitem">
-            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.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">||(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_logical_or</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_logical_or</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span>
-</pre>
-          </li>
-<li class="listitem">
-            There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">||</span></code>
-            is defined but does not bind for a given template type, it is still detected
-            by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code>
-            instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example:
-<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_logical_or</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<p>
+        For modern compilers (those that support arbitrary SFINAE-expressions and
+        decltype/declval) this trait offers near perfect detection. In this situation
+        the macro <code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        will be defined after including <code class="literal">&lt;boost/type_traits/has_logical_or.hpp&gt;</code>.
+        Please note however, that detection is based on function signature only,
+        in the case that the operator is a function template then has_logical_or
+        cannot perform introspection of the template function body to ensure that
+        the type meets all of the conceptual requirements of the actual code.
+      </p>
+<p>
+        Example:
+      </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>has_logical_or<span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</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="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span>
+<span class="keyword">struct</span> <span class="identifier">contains</span>
+<span class="special">{</span>
+   <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span>
+   <span class="identifier">contains</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">d</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">data</span><span class="special">(</span><span class="identifier">d</span><span class="special">)</span> <span class="special">{}</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="keyword">bool</span> <span class="keyword">operator</span><span class="special">||(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
-	<span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
+bool <span class="keyword">operator</span> || <span class="special">(</span>const <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
+    <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
 <span class="special">}</span>
 
 <span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span>
 <span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="special">}</span>
+<span class="identifier">good</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="comment">/*something*/</span><span class="special">;</span> <span class="special">}</span>
 
 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
-	<span class="comment">// works fine for contains&lt;good&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_logical_or</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
-	<span class="identifier">g</span><span class="special">||</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
-	<span class="comment">// does not work for contains&lt;bad&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_logical_or</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
-	<span class="identifier">b</span><span class="special">||</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
-	<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
+    <span class="comment">// works fine for contains&lt;good&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_logical_or<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
+    <span class="identifier">g</span><span class="special">&amp;</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
+    <span class="comment">// does not work for contains&lt;bad&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_logical_or<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
+    <span class="identifier">b</span><span class="special">&amp;</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
+    <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
 <span class="special">}</span>
 </pre>
-          </li>
-<li class="listitem">
+<p>
+        For older compilers (<code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        not defined) then there are a number of issues:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span></code>||
+            is public or not: if <code class="computeroutput"><span class="keyword">operator</span></code>||
+            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
+            then instantiating <code class="literal">has_logical_or&lt;Lhs&gt;</code> will
+            produce a compiler error. For this reason <code class="literal">has_logical_or</code>
+            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span></code>|| or not.
+          </li></ul></div>
+<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> bool <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>has_logical_or<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            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.
+          </li></ul></div>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+bool <span class="keyword">operator</span> || <span class="special">(</span>const <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>has_logical_or<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>has_logical_or<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
             <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not
             properly handled and would lead to undefined behavior
-          </li>
-</ul></div>
+          </li></ul></div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>

doc/html/boost_typetraits/reference/has_minus.html

@@ -113,66 +113,82 @@
 <p>
         <span class="bold"><strong>Known issues:</strong></span>
       </p>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
-            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_minus</span><span class="special">&lt;</span><span class="identifier">Lhs</span><span class="special">&gt;</span></code>
-            will produce a compiler error. For this reason <code class="computeroutput"><span class="identifier">has_minus</span></code>
-            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code>
-            or not.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">-(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_minus</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator-(const A&amp;) is private</span>
-</pre>
-          </li>
-<li class="listitem">
-            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.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">-(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_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_minus</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span>
-</pre>
-          </li>
-<li class="listitem">
-            There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">-</span></code>
-            is defined but does not bind for a given template type, it is still detected
-            by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code>
-            instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example:
-<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_minus</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<p>
+        For modern compilers (those that support arbitrary SFINAE-expressions and
+        decltype/declval) this trait offers near perfect detection. In this situation
+        the macro <code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        will be defined after including <code class="literal">&lt;boost/type_traits/has_minus.hpp&gt;</code>.
+        Please note however, that detection is based on function signature only,
+        in the case that the operator is a function template then has_minus cannot
+        perform introspection of the template function body to ensure that the type
+        meets all of the conceptual requirements of the actual code.
+      </p>
+<p>
+        Example:
+      </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>has_minus<span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</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="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span>
+<span class="keyword">struct</span> <span class="identifier">contains</span>
+<span class="special">{</span>
+   <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span>
+   <span class="identifier">contains</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">d</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">data</span><span class="special">(</span><span class="identifier">d</span><span class="special">)</span> <span class="special">{}</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="keyword">bool</span> <span class="keyword">operator</span><span class="special">-(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
-	<span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
+contains&lt;T&gt; <span class="keyword">operator</span> - <span class="special">(</span>const <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
+    <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
 <span class="special">}</span>
 
 <span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span>
 <span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="special">}</span>
+<span class="identifier">good</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="comment">/*something*/</span><span class="special">;</span> <span class="special">}</span>
 
 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
-	<span class="comment">// works fine for contains&lt;good&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_minus</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
-	<span class="identifier">g</span><span class="special">-</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
-	<span class="comment">// does not work for contains&lt;bad&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_minus</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
-	<span class="identifier">b</span><span class="special">-</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
-	<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
+    <span class="comment">// works fine for contains&lt;good&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_minus<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
+    <span class="identifier">g</span><span class="special">&amp;</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
+    <span class="comment">// does not work for contains&lt;bad&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_minus<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
+    <span class="identifier">b</span><span class="special">&amp;</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
+    <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
 <span class="special">}</span>
 </pre>
-          </li>
-<li class="listitem">
+<p>
+        For older compilers (<code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        not defined) then there are a number of issues:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span></code>-
+            is public or not: if <code class="computeroutput"><span class="keyword">operator</span></code>-
+            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
+            then instantiating <code class="literal">has_minus&lt;Lhs&gt;</code> will produce
+            a compiler error. For this reason <code class="literal">has_minus</code> cannot
+            be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span></code>-
+            or not.
+          </li></ul></div>
+<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> A <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>has_minus<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            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.
+          </li></ul></div>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+A <span class="keyword">operator</span> - <span class="special">(</span>const <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>has_minus<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>has_minus<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
             <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not
             properly handled and would lead to undefined behavior
-          </li>
-</ul></div>
+          </li></ul></div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>

doc/html/boost_typetraits/reference/has_minus_assign.html

@@ -113,68 +113,81 @@
 <p>
         <span class="bold"><strong>Known issues:</strong></span>
       </p>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
-            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">-=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">-=</span></code>
-            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
-            then instantiating <code class="computeroutput"><span class="identifier">has_minus_assign</span><span class="special">&lt;</span><span class="identifier">Lhs</span><span class="special">&gt;</span></code> will produce a compiler error. For
-            this reason <code class="computeroutput"><span class="identifier">has_minus_assign</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.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">-=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_minus_assign</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>
-          </li>
-<li class="listitem">
-            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.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">-=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_minus_assign</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_minus_assign</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>
-          </li>
-<li class="listitem">
-            There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">-=</span></code>
-            is defined but does not bind for a given template type, it is still detected
-            by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code>
-            instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example:
-<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_minus_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<p>
+        For modern compilers (those that support arbitrary SFINAE-expressions and
+        decltype/declval) this trait offers near perfect detection. In this situation
+        the macro <code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        will be defined after including <code class="literal">&lt;boost/type_traits/has_minus_assign.hpp&gt;</code>.
+        Please note however, that detection is based on function signature only,
+        in the case that the operator is a function template then has_minus_assign
+        cannot perform introspection of the template function body to ensure that
+        the type meets all of the conceptual requirements of the actual code.
+      </p>
+<p>
+        Example:
+      </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>has_minus_assign<span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</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="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span>
+<span class="keyword">struct</span> <span class="identifier">contains</span>
+<span class="special">{</span>
+   <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span>
+   <span class="identifier">contains</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">d</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">data</span><span class="special">(</span><span class="identifier">d</span><span class="special">)</span> <span class="special">{}</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="keyword">bool</span> <span class="keyword">operator</span><span class="special">-=(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
-	<span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
+contains&lt;T&gt;&amp; <span class="keyword">operator</span> -= <span class="special">(</span><span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
+    <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
 <span class="special">}</span>
 
 <span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span>
 <span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="special">}</span>
+<span class="identifier">good</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="comment">/*something*/</span><span class="special">;</span> <span class="special">}</span>
 
 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
-	<span class="comment">// works fine for contains&lt;good&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_minus_assign</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
-	<span class="identifier">g</span><span class="special">-=</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
-	<span class="comment">// does not work for contains&lt;bad&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_minus_assign</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
-	<span class="identifier">b</span><span class="special">-=</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
-	<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
+    <span class="comment">// works fine for contains&lt;good&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_minus_assign<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
+    <span class="identifier">g</span><span class="special">&amp;</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
+    <span class="comment">// does not work for contains&lt;bad&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_minus_assign<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
+    <span class="identifier">b</span><span class="special">&amp;</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
+    <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
 <span class="special">}</span>
 </pre>
-          </li>
-<li class="listitem">
+<p>
+        For older compilers (<code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        not defined) then there are a number of issues:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span></code>-=
+            is public or not: if <code class="computeroutput"><span class="keyword">operator</span></code>-=
+            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
+            then instantiating <code class="literal">has_minus_assign&lt;Lhs&gt;</code> will
+            produce a compiler error. For this reason <code class="literal">has_minus_assign</code>
+            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span></code>-= or not.
+          </li></ul></div>
+<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> A&amp; <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>has_minus_assign<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            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.
+          </li></ul></div>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+A&amp; <span class="keyword">operator</span> -= <span class="special">(</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>has_minus_assign<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>has_minus_assign<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
             <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not
             properly handled and would lead to undefined behavior
-          </li>
-</ul></div>
+          </li></ul></div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>

doc/html/boost_typetraits/reference/has_modulus.html

@@ -106,66 +106,82 @@
 <p>
         <span class="bold"><strong>Known issues:</strong></span>
       </p>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
-            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">%</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">%</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_modulus</span><span class="special">&lt;</span><span class="identifier">Lhs</span><span class="special">&gt;</span></code>
-            will produce a compiler error. For this reason <code class="computeroutput"><span class="identifier">has_modulus</span></code>
-            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">%</span></code>
-            or not.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">%(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_modulus</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator%(const A&amp;) is private</span>
-</pre>
-          </li>
-<li class="listitem">
-            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.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">%(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_modulus</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_modulus</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span>
-</pre>
-          </li>
-<li class="listitem">
-            There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">%</span></code>
-            is defined but does not bind for a given template type, it is still detected
-            by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code>
-            instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example:
-<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_modulus</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<p>
+        For modern compilers (those that support arbitrary SFINAE-expressions and
+        decltype/declval) this trait offers near perfect detection. In this situation
+        the macro <code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        will be defined after including <code class="literal">&lt;boost/type_traits/has_modulus.hpp&gt;</code>.
+        Please note however, that detection is based on function signature only,
+        in the case that the operator is a function template then has_modulus cannot
+        perform introspection of the template function body to ensure that the type
+        meets all of the conceptual requirements of the actual code.
+      </p>
+<p>
+        Example:
+      </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>has_modulus<span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</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="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span>
+<span class="keyword">struct</span> <span class="identifier">contains</span>
+<span class="special">{</span>
+   <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span>
+   <span class="identifier">contains</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">d</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">data</span><span class="special">(</span><span class="identifier">d</span><span class="special">)</span> <span class="special">{}</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="keyword">bool</span> <span class="keyword">operator</span><span class="special">%(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
-	<span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
+contains&lt;T&gt; <span class="keyword">operator</span> % <span class="special">(</span>const <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
+    <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
 <span class="special">}</span>
 
 <span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span>
 <span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="special">}</span>
+<span class="identifier">good</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="comment">/*something*/</span><span class="special">;</span> <span class="special">}</span>
 
 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
-	<span class="comment">// works fine for contains&lt;good&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_modulus</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
-	<span class="identifier">g</span><span class="special">%</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
-	<span class="comment">// does not work for contains&lt;bad&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_modulus</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
-	<span class="identifier">b</span><span class="special">%</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
-	<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
+    <span class="comment">// works fine for contains&lt;good&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_modulus<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
+    <span class="identifier">g</span><span class="special">&amp;</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
+    <span class="comment">// does not work for contains&lt;bad&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_modulus<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
+    <span class="identifier">b</span><span class="special">&amp;</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
+    <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
 <span class="special">}</span>
 </pre>
-          </li>
-<li class="listitem">
+<p>
+        For older compilers (<code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        not defined) then there are a number of issues:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span></code>%
+            is public or not: if <code class="computeroutput"><span class="keyword">operator</span></code>%
+            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
+            then instantiating <code class="literal">has_modulus&lt;Lhs&gt;</code> will produce
+            a compiler error. For this reason <code class="literal">has_modulus</code> cannot
+            be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span></code>%
+            or not.
+          </li></ul></div>
+<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> A <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>has_modulus<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            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.
+          </li></ul></div>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+A <span class="keyword">operator</span> % <span class="special">(</span>const <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>has_modulus<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>has_modulus<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
             <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not
             properly handled and would lead to undefined behavior
-          </li>
-</ul></div>
+          </li></ul></div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>

doc/html/boost_typetraits/reference/has_modulus_assign.html

@@ -106,68 +106,81 @@
 <p>
         <span class="bold"><strong>Known issues:</strong></span>
       </p>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
-            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">%=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">%=</span></code>
-            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
-            then instantiating <code class="computeroutput"><span class="identifier">has_modulus_assign</span><span class="special">&lt;</span><span class="identifier">Lhs</span><span class="special">&gt;</span></code> will produce a compiler error. For
-            this reason <code class="computeroutput"><span class="identifier">has_modulus_assign</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.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">%=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_modulus_assign</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>
-          </li>
-<li class="listitem">
-            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.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">%=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_modulus_assign</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_modulus_assign</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>
-          </li>
-<li class="listitem">
-            There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">%=</span></code>
-            is defined but does not bind for a given template type, it is still detected
-            by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code>
-            instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example:
-<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_modulus_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<p>
+        For modern compilers (those that support arbitrary SFINAE-expressions and
+        decltype/declval) this trait offers near perfect detection. In this situation
+        the macro <code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        will be defined after including <code class="literal">&lt;boost/type_traits/has_modulus_assign.hpp&gt;</code>.
+        Please note however, that detection is based on function signature only,
+        in the case that the operator is a function template then has_modulus_assign
+        cannot perform introspection of the template function body to ensure that
+        the type meets all of the conceptual requirements of the actual code.
+      </p>
+<p>
+        Example:
+      </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>has_modulus_assign<span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</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="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span>
+<span class="keyword">struct</span> <span class="identifier">contains</span>
+<span class="special">{</span>
+   <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span>
+   <span class="identifier">contains</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">d</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">data</span><span class="special">(</span><span class="identifier">d</span><span class="special">)</span> <span class="special">{}</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="keyword">bool</span> <span class="keyword">operator</span><span class="special">%=(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
-	<span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
+contains&lt;T&gt;&amp; <span class="keyword">operator</span> %= <span class="special">(</span><span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
+    <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
 <span class="special">}</span>
 
 <span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span>
 <span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="special">}</span>
+<span class="identifier">good</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="comment">/*something*/</span><span class="special">;</span> <span class="special">}</span>
 
 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
-	<span class="comment">// works fine for contains&lt;good&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_modulus_assign</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
-	<span class="identifier">g</span><span class="special">%=</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
-	<span class="comment">// does not work for contains&lt;bad&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_modulus_assign</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
-	<span class="identifier">b</span><span class="special">%=</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
-	<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
+    <span class="comment">// works fine for contains&lt;good&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_modulus_assign<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
+    <span class="identifier">g</span><span class="special">&amp;</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
+    <span class="comment">// does not work for contains&lt;bad&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_modulus_assign<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
+    <span class="identifier">b</span><span class="special">&amp;</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
+    <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
 <span class="special">}</span>
 </pre>
-          </li>
-<li class="listitem">
+<p>
+        For older compilers (<code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        not defined) then there are a number of issues:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span></code>%=
+            is public or not: if <code class="computeroutput"><span class="keyword">operator</span></code>%=
+            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
+            then instantiating <code class="literal">has_modulus_assign&lt;Lhs&gt;</code> will
+            produce a compiler error. For this reason <code class="literal">has_modulus_assign</code>
+            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span></code>%= or not.
+          </li></ul></div>
+<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> A&amp; <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>has_modulus_assign<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            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.
+          </li></ul></div>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+A&amp; <span class="keyword">operator</span> %= <span class="special">(</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>has_modulus_assign<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>has_modulus_assign<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
             <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not
             properly handled and would lead to undefined behavior
-          </li>
-</ul></div>
+          </li></ul></div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>

doc/html/boost_typetraits/reference/has_multiplies.html

@@ -113,66 +113,81 @@
 <p>
         <span class="bold"><strong>Known issues:</strong></span>
       </p>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
-            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_multiplies</span><span class="special">&lt;</span><span class="identifier">Lhs</span><span class="special">&gt;</span></code>
-            will produce a compiler error. For this reason <code class="computeroutput"><span class="identifier">has_multiplies</span></code>
-            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code>
-            or not.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">*(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_multiplies</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator*(const A&amp;) is private</span>
-</pre>
-          </li>
-<li class="listitem">
-            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.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">*(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_multiplies</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_multiplies</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span>
-</pre>
-          </li>
-<li class="listitem">
-            There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">*</span></code>
-            is defined but does not bind for a given template type, it is still detected
-            by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code>
-            instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example:
-<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_multiplies</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<p>
+        For modern compilers (those that support arbitrary SFINAE-expressions and
+        decltype/declval) this trait offers near perfect detection. In this situation
+        the macro <code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        will be defined after including <code class="literal">&lt;boost/type_traits/has_multiplies.hpp&gt;</code>.
+        Please note however, that detection is based on function signature only,
+        in the case that the operator is a function template then has_multiplies
+        cannot perform introspection of the template function body to ensure that
+        the type meets all of the conceptual requirements of the actual code.
+      </p>
+<p>
+        Example:
+      </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>has_multiplies<span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</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="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span>
+<span class="keyword">struct</span> <span class="identifier">contains</span>
+<span class="special">{</span>
+   <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span>
+   <span class="identifier">contains</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">d</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">data</span><span class="special">(</span><span class="identifier">d</span><span class="special">)</span> <span class="special">{}</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="keyword">bool</span> <span class="keyword">operator</span><span class="special">*(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
-	<span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
+contains&lt;T&gt; <span class="keyword">operator</span> * <span class="special">(</span>const <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
+    <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
 <span class="special">}</span>
 
 <span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span>
 <span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="special">}</span>
+<span class="identifier">good</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="comment">/*something*/</span><span class="special">;</span> <span class="special">}</span>
 
 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
-	<span class="comment">// works fine for contains&lt;good&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_multiplies</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
-	<span class="identifier">g</span><span class="special">*</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
-	<span class="comment">// does not work for contains&lt;bad&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_multiplies</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
-	<span class="identifier">b</span><span class="special">*</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
-	<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
+    <span class="comment">// works fine for contains&lt;good&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_multiplies<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
+    <span class="identifier">g</span><span class="special">&amp;</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
+    <span class="comment">// does not work for contains&lt;bad&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_multiplies<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
+    <span class="identifier">b</span><span class="special">&amp;</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
+    <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
 <span class="special">}</span>
 </pre>
-          </li>
-<li class="listitem">
+<p>
+        For older compilers (<code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        not defined) then there are a number of issues:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span></code>*
+            is public or not: if <code class="computeroutput"><span class="keyword">operator</span></code>*
+            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
+            then instantiating <code class="literal">has_multiplies&lt;Lhs&gt;</code> will
+            produce a compiler error. For this reason <code class="literal">has_multiplies</code>
+            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span></code>* or not.
+          </li></ul></div>
+<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> A <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>has_multiplies<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            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.
+          </li></ul></div>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+A <span class="keyword">operator</span> * <span class="special">(</span>const <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>has_multiplies<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>has_multiplies<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
             <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not
             properly handled and would lead to undefined behavior
-          </li>
-</ul></div>
+          </li></ul></div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>

doc/html/boost_typetraits/reference/has_multiplies_assign.html

@@ -113,68 +113,81 @@
 <p>
         <span class="bold"><strong>Known issues:</strong></span>
       </p>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
-            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">*=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">*=</span></code>
-            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
-            then instantiating <code class="computeroutput"><span class="identifier">has_multiplies_assign</span><span class="special">&lt;</span><span class="identifier">Lhs</span><span class="special">&gt;</span></code> will produce a compiler error. For
-            this reason <code class="computeroutput"><span class="identifier">has_multiplies_assign</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.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">*=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_multiplies_assign</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>
-          </li>
-<li class="listitem">
-            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.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">*=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_multiplies_assign</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_multiplies_assign</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>
-          </li>
-<li class="listitem">
-            There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">*=</span></code>
-            is defined but does not bind for a given template type, it is still detected
-            by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code>
-            instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example:
-<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_multiplies_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<p>
+        For modern compilers (those that support arbitrary SFINAE-expressions and
+        decltype/declval) this trait offers near perfect detection. In this situation
+        the macro <code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        will be defined after including <code class="literal">&lt;boost/type_traits/has_multiplies_assign.hpp&gt;</code>.
+        Please note however, that detection is based on function signature only,
+        in the case that the operator is a function template then has_multiplies_assign
+        cannot perform introspection of the template function body to ensure that
+        the type meets all of the conceptual requirements of the actual code.
+      </p>
+<p>
+        Example:
+      </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>has_multiplies_assign<span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</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="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span>
+<span class="keyword">struct</span> <span class="identifier">contains</span>
+<span class="special">{</span>
+   <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span>
+   <span class="identifier">contains</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">d</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">data</span><span class="special">(</span><span class="identifier">d</span><span class="special">)</span> <span class="special">{}</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="keyword">bool</span> <span class="keyword">operator</span><span class="special">*=(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
-	<span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
+contains&lt;T&gt;&amp; <span class="keyword">operator</span> *= <span class="special">(</span><span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
+    <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
 <span class="special">}</span>
 
 <span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span>
 <span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="special">}</span>
+<span class="identifier">good</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="comment">/*something*/</span><span class="special">;</span> <span class="special">}</span>
 
 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
-	<span class="comment">// works fine for contains&lt;good&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_multiplies_assign</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
-	<span class="identifier">g</span><span class="special">*=</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
-	<span class="comment">// does not work for contains&lt;bad&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_multiplies_assign</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
-	<span class="identifier">b</span><span class="special">*=</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
-	<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
+    <span class="comment">// works fine for contains&lt;good&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_multiplies_assign<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
+    <span class="identifier">g</span><span class="special">&amp;</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
+    <span class="comment">// does not work for contains&lt;bad&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_multiplies_assign<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
+    <span class="identifier">b</span><span class="special">&amp;</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
+    <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
 <span class="special">}</span>
 </pre>
-          </li>
-<li class="listitem">
+<p>
+        For older compilers (<code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        not defined) then there are a number of issues:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span></code>*=
+            is public or not: if <code class="computeroutput"><span class="keyword">operator</span></code>*=
+            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
+            then instantiating <code class="literal">has_multiplies_assign&lt;Lhs&gt;</code>
+            will produce a compiler error. For this reason <code class="literal">has_multiplies_assign</code>
+            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span></code>*= or not.
+          </li></ul></div>
+<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> A&amp; <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>has_multiplies_assign<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            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.
+          </li></ul></div>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+A&amp; <span class="keyword">operator</span> *= <span class="special">(</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>has_multiplies_assign<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>has_multiplies_assign<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
             <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not
             properly handled and would lead to undefined behavior
-          </li>
-</ul></div>
+          </li></ul></div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>

doc/html/boost_typetraits/reference/has_not_equal_to.html

@@ -112,68 +112,81 @@
 <p>
         <span class="bold"><strong>Known issues:</strong></span>
       </p>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
-            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">!=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">!=</span></code>
-            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
-            then instantiating <code class="computeroutput"><span class="identifier">has_not_equal_to</span><span class="special">&lt;</span><span class="identifier">Lhs</span><span class="special">&gt;</span></code> will produce a compiler error. For
-            this reason <code class="computeroutput"><span class="identifier">has_not_equal_to</span></code>
-            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">!=</span></code>
-            or not.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_not_equal_to</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator!=(const A&amp;) is private</span>
-</pre>
-          </li>
-<li class="listitem">
-            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.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_not_equal_to</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_not_equal_to</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span>
-</pre>
-          </li>
-<li class="listitem">
-            There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">!=</span></code>
-            is defined but does not bind for a given template type, it is still detected
-            by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code>
-            instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example:
-<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_not_equal_to</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<p>
+        For modern compilers (those that support arbitrary SFINAE-expressions and
+        decltype/declval) this trait offers near perfect detection. In this situation
+        the macro <code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        will be defined after including <code class="literal">&lt;boost/type_traits/has_not_equal_to.hpp&gt;</code>.
+        Please note however, that detection is based on function signature only,
+        in the case that the operator is a function template then has_not_equal_to
+        cannot perform introspection of the template function body to ensure that
+        the type meets all of the conceptual requirements of the actual code.
+      </p>
+<p>
+        Example:
+      </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>has_not_equal_to<span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</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="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span>
+<span class="keyword">struct</span> <span class="identifier">contains</span>
+<span class="special">{</span>
+   <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span>
+   <span class="identifier">contains</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">d</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">data</span><span class="special">(</span><span class="identifier">d</span><span class="special">)</span> <span class="special">{}</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="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
-	<span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
+bool <span class="keyword">operator</span> != <span class="special">(</span>const <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
+    <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
 <span class="special">}</span>
 
 <span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span>
 <span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="special">}</span>
+<span class="identifier">good</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="comment">/*something*/</span><span class="special">;</span> <span class="special">}</span>
 
 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
-	<span class="comment">// works fine for contains&lt;good&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_not_equal_to</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
-	<span class="identifier">g</span><span class="special">!=</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
-	<span class="comment">// does not work for contains&lt;bad&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_not_equal_to</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
-	<span class="identifier">b</span><span class="special">!=</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
-	<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
+    <span class="comment">// works fine for contains&lt;good&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_not_equal_to<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
+    <span class="identifier">g</span><span class="special">&amp;</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
+    <span class="comment">// does not work for contains&lt;bad&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_not_equal_to<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
+    <span class="identifier">b</span><span class="special">&amp;</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
+    <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
 <span class="special">}</span>
 </pre>
-          </li>
-<li class="listitem">
+<p>
+        For older compilers (<code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        not defined) then there are a number of issues:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span></code>!=
+            is public or not: if <code class="computeroutput"><span class="keyword">operator</span></code>!=
+            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
+            then instantiating <code class="literal">has_not_equal_to&lt;Lhs&gt;</code> will
+            produce a compiler error. For this reason <code class="literal">has_not_equal_to</code>
+            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span></code>!= or not.
+          </li></ul></div>
+<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> bool <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>has_not_equal_to<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            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.
+          </li></ul></div>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+bool <span class="keyword">operator</span> != <span class="special">(</span>const <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>has_not_equal_to<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>has_not_equal_to<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
             <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not
             properly handled and would lead to undefined behavior
-          </li>
-</ul></div>
+          </li></ul></div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>

doc/html/boost_typetraits/reference/has_plus.html

@@ -113,66 +113,82 @@
 <p>
         <span class="bold"><strong>Known issues:</strong></span>
       </p>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
-            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code> is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code> then instantiating <code class="computeroutput"><span class="identifier">has_plus</span><span class="special">&lt;</span><span class="identifier">Lhs</span><span class="special">&gt;</span></code>
-            will produce a compiler error. For this reason <code class="computeroutput"><span class="identifier">has_plus</span></code>
-            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code>
-            or not.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">+(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_plus</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator+(const A&amp;) is private</span>
-</pre>
-          </li>
-<li class="listitem">
-            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.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">+(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_plus</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_plus</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span>
-</pre>
-          </li>
-<li class="listitem">
-            There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">+</span></code>
-            is defined but does not bind for a given template type, it is still detected
-            by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code>
-            instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example:
-<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_plus</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<p>
+        For modern compilers (those that support arbitrary SFINAE-expressions and
+        decltype/declval) this trait offers near perfect detection. In this situation
+        the macro <code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        will be defined after including <code class="literal">&lt;boost/type_traits/has_plus.hpp&gt;</code>.
+        Please note however, that detection is based on function signature only,
+        in the case that the operator is a function template then has_plus cannot
+        perform introspection of the template function body to ensure that the type
+        meets all of the conceptual requirements of the actual code.
+      </p>
+<p>
+        Example:
+      </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>has_plus<span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</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="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span>
+<span class="keyword">struct</span> <span class="identifier">contains</span>
+<span class="special">{</span>
+   <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span>
+   <span class="identifier">contains</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">d</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">data</span><span class="special">(</span><span class="identifier">d</span><span class="special">)</span> <span class="special">{}</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="keyword">bool</span> <span class="keyword">operator</span><span class="special">+(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
-	<span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
+contains&lt;T&gt; <span class="keyword">operator</span> + <span class="special">(</span>const <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
+    <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
 <span class="special">}</span>
 
 <span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span>
 <span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="special">}</span>
+<span class="identifier">good</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="comment">/*something*/</span><span class="special">;</span> <span class="special">}</span>
 
 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
-	<span class="comment">// works fine for contains&lt;good&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_plus</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
-	<span class="identifier">g</span><span class="special">+</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
-	<span class="comment">// does not work for contains&lt;bad&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_plus</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
-	<span class="identifier">b</span><span class="special">+</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
-	<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
+    <span class="comment">// works fine for contains&lt;good&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_plus<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
+    <span class="identifier">g</span><span class="special">&amp;</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
+    <span class="comment">// does not work for contains&lt;bad&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_plus<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
+    <span class="identifier">b</span><span class="special">&amp;</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
+    <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
 <span class="special">}</span>
 </pre>
-          </li>
-<li class="listitem">
+<p>
+        For older compilers (<code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        not defined) then there are a number of issues:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span></code>+
+            is public or not: if <code class="computeroutput"><span class="keyword">operator</span></code>+
+            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
+            then instantiating <code class="literal">has_plus&lt;Lhs&gt;</code> will produce
+            a compiler error. For this reason <code class="literal">has_plus</code> cannot
+            be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span></code>+
+            or not.
+          </li></ul></div>
+<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> A <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>has_plus<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            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.
+          </li></ul></div>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+A <span class="keyword">operator</span> + <span class="special">(</span>const <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>has_plus<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>has_plus<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
             <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not
             properly handled and would lead to undefined behavior
-          </li>
-</ul></div>
+          </li></ul></div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>

doc/html/boost_typetraits/reference/has_plus_assign.html

@@ -113,68 +113,81 @@
 <p>
         <span class="bold"><strong>Known issues:</strong></span>
       </p>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
-            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">+=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">+=</span></code>
-            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
-            then instantiating <code class="computeroutput"><span class="identifier">has_plus_assign</span><span class="special">&lt;</span><span class="identifier">Lhs</span><span class="special">&gt;</span></code> will produce a compiler error. For
-            this reason <code class="computeroutput"><span class="identifier">has_plus_assign</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.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">+=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_plus_assign</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>
-          </li>
-<li class="listitem">
-            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.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">+=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_plus_assign</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_plus_assign</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>
-          </li>
-<li class="listitem">
-            There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">+=</span></code>
-            is defined but does not bind for a given template type, it is still detected
-            by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code>
-            instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example:
-<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_plus_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<p>
+        For modern compilers (those that support arbitrary SFINAE-expressions and
+        decltype/declval) this trait offers near perfect detection. In this situation
+        the macro <code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        will be defined after including <code class="literal">&lt;boost/type_traits/has_plus_assign.hpp&gt;</code>.
+        Please note however, that detection is based on function signature only,
+        in the case that the operator is a function template then has_plus_assign
+        cannot perform introspection of the template function body to ensure that
+        the type meets all of the conceptual requirements of the actual code.
+      </p>
+<p>
+        Example:
+      </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>has_plus_assign<span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</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="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span>
+<span class="keyword">struct</span> <span class="identifier">contains</span>
+<span class="special">{</span>
+   <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span>
+   <span class="identifier">contains</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">d</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">data</span><span class="special">(</span><span class="identifier">d</span><span class="special">)</span> <span class="special">{}</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="keyword">bool</span> <span class="keyword">operator</span><span class="special">+=(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
-	<span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
+contains&lt;T&gt;&amp; <span class="keyword">operator</span> += <span class="special">(</span>const <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
+    <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
 <span class="special">}</span>
 
 <span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span>
 <span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="special">}</span>
+<span class="identifier">good</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="comment">/*something*/</span><span class="special">;</span> <span class="special">}</span>
 
 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
-	<span class="comment">// works fine for contains&lt;good&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_plus_assign</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
-	<span class="identifier">g</span><span class="special">+=</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
-	<span class="comment">// does not work for contains&lt;bad&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_plus_assign</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
-	<span class="identifier">b</span><span class="special">+=</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
-	<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
+    <span class="comment">// works fine for contains&lt;good&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_plus_assign<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
+    <span class="identifier">g</span><span class="special">&amp;</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
+    <span class="comment">// does not work for contains&lt;bad&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_plus_assign<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
+    <span class="identifier">b</span><span class="special">&amp;</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
+    <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
 <span class="special">}</span>
 </pre>
-          </li>
-<li class="listitem">
+<p>
+        For older compilers (<code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        not defined) then there are a number of issues:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span></code>+=
+            is public or not: if <code class="computeroutput"><span class="keyword">operator</span></code>+=
+            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
+            then instantiating <code class="literal">has_plus_assign&lt;Lhs&gt;</code> will
+            produce a compiler error. For this reason <code class="literal">has_plus_assign</code>
+            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span></code>+= or not.
+          </li></ul></div>
+<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> A&amp; <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>has_plus_assign<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            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.
+          </li></ul></div>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+A&amp; <span class="keyword">operator</span> += <span class="special">(</span>const <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>has_plus_assign<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>has_plus_assign<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
             <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not
             properly handled and would lead to undefined behavior
-          </li>
-</ul></div>
+          </li></ul></div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>

doc/html/boost_typetraits/reference/has_right_shift.html

@@ -119,68 +119,81 @@
 <p>
         <span class="bold"><strong>Known issues:</strong></span>
       </p>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
-            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;&gt;</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;&gt;</span></code>
-            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
-            then instantiating <code class="computeroutput"><span class="identifier">has_right_shift</span><span class="special">&lt;</span><span class="identifier">Lhs</span><span class="special">&gt;</span></code> will produce a compiler error. For
-            this reason <code class="computeroutput"><span class="identifier">has_right_shift</span></code>
-            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;&gt;</span></code>
-            or not.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&gt;&gt;(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_right_shift</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator&gt;&gt;(const A&amp;) is private</span>
-</pre>
-          </li>
-<li class="listitem">
-            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.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&gt;&gt;(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_right_shift</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// this is fine</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_right_shift</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: ambiguous overload</span>
-</pre>
-          </li>
-<li class="listitem">
-            There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;&gt;</span></code>
-            is defined but does not bind for a given template type, it is still detected
-            by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code>
-            instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example:
-<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_right_shift</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<p>
+        For modern compilers (those that support arbitrary SFINAE-expressions and
+        decltype/declval) this trait offers near perfect detection. In this situation
+        the macro <code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        will be defined after including <code class="literal">&lt;boost/type_traits/has_right_shift.hpp&gt;</code>.
+        Please note however, that detection is based on function signature only,
+        in the case that the operator is a function template then has_right_shift
+        cannot perform introspection of the template function body to ensure that
+        the type meets all of the conceptual requirements of the actual code.
+      </p>
+<p>
+        Example:
+      </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>has_right_shift<span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</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="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span>
+<span class="keyword">struct</span> <span class="identifier">contains</span>
+<span class="special">{</span>
+   <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span>
+   <span class="identifier">contains</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">d</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">data</span><span class="special">(</span><span class="identifier">d</span><span class="special">)</span> <span class="special">{}</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="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;&gt;(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
-	<span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
+contains&lt;T&gt; <span class="keyword">operator</span> &gt;&gt; <span class="special">(</span>const <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
+    <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
 <span class="special">}</span>
 
 <span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span>
 <span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="special">}</span>
+<span class="identifier">good</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="comment">/*something*/</span><span class="special">;</span> <span class="special">}</span>
 
 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
-	<span class="comment">// works fine for contains&lt;good&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_right_shift</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
-	<span class="identifier">g</span><span class="special">&gt;&gt;</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
-	<span class="comment">// does not work for contains&lt;bad&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_right_shift</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
-	<span class="identifier">b</span><span class="special">&gt;&gt;</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
-	<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
+    <span class="comment">// works fine for contains&lt;good&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_right_shift<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
+    <span class="identifier">g</span><span class="special">&amp;</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
+    <span class="comment">// does not work for contains&lt;bad&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_right_shift<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
+    <span class="identifier">b</span><span class="special">&amp;</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
+    <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
 <span class="special">}</span>
 </pre>
-          </li>
-<li class="listitem">
+<p>
+        For older compilers (<code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        not defined) then there are a number of issues:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span></code>&gt;&gt;
+            is public or not: if <code class="computeroutput"><span class="keyword">operator</span></code>&gt;&gt;
+            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
+            then instantiating <code class="literal">has_right_shift&lt;Lhs&gt;</code> will
+            produce a compiler error. For this reason <code class="literal">has_right_shift</code>
+            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span></code>&gt;&gt; or not.
+          </li></ul></div>
+<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> A <span class="keyword">operator</span> &gt;&gt; <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>has_right_shift<span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator &gt;&gt; (const A&amp;) is private</span>
+</pre>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            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.
+          </li></ul></div>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+A <span class="keyword">operator</span> &gt;&gt; <span class="special">(</span>const <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>has_right_shift<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>has_right_shift<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
             <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not
             properly handled and would lead to undefined behavior
-          </li>
-</ul></div>
+          </li></ul></div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>

doc/html/boost_typetraits/reference/has_right_shift_assign.html

@@ -111,68 +111,81 @@
 <p>
         <span class="bold"><strong>Known issues:</strong></span>
       </p>
-<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
-<li class="listitem">
-            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;&gt;=</span></code> is public or not: if <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;&gt;=</span></code>
-            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
-            then instantiating <code class="computeroutput"><span class="identifier">has_right_shift_assign</span><span class="special">&lt;</span><span class="identifier">Lhs</span><span class="special">&gt;</span></code> will produce a compiler error. For
-            this reason <code class="computeroutput"><span class="identifier">has_right_shift_assign</span></code>
-            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;&gt;=</span></code>
-            or not.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="keyword">private</span><span class="special">:</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&gt;&gt;=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_right_shift_assign</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator&gt;&gt;=(const A&amp;) is private</span>
-</pre>
-          </li>
-<li class="listitem">
-            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.
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">&gt;&gt;=(</span><span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;);</span>
-<span class="keyword">struct</span> <span class="identifier">B</span> <span class="special">{</span> <span class="keyword">operator</span> <span class="identifier">A</span><span class="special">();</span> <span class="special">};</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_right_shift_assign</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_right_shift_assign</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>
-          </li>
-<li class="listitem">
-            There is an issue when applying this trait to template classes. If <code class="computeroutput"><span class="keyword">operator</span><span class="special">&gt;&gt;=</span></code>
-            is defined but does not bind for a given template type, it is still detected
-            by the trait which returns <code class="computeroutput"><span class="keyword">true</span></code>
-            instead of <code class="computeroutput"><span class="keyword">false</span></code>. Example:
-<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_right_shift_assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<p>
+        For modern compilers (those that support arbitrary SFINAE-expressions and
+        decltype/declval) this trait offers near perfect detection. In this situation
+        the macro <code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        will be defined after including <code class="literal">&lt;boost/type_traits/has_right_shift_assign.hpp&gt;</code>.
+        Please note however, that detection is based on function signature only,
+        in the case that the operator is a function template then has_right_shift_assign
+        cannot perform introspection of the template function body to ensure that
+        the type meets all of the conceptual requirements of the actual code.
+      </p>
+<p>
+        Example:
+      </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>has_right_shift_assign<span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</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="keyword">struct</span> <span class="identifier">contains</span> <span class="special">{</span> <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span> <span class="special">};</span>
+<span class="keyword">struct</span> <span class="identifier">contains</span>
+<span class="special">{</span>
+   <span class="identifier">T</span> <span class="identifier">data</span><span class="special">;</span>
+   <span class="identifier">contains</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">d</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">data</span><span class="special">(</span><span class="identifier">d</span><span class="special">)</span> <span class="special">{}</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="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;&gt;=(</span><span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
-	<span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
+contains&lt;T&gt;&amp; <span class="keyword">operator</span> &gt;&gt;= <span class="special">(</span><span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">lhs</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">rhs</span><span class="special">)</span> <span class="special">{</span>
+    <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">lhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">,</span> <span class="identifier">rhs</span><span class="special">.</span><span class="identifier">data</span><span class="special">);</span>
 <span class="special">}</span>
 
 <span class="keyword">class</span> <span class="identifier">bad</span> <span class="special">{</span> <span class="special">};</span>
 <span class="keyword">class</span> <span class="identifier">good</span> <span class="special">{</span> <span class="special">};</span>
-<span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="special">}</span>
+<span class="identifier">good</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">good</span><span class="special">&amp;)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="comment">/*something*/</span><span class="special">;</span> <span class="special">}</span>
 
 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
-	<span class="comment">// works fine for contains&lt;good&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_right_shift_assign</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
-	<span class="identifier">g</span><span class="special">&gt;&gt;=</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
-	<span class="comment">// does not work for contains&lt;bad&gt;</span>
-	<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_right_shift_assign</span><span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
-	<span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
-	<span class="identifier">b</span><span class="special">&gt;&gt;=</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
-	<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">boolalpha</span><span class="special">;</span>
+    <span class="comment">// works fine for contains&lt;good&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_right_shift_assign<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">good</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">good</span><span class="special">&gt;</span> <span class="identifier">g</span><span class="special">;</span>
+    <span class="identifier">g</span><span class="special">&amp;</span><span class="identifier">g</span><span class="special">;</span> <span class="comment">// ok</span>
+    <span class="comment">// does not work for contains&lt;bad&gt;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">&lt;&lt;</span><span class="identifier">boost</span><span class="special">::</span>has_right_shift_assign<span class="special">&lt;</span> <span class="identifier">contains</span><span class="special">&lt;</span> <span class="identifier">bad</span> <span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&lt;&lt;</span><span class="char">'\n'</span><span class="special">;</span> <span class="comment">// true, should be false</span>
+    <span class="identifier">contains</span><span class="special">&lt;</span><span class="identifier">bad</span><span class="special">&gt;</span> <span class="identifier">b</span><span class="special">;</span>
+    <span class="identifier">b</span><span class="special">&amp;</span><span class="identifier">b</span><span class="special">;</span> <span class="comment">// compile time error</span>
+    <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
 <span class="special">}</span>
 </pre>
-          </li>
-<li class="listitem">
+<p>
+        For older compilers (<code class="computeroutput"><span class="identifier">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></code>
+        not defined) then there are a number of issues:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            This trait cannot detect whether binary <code class="computeroutput"><span class="keyword">operator</span></code>&gt;&gt;=
+            is public or not: if <code class="computeroutput"><span class="keyword">operator</span></code>&gt;&gt;=
+            is defined as a private member of <code class="computeroutput"><span class="identifier">Lhs</span></code>
+            then instantiating <code class="literal">has_right_shift_assign&lt;Lhs&gt;</code>
+            will produce a compiler error. For this reason <code class="literal">has_right_shift_assign</code>
+            cannot be used to determine whether a type has a public <code class="computeroutput"><span class="keyword">operator</span></code>&gt;&gt;= or not.
+          </li></ul></div>
+<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> A&amp; <span class="keyword">operator</span> &gt;&gt;= <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>has_right_shift_assign<span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">;</span> <span class="comment">// error: A::operator &gt;&gt;= (const A&amp;) is private</span>
+</pre>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
+            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.
+          </li></ul></div>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span> <span class="special">{</span> <span class="special">};</span>
+A&amp; <span class="keyword">operator</span> &gt;&gt;= <span class="special">(</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>has_right_shift_assign<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>has_right_shift_assign<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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
             <code class="computeroutput"><span class="keyword">volatile</span></code> qualifier is not
             properly handled and would lead to undefined behavior
-          </li>
-</ul></div>
+          </li></ul></div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>

doc/html/boost_typetraits/reference/is_class.html

@@ -7,7 +7,7 @@
 <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="is_base_of.html" title="is_base_of">
-<link rel="next" href="is_complex.html" title="is_complex">
+<link rel="next" href="is_complete.html" title="is_complete">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -20,7 +20,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="is_base_of.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_complex.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="is_base_of.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_complete.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
@@ -93,7 +93,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="is_base_of.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_complex.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="is_base_of.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_complete.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

doc/html/boost_typetraits/reference/is_complete.html

@@ -0,0 +1,79 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>is_complete</title>
+<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
+<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="is_class.html" title="is_class">
+<link rel="next" href="is_complex.html" title="is_complex">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="is_class.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_complex.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.reference.is_complete"></a><a class="link" href="is_complete.html" title="is_complete">is_complete</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">T</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">is_complete</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 <code class="computeroutput"><span class="identifier">T</span></code>
+        is a complete type 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>
+<div class="important"><table border="0" summary="Important">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Important]" src="../../../../../../doc/src/images/important.png"></td>
+<th align="left">Important</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+          This trait is designed for one use only: to trigger a hard error (via a
+          <code class="computeroutput"><span class="keyword">static_assert</span></code>) when a template
+          is accidentally instantiated on an incomplete type. Any other use case
+          will cause ODR violations as the "completeness" of type <code class="computeroutput"><span class="identifier">T</span></code> may vary at different points in the
+          current translation unit, as well as across translations units. <span class="emphasis"><em><span class="bold"><strong>In particular this trait should never ever be used to change
+          code paths depending on the completeness of a type</strong></span></em></span>.
+        </p></td></tr>
+</table></div>
+<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">is_complete</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+        or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+      </p>
+<p>
+        <span class="bold"><strong>Compiler Compatibility:</strong></span> Requires C++11 SFINAE-expressions
+        to function fully. The macro <code class="computeroutput"><span class="identifier">BOOST_TT_HAS_WORKING_IS_COMPLETE</span></code>
+        is defined when the trait is fully functional.
+      </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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="is_class.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_complex.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

doc/html/boost_typetraits/reference/is_complex.html

@@ -6,7 +6,7 @@
 <meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
 <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="is_class.html" title="is_class">
+<link rel="prev" href="is_complete.html" title="is_complete">
 <link rel="next" href="is_compound.html" title="is_compound">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -20,7 +20,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="is_class.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_compound.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="is_complete.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_compound.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
@@ -62,7 +62,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="is_class.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_compound.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="is_complete.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_compound.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

doc/html/boost_typetraits/reference/is_constructible.html

@@ -70,7 +70,9 @@
         the C++11 features <code class="computeroutput"><span class="keyword">decltype</span></code>
         variadic templates and SFINAE-expression support for full support. While
         there is some fallback code for cases where this is not the case, the trait
-        should really be considered broken in that case.
+        should really be considered broken in that case. The header will define the
+        macro <code class="computeroutput"><span class="identifier">BOOST_TT_IS_CONSTRUCTIBLE_CONFORMING</span></code>
+        when the full implementation is available.
       </p>
 <p>
         <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span>

doc/html/boost_typetraits/reference/is_destructible.html

@@ -7,7 +7,7 @@
 <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="is_default_constructible.html" title="is_default_constructible">
-<link rel="next" href="is_empty.html" title="is_empty">
+<link rel="next" href="is_detected.html" title="is_detected">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -20,7 +20,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="is_default_constructible.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_empty.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="is_default_constructible.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_detected.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
@@ -63,7 +63,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="is_default_constructible.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_empty.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="is_default_constructible.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_detected.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

doc/html/boost_typetraits/reference/is_detected.html

@@ -0,0 +1,94 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>is_detected</title>
+<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
+<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="is_destructible.html" title="is_destructible">
+<link rel="next" href="is_detected_convertible.html" title="is_detected_convertible">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="is_destructible.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_detected_convertible.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.reference.is_detected"></a><a class="link" href="is_detected.html" title="is_detected">is_detected</a>
+</h3></div></div></div>
+<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...&gt;</span> <span class="keyword">class</span> <span class="identifier">Op</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span>
+<span class="keyword">using</span> <span class="identifier">is_detected</span> <span class="special">=</span> <em class="replaceable"><code>see-below</code></em><span class="special">;</span>
+
+<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...&gt;</span> <span class="keyword">class</span> <span class="identifier">Op</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span>
+<span class="keyword">constexpr</span> <span class="keyword">bool</span> <span class="identifier">is_detected_v</span> <span class="special">=</span> <span class="identifier">is_detected</span><span class="special">&lt;</span><span class="identifier">Op</span><span class="special">,</span> <span class="identifier">Args</span><span class="special">...&gt;::</span><span class="identifier">value</span><span class="special">;</span>
+</pre>
+<p>
+        <span class="bold"><strong>Aliases:</strong></span> If <code class="computeroutput"><span class="identifier">Op</span><span class="special">&lt;</span><span class="identifier">Args</span><span class="special">...&gt;</span></code> is a valid template-id, aliases <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>,
+        otherwise aliases <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>.
+      </p>
+<p>
+        <span class="bold"><strong>C++ Standard Paper:</strong></span> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4502.pdf" target="_top">N4502</a>
+      </p>
+<p>
+        <span class="bold"><strong>Compiler Compatibility:</strong></span> Requires C++11 variadic
+        templates and C++11 template aliases.
+      </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">is_detected</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>
+<p>
+        Suppose we wish to "reset" a value of type T, if the type has a
+        <code class="computeroutput"><span class="identifier">clear</span><span class="special">()</span></code>
+        member function then we should call it, otherwise we should assign a default
+        constructed value:
+      </p>
+<pre class="programlisting"><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="keyword">using</span> <span class="identifier">clear_t</span> <span class="special">=</span> <span class="keyword">decltype</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">declval</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&amp;&gt;().</span><span class="identifier">clear</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="keyword">void</span> <span class="identifier">clear</span><span class="special">(</span><span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">value</span><span class="special">)</span>
+<span class="special">{</span>
+    <span class="keyword">if</span> <span class="keyword">constexpr</span> <span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_detected_v</span><span class="special">&lt;</span><span class="identifier">clear_t</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;)</span> <span class="special">{</span>
+        <span class="identifier">value</span><span class="special">.</span><span class="identifier">clear</span><span class="special">();</span>
+    <span class="special">}</span> <span class="keyword">else</span> <span class="special">{</span>
+        <span class="identifier">value</span> <span class="special">=</span> <span class="identifier">T</span><span class="special">();</span>
+    <span class="special">}</span>
+<span class="special">}</span>
+</pre>
+<p>
+        See also: <a class="link" href="is_detected_convertible.html" title="is_detected_convertible">is_detected_convertible</a>,
+        <a class="link" href="is_detected_exact.html" title="is_detected_exact">is_detected_exact</a>.
+      </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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="is_destructible.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_detected_convertible.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

doc/html/boost_typetraits/reference/is_detected_convertible.html

@@ -0,0 +1,84 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>is_detected_convertible</title>
+<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
+<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="is_detected.html" title="is_detected">
+<link rel="next" href="is_detected_exact.html" title="is_detected_exact">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="is_detected.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_detected_exact.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.reference.is_detected_convertible"></a><a class="link" href="is_detected_convertible.html" title="is_detected_convertible">is_detected_convertible</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">To</span><span class="special">,</span> <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...&gt;</span> <span class="keyword">class</span> <span class="identifier">Op</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span>
+<span class="keyword">using</span> <span class="identifier">is_detected_convertible</span> <span class="special">=</span> <span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="identifier">detected_t</span><span class="special">&lt;</span><span class="identifier">Op</span><span class="special">,</span> <span class="identifier">Args</span><span class="special">...&gt;,</span> <span class="identifier">To</span><span class="special">&gt;;</span>
+
+<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">To</span><span class="special">,</span> <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...&gt;</span> <span class="keyword">class</span> <span class="identifier">Op</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span>
+<span class="keyword">constexpr</span> <span class="keyword">bool</span> <span class="identifier">is_detected_convertible_v</span> <span class="special">=</span> <span class="identifier">is_detected_convertible</span><span class="special">&lt;</span><span class="identifier">Op</span><span class="special">,</span> <span class="identifier">Args</span><span class="special">...&gt;::</span><span class="identifier">value</span><span class="special">;</span>
+</pre>
+<p>
+        <span class="bold"><strong>C++ Standard Paper:</strong></span> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4502.pdf" target="_top">N4502</a>
+      </p>
+<p>
+        <span class="bold"><strong>Compiler Compatibility:</strong></span> Requires C++11 variadic
+        templates and C++11 template aliases.
+      </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">is_detected_convertible</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+      </p>
+<p>
+        The type <code class="computeroutput"><span class="identifier">is_detected_convertible</span><span class="special">&lt;</span><span class="identifier">To</span><span class="special">,</span> <span class="identifier">Op</span><span class="special">,</span>
+        <span class="identifier">Args</span><span class="special">&gt;</span></code>
+        is an alias for <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>
+        if the result of <code class="computeroutput"><span class="identifier">Op</span><span class="special">&lt;</span><span class="identifier">Args</span><span class="special">&gt;</span></code>
+        is convertible to type <code class="computeroutput"><span class="identifier">To</span></code>.
+        Otherwise it's the type <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>;
+      </p>
+<p>
+        <span class="bold"><strong>Examples:</strong></span>
+      </p>
+<pre class="programlisting"><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="keyword">using</span> <span class="identifier">size_type_t</span> <span class="special">=</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">::</span><span class="identifier">size_type</span><span class="special">;</span>
+
+<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_detected_convertible_v</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">,</span> <span class="identifier">size_type_t</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;);</span>
+</pre>
+<p>
+        See also: <a class="link" href="is_detected.html" title="is_detected">is_detected</a>,
+        <a class="link" href="is_detected_exact.html" title="is_detected_exact">is_detected_exact</a>.
+      </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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="is_detected.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_detected_exact.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

doc/html/boost_typetraits/reference/is_detected_exact.html

@@ -0,0 +1,84 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>is_detected_exact</title>
+<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
+<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="is_detected_convertible.html" title="is_detected_convertible">
+<link rel="next" href="is_empty.html" title="is_empty">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="is_detected_convertible.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_empty.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.reference.is_detected_exact"></a><a class="link" href="is_detected_exact.html" title="is_detected_exact">is_detected_exact</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">Expected</span><span class="special">,</span> <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...&gt;</span> <span class="keyword">class</span> <span class="identifier">Op</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span>
+<span class="keyword">using</span> <span class="identifier">is_detected_exact</span> <span class="special">=</span> <span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">Expected</span><span class="special">,</span> <span class="identifier">detected_t</span><span class="special">&lt;</span><span class="identifier">Op</span><span class="special">,</span> <span class="identifier">Args</span><span class="special">...&gt;</span> <span class="special">&gt;;</span>
+
+<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Expected</span><span class="special">,</span> <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...&gt;</span> <span class="keyword">class</span> <span class="identifier">Op</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span>
+<span class="keyword">constexpr</span> <span class="keyword">bool</span> <span class="identifier">is_detected_exact_v</span> <span class="special">=</span> <span class="identifier">is_detected_exact</span><span class="special">&lt;</span><span class="identifier">Op</span><span class="special">,</span> <span class="identifier">Args</span><span class="special">...&gt;::</span><span class="identifier">value</span><span class="special">;</span>
+</pre>
+<p>
+        <span class="bold"><strong>C++ Standard Paper:</strong></span> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4502.pdf" target="_top">N4502</a>
+      </p>
+<p>
+        <span class="bold"><strong>Compiler Compatibility:</strong></span> Requires C++11 variadic
+        templates and C++11 template aliases.
+      </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">is_detected_exact</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+      </p>
+<p>
+        The type <code class="computeroutput"><span class="identifier">is_detected_exact</span><span class="special">&lt;</span><span class="identifier">To</span><span class="special">,</span> <span class="identifier">Op</span><span class="special">,</span>
+        <span class="identifier">Args</span><span class="special">&gt;</span></code>
+        is an alias for <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>
+        if the result of <code class="computeroutput"><span class="identifier">Op</span><span class="special">&lt;</span><span class="identifier">Args</span><span class="special">&gt;</span></code>
+        is type <code class="computeroutput"><span class="identifier">To</span></code>. Otherwise it's
+        the type <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>;
+      </p>
+<p>
+        <span class="bold"><strong>Examples:</strong></span>
+      </p>
+<pre class="programlisting"><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="keyword">using</span> <span class="identifier">difference_t</span> <span class="special">=</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">::</span><span class="identifier">difference_type</span><span class="special">;</span>
+
+<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_detected_exact_v</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ptrdiff_t</span><span class="special">,</span> <span class="identifier">difference_t</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;);</span>
+</pre>
+<p>
+        See also: <a class="link" href="is_detected.html" title="is_detected">is_detected</a>,
+        <a class="link" href="is_detected_convertible.html" title="is_detected_convertible">is_detected_convertible</a>.
+      </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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="is_detected_convertible.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_empty.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

doc/html/boost_typetraits/reference/is_empty.html

@@ -6,7 +6,7 @@
 <meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
 <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="is_destructible.html" title="is_destructible">
+<link rel="prev" href="is_detected_exact.html" title="is_detected_exact">
 <link rel="next" href="is_enum.html" title="is_enum">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -20,7 +20,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="is_destructible.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_enum.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="is_detected_exact.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_enum.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
@@ -96,7 +96,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="is_destructible.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_enum.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="is_detected_exact.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_enum.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

doc/html/boost_typetraits/reference/is_integral.html

@@ -7,7 +7,7 @@
 <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="is_fundamental.html" title="is_fundamental">
-<link rel="next" href="is_lvalue_reference.html" title="is_lvalue_reference">
+<link rel="next" href="is_list_constructible.html" title="is_list_constructible">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -20,7 +20,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="is_fundamental.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_lvalue_reference.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="is_fundamental.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_list_constructible.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
@@ -79,7 +79,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="is_fundamental.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_lvalue_reference.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="is_fundamental.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_list_constructible.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

doc/html/boost_typetraits/reference/is_list_constructible.html

@@ -0,0 +1,66 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>is_list_constructible</title>
+<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
+<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="is_integral.html" title="is_integral">
+<link rel="next" href="is_lvalue_reference.html" title="is_lvalue_reference">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="is_integral.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_lvalue_reference.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.reference.is_list_constructible"></a><a class="link" href="is_list_constructible.html" title="is_list_constructible">is_list_constructible</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">T</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">is_list_constructible</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 <code class="computeroutput"><span class="identifier">T</span></code>
+        can be constructed from <code class="computeroutput"><span class="identifier">Args</span></code>
+        using list initialization (<code class="computeroutput"><span class="identifier">T</span><span class="special">{</span><span class="identifier">declval</span><span class="special">&lt;</span><span class="identifier">Args</span><span class="special">&gt;()...}</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>.
+        <code class="computeroutput"><span class="identifier">T</span></code> must be a complete type.
+      </p>
+<p>
+        <span class="bold"><strong>Compiler Compatibility:</strong></span> This trait requires
+        C++11.
+      </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">is_list_constructible</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+        or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+      </p>
+</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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="is_integral.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_lvalue_reference.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

doc/html/boost_typetraits/reference/is_lvalue_reference.html

@@ -6,7 +6,7 @@
 <meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
 <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="is_integral.html" title="is_integral">
+<link rel="prev" href="is_list_constructible.html" title="is_list_constructible">
 <link rel="next" href="is_member_function_pointer.html" title="is_member_function_pointer">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -20,7 +20,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="is_integral.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_member_function_pointer.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="is_list_constructible.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_member_function_pointer.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
@@ -84,7 +84,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="is_integral.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_member_function_pointer.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="is_list_constructible.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_member_function_pointer.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

doc/html/boost_typetraits/reference/is_nothrow_move_constructible.html

@@ -7,7 +7,7 @@
 <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="is_nothrow_move_assignable.html" title="is_nothrow_move_assignable">
-<link rel="next" href="is_object.html" title="is_object">
+<link rel="next" href="is_nothrow_swappable.html" title="is_nothrow_swappable">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -20,7 +20,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="is_nothrow_move_assignable.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_object.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="is_nothrow_move_assignable.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_nothrow_swappable.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
@@ -70,7 +70,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="is_nothrow_move_assignable.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_object.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="is_nothrow_move_assignable.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_nothrow_swappable.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

doc/html/boost_typetraits/reference/is_nothrow_swappable.html

@@ -0,0 +1,69 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>is_nothrow_swappable</title>
+<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
+<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="is_nothrow_move_constructible.html" title="is_nothrow_move_constructible">
+<link rel="next" href="is_object.html" title="is_object">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="is_nothrow_move_constructible.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_object.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.reference.is_nothrow_swappable"></a><a class="link" href="is_nothrow_swappable.html" title="is_nothrow_swappable">is_nothrow_swappable</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">T</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">is_nothrow_swappable</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 the expression <code class="computeroutput"><span class="identifier">swap</span><span class="special">(</span><span class="identifier">declval</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&amp;&gt;(),</span>
+        <span class="identifier">declval</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&amp;&gt;())</span></code>
+        (in a context where <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">swap</span></code> is visible) is valid and non-throwing,
+        inherits from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>,
+        otherwise from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>.
+      </p>
+<p>
+        <span class="bold"><strong>Compiler Compatibility:</strong></span> This trait requires
+        C++11 for full support. Without C++11 it will inherit from <a class="link" href="integral_constant.html" title="integral_constant">true_type</a>
+        for scalar types (including integral, floating point, enumeration, pointer
+        and pointer-to-member types), and from <a class="link" href="integral_constant.html" title="integral_constant">false_type</a>
+        for anything else.
+      </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">is_nothrow_swappable</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+        or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+      </p>
+</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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="is_nothrow_move_constructible.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_object.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

doc/html/boost_typetraits/reference/is_object.html

@@ -6,7 +6,7 @@
 <meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
 <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="is_nothrow_move_constructible.html" title="is_nothrow_move_constructible">
+<link rel="prev" href="is_nothrow_swappable.html" title="is_nothrow_swappable">
 <link rel="next" href="is_pod.html" title="is_pod">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -20,7 +20,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="is_nothrow_move_constructible.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_pod.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="is_nothrow_swappable.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_pod.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
@@ -97,7 +97,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="is_nothrow_move_constructible.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_pod.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="is_nothrow_swappable.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="is_pod.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

doc/html/boost_typetraits/reference/make_void.html

@@ -7,7 +7,7 @@
 <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="make_unsigned.html" title="make_unsigned">
-<link rel="next" href="promote.html" title="promote">
+<link rel="next" href="nonesuch.html" title="nonesuch">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -20,7 +20,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="make_unsigned.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="promote.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="make_unsigned.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="nonesuch.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
@@ -173,7 +173,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="make_unsigned.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="promote.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="make_unsigned.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="nonesuch.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

doc/html/boost_typetraits/reference/nonesuch.html

@@ -0,0 +1,62 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>nonesuch</title>
+<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
+<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="make_void.html" title="make_void">
+<link rel="next" href="promote.html" title="promote">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="make_void.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="promote.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.reference.nonesuch"></a><a class="link" href="nonesuch.html" title="nonesuch">nonesuch</a>
+</h3></div></div></div>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">nonesuch</span> <span class="special">{</span>
+    <span class="identifier">nonesuch</span><span class="special">()</span> <span class="special">=</span> <span class="keyword">delete</span><span class="special">;</span>
+    <span class="special">~</span><span class="identifier">nonesuch</span><span class="special">()</span> <span class="special">=</span> <span class="keyword">delete</span><span class="special">;</span>
+    <span class="identifier">nonesuch</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">nonesuch</span><span class="special">&amp;)</span> <span class="special">=</span> <span class="keyword">delete</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">nonesuch</span><span class="special">&amp;)</span> <span class="special">=</span> <span class="keyword">delete</span><span class="special">;</span>
+<span class="special">};</span>
+</pre>
+<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">nonesuch</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+      </p>
+<p>
+        Type <code class="computeroutput"><span class="identifier">nonesuch</span></code> is a placeholder
+        type used when the detection idiom fails - see <a class="link" href="detected.html" title="detected">detected</a>.
+      </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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="make_void.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="promote.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

doc/html/boost_typetraits/reference/promote.html

@@ -6,7 +6,7 @@
 <meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
 <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="make_void.html" title="make_void">
+<link rel="prev" href="nonesuch.html" title="nonesuch">
 <link rel="next" href="rank.html" title="rank">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -20,7 +20,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="make_void.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="rank.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="nonesuch.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="rank.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
@@ -131,7 +131,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="make_void.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="rank.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="nonesuch.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="rank.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

doc/html/boost_typetraits/reference/remove_cv.html

@@ -7,7 +7,7 @@
 <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="remove_const.html" title="remove_const">
-<link rel="next" href="remove_extent.html" title="remove_extent">
+<link rel="next" href="remove_cv_ref.html" title="remove_cv_ref">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
@@ -20,7 +20,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="remove_const.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="remove_extent.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="remove_const.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="remove_cv_ref.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
@@ -150,7 +150,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="remove_const.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="remove_extent.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="remove_const.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="remove_cv_ref.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

doc/html/boost_typetraits/reference/remove_cv_ref.html

@@ -0,0 +1,157 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>remove_cv_ref</title>
+<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
+<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="remove_cv.html" title="remove_cv">
+<link rel="next" href="remove_extent.html" title="remove_extent">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="remove_cv.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="remove_extent.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.reference.remove_cv_ref"></a><a class="link" href="remove_cv_ref.html" title="remove_cv_ref">remove_cv_ref</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">T</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">remove_cv_ref</span>
+<span class="special">{</span>
+   <span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">type</span><span class="special">;</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="keyword">using</span> <span class="identifier">remove_cv_ref_t</span> <span class="special">=</span> <span class="keyword">typename</span> <span class="identifier">remove_cv_ref</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">;</span> <span class="comment">// C++11 and above</span>
+</pre>
+<p>
+        <span class="bold"><strong>type:</strong></span> The same type as <code class="computeroutput"><span class="identifier">T</span></code>,
+        but with any reference modifiers and <span class="emphasis"><em>top level</em></span> cv-qualifiers
+        removed.
+      </p>
+<p>
+        <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.3, 8.3.2.
+      </p>
+<p>
+        <span class="bold"><strong>Compiler Compatibility:</strong></span> All current compilers
+        are supported by this trait.
+      </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">remove_cv_ref</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+        or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+      </p>
+<div class="table">
+<a name="boost_typetraits.reference.remove_cv_ref.examples"></a><p class="title"><b>Table&#160;1.30.&#160;Examples</b></p>
+<div class="table-contents"><table class="table" summary="Examples">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+                <p>
+                  Expression
+                </p>
+              </th>
+<th>
+                <p>
+                  Result Type
+                </p>
+              </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+                <p>
+                  <code class="computeroutput"><span class="identifier">remove_cv_ref</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
+                </p>
+              </td>
+<td>
+                <p>
+                  <code class="computeroutput"><span class="keyword">int</span></code>
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  <code class="computeroutput"><span class="identifier">remove_cv_ref</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
+                </p>
+              </td>
+<td>
+                <p>
+                  <code class="computeroutput"><span class="keyword">int</span></code>
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  <code class="computeroutput"><span class="identifier">remove_cv_ref</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span>
+                  <span class="keyword">volatile</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
+                </p>
+              </td>
+<td>
+                <p>
+                  <code class="computeroutput"><span class="keyword">int</span></code>
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  <code class="computeroutput"><span class="identifier">remove_cv_ref</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span></code>
+                </p>
+              </td>
+<td>
+                <p>
+                  <code class="computeroutput"><span class="keyword">int</span></code>
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  <code class="computeroutput"><span class="identifier">remove_cv_ref</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">*&gt;::</span><span class="identifier">type</span></code>
+                </p>
+              </td>
+<td>
+                <p>
+                  <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span><span class="special">*</span></code>
+                </p>
+              </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<br class="table-break">
+</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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="remove_cv.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="remove_extent.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

doc/html/boost_typetraits/reference/remove_extent.html

@@ -6,7 +6,7 @@
 <meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
 <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="remove_cv.html" title="remove_cv">
+<link rel="prev" href="remove_cv_ref.html" title="remove_cv_ref">
 <link rel="next" href="remove_pointer.html" title="remove_pointer">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -20,7 +20,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="remove_cv.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="remove_pointer.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="remove_cv_ref.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="remove_pointer.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
@@ -52,7 +52,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="boost_typetraits.reference.remove_extent.examples"></a><p class="title"><b>Table&#160;1.30.&#160;Examples</b></p>
+<a name="boost_typetraits.reference.remove_extent.examples"></a><p class="title"><b>Table&#160;1.31.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>
@@ -150,7 +150,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="remove_cv.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="remove_pointer.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="remove_cv_ref.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="remove_pointer.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

doc/html/boost_typetraits/reference/remove_pointer.html

@@ -53,7 +53,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="boost_typetraits.reference.remove_pointer.examples"></a><p class="title"><b>Table&#160;1.31.&#160;Examples</b></p>
+<a name="boost_typetraits.reference.remove_pointer.examples"></a><p class="title"><b>Table&#160;1.32.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>

doc/html/boost_typetraits/reference/remove_reference.html

@@ -51,7 +51,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="boost_typetraits.reference.remove_reference.examples"></a><p class="title"><b>Table&#160;1.32.&#160;Examples</b></p>
+<a name="boost_typetraits.reference.remove_reference.examples"></a><p class="title"><b>Table&#160;1.33.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>

doc/html/boost_typetraits/reference/remove_volatile.html

@@ -51,7 +51,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="boost_typetraits.reference.remove_volatile.examples"></a><p class="title"><b>Table&#160;1.33.&#160;Examples</b></p>
+<a name="boost_typetraits.reference.remove_volatile.examples"></a><p class="title"><b>Table&#160;1.34.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>

doc/html/boost_typetraits/reference/type_identity.html

@@ -40,7 +40,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="boost_typetraits.reference.type_identity.examples"></a><p class="title"><b>Table&#160;1.34.&#160;Examples</b></p>
+<a name="boost_typetraits.reference.type_identity.examples"></a><p class="title"><b>Table&#160;1.35.&#160;Examples</b></p>
 <div class="table-contents"><table class="table" summary="Examples">
 <colgroup>
 <col>

doc/html/index.html

@@ -97,6 +97,8 @@
 <dt><span class="section"><a href="boost_typetraits/reference/copy_cv.html">copy_cv</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/decay.html">decay</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/declval.html">declval</a></span></dt>
+<dt><span class="section"><a href="boost_typetraits/reference/detected.html">detected</a></span></dt>
+<dt><span class="section"><a href="boost_typetraits/reference/detected_or.html">detected_or</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/extent.html">extent</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/floating_point_promotion.html">floating_point_promotion</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/function_traits.html">function_traits</a></span></dt>
@@ -162,6 +164,7 @@
 <dt><span class="section"><a href="boost_typetraits/reference/is_assignable.html">is_assignable</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/is_base_of.html">is_base_of</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/is_class.html">is_class</a></span></dt>
+<dt><span class="section"><a href="boost_typetraits/reference/is_complete.html">is_complete</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/is_complex.html">is_complex</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/is_compound.html">is_compound</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/is_const.html">is_const</a></span></dt>
@@ -171,6 +174,9 @@
 <dt><span class="section"><a href="boost_typetraits/reference/is_copy_constructible.html">is_copy_constructible</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/is_default_constructible.html">is_default_constructible</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/is_destructible.html">is_destructible</a></span></dt>
+<dt><span class="section"><a href="boost_typetraits/reference/is_detected.html">is_detected</a></span></dt>
+<dt><span class="section"><a href="boost_typetraits/reference/is_detected_convertible.html">is_detected_convertible</a></span></dt>
+<dt><span class="section"><a href="boost_typetraits/reference/is_detected_exact.html">is_detected_exact</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/is_empty.html">is_empty</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/is_enum.html">is_enum</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/is_final.html">is_final</a></span></dt>
@@ -178,12 +184,14 @@
 <dt><span class="section"><a href="boost_typetraits/reference/is_function.html">is_function</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/is_fundamental.html">is_fundamental</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/is_integral.html">is_integral</a></span></dt>
+<dt><span class="section"><a href="boost_typetraits/reference/is_list_constructible.html">is_list_constructible</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/is_lvalue_reference.html">is_lvalue_reference</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/is_member_function_pointer.html">is_member_function_pointer</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/is_member_object_pointer.html">is_member_object_pointer</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/is_member_pointer.html">is_member_pointer</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/is_nothrow_move_assignable.html">is_nothrow_move_assignable</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/is_nothrow_move_constructible.html">is_nothrow_move_constructible</a></span></dt>
+<dt><span class="section"><a href="boost_typetraits/reference/is_nothrow_swappable.html">is_nothrow_swappable</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/is_object.html">is_object</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/is_pod.html">is_pod</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/is_pointer.html">is_pointer</a></span></dt>
@@ -202,11 +210,13 @@
 <dt><span class="section"><a href="boost_typetraits/reference/make_signed.html">make_signed</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/make_unsigned.html">make_unsigned</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/make_void.html">make_void</a></span></dt>
+<dt><span class="section"><a href="boost_typetraits/reference/nonesuch.html">nonesuch</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/promote.html">promote</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/rank.html">rank</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/remove_all_extents.html">remove_all_extents</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/remove_const.html">remove_const</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/remove_cv.html">remove_cv</a></span></dt>
+<dt><span class="section"><a href="boost_typetraits/reference/remove_cv_ref.html">remove_cv_ref</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/remove_extent.html">remove_extent</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/remove_pointer.html">remove_pointer</a></span></dt>
 <dt><span class="section"><a href="boost_typetraits/reference/remove_reference.html">remove_reference</a></span></dt>

doc/html/index/s11.html

@@ -24,7 +24,7 @@
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="id1101825"></a>Class Index</h2></div></div></div>
+<a name="id1662149"></a>Class Index</h2></div></div></div>
 <p><a class="link" href="s11.html#idx_id_0">A</a> <a class="link" href="s11.html#idx_id_2">C</a> <a class="link" href="s11.html#idx_id_3">D</a> <a class="link" href="s11.html#idx_id_4">E</a> <a class="link" href="s11.html#idx_id_5">F</a> <a class="link" href="s11.html#idx_id_6">H</a> <a class="link" href="s11.html#idx_id_7">I</a> <a class="link" href="s11.html#idx_id_8">M</a> <a class="link" href="s11.html#idx_id_9">N</a> <a class="link" href="s11.html#idx_id_10">O</a> <a class="link" href="s11.html#idx_id_11">P</a> <a class="link" href="s11.html#idx_id_12">R</a> <a class="link" href="s11.html#idx_id_13">T</a></p>
 <div class="variablelist"><dl class="variablelist">
 <dt>
@@ -232,6 +232,7 @@
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/user_defined.html" title="User Defined Specializations"><span class="index-entry-level-1">User Defined Specializations</span></a></p></li>
 </ul></div>
 </li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_complete.html" title="is_complete"><span class="index-entry-level-0">is_complete</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_complex.html" title="is_complex"><span class="index-entry-level-0">is_complex</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_compound.html" title="is_compound"><span class="index-entry-level-0">is_compound</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_const.html" title="is_const"><span class="index-entry-level-0">is_const</span></a></p></li>
@@ -248,12 +249,14 @@
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_function.html" title="is_function"><span class="index-entry-level-0">is_function</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_fundamental.html" title="is_fundamental"><span class="index-entry-level-0">is_fundamental</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_integral.html" title="is_integral"><span class="index-entry-level-0">is_integral</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_list_constructible.html" title="is_list_constructible"><span class="index-entry-level-0">is_list_constructible</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_lvalue_reference.html" title="is_lvalue_reference"><span class="index-entry-level-0">is_lvalue_reference</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_member_function_pointer.html" title="is_member_function_pointer"><span class="index-entry-level-0">is_member_function_pointer</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_member_object_pointer.html" title="is_member_object_pointer"><span class="index-entry-level-0">is_member_object_pointer</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_member_pointer.html" title="is_member_pointer"><span class="index-entry-level-0">is_member_pointer</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_nothrow_move_assignable.html" title="is_nothrow_move_assignable"><span class="index-entry-level-0">is_nothrow_move_assignable</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_nothrow_move_constructible.html" title="is_nothrow_move_constructible"><span class="index-entry-level-0">is_nothrow_move_constructible</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_nothrow_swappable.html" title="is_nothrow_swappable"><span class="index-entry-level-0">is_nothrow_swappable</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_object.html" title="is_object"><span class="index-entry-level-0">is_object</span></a></p></li>
 <li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">is_pointer</span></p>
@@ -297,10 +300,13 @@
 <dt>
 <a name="idx_id_9"></a><span class="term">N</span>
 </dt>
-<dd><div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none">
+<dd><div class="index"><ul class="index" style="list-style-type: none; ">
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/nonesuch.html" title="nonesuch"><span class="index-entry-level-0">nonesuch</span></a></p></li>
+<li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">no_operator</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li></ul></div>
-</li></ul></div></dd>
+</li>
+</ul></div></dd>
 <dt>
 <a name="idx_id_10"></a><span class="term">O</span>
 </dt>
@@ -329,6 +335,7 @@
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/remove_all_extents.html" title="remove_all_extents"><span class="index-entry-level-0">remove_all_extents</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/remove_const.html" title="remove_const"><span class="index-entry-level-0">remove_const</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/remove_cv.html" title="remove_cv"><span class="index-entry-level-0">remove_cv</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/remove_cv_ref.html" title="remove_cv_ref"><span class="index-entry-level-0">remove_cv_ref</span></a></p></li>
 <li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">remove_extent</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; ">
@@ -351,42 +358,14 @@
 <li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">trait</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; ">
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_and.html" title="has_bit_and"><span class="index-entry-level-1">has_bit_and</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_and_assign.html" title="has_bit_and_assign"><span class="index-entry-level-1">has_bit_and_assign</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_or.html" title="has_bit_or"><span class="index-entry-level-1">has_bit_or</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_or_assign.html" title="has_bit_or_assign"><span class="index-entry-level-1">has_bit_or_assign</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_xor.html" title="has_bit_xor"><span class="index-entry-level-1">has_bit_xor</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_xor_assign.html" title="has_bit_xor_assign"><span class="index-entry-level-1">has_bit_xor_assign</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_complement.html" title="has_complement"><span class="index-entry-level-1">has_complement</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_dereference.html" title="has_dereference"><span class="index-entry-level-1">has_dereference</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_divides.html" title="has_divides"><span class="index-entry-level-1">has_divides</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_divides_assign.html" title="has_divides_assign"><span class="index-entry-level-1">has_divides_assign</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_equal_to.html" title="has_equal_to"><span class="index-entry-level-1">has_equal_to</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_greater.html" title="has_greater"><span class="index-entry-level-1">has_greater</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_greater_equal.html" title="has_greater_equal"><span class="index-entry-level-1">has_greater_equal</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_left_shift.html" title="has_left_shift"><span class="index-entry-level-1">has_left_shift</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_left_shift_assign.html" title="has_left_shift_assign"><span class="index-entry-level-1">has_left_shift_assign</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_less.html" title="has_less"><span class="index-entry-level-1">has_less</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_less_equal.html" title="has_less_equal"><span class="index-entry-level-1">has_less_equal</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_and.html" title="has_logical_and"><span class="index-entry-level-1">has_logical_and</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_not.html" title="has_logical_not"><span class="index-entry-level-1">has_logical_not</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_or.html" title="has_logical_or"><span class="index-entry-level-1">has_logical_or</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_minus.html" title="has_minus"><span class="index-entry-level-1">has_minus</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_minus_assign.html" title="has_minus_assign"><span class="index-entry-level-1">has_minus_assign</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_modulus.html" title="has_modulus"><span class="index-entry-level-1">has_modulus</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_modulus_assign.html" title="has_modulus_assign"><span class="index-entry-level-1">has_modulus_assign</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_multiplies.html" title="has_multiplies"><span class="index-entry-level-1">has_multiplies</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_multiplies_assign.html" title="has_multiplies_assign"><span class="index-entry-level-1">has_multiplies_assign</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_negate.html" title="has_negate"><span class="index-entry-level-1">has_negate</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_not_equal_to.html" title="has_not_equal_to"><span class="index-entry-level-1">has_not_equal_to</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_plus.html" title="has_plus"><span class="index-entry-level-1">has_plus</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_plus_assign.html" title="has_plus_assign"><span class="index-entry-level-1">has_plus_assign</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_post_decrement.html" title="has_post_decrement"><span class="index-entry-level-1">has_post_decrement</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_post_increment.html" title="has_post_increment"><span class="index-entry-level-1">has_post_increment</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_pre_decrement.html" title="has_pre_decrement"><span class="index-entry-level-1">has_pre_decrement</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_pre_increment.html" title="has_pre_increment"><span class="index-entry-level-1">has_pre_increment</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_right_shift.html" title="has_right_shift"><span class="index-entry-level-1">has_right_shift</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_right_shift_assign.html" title="has_right_shift_assign"><span class="index-entry-level-1">has_right_shift_assign</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_unary_minus.html" title="has_unary_minus"><span class="index-entry-level-1">has_unary_minus</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_unary_plus.html" title="has_unary_plus"><span class="index-entry-level-1">has_unary_plus</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li>

doc/html/index/s12.html

@@ -24,7 +24,7 @@
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="id1105376"></a>Typedef Index</h2></div></div></div>
+<a name="id1665325"></a>Typedef Index</h2></div></div></div>
 <p><a class="link" href="s12.html#idx_id_21">F</a> <a class="link" href="s12.html#idx_id_28">R</a> <a class="link" href="s12.html#idx_id_29">T</a> <a class="link" href="s12.html#idx_id_31">V</a></p>
 <div class="variablelist"><dl class="variablelist">
 <dt>

doc/html/index/s13.html

@@ -24,7 +24,7 @@
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="id1105605"></a>Macro Index</h2></div></div></div>
+<a name="id1665544"></a>Macro Index</h2></div></div></div>
 <p><a class="link" href="s13.html#idx_id_33">B</a></p>
 <div class="variablelist"><dl class="variablelist">
 <dt>
@@ -164,9 +164,50 @@
 </ul></div>
 </li>
 <li class="listitem" style="list-style-type: none">
+<p><span class="index-entry-level-0">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></p>
+<div class="index"><ul class="index" style="list-style-type: none; ">
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_and.html" title="has_bit_and"><span class="index-entry-level-1">has_bit_and</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_and_assign.html" title="has_bit_and_assign"><span class="index-entry-level-1">has_bit_and_assign</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_or.html" title="has_bit_or"><span class="index-entry-level-1">has_bit_or</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_or_assign.html" title="has_bit_or_assign"><span class="index-entry-level-1">has_bit_or_assign</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_xor.html" title="has_bit_xor"><span class="index-entry-level-1">has_bit_xor</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_xor_assign.html" title="has_bit_xor_assign"><span class="index-entry-level-1">has_bit_xor_assign</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_divides.html" title="has_divides"><span class="index-entry-level-1">has_divides</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_divides_assign.html" title="has_divides_assign"><span class="index-entry-level-1">has_divides_assign</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_equal_to.html" title="has_equal_to"><span class="index-entry-level-1">has_equal_to</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_greater.html" title="has_greater"><span class="index-entry-level-1">has_greater</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_greater_equal.html" title="has_greater_equal"><span class="index-entry-level-1">has_greater_equal</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_left_shift.html" title="has_left_shift"><span class="index-entry-level-1">has_left_shift</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_left_shift_assign.html" title="has_left_shift_assign"><span class="index-entry-level-1">has_left_shift_assign</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_less.html" title="has_less"><span class="index-entry-level-1">has_less</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_less_equal.html" title="has_less_equal"><span class="index-entry-level-1">has_less_equal</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_and.html" title="has_logical_and"><span class="index-entry-level-1">has_logical_and</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_or.html" title="has_logical_or"><span class="index-entry-level-1">has_logical_or</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_minus.html" title="has_minus"><span class="index-entry-level-1">has_minus</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_minus_assign.html" title="has_minus_assign"><span class="index-entry-level-1">has_minus_assign</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_modulus.html" title="has_modulus"><span class="index-entry-level-1">has_modulus</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_modulus_assign.html" title="has_modulus_assign"><span class="index-entry-level-1">has_modulus_assign</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_multiplies.html" title="has_multiplies"><span class="index-entry-level-1">has_multiplies</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_multiplies_assign.html" title="has_multiplies_assign"><span class="index-entry-level-1">has_multiplies_assign</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_not_equal_to.html" title="has_not_equal_to"><span class="index-entry-level-1">has_not_equal_to</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_plus.html" title="has_plus"><span class="index-entry-level-1">has_plus</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_plus_assign.html" title="has_plus_assign"><span class="index-entry-level-1">has_plus_assign</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_right_shift.html" title="has_right_shift"><span class="index-entry-level-1">has_right_shift</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_right_shift_assign.html" title="has_right_shift_assign"><span class="index-entry-level-1">has_right_shift_assign</span></a></p></li>
+</ul></div>
+</li>
+<li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_class.html" title="is_class"><span class="index-entry-level-1">is_class</span></a></p></li></ul></div>
 </li>
+<li class="listitem" style="list-style-type: none">
+<p><span class="index-entry-level-0">BOOST_TT_HAS_WORKING_IS_COMPLETE</span></p>
+<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_complete.html" title="is_complete"><span class="index-entry-level-1">is_complete</span></a></p></li></ul></div>
+</li>
+<li class="listitem" style="list-style-type: none">
+<p><span class="index-entry-level-0">BOOST_TT_IS_CONSTRUCTIBLE_CONFORMING</span></p>
+<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_constructible.html" title="is_constructible"><span class="index-entry-level-1">is_constructible</span></a></p></li></ul></div>
+</li>
 </ul></div></dd>
 </dl></div>
 </div>

doc/html/index/s14.html

@@ -23,7 +23,7 @@
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="id1106284"></a>Index</h2></div></div></div>
+<a name="id1664234"></a>Index</h2></div></div></div>
 <p><a class="link" href="s14.html#idx_id_48">A</a> <a class="link" href="s14.html#idx_id_49">B</a> <a class="link" href="s14.html#idx_id_50">C</a> <a class="link" href="s14.html#idx_id_51">D</a> <a class="link" href="s14.html#idx_id_52">E</a> <a class="link" href="s14.html#idx_id_53">F</a> <a class="link" href="s14.html#idx_id_54">H</a> <a class="link" href="s14.html#idx_id_55">I</a> <a class="link" href="s14.html#idx_id_56">M</a> <a class="link" href="s14.html#idx_id_57">N</a> <a class="link" href="s14.html#idx_id_58">O</a> <a class="link" href="s14.html#idx_id_59">P</a> <a class="link" href="s14.html#idx_id_60">R</a> <a class="link" href="s14.html#idx_id_61">T</a> <a class="link" href="s14.html#idx_id_62">U</a> <a class="link" href="s14.html#idx_id_63">V</a></p>
 <div class="variablelist"><dl class="variablelist">
 <dt>
@@ -195,15 +195,60 @@
 </ul></div>
 </li>
 <li class="listitem" style="list-style-type: none">
+<p><span class="index-entry-level-0">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></p>
+<div class="index"><ul class="index" style="list-style-type: none; ">
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_and.html" title="has_bit_and"><span class="index-entry-level-1">has_bit_and</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_and_assign.html" title="has_bit_and_assign"><span class="index-entry-level-1">has_bit_and_assign</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_or.html" title="has_bit_or"><span class="index-entry-level-1">has_bit_or</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_or_assign.html" title="has_bit_or_assign"><span class="index-entry-level-1">has_bit_or_assign</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_xor.html" title="has_bit_xor"><span class="index-entry-level-1">has_bit_xor</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_xor_assign.html" title="has_bit_xor_assign"><span class="index-entry-level-1">has_bit_xor_assign</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_divides.html" title="has_divides"><span class="index-entry-level-1">has_divides</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_divides_assign.html" title="has_divides_assign"><span class="index-entry-level-1">has_divides_assign</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_equal_to.html" title="has_equal_to"><span class="index-entry-level-1">has_equal_to</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_greater.html" title="has_greater"><span class="index-entry-level-1">has_greater</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_greater_equal.html" title="has_greater_equal"><span class="index-entry-level-1">has_greater_equal</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_left_shift.html" title="has_left_shift"><span class="index-entry-level-1">has_left_shift</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_left_shift_assign.html" title="has_left_shift_assign"><span class="index-entry-level-1">has_left_shift_assign</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_less.html" title="has_less"><span class="index-entry-level-1">has_less</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_less_equal.html" title="has_less_equal"><span class="index-entry-level-1">has_less_equal</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_and.html" title="has_logical_and"><span class="index-entry-level-1">has_logical_and</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_or.html" title="has_logical_or"><span class="index-entry-level-1">has_logical_or</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_minus.html" title="has_minus"><span class="index-entry-level-1">has_minus</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_minus_assign.html" title="has_minus_assign"><span class="index-entry-level-1">has_minus_assign</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_modulus.html" title="has_modulus"><span class="index-entry-level-1">has_modulus</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_modulus_assign.html" title="has_modulus_assign"><span class="index-entry-level-1">has_modulus_assign</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_multiplies.html" title="has_multiplies"><span class="index-entry-level-1">has_multiplies</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_multiplies_assign.html" title="has_multiplies_assign"><span class="index-entry-level-1">has_multiplies_assign</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_not_equal_to.html" title="has_not_equal_to"><span class="index-entry-level-1">has_not_equal_to</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_plus.html" title="has_plus"><span class="index-entry-level-1">has_plus</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_plus_assign.html" title="has_plus_assign"><span class="index-entry-level-1">has_plus_assign</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_right_shift.html" title="has_right_shift"><span class="index-entry-level-1">has_right_shift</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_right_shift_assign.html" title="has_right_shift_assign"><span class="index-entry-level-1">has_right_shift_assign</span></a></p></li>
+</ul></div>
+</li>
+<li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_class.html" title="is_class"><span class="index-entry-level-1">is_class</span></a></p></li></ul></div>
 </li>
+<li class="listitem" style="list-style-type: none">
+<p><span class="index-entry-level-0">BOOST_TT_HAS_WORKING_IS_COMPLETE</span></p>
+<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_complete.html" title="is_complete"><span class="index-entry-level-1">is_complete</span></a></p></li></ul></div>
+</li>
+<li class="listitem" style="list-style-type: none">
+<p><span class="index-entry-level-0">BOOST_TT_IS_CONSTRUCTIBLE_CONFORMING</span></p>
+<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_constructible.html" title="is_constructible"><span class="index-entry-level-1">is_constructible</span></a></p></li></ul></div>
+</li>
 </ul></div></dd>
 <dt>
 <a name="idx_id_50"></a><span class="term">C</span>
 </dt>
 <dd><div class="index"><ul class="index" style="list-style-type: none; ">
 <li class="listitem" style="list-style-type: none">
+<p><span class="index-entry-level-0">check</span></p>
+<div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li></ul></div>
+</li>
+<li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">common_type</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; ">
 <li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/common_type.html" title="common_type"><span class="index-entry-level-1">common_type</span></a></strong></span></p></li>
@@ -296,49 +341,49 @@
 <li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">has_bit_and</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; ">
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_and.html" title="has_bit_and"><span class="index-entry-level-1">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_and.html" title="has_bit_and"><span class="index-entry-level-1">dont_care</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_bit_and.html" title="has_bit_and"><span class="index-entry-level-1">has_bit_and</span></a></strong></span></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_and.html" title="has_bit_and"><span class="index-entry-level-1">trait</span></a></p></li>
 </ul></div>
 </li>
 <li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">has_bit_and_assign</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; ">
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_and_assign.html" title="has_bit_and_assign"><span class="index-entry-level-1">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_and_assign.html" title="has_bit_and_assign"><span class="index-entry-level-1">dont_care</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_bit_and_assign.html" title="has_bit_and_assign"><span class="index-entry-level-1">has_bit_and_assign</span></a></strong></span></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_and_assign.html" title="has_bit_and_assign"><span class="index-entry-level-1">trait</span></a></p></li>
 </ul></div>
 </li>
 <li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">has_bit_or</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; ">
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_or.html" title="has_bit_or"><span class="index-entry-level-1">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_or.html" title="has_bit_or"><span class="index-entry-level-1">dont_care</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_bit_or.html" title="has_bit_or"><span class="index-entry-level-1">has_bit_or</span></a></strong></span></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_or.html" title="has_bit_or"><span class="index-entry-level-1">trait</span></a></p></li>
 </ul></div>
 </li>
 <li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">has_bit_or_assign</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; ">
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_or_assign.html" title="has_bit_or_assign"><span class="index-entry-level-1">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_or_assign.html" title="has_bit_or_assign"><span class="index-entry-level-1">dont_care</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_bit_or_assign.html" title="has_bit_or_assign"><span class="index-entry-level-1">has_bit_or_assign</span></a></strong></span></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_or_assign.html" title="has_bit_or_assign"><span class="index-entry-level-1">trait</span></a></p></li>
 </ul></div>
 </li>
 <li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">has_bit_xor</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; ">
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_xor.html" title="has_bit_xor"><span class="index-entry-level-1">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_xor.html" title="has_bit_xor"><span class="index-entry-level-1">dont_care</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_bit_xor.html" title="has_bit_xor"><span class="index-entry-level-1">has_bit_xor</span></a></strong></span></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_xor.html" title="has_bit_xor"><span class="index-entry-level-1">trait</span></a></p></li>
 </ul></div>
 </li>
 <li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">has_bit_xor_assign</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; ">
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_xor_assign.html" title="has_bit_xor_assign"><span class="index-entry-level-1">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_xor_assign.html" title="has_bit_xor_assign"><span class="index-entry-level-1">dont_care</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_bit_xor_assign.html" title="has_bit_xor_assign"><span class="index-entry-level-1">has_bit_xor_assign</span></a></strong></span></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_xor_assign.html" title="has_bit_xor_assign"><span class="index-entry-level-1">trait</span></a></p></li>
 </ul></div>
 </li>
 <li class="listitem" style="list-style-type: none">
@@ -360,82 +405,82 @@
 <li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">has_divides</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; ">
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_divides.html" title="has_divides"><span class="index-entry-level-1">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_divides.html" title="has_divides"><span class="index-entry-level-1">dont_care</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_divides.html" title="has_divides"><span class="index-entry-level-1">has_divides</span></a></strong></span></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_divides.html" title="has_divides"><span class="index-entry-level-1">trait</span></a></p></li>
 </ul></div>
 </li>
 <li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">has_divides_assign</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; ">
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_divides_assign.html" title="has_divides_assign"><span class="index-entry-level-1">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_divides_assign.html" title="has_divides_assign"><span class="index-entry-level-1">dont_care</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_divides_assign.html" title="has_divides_assign"><span class="index-entry-level-1">has_divides_assign</span></a></strong></span></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_divides_assign.html" title="has_divides_assign"><span class="index-entry-level-1">trait</span></a></p></li>
 </ul></div>
 </li>
 <li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">has_equal_to</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; ">
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_equal_to.html" title="has_equal_to"><span class="index-entry-level-1">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_equal_to.html" title="has_equal_to"><span class="index-entry-level-1">dont_care</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_equal_to.html" title="has_equal_to"><span class="index-entry-level-1">has_equal_to</span></a></strong></span></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_equal_to.html" title="has_equal_to"><span class="index-entry-level-1">trait</span></a></p></li>
 </ul></div>
 </li>
 <li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">has_greater</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; ">
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_greater.html" title="has_greater"><span class="index-entry-level-1">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_greater.html" title="has_greater"><span class="index-entry-level-1">dont_care</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_greater.html" title="has_greater"><span class="index-entry-level-1">has_greater</span></a></strong></span></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_greater.html" title="has_greater"><span class="index-entry-level-1">trait</span></a></p></li>
 </ul></div>
 </li>
 <li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">has_greater_equal</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; ">
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_greater_equal.html" title="has_greater_equal"><span class="index-entry-level-1">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_greater_equal.html" title="has_greater_equal"><span class="index-entry-level-1">dont_care</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_greater_equal.html" title="has_greater_equal"><span class="index-entry-level-1">has_greater_equal</span></a></strong></span></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_greater_equal.html" title="has_greater_equal"><span class="index-entry-level-1">trait</span></a></p></li>
 </ul></div>
 </li>
 <li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">has_left_shift</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; ">
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_left_shift.html" title="has_left_shift"><span class="index-entry-level-1">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_left_shift.html" title="has_left_shift"><span class="index-entry-level-1">dont_care</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_left_shift.html" title="has_left_shift"><span class="index-entry-level-1">has_left_shift</span></a></strong></span></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_left_shift.html" title="has_left_shift"><span class="index-entry-level-1">trait</span></a></p></li>
 </ul></div>
 </li>
 <li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">has_left_shift_assign</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; ">
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_left_shift_assign.html" title="has_left_shift_assign"><span class="index-entry-level-1">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_left_shift_assign.html" title="has_left_shift_assign"><span class="index-entry-level-1">dont_care</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_left_shift_assign.html" title="has_left_shift_assign"><span class="index-entry-level-1">has_left_shift_assign</span></a></strong></span></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_left_shift_assign.html" title="has_left_shift_assign"><span class="index-entry-level-1">trait</span></a></p></li>
 </ul></div>
 </li>
 <li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">has_less</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; ">
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_less.html" title="has_less"><span class="index-entry-level-1">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_less.html" title="has_less"><span class="index-entry-level-1">dont_care</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_less.html" title="has_less"><span class="index-entry-level-1">has_less</span></a></strong></span></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_less.html" title="has_less"><span class="index-entry-level-1">trait</span></a></p></li>
 </ul></div>
 </li>
 <li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">has_less_equal</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; ">
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_less_equal.html" title="has_less_equal"><span class="index-entry-level-1">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_less_equal.html" title="has_less_equal"><span class="index-entry-level-1">dont_care</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_less_equal.html" title="has_less_equal"><span class="index-entry-level-1">has_less_equal</span></a></strong></span></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_less_equal.html" title="has_less_equal"><span class="index-entry-level-1">trait</span></a></p></li>
 </ul></div>
 </li>
 <li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">has_logical_and</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; ">
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_and.html" title="has_logical_and"><span class="index-entry-level-1">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_and.html" title="has_logical_and"><span class="index-entry-level-1">dont_care</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_logical_and.html" title="has_logical_and"><span class="index-entry-level-1">has_logical_and</span></a></strong></span></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_and.html" title="has_logical_and"><span class="index-entry-level-1">trait</span></a></p></li>
 </ul></div>
 </li>
 <li class="listitem" style="list-style-type: none">
@@ -449,57 +494,57 @@
 <li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">has_logical_or</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; ">
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_or.html" title="has_logical_or"><span class="index-entry-level-1">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_or.html" title="has_logical_or"><span class="index-entry-level-1">dont_care</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_logical_or.html" title="has_logical_or"><span class="index-entry-level-1">has_logical_or</span></a></strong></span></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_or.html" title="has_logical_or"><span class="index-entry-level-1">trait</span></a></p></li>
 </ul></div>
 </li>
 <li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">has_minus</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; ">
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_minus.html" title="has_minus"><span class="index-entry-level-1">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_minus.html" title="has_minus"><span class="index-entry-level-1">dont_care</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_minus.html" title="has_minus"><span class="index-entry-level-1">has_minus</span></a></strong></span></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_minus.html" title="has_minus"><span class="index-entry-level-1">trait</span></a></p></li>
 </ul></div>
 </li>
 <li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">has_minus_assign</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; ">
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_minus_assign.html" title="has_minus_assign"><span class="index-entry-level-1">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_minus_assign.html" title="has_minus_assign"><span class="index-entry-level-1">dont_care</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_minus_assign.html" title="has_minus_assign"><span class="index-entry-level-1">has_minus_assign</span></a></strong></span></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_minus_assign.html" title="has_minus_assign"><span class="index-entry-level-1">trait</span></a></p></li>
 </ul></div>
 </li>
 <li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">has_modulus</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; ">
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_modulus.html" title="has_modulus"><span class="index-entry-level-1">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_modulus.html" title="has_modulus"><span class="index-entry-level-1">dont_care</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_modulus.html" title="has_modulus"><span class="index-entry-level-1">has_modulus</span></a></strong></span></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_modulus.html" title="has_modulus"><span class="index-entry-level-1">trait</span></a></p></li>
 </ul></div>
 </li>
 <li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">has_modulus_assign</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; ">
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_modulus_assign.html" title="has_modulus_assign"><span class="index-entry-level-1">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_modulus_assign.html" title="has_modulus_assign"><span class="index-entry-level-1">dont_care</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_modulus_assign.html" title="has_modulus_assign"><span class="index-entry-level-1">has_modulus_assign</span></a></strong></span></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_modulus_assign.html" title="has_modulus_assign"><span class="index-entry-level-1">trait</span></a></p></li>
 </ul></div>
 </li>
 <li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">has_multiplies</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; ">
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_multiplies.html" title="has_multiplies"><span class="index-entry-level-1">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_multiplies.html" title="has_multiplies"><span class="index-entry-level-1">dont_care</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_multiplies.html" title="has_multiplies"><span class="index-entry-level-1">has_multiplies</span></a></strong></span></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_multiplies.html" title="has_multiplies"><span class="index-entry-level-1">trait</span></a></p></li>
 </ul></div>
 </li>
 <li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">has_multiplies_assign</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; ">
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_multiplies_assign.html" title="has_multiplies_assign"><span class="index-entry-level-1">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_multiplies_assign.html" title="has_multiplies_assign"><span class="index-entry-level-1">dont_care</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_multiplies_assign.html" title="has_multiplies_assign"><span class="index-entry-level-1">has_multiplies_assign</span></a></strong></span></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_multiplies_assign.html" title="has_multiplies_assign"><span class="index-entry-level-1">trait</span></a></p></li>
 </ul></div>
 </li>
 <li class="listitem" style="list-style-type: none">
@@ -546,9 +591,9 @@
 <li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">has_not_equal_to</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; ">
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_not_equal_to.html" title="has_not_equal_to"><span class="index-entry-level-1">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_not_equal_to.html" title="has_not_equal_to"><span class="index-entry-level-1">dont_care</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_not_equal_to.html" title="has_not_equal_to"><span class="index-entry-level-1">has_not_equal_to</span></a></strong></span></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_not_equal_to.html" title="has_not_equal_to"><span class="index-entry-level-1">trait</span></a></p></li>
 </ul></div>
 </li>
 <li class="listitem" style="list-style-type: none">
@@ -558,17 +603,17 @@
 <li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">has_plus</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; ">
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_plus.html" title="has_plus"><span class="index-entry-level-1">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_plus.html" title="has_plus"><span class="index-entry-level-1">dont_care</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_plus.html" title="has_plus"><span class="index-entry-level-1">has_plus</span></a></strong></span></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_plus.html" title="has_plus"><span class="index-entry-level-1">trait</span></a></p></li>
 </ul></div>
 </li>
 <li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">has_plus_assign</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; ">
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_plus_assign.html" title="has_plus_assign"><span class="index-entry-level-1">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_plus_assign.html" title="has_plus_assign"><span class="index-entry-level-1">dont_care</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_plus_assign.html" title="has_plus_assign"><span class="index-entry-level-1">has_plus_assign</span></a></strong></span></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_plus_assign.html" title="has_plus_assign"><span class="index-entry-level-1">trait</span></a></p></li>
 </ul></div>
 </li>
 <li class="listitem" style="list-style-type: none">
@@ -606,17 +651,17 @@
 <li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">has_right_shift</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; ">
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_right_shift.html" title="has_right_shift"><span class="index-entry-level-1">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_right_shift.html" title="has_right_shift"><span class="index-entry-level-1">dont_care</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_right_shift.html" title="has_right_shift"><span class="index-entry-level-1">has_right_shift</span></a></strong></span></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_right_shift.html" title="has_right_shift"><span class="index-entry-level-1">trait</span></a></p></li>
 </ul></div>
 </li>
 <li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">has_right_shift_assign</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; ">
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_right_shift_assign.html" title="has_right_shift_assign"><span class="index-entry-level-1">BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_right_shift_assign.html" title="has_right_shift_assign"><span class="index-entry-level-1">dont_care</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/has_right_shift_assign.html" title="has_right_shift_assign"><span class="index-entry-level-1">has_right_shift_assign</span></a></strong></span></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_right_shift_assign.html" title="has_right_shift_assign"><span class="index-entry-level-1">trait</span></a></p></li>
 </ul></div>
 </li>
 <li class="listitem" style="list-style-type: none">
@@ -730,10 +775,23 @@
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/user_defined.html" title="User Defined Specializations"><span class="index-entry-level-1">User Defined Specializations</span></a></p></li>
 </ul></div>
 </li>
+<li class="listitem" style="list-style-type: none">
+<p><span class="index-entry-level-0">is_complete</span></p>
+<div class="index"><ul class="index" style="list-style-type: none; ">
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_complete.html" title="is_complete"><span class="index-entry-level-1">BOOST_TT_HAS_WORKING_IS_COMPLETE</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/is_complete.html" title="is_complete"><span class="index-entry-level-1">is_complete</span></a></strong></span></p></li>
+</ul></div>
+</li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_complex.html" title="is_complex"><span class="index-entry-level-0">is_complex</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_compound.html" title="is_compound"><span class="index-entry-level-0">is_compound</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_const.html" title="is_const"><span class="index-entry-level-0">is_const</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_constructible.html" title="is_constructible"><span class="index-entry-level-0">is_constructible</span></a></p></li>
+<li class="listitem" style="list-style-type: none">
+<p><span class="index-entry-level-0">is_constructible</span></p>
+<div class="index"><ul class="index" style="list-style-type: none; ">
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_constructible.html" title="is_constructible"><span class="index-entry-level-1">BOOST_TT_IS_CONSTRUCTIBLE_CONFORMING</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><span class="bold"><strong><a class="link" href="../boost_typetraits/reference/is_constructible.html" title="is_constructible"><span class="index-entry-level-1">is_constructible</span></a></strong></span></p></li>
+</ul></div>
+</li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_convertible.html" title="is_convertible"><span class="index-entry-level-0">is_convertible</span></a></p></li>
 <li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">is_convertible_to_Ret</span></p>
@@ -762,12 +820,14 @@
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_function.html" title="is_function"><span class="index-entry-level-0">is_function</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_fundamental.html" title="is_fundamental"><span class="index-entry-level-0">is_fundamental</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_integral.html" title="is_integral"><span class="index-entry-level-0">is_integral</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_list_constructible.html" title="is_list_constructible"><span class="index-entry-level-0">is_list_constructible</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_lvalue_reference.html" title="is_lvalue_reference"><span class="index-entry-level-0">is_lvalue_reference</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_member_function_pointer.html" title="is_member_function_pointer"><span class="index-entry-level-0">is_member_function_pointer</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_member_object_pointer.html" title="is_member_object_pointer"><span class="index-entry-level-0">is_member_object_pointer</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_member_pointer.html" title="is_member_pointer"><span class="index-entry-level-0">is_member_pointer</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_nothrow_move_assignable.html" title="is_nothrow_move_assignable"><span class="index-entry-level-0">is_nothrow_move_assignable</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_nothrow_move_constructible.html" title="is_nothrow_move_constructible"><span class="index-entry-level-0">is_nothrow_move_constructible</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_nothrow_swappable.html" title="is_nothrow_swappable"><span class="index-entry-level-0">is_nothrow_swappable</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/is_object.html" title="is_object"><span class="index-entry-level-0">is_object</span></a></p></li>
 <li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">is_pod</span></p>
@@ -844,10 +904,13 @@
 <dt>
 <a name="idx_id_57"></a><span class="term">N</span>
 </dt>
-<dd><div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none">
+<dd><div class="index"><ul class="index" style="list-style-type: none; ">
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/nonesuch.html" title="nonesuch"><span class="index-entry-level-0">nonesuch</span></a></p></li>
+<li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">no_operator</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; "><li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li></ul></div>
-</li></ul></div></dd>
+</li>
+</ul></div></dd>
 <dt>
 <a name="idx_id_58"></a><span class="term">O</span>
 </dt>
@@ -856,6 +919,7 @@
 <p><span class="index-entry-level-0">Operator Type Traits</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; ">
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">any</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">check</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">dont_care</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">has_equal_to</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">has_operator</span></a></p></li>
@@ -908,6 +972,7 @@
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/remove_all_extents.html" title="remove_all_extents"><span class="index-entry-level-0">remove_all_extents</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/remove_const.html" title="remove_const"><span class="index-entry-level-0">remove_const</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/remove_cv.html" title="remove_cv"><span class="index-entry-level-0">remove_cv</span></a></p></li>
+<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/remove_cv_ref.html" title="remove_cv_ref"><span class="index-entry-level-0">remove_cv_ref</span></a></p></li>
 <li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">remove_extent</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; ">
@@ -950,42 +1015,14 @@
 <li class="listitem" style="list-style-type: none">
 <p><span class="index-entry-level-0">trait</span></p>
 <div class="index"><ul class="index" style="list-style-type: none; ">
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_and.html" title="has_bit_and"><span class="index-entry-level-1">has_bit_and</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_and_assign.html" title="has_bit_and_assign"><span class="index-entry-level-1">has_bit_and_assign</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_or.html" title="has_bit_or"><span class="index-entry-level-1">has_bit_or</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_or_assign.html" title="has_bit_or_assign"><span class="index-entry-level-1">has_bit_or_assign</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_xor.html" title="has_bit_xor"><span class="index-entry-level-1">has_bit_xor</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_bit_xor_assign.html" title="has_bit_xor_assign"><span class="index-entry-level-1">has_bit_xor_assign</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_complement.html" title="has_complement"><span class="index-entry-level-1">has_complement</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_dereference.html" title="has_dereference"><span class="index-entry-level-1">has_dereference</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_divides.html" title="has_divides"><span class="index-entry-level-1">has_divides</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_divides_assign.html" title="has_divides_assign"><span class="index-entry-level-1">has_divides_assign</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_equal_to.html" title="has_equal_to"><span class="index-entry-level-1">has_equal_to</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_greater.html" title="has_greater"><span class="index-entry-level-1">has_greater</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_greater_equal.html" title="has_greater_equal"><span class="index-entry-level-1">has_greater_equal</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_left_shift.html" title="has_left_shift"><span class="index-entry-level-1">has_left_shift</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_left_shift_assign.html" title="has_left_shift_assign"><span class="index-entry-level-1">has_left_shift_assign</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_less.html" title="has_less"><span class="index-entry-level-1">has_less</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_less_equal.html" title="has_less_equal"><span class="index-entry-level-1">has_less_equal</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_and.html" title="has_logical_and"><span class="index-entry-level-1">has_logical_and</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_not.html" title="has_logical_not"><span class="index-entry-level-1">has_logical_not</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_logical_or.html" title="has_logical_or"><span class="index-entry-level-1">has_logical_or</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_minus.html" title="has_minus"><span class="index-entry-level-1">has_minus</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_minus_assign.html" title="has_minus_assign"><span class="index-entry-level-1">has_minus_assign</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_modulus.html" title="has_modulus"><span class="index-entry-level-1">has_modulus</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_modulus_assign.html" title="has_modulus_assign"><span class="index-entry-level-1">has_modulus_assign</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_multiplies.html" title="has_multiplies"><span class="index-entry-level-1">has_multiplies</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_multiplies_assign.html" title="has_multiplies_assign"><span class="index-entry-level-1">has_multiplies_assign</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_negate.html" title="has_negate"><span class="index-entry-level-1">has_negate</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_not_equal_to.html" title="has_not_equal_to"><span class="index-entry-level-1">has_not_equal_to</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_plus.html" title="has_plus"><span class="index-entry-level-1">has_plus</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_plus_assign.html" title="has_plus_assign"><span class="index-entry-level-1">has_plus_assign</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_post_decrement.html" title="has_post_decrement"><span class="index-entry-level-1">has_post_decrement</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_post_increment.html" title="has_post_increment"><span class="index-entry-level-1">has_post_increment</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_pre_decrement.html" title="has_pre_decrement"><span class="index-entry-level-1">has_pre_decrement</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_pre_increment.html" title="has_pre_increment"><span class="index-entry-level-1">has_pre_increment</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_right_shift.html" title="has_right_shift"><span class="index-entry-level-1">has_right_shift</span></a></p></li>
-<li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_right_shift_assign.html" title="has_right_shift_assign"><span class="index-entry-level-1">has_right_shift_assign</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_unary_minus.html" title="has_unary_minus"><span class="index-entry-level-1">has_unary_minus</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/reference/has_unary_plus.html" title="has_unary_plus"><span class="index-entry-level-1">has_unary_plus</span></a></p></li>
 <li class="listitem" style="list-style-type: none"><p><a class="link" href="../boost_typetraits/category/value_traits/operators.html" title="Operator Type Traits"><span class="index-entry-level-1">Operator Type Traits</span></a></p></li>