bsl::is_trivially_copyable

This struct template implements a meta-function to determine whether the (template parameter) t_TYPE is trivially copyable. This struct derives from bsl::true_type if the t_TYPE is trivially copyable, and from bsl::false_type otherwise. This meta-function has the same syntax as the is_trivially_copyable meta-function defined in the C++11 standard [meta.unary.prop]; however, this meta-function can automatically determine the value for the following types only: reference types, fundamental types, enumerated types, pointers to members, and types declared to have the bsl::is_trivially_copyable trait using the BSLMF_NESTED_TRAIT_DECLARATION macro (the value for other types defaults to false). To support other trivially copyable types, this template must be specialized to inherit from bsl::true_type for them.

Synopsis

Declared in <bslmf_istriviallycopyable.h>

template<class t_TYPE>
struct is_trivially_copyable
    : BloombergLP::bslmf::IsTriviallyCopyable_Intrinsic<t_TYPE>::type

Base Classes

Name	Description
`BloombergLP::bslmf::IsTriviallyCopyable_Intrinsic<t_TYPE>::type`

Specializations

Name	Description
`is_trivially_copyable<BloombergLP::bsls::TimeInterval>`	This template specialization for `is_trivially_copyable` indicates that `TimeInterval` is a trivially copyable type.
`is_trivially_copyable<owner_equal>`
`is_trivially_copyable<owner_hash>`
`is_trivially_copyable<type_index>`	This template specialization for `is_trivially_copyable` indicates that `type_index` is a trivially copyable type. Note that this explicit specialization is needed only for C++98/03 compilers, as the C++11 trait will implicitly deduce triviality.
`is_trivially_copyable<hash<TYPE>>`
`is_trivially_copyable<owner_less<POINTER_TYPE>>`
`is_trivially_copyable<t_TYPE volatile>`	This partial specialization ensures that volatile-qualified types have the same result as their element type.
`is_trivially_copyable<t_TYPE const>`	This partial specialization ensures that const-qualified types have the same result as their element type.
`is_trivially_copyable<t_TYPE const volatile>`	This partial specialization ensures that const-volatile-qualified types have the same result as their element type.
`is_trivially_copyable<t_TYPE&>`	This partial specialization optimizes away a number of nested template instantiations to prove that reference types are never trivially copyable.
`is_trivially_copyable<t_TYPE&&>`	This partial specialization optimizes away a number of nested template instantiations to prove that reference types are never trivially copyable.
`is_trivially_copyable<t_TYPE[]>`	This partial specialization ensures that array-of-unknown-bound types have the same result as their element type.
`is_trivially_copyable<t_TYPE volatile[]>`	This partial specialization ensures that volatile-qualified array-of-unknown-bound types have the same result as their element type.
`is_trivially_copyable<t_TYPE const[]>`	This partial specialization ensures that const-qualified array-of-unknown-bound types have the same result as their element type.
`is_trivially_copyable<t_TYPE const volatile[]>`	This partial specialization ensures that const-volatile-qualified array-of-unknown-bound types have the same result as their element type.
`is_trivially_copyable<t_TYPE[]>`	This partial specialization ensures that array types have the same result as their element type.
`is_trivially_copyable<t_TYPE volatile[]>`	This partial specialization ensures that volatile-qualified array types have the same result as their element type.
`is_trivially_copyable<t_TYPE const[]>`	This partial specialization ensures that const-qualified array types have the same result as their element type.
`is_trivially_copyable<t_TYPE const volatile[]>`	This partial specialization ensures that const-volatile-qualified array types have the same result as their element type.

Derived Classes

Name	Description
`IsTriviallyCopyableCheck`	This `struct` exists to return the same value as `is_trivially_copyable` and is intended to never be specialized. The purpose of using it is to perform the following static assert that the `bsl` and `std` versions of `is_trivially_copyable` are in sync.