// bslmf_iscopyconstructible.h                                        -*-C++-*-
#ifndef INCLUDED_BSLMF_ISCOPYCONSTRUCTIBLE
#define INCLUDED_BSLMF_ISCOPYCONSTRUCTIBLE

#include <bsls_ident.h>
BSLS_IDENT("$Id: $")

//@PURPOSE: Provide a meta-function to report if a type is copy constructible.
//
//@CLASSES:
//  bsl::is_copy_constructible: type-traits meta-function
//  bsl::is_copy_constructible_v: the result value of the meta-function
//
//@SEE_ALSO: bslmf_integralconstant, bslmf_nestedtraitdeclaration
//
//@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:
// ```
//  namespace bsl {
//      template <>
//      struct is_copy_constructible<T> : false_type { };
//  }
// ```
// 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.

#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 BloombergLP {
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
}  // close enterprise 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 ----------------------------------
