|  | Home | Libraries | People | FAQ | More | 
template <class Lhs, class Rhs=Lhs, class Ret=dont_care>
struct has_bit_and_assign : public true_type-or-false_type {};
        Inherits: If (i) lhs
        of type Lhs and rhs of type Rhs
        can be used in expression lhs&=rhs,
        and (ii) Ret=dont_care or the result of expression
        lhs&=rhs is convertible to Ret
        then inherits from true_type,
        otherwise inherits from false_type.
      
        The default behaviour (Ret=dont_care)
        is to not check for the return value of binary operator&=. If Ret
        is different from the default dont_care
        type, the return value is checked to be convertible to Ret.
        Convertible to Ret means
        that the return value of the operator can be used as argument to a function
        expecting Ret:
void f(Ret); Lhs lhs; Rhs rhs; f(lhs&=rhs); // is valid if has_bit_and_assign<Lhs, Rhs, Ret>::value==true
        If Ret=void, the return type is checked to be exactly
        void.
      
        Header: #include
        <boost/type_traits/has_bit_and_assign.hpp>
        or #include <boost/type_traits/has_operator.hpp>
        or #include <boost/type_traits.hpp>
      
Compiler Compatibility: Requires working SFINAE (i.e. BOOST_NO_SFINAE is not set). Only a minority of rather old compilers do not support this.
Examples:
has_bit_and_assign<Lhs, Rhs, Ret>::value_typeis the typebool.
has_bit_and_assign<Lhs, Rhs, Ret>::valueis aboolintegral constant expression.
has_bit_and_assign<int>::valueis aboolintegral constant expression that evaluates totrue.
has_bit_and_assign<long>inherits fromtrue_type.
has_bit_and_assign<int, int, int>inherits fromtrue_type.
has_bit_and_assign<const int, int>inherits fromfalse_type.
has_bit_and_assign<int, double, bool>inherits fromfalse_type.
has_bit_and_assign<int, int, std::string>inherits fromfalse_type.
See also: Operator Type Traits
Known issues:
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
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
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