|  | Home | Libraries | People | FAQ | More | 
template <class T>
struct is_copy_assignable : public true_type-or-false_type {};
        Inherits: If T
        is CopyAssignable (i.e. has
        an accessible explicit or implicit copy assignment operator), then inherits
        from true_type,
        otherwise inherits from false_type.
        Type T must be a complete
        type.
      
        In other words, inherits from true_type
        only if copy assignment of T
        from const T
        & is not marked with = delete,
        T does not derives from
        boost::noncopyable and is not marked with BOOST_MOVABLE_BUT_NOT_COPYABLE(T).
      
        Compiler Compatibility: Requires the C++11
        features decltype and SFINAE-expressions
        for full support.
      
        If your compiler does not support C++11 deleted functions (= delete)
        or does not support SFINAE for the deleted assignments, then derive your
        classes from boost::noncopyable or mark them with BOOST_MOVABLE_BUT_NOT_COPYABLE(T) to show
        that class is non-assignable.
      
Trait does not care about access modifiers, so if you see errors like this:
'T::operator=(const T&)' is private boost/type_traits/is_copy_assignable.hpp:68:5: error: within this context
then you are trying to call that macro for a structure with private assignment:
struct T { // ... private: T &operator=(const T &); // ... };
        To fix that you must modify your structure, explicitly marking it as noncopyable
        (= delete,
        boost::noncopyable or BOOST_MOVABLE_BUT_NOT_COPYABLE(T))
        or explicitly specializing
        the trait.
      
        Header:  #include
        <boost/type_traits/is_copy_assignable.hpp>
        or  #include <boost/type_traits.hpp>