bslmf_iscopyconstructible.h

Go to the documentation of this file.

/// @file bslmf_iscopyconstructible.h
///
/// The content of this file has been pre-processed for Doxygen.
///
 
 
// bslmf_iscopyconstructible.h                                        -*-C++-*-
#ifndef INCLUDED_BSLMF_ISCOPYCONSTRUCTIBLE
#define INCLUDED_BSLMF_ISCOPYCONSTRUCTIBLE
 
#include <bsls_ident.h>
BSLS_IDENT("$Id: $")
 
/// @defgroup bslmf_iscopyconstructible bslmf_iscopyconstructible
/// @brief  Provide a meta-function to report if a type is copy constructible.
/// @addtogroup bsl
/// @{
/// @addtogroup bslmf
/// @{
/// @addtogroup bslmf_iscopyconstructible
/// @{
///
/// <h1> Outline </h1>
/// * <a href="#bslmf_iscopyconstructible-purpose"> Purpose</a>
/// * <a href="#bslmf_iscopyconstructible-classes"> Classes </a>
/// * <a href="#bslmf_iscopyconstructible-description"> Description </a>
///
/// # Purpose {#bslmf_iscopyconstructible-purpose}
/// Provide a meta-function to report if a type is copy constructible.
///
/// # Classes {#bslmf_iscopyconstructible-classes}
///
/// -  bsl::is_copy_constructible: type-traits meta-function
/// -  bsl::is_copy_constructible_v: the result value of the meta-function
///
/// @see  bslmf_integralconstant, bslmf_nestedtraitdeclaration
///
/// # Description {#bslmf_iscopyconstructible-description}
/// This component defines a meta-function,
/// `bsl::is_copy_constructible` and a template variable
/// `bsl::is_copy_constructible_v`, that represents the result value of the
/// `bsl::is_copy_constructible` meta-function, that may be used to query
/// whether a type is copy constructible.
///
/// `bsl::is_copy_constructible` has the same syntax as the
/// `is_copy_constructible` template from the C++11 standard [meta.unary.prop].
/// Indeed, in C++11 compilation environments, `bsl::is_copy_constructible`
/// simply forwards to the native implementation, which can determine the
/// correct value for all types without requiring specialization; in C++03
/// environments, `bsl::is_copy_construcible` provides welcome backward
/// compatibility but returns `true` for all user-defined types and requires
/// explicit specialization for types that are not copy constructible (e.g.,
/// move-only types).
///
/// Note that the `bsl::is_copy_constructible` trait cannot be declared as a
/// nested trait because the default value of the trait is `true` and nested
/// traits work properly only for traits that have default value `false`.  In
/// order to indicate that a certain type `T` is not copy constructible, the
/// following idiom should be used:
/// @code
///  namespace bsl {
///      template <>
///      struct is_copy_constructible<T> : false_type { };
///  }
/// @endcode
/// Also note that the template variable `is_copy_constructible_v` is defined in
/// the C++17 standard as an inline variable.  If the current compiler supports
/// the inline variable C++17 compiler feature, `bsl::is_copy_constructible_v`
/// is defined as an `inline constexpr bool` variable.  Otherwise, if the
/// compiler supports the variable templates C++14 compiler feature,
/// `bsl::is_copy_constructible_v` is defined as a non-inline `constexpr bool`
/// variable.  See `BSLS_COMPILERFEATURES_SUPPORT_INLINE_VARIABLES` and
/// `BSLS_COMPILERFEATURES_SUPPORT_VARIABLE_TEMPLATES` macros in
/// bsls_compilerfeatures component for details.
/// @}
/** @} */
/** @} */
 
/** @addtogroup bsl
 * @{
 */
/** @addtogroup bslmf
 * @{
 */
/** @addtogroup bslmf_iscopyconstructible
 * @{
 */
 
#include <bslscm_version.h>
 
#include <bslmf_detectnestedtrait.h>
#include <bslmf_integralconstant.h>
#include <bslmf_isarray.h>
#include <bslmf_isbitwisecopyable.h>
#include <bslmf_isfunction.h>
#include <bslmf_isreference.h>
#include <bslmf_isvolatile.h>
 
#include <bsls_compilerfeatures.h>
#include <bsls_keyword.h>
 
#if defined(BSLS_COMPILERFEATURES_SUPPORT_TRAITS_HEADER)
# include <type_traits>
#endif // BSLS_COMPILERFEATURES_SUPPORT_TRAITS_HEADER
 
#ifndef BDE_DONT_ALLOW_TRANSITIVE_INCLUDES
#include <bsls_nativestd.h>
#endif // BDE_DONT_ALLOW_TRANSITIVE_INCLUDES
 
#if defined(BSLS_COMPILERFEATURES_SUPPORT_TRAITS_HEADER)
# define BSLS_ISCOPYCONSTRUCTIBLE_USE_NATIVE_TRAIT 1
#endif
 
namespace bsl {
 
                        // ============================
                        // struct is_copy_constructible
                        // ============================
 
/// This `struct` template implements a meta-function to determine whether
/// the (template parameter) `t_TYPE` is copy constructible.  This `struct`
/// derives from `bsl::true_type` if the `t_TYPE` is copy constructible, and
/// from `bsl::false_type` otherwise.  This meta-function has the same
/// syntax as the `is_copy_constructible` meta-function defined in the C++11
/// standard [meta.unary.prop]; on C++03 platforms, however, this
/// meta-function defaults to `true_type` for all types that are not
/// explicitly declared to have the `bslmf::IsNonCopyable` trait using the
/// `BSLMF_NESTED_TRAIT_DECLARATION` macro.  To mark a type as non-copyable,
/// `bslmf::IsNonCopyable` must be specialized (for that type) to inherit
/// from `bsl::true_type`.
template <class t_TYPE>
struct is_copy_constructible;
 
}  // close namespace bsl
 
// ============================================================================
//                          CLASS TEMPLATE DEFINITIONS
// ============================================================================
 
#if defined(BSLS_ISCOPYCONSTRUCTIBLE_USE_NATIVE_TRAIT)
namespace bsl {
 
                        // ====================================
                        // struct is_copy_constructible (C++11)
                        // ====================================
 
///Implementation Notes
///--------------------
// In C++20 certain array types which decay to their element type, such as
// 'const void*' and 'bool', report as copy constructible through
// 'std::is_copy_constructible'.  In fact, initialization that attempts such
// copy constructions does not result in a copy of the original array but
// instead initializes only the first element of the new array -- and that is
// set to the address of the original array, not the original's first element.
//
// This behavior has been observed in 'gcc-11' targeting C++20 and should occur
// with any compiler correctly supporting C++20 aggregate initialization with
// parenthesis (identified by the feature test macro
// '__cpp_aggregate_paren_init').
//
// An LWG issue (https://wg21.link/lwg####) has been filed to correct this
// behavior and continue to return 'false' for all array types.
//
// The implementation below preemptively implements the expected resolution of
// that issue on all platforms.
 
/// This specialization largely defers to the native trait on supported
/// C++11 compilers.  See {Implementation Notes} above.
template <class t_TYPE>
struct is_copy_constructible
: bsl::integral_constant<bool,
                         (bsl::is_array<t_TYPE>::value
                              ? false
                              : std::is_copy_constructible<t_TYPE>::value)> {
};
 
#ifdef BSLS_COMPILERFEATURES_SUPPORT_VARIABLE_TEMPLATES
/// This template variable represents the result value of the
/// `bsl::is_copy_constructible` meta-function.
template <class t_TYPE>
BSLS_KEYWORD_INLINE_VARIABLE constexpr bool is_copy_constructible_v =
                                          is_copy_constructible<t_TYPE>::value;
#endif
 
}  // close namespace bsl
 
#else
 
 
namespace bslmf {
 
                       // ==============================
                       // struct IsCopyConstructible_Imp
                       // ==============================
 
/// This `struct` template implements a meta-function to determine whether
/// the (non-cv-qualified) (template parameter) `t_TYPE` has a copy
/// constructor.
template <class t_TYPE>
struct IsCopyConstructible_Imp
: bsl::integral_constant<bool,
                         bslmf::IsBitwiseCopyable<t_TYPE>::value ||
                             bsl::is_reference<t_TYPE>::value ||
                             !(bsl::is_volatile<t_TYPE>::value ||
                               bsl::is_function<t_TYPE>::value)> {
};
 
/// This explicit specialization reports that `void` does not have a copy
/// constructor, despite being a fundamental type.
template <>
struct IsCopyConstructible_Imp<void> : bsl::false_type
{
};
 
/// This explicit specialization reports that `volatile void` does not have
/// a copy constructor, despite being a fundamental type.
template <>
struct IsCopyConstructible_Imp<volatile void> : bsl::false_type
{
};
 
/// This explicit specialization reports that volatile pointer objects have
/// a copy constructor, just like a fundamental type.
template <class t_TYPE>
struct IsCopyConstructible_Imp<t_TYPE *volatile> : bsl::true_type {
};
 
}  // close package namespace
 
 
namespace bsl {
 
                        // ====================================
                        // struct is_copy_constructible (C++03)
                        // ====================================
 
/// The primary template for this traits handles only non-`const`-qualified
/// types; partial specializations will handle some interesting cases,
/// including the remaining `const`-qualified types.
template <class t_TYPE>
struct is_copy_constructible
: BloombergLP::bslmf::IsCopyConstructible_Imp<t_TYPE>::type {
};
 
/// This partial specialization ensures that const-qualified types have the
/// same result as their element type.
template <class t_TYPE>
struct is_copy_constructible<const t_TYPE>
: is_copy_constructible<t_TYPE>::type {
};
 
/// This partial specialization ensures that array types have the result
/// `false`.
template <class t_TYPE, size_t t_LEN>
struct is_copy_constructible<t_TYPE[t_LEN]> : false_type {
};
 
/// This partial specialization ensures that const-qualified array types
/// have result `false`.
template <class t_TYPE, size_t t_LEN>
struct is_copy_constructible<const t_TYPE[t_LEN]> : false_type {
};
 
/// This partial specialization ensures that volatile-qualified array types
/// have the result `false`.
template <class t_TYPE, size_t t_LEN>
struct is_copy_constructible<volatile t_TYPE[t_LEN]> : false_type {
};
 
/// This partial specialization ensures that const-volatile-qualified array
/// types have the result false.
template <class t_TYPE, size_t t_LEN>
struct is_copy_constructible<const volatile t_TYPE[t_LEN]> : false_type {
};
 
#if !defined(BSLS_PLATFORM_CMP_IBM)
// Last checked with the xlC 12.1 compiler.  The IBM xlC compiler has problems
// correctly handling arrays of unknown bound as template parameters.
 
/// This partial specialization ensures that array-of-unknown-bound types
/// have the result `false`.
template <class t_TYPE>
struct is_copy_constructible<t_TYPE[]> : false_type {
};
 
/// This partial specialization ensures that const-qualified
/// array-of-unknown-bound types have the result `false`.
template <class t_TYPE>
struct is_copy_constructible<const t_TYPE[]> : false_type {
};
 
/// This partial specialization ensures that volatile-qualified
/// array-of-unknown-bound types have the result `false`.
template <class t_TYPE>
struct is_copy_constructible<volatile t_TYPE[]> : false_type {
};
 
/// This partial specialization ensures that const-volatile-qualified
/// array-of-unknown-bound types have the result `false`.
template <class t_TYPE>
struct is_copy_constructible<const volatile t_TYPE[]> : false_type {
};
 
#endif  // defined(BSLS_PLATFORM_CMP_IBM)
 
}  // close namespace bsl
 
#endif  // defined(BSLS_ISCOPYCONSTRUCTIBLE_USE_NATIVE_TRAIT)
 
#endif
 
// ----------------------------------------------------------------------------
// Copyright 2016 Bloomberg Finance L.P.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// ----------------------------- END-OF-FILE ----------------------------------
 
/** @} */
/** @} */
/** @} */