bslmf_isconvertible.h

Go to the documentation of this file.

/// @file bslmf_isconvertible.h
///
/// The content of this file has been pre-processed for Doxygen.
///
 
 
// bslmf_isconvertible.h                                              -*-C++-*-
#ifndef INCLUDED_BSLMF_ISCONVERTIBLE
#define INCLUDED_BSLMF_ISCONVERTIBLE
 
#include <bsls_ident.h>
BSLS_IDENT("$Id: $")
 
/// @defgroup bslmf_isconvertible bslmf_isconvertible
/// @brief  Provide a compile-time check for type conversion.
/// @addtogroup bsl
/// @{
/// @addtogroup bslmf
/// @{
/// @addtogroup bslmf_isconvertible
/// @{
///
/// <h1> Outline </h1>
/// * <a href="#bslmf_isconvertible-purpose"> Purpose</a>
/// * <a href="#bslmf_isconvertible-classes"> Classes </a>
/// * <a href="#bslmf_isconvertible-description"> Description </a>
///   * <a href="#bslmf_isconvertible-usage"> Usage </a>
///     * <a href="#bslmf_isconvertible-example-1-select-function-based-on-type-convertibility"> Example 1: Select Function Based on Type Convertibility </a>
///
/// # Purpose {#bslmf_isconvertible-purpose}
/// Provide a compile-time check for type conversion.
///
/// # Classes {#bslmf_isconvertible-classes}
///
/// -  bsl::is_convertible: standard meta-function for type conversion checking
/// -  bsl::is_convertible_v: the result value of `bsl::is_convertible`
/// -  bslmf::IsConvertible: meta-function for type conversion checking
///
/// @see  bslmf_integralconstant
///
/// # Description {#bslmf_isconvertible-description}
/// This component defines two meta-functions,
/// `bsl::is_convertible` and `BloombergLP::bslmf::IsConvertible` and a template
/// variable `bsl::is_convertible_v`, that represents the result value of the
/// `bsl::is_convertible` meta-function.  All these meta-functions may be used
/// to check whether an implicit conversion exists from one type to another.
///
/// When compiling on C++11 or later, both meta-functions are aliases to the
/// standard library implementation std::is_convertible.
///
/// When compiling on C++03 `bsl::is_convertible` tries to meet the requirements
/// of the `is_convertible` template defined in the C++11 standard [meta.rel] as
/// much as possible but fails in some corner cases.  One example of such a
/// case:
/// @code
/// class A {};
/// class B { public: B(A& ); };
///
/// BSLMF_ASSERT((!bsl::is_convertible<A, B>::value)); //<-- FAIL in C++03 mode
/// @endcode
///
/// `bslmf::IsConvertible` was devised before `is_convertible` was standardized
/// and is functionally equivalent except that `bsl::is_convertible` does not
/// allow its template parameter types to be incomplete types according to the
/// C++11 standard while `bslmf::IsConvertible` tests conversions involving
/// incomplete types.
///
/// Note that `bsl::is_convertible` should be preferred over
/// `bslmf::IsConvertible`, and in general, should be used by new components.
/// Also note that `bsl::is_convertible` and `bslmf::IsConvertible` can produce
/// compiler errors if the conversion is ambiguous.  For example:
/// @code
/// struct A {};
/// struct B : public A {};
/// struct C : public A {};
/// struct D : public B, public C {};
///
/// static int const C = bsl::is_convertible<D*, A*>::value;  // ERROR!
/// @endcode
/// Also note that the template variable `is_convertible_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_convertible_v` is defined
/// as an `inline constexpr bool` variable.  Otherwise, if the compiler supports
/// the variable templates C++14 compiler feature, `bsl::is_convertible_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.
///
/// ## Usage {#bslmf_isconvertible-usage}
///
///
/// In this section we show intended use of this component.
///
/// ### Example 1: Select Function Based on Type Convertibility {#bslmf_isconvertible-example-1-select-function-based-on-type-convertibility}
///
///
/// The `bsl::is_convertible` meta-function can be used to select an appropriate
/// function (at compile time) based on the convertibility of one type to
/// another without causing a compiler error by actually trying the conversion.
///
/// First, we define two classes, `Foo` and `Bar`.  The `Foo` class has an
/// explict constructor from `int`, an implicit conversion operator that returns
/// an integer value while the `Bar` class does neither:
/// @code
/// class Foo {
///     // DATA
///     int d_value;
///
///   public:
///     // CREATORS
///     explicit Foo(int value) : d_value(value) {}
///
///     // ACCESSORS
///     operator int() const { return d_value; }
/// };
///
/// class Bar {};
/// @endcode
/// Then, we run:
/// @code
/// assert(false == (bsl::is_convertible<int, Foo>::value));
/// assert(false == (bsl::is_convertible<int, Bar>::value));
///
/// assert(true  == (bsl::is_convertible<Foo, int>::value));
/// assert(false == (bsl::is_convertible<Bar, int>::value));
/// @endcode
/// Note that `int` to `Foo` is false, even though `Foo` has a constructor that
/// takes an `int`.  This is because that constructor is explicit, and
/// `is_converitble` ignores explicit constructors.
///
/// Next, we go on to demonstrate how this could be used.  Suppose we are
/// implementing a `convertToInt` template method that converts a given object
/// of the (template parameter) `t_TYPE` to `int` type, and returns the integer
/// value.  If the given object can not convert to `int`, return 0.  The method
/// calls an overloaded function, `getIntValue`, to get the converted integer
/// value.  The idea is to invoke one version of `getIntValue` if the type
/// provides a conversion operator that returns an integer value, and another
/// version if the type does not provide such an operator.
///
/// We define the first `getIntValue` function that takes a `bsl::false_type` as
/// its last argument, whereas the second `getIntValue` function takes a
/// `bsl::true_type` object.  The result of the `bsl::is_convertible`
/// meta-function (i.e., its `type` member) is used to create the last argument
/// passed to `getIntValue`.  Neither version of `getIntValue` makes use of this
/// argument -- it is used only to differentiate the argument list so we can
/// overload the function.
/// @code
/// template <class t_TYPE>
/// inline
/// int getIntValue(t_TYPE *, bsl::false_type)
/// {
///     // Return 0 because the specified 't_TYPE' is not convertible to the
///     // 'int' type.
///
///     return 0;
/// }
///
/// template <class t_TYPE>
/// inline
/// int getIntValue(t_TYPE *object, bsl::true_type)
/// {
///     // Return the integer value converted from the specified 'object' of
///     // the (template parameter) 't_TYPE'.
///
///     return int(*object);
/// }
/// @endcode
/// Now, we define our `convertToInt` method:
/// @code
/// template <class t_TYPE>
/// inline
/// int convertToInt(t_TYPE *object)
/// {
///     typedef typename bsl::is_convertible<t_TYPE,
///                                          int>::type CanConvertToInt;
///     return getIntValue(object, CanConvertToInt());
/// }
/// @endcode
/// Notice that we use `bsl::is_convertible` to get a `bsl::false_type` or
/// `bsl::true_type`, and then call the corresponding overloaded `getIntValue`
/// method.
///
/// Finally, we call our finished product and observe the return values:
/// @code
/// Foo foo(99);
/// Bar bar;
///
/// assert(99 == convertToInt(&foo));
/// assert(0  == convertToInt(&bar));
/// @endcode
/// @}
/** @} */
/** @} */
 
/** @addtogroup bsl
 * @{
 */
/** @addtogroup bslmf
 * @{
 */
/** @addtogroup bslmf_isconvertible
 * @{
 */
 
#include <bslscm_version.h>
 
#include <bslmf_addconst.h>
#include <bslmf_addlvaluereference.h>
#include <bslmf_assert.h>
#include <bslmf_conditional.h>
#include <bslmf_enableif.h>
#include <bslmf_integralconstant.h>
#include <bslmf_isarray.h>
#include <bslmf_isfunction.h>
#include <bslmf_isfundamental.h>
#include <bslmf_ispointer.h>
#include <bslmf_isvoid.h>
#include <bslmf_matchanytype.h>
#include <bslmf_removecv.h>
 
#include <bsls_compilerfeatures.h>
#include <bsls_keyword.h>
#include <bsls_platform.h>
 
#ifdef 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) && \
    !(defined(BSLS_PLATFORM_CMP_MSVC) && BSLS_PLATFORM_CMP_VERSION <= 1900)
    // The Microsoft implementation of native traits allows binding of rvalues
    // (including temporaries invented for conversion) to 'const volatile &'
    // references.  Early versions also do not correctly disallow conversion
    // from itself for types that are neither copy- nor move-constructible.
#   define BSLMF_ISCONVERTIBLE_USE_NATIVE_TRAITS
#endif
 
namespace bsl {
 
template <class t_FROM_TYPE, class t_TO_TYPE>
struct is_convertible;
 
#ifdef BSLS_COMPILERFEATURES_SUPPORT_VARIABLE_TEMPLATES
/// This template variable represents the result value of the
/// `bsl::is_convertible` meta-function.
template <class t_FROM_TYPE, class t_TO_TYPE>
BSLS_KEYWORD_INLINE_VARIABLE constexpr bool is_convertible_v =
                                 is_convertible<t_FROM_TYPE, t_TO_TYPE>::value;
#endif
 
}  // close namespace bsl
 
 
namespace bslmf {
 
                 // =========================================
                 // private class IsConvertible_CheckComplete
                 // =========================================
 
template <class t_TYPE,
          bool = bsl::is_function<t_TYPE>::value ||
                 bsl::is_void<t_TYPE>::value>
struct IsConvertible_CheckComplete {
    typedef t_TYPE type;
 
    enum { k_CHECK_COMPLETE = sizeof(t_TYPE) };
};
 
template <class t_TYPE>
struct IsConvertible_CheckComplete<t_TYPE&, false>
: IsConvertible_CheckComplete<t_TYPE> {
    typedef t_TYPE&  type;
};
 
#if defined(BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES)
template <class t_TYPE>
struct IsConvertible_CheckComplete<t_TYPE&&, false>
: IsConvertible_CheckComplete<t_TYPE> {
    typedef t_TYPE && type;
};
#endif
 
template <class t_TYPE>
struct IsConvertible_CheckComplete<t_TYPE, true> {
    typedef t_TYPE type;
};
 
#if !defined(BSLS_PLATFORM_CMP_IBM)  // IBM rejects this valid specialization
template <class t_TYPE>
struct IsConvertible_CheckComplete<t_TYPE[], false> {
    typedef t_TYPE type[];
};
#endif
 
}  // close package namespace
 
 
#ifdef BSLMF_ISCONVERTIBLE_USE_NATIVE_TRAITS
 
namespace bsl {
 
template <class t_FROM_TYPE, class t_TO_TYPE>
struct is_convertible
: ::bsl::integral_constant<
      bool,
      ::std::is_convertible<
          typename BloombergLP::bslmf::IsConvertible_CheckComplete<
              t_FROM_TYPE>::type,
          typename BloombergLP::bslmf::IsConvertible_CheckComplete<
              t_TO_TYPE>::type>::value> {
};
 
}  // close namespace bsl
#else
 
 
namespace bslmf {
 
                         // ==========================
                         // struct IsConvertible_Match
                         // ==========================
 
/// This `struct` provides functions to check for successful conversion
/// matches.  Sun CC 5.2 requires that this `struct` not be nested within
/// `IsConvertible_Imp`.
struct IsConvertible_Match {
 
    typedef struct { char a;    } yes_type;
    typedef struct { char a[2]; } no_type;
 
    /// Return @ref yes_type  if called on `IsConvertible_Match` type.
    static yes_type match(IsConvertible_Match&);
 
#if !defined(BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES)
    /// Return @ref yes_type  if the (template parameter) `t_TYPE` is
    /// `IsConvertible_Match`, and `no_type` otherwise.
    template <class t_TYPE>
    static no_type match(const t_TYPE&);
 
    /// Return @ref yes_type  if the (template parameter) `t_TYPE` is
    /// `IsConvertible_Match` and `no_type` otherwise.
    template <class t_TYPE>
    static no_type match(const volatile t_TYPE&);
 
    /// Return @ref yes_type  if the (template parameter) `t_TYPE` is
    /// `IsConvertible_Match` and `no_type` otherwise.
    template <class t_TYPE>
    static typename
    bsl::enable_if<bsl::is_function<t_TYPE>::value, no_type>::type
    match(t_TYPE&);
#else
    template <class t_TYPE>
    static no_type match(t_TYPE&&);
        // Return @ref yes_type  if the (template parameter) 't_TYPE' is
        // 'IsConvertible_Match', and 'no_type' otherwise.
#endif
};
 
                         // ========================
                         // struct IsConvertible_Imp
                         // ========================
 
/// This `struct` template implements the meta-function to determine type
/// conversion between the (template parameter) `t_FROM_TYPE` and the
/// (template parameter) `t_TO_TYPE` where the conversion to the `t_TO_TYPE`
/// is not necessarily the same as conversion to `const t_TO_TYPE&`.
///
/// Note that significant documentation about the details of this
/// implementation can be found in `bslmf_isconvertible.cpp`.
template <class t_FROM_TYPE,
          class t_TO_TYPE
#if defined(BSLS_PLATFORM_CMP_GNU) || defined(BSLS_PLATFORM_CMP_CLANG)
          ,
          int IS_FROM_FUNDAMENTAL = bsl::is_fundamental<t_FROM_TYPE>::value,
          int IS_TO_FUNDAMENTAL   = bsl::is_fundamental<t_TO_TYPE>::value
#endif
          >
struct IsConvertible_Imp {
 
  private:
    /// A unique (empty) type returned by the comma operator.
    struct Test
    {
 
        /// Return a reference to type `IsConvertible_Match`.
        IsConvertible_Match& operator, (t_TO_TYPE) const;
    };
 
  public:
 
#ifdef BSLS_PLATFORM_CMP_MSVC
#   pragma warning(push)
#   pragma warning(disable: 4244)  // loss of precision warning ignored
#endif
    enum {
 
        value = (sizeof(IsConvertible_Match::yes_type) ==
                 sizeof(IsConvertible_Match::match(
                                       (Test(), TypeRep<t_FROM_TYPE>::rep()))))
        // Return the convertibility between 't_FROM_TYPE' and 't_TO_TYPE'.
        // This is set by invoking the 'operator,' method having 'Test&' on
        // the left and 't_FROM_TYPE' on the right.  The 'value' is 'true' if
        // 't_FROM_TYPE' is convertible to 't_TO_TYPE', and 'false' otherwise.
    };
 
#ifdef BSLS_PLATFORM_CMP_MSVC
#   pragma warning(pop)
#endif
 
    /// This `typedef` returns `bsl::true_type` if `t_FROM_TYPE` is
    /// convertible to `t_TO_TYPE`, and `bsl::false_type` otherwise.
    typedef bsl::integral_constant<bool, value> type;
};
 
#if 0 // defined(BSLS_PLATFORM_CMP_GNU) || defined(BSLS_PLATFORM_CMP_CLANG)
// The following template partial specializations produce the same results as
// the unspecialized template would, but avoid generating conversion warnings
// on the affected compilers.  However, there is one known bug in this block of
// code (reported by the test driver, not yet tracked down) and experimentally
// removing it seems to clear the bug, without raising the feared warnings on
// supported gcc platforms - although it still raises a few warnings with gcc
// 4.3.5.
 
#define BSLMF_ISCONVERTIBLE_SAMETYPEVALUE(t_VALUE,                            \
                                          t_FROM,                             \
                                          t_TO,                               \
                                          t_FROM_FUND,                        \
                                          t_TO_FUND)                          \
    template <class t_TYPE>                                                   \
    struct IsConvertible_Imp<t_FROM, t_TO, t_FROM_FUND, t_TO_FUND>            \
    : bsl::integral_constant<bool, VALUE> {                                   \
    };
    // This partial specialization of 'bslmf::IsConvertible_Imp' derives from
    // 'bsl::integral_constant' having the specified macro argument 'VALUE'.
    // The specified macro arguments 't_FROM' and 't_TO' are cv-qualified type
    // expressions constructed out of the (template parameter) 't_TYPE'.
 
#define BSLMF_ISCONVERTIBLE_VALUE(t_VALUE,                                    \
                                  t_FROM,                                     \
                                  t_TO,                                       \
                                  t_FROM_FUND,                                \
                                  t_TO_FUND)                                  \
    template <class t_FROM_TYPE, class t_TO_TYPE>                             \
    struct IsConvertible_Imp<t_FROM, t_TO, t_FROM_FUND, t_TO_FUND>            \
    : bsl::integral_constant<bool, t_VALUE> {                                 \
    };
    // This partial specialization of 'bslmf::IsConvertible_Imp' derives from
    // 'bsl::integral_constant' having the specified macro argument 't_VALUE'.
    // The specified macro arguments 't_FROM' and 't_TO' are cv-qualified type
    // expressions constructed out of 't_FROM_TYPE' and 't_TO_TYPE',
    // respectively.
 
#define BSLMF_ISCONVERTIBLE_FORWARD(t_FROM, t_TO, t_FROM_FUND, t_TO_FUND)     \
    template <class t_FROM_TYPE, class t_TO_TYPE>                             \
    struct IsConvertible_Imp<t_FROM, t_TO, t_FROM_FUND, t_TO_FUND>            \
    : IsConvertible_Imp<t_FROM, t_TO, 0, 0> {                                 \
    };
    // This partial specialization of 'bslmf::IsConvertible_Imp' applies the
    // general mechanism for non-fundamental types.  The specified macro
    // arguments 't_FROM' and 't_TO' are cv-qualified type expressions
    // constructed out of 't_FROM_TYPE' and 't_TO_TYPE', respectively.
 
BSLMF_ISCONVERTIBLE_SAMETYPEVALUE(0,
                                  const volatile t_TYPE,
                                  const t_TYPE&,
                                  1,
                                  1)
BSLMF_ISCONVERTIBLE_SAMETYPEVALUE(0,
                                  volatile t_TYPE,
                                  const t_TYPE&,
                                  1,
                                  1)
    // These two partial specializations are instantiated when a (possibly
    // 'const'-qualified) 'volatile' fundamental type is tested for
    // convertibility to its 'const' reference type.  The conversion shall
    // fail.
 
BSLMF_ISCONVERTIBLE_VALUE(1,
                          const volatile t_FROM_TYPE,
                          const t_TO_TYPE&,
                          1,
                          1)
BSLMF_ISCONVERTIBLE_VALUE(1,
                          volatile t_FROM_TYPE,
                          const t_TO_TYPE&,
                          1,
                          1)
    // These two partial specializations are instantiated when a (possibly
    // 'const'-qualified) 'volatile' type is tested for convertibility to the
    // 'const' reference type of another fundamental type.  These partial
    // specializations will be picked up if the previous two fail to match.
    // The conversion shall succeed.
 
BSLMF_ISCONVERTIBLE_VALUE(1, const t_FROM_TYPE, const t_TO_TYPE&, 1, 1)
BSLMF_ISCONVERTIBLE_VALUE(1,       t_FROM_TYPE, const t_TO_TYPE&, 1, 1)
    // These two partial specializations are instantiated when a (possibly
    // 'const'-qualified) fundamental type is tested for convertibility to the
    // 'const' reference type of another fundamental type.  These partial
    // specializations will be picked up if the previous two fail to match.
    // The conversion shall succeed.
 
BSLMF_ISCONVERTIBLE_FORWARD(const volatile t_FROM_TYPE,
                            const volatile t_TO_TYPE&, 1, 1)
BSLMF_ISCONVERTIBLE_FORWARD(      volatile t_FROM_TYPE,
                            const volatile t_TO_TYPE&, 1, 1)
BSLMF_ISCONVERTIBLE_FORWARD(const          t_FROM_TYPE,
                            const volatile t_TO_TYPE&, 1, 1)
BSLMF_ISCONVERTIBLE_FORWARD(               t_FROM_TYPE,
                            const volatile t_TO_TYPE&, 1, 1)
    // These four partial specializations are instantiated when a (possibly
    // cv-qualified) fundamental type is tested for convertibility to the
    // 'const volatile' reference type of another fundamental type.
 
BSLMF_ISCONVERTIBLE_FORWARD(const volatile t_FROM_TYPE,
                                  volatile t_TO_TYPE&, 1, 1)
BSLMF_ISCONVERTIBLE_FORWARD(      volatile t_FROM_TYPE,
                                  volatile t_TO_TYPE&, 1, 1)
BSLMF_ISCONVERTIBLE_FORWARD(const          t_FROM_TYPE,
                                  volatile t_TO_TYPE&, 1, 1)
BSLMF_ISCONVERTIBLE_FORWARD(               t_FROM_TYPE,
                                  volatile t_TO_TYPE&, 1, 1)
    // These four partial specializations are instantiated when a (possibly
    // cv-qualified) fundamental type is tested for convertibility to the
    // 'volatile' reference type of another fundamental type.
 
BSLMF_ISCONVERTIBLE_FORWARD(const volatile t_FROM_TYPE, t_TO_TYPE&, 1, 1)
BSLMF_ISCONVERTIBLE_FORWARD(      volatile t_FROM_TYPE, t_TO_TYPE&, 1, 1)
BSLMF_ISCONVERTIBLE_FORWARD(const          t_FROM_TYPE, t_TO_TYPE&, 1, 1)
BSLMF_ISCONVERTIBLE_FORWARD(               t_FROM_TYPE, t_TO_TYPE&, 1, 1)
    // These four partial specializations are instantiated when a (possibly
    // cv-qualified) fundamental type is tested for convertibility to the
    // non-cv-qualified reference type of another fundamental type.
 
template <class t_FROM_TYPE, class t_TO_TYPE>
struct IsConvertible_Imp<const t_FROM_TYPE, t_TO_TYPE, 1, 1>
    : IsConvertible_Imp<const t_FROM_TYPE, double, 0, 0>::type {
    // This partial specialization is instantiated when the 'const' (template
    // parameter) fundamental 't_FROM_TYPE' is tested for convertibility to
    // another (template parameter) fundamental 't_TO_TYPE'.  This partial
    // specialization derives from
    // 'IsConvertible_Imp<const t_FROM_TYPE, double, 0, 0>' to avoid any
    // compilation warnings in case the 't_TO_TYPE' is an integral type and
    // 't_FROM_TYPE' is a floating-point type.
};
 
template <class t_FROM_TYPE, class t_TO_TYPE>
struct IsConvertible_Imp<t_FROM_TYPE, t_TO_TYPE, 1, 1>
    : IsConvertible_Imp<t_FROM_TYPE, double, 0, 0>::type {
    // This partial specialization is instantiated when the (template
    // parameter) fundamental 't_FROM_TYPE' is tested for convertibility to
    // another (template parameter) fundamental 't_TO_TYPE'.  This partial
    // specialization derives from
    // 'IsConvertible_Imp<t_FROM_TYPE, double, 0, 0>' to avoid any compilation
    // warnings in case that the 't_FROM_TYPE' is a floating-point type and
    // 't_TO_TYPE' is an integral type.
};
 
template <class t_FROM_TYPE, class t_TO_TYPE>
struct IsConvertible_Imp<t_FROM_TYPE, t_TO_TYPE, 0, 1>
    : IsConvertible_Imp<t_FROM_TYPE, double, 0, 0>::type {
    // This partial specialization is instantiated when the (template
    // parameter) 't_FROM_TYPE' is a non-fundamental type, and the (template
    // parameter) 't_TO_TYPE' is a non-'void' fundamental type.  This partial
    // specialization derives from
    // 'IsConvertible_Imp<t_FROM_TYPE, double, 0, 0>' to avoid any compilation
    // warnings in case that the 't_FROM_TYPE' is a floating-point type and the
    // 't_TO_TYPE' is an integral type.
};
 
template <class t_FROM_TYPE, class t_TO_TYPE>
struct IsConvertible_Imp<t_FROM_TYPE, t_TO_TYPE, 1, 0>
    : IsConvertible_Imp<int, t_TO_TYPE, 0, 0>::type {
    // This partial specialization is instantiated when the (template
    // parameter) 't_FROM_TYPE' is a non-'void' fundamental type, and the
    // (template parameter) 't_TO_TYPE' is a non-fundamental type.  This
    // partial specialization derives from
    // 'IsConvertible_Imp<int, t_TO_TYPE, 0, 0>' to avoid any compilation
    // warnings in case that the 't_FROM_TYPE' is a floating-point type and the
    // 't_TO_TYPE' is an integral type.
};
 
#undef BSLMF_ISCONVERTIBLE_SAMETYPEVALUE
#undef BSLMF_ISCONVERTIBLE_VALUE
#undef BSLMF_ISCONVERTIBLE_FORWARD
 
#endif
 
template <class t_TO_TYPE>
struct IsConvertible_LazyTrait
: bsl::add_lvalue_reference<typename bsl::add_const<
      typename bsl::remove_cv<t_TO_TYPE>::type>::type> {
};
 
template <class t_FROM_TYPE, class t_TO_TYPE>
struct IsConvertible_IsNeverConvertible
: bsl::integral_constant<bool,
                         bsl::is_void<t_FROM_TYPE>::value ||
                             bsl::is_array<t_TO_TYPE>::value ||
                             bsl::is_function<t_TO_TYPE>::value> {
};
 
template <class t_FROM_TYPE, class t_TO_TYPE>
struct IsConvertible_FilterNeverConvertible
: bsl::conditional<
      IsConvertible_IsNeverConvertible<t_FROM_TYPE, t_TO_TYPE>::value,
      bsl::false_type,
      IsConvertible_Imp<t_FROM_TYPE,
                        typename IsConvertible_LazyTrait<t_TO_TYPE>::type> >::
      type {
};
 
template <class t_FROM_TYPE, class t_TO_TYPE>
struct IsConvertible_Conditional
: bsl::conditional<
      bsl::is_void<t_TO_TYPE>::value,
      typename bsl::is_void<t_FROM_TYPE>::type,
      IsConvertible_FilterNeverConvertible<
          typename IsConvertible_CheckComplete<t_FROM_TYPE>::type,
          typename IsConvertible_CheckComplete<t_TO_TYPE>::type> >::type {
};
 
}  // close package namespace
 
 
namespace bsl {
 
                         // ==============================
                         // struct is_convertible_dispatch
                         // ==============================
 
/// This `struct` template implements the `is_convertible_dispatch`
/// meta-function defined in the C++11 standard [meta.rel] to determine if
/// the (template parameter) `t_FROM_TYPE` is convertible to the (template
/// parameter) `t_TO_TYPE`.  This `struct` derives from `bsl::true_type` if
/// the `t_FROM_TYPE` is convertible to `t_TO_TYPE`, and from
/// `bsl::false_type` otherwise.  Note that both `t_FROM_TYPE` and
/// `t_TO_TYPE` should be complete types, arrays of unknown bound, or
/// (possibly cv-qualified) `void` types.
template <class t_FROM_TYPE, class t_TO_TYPE>
struct is_convertible_dispatch
: BloombergLP::bslmf::IsConvertible_Conditional<t_FROM_TYPE, t_TO_TYPE>::type {
};
 
/// This set of rules corresponds with the reference binding rules in c++11,
/// where the specification of `is_convertible_dispatch` relies on
/// rvalue-references.  We must supply these specializations directly in
/// order to support C++03 compilers that do not have a good substitute for
/// rvalue-references, as using `const &` instead produces subtly different
/// results in some cases.
template <class t_TYPE>
struct is_convertible_dispatch<t_TYPE, t_TYPE&>
: integral_constant<bool,
                    is_reference<t_TYPE>::value ||
                        is_function<t_TYPE>::value ||
                        is_const<t_TYPE>::value> {
};
 
// Some compilers need explicit guidance on a few of the reference-binding
// conversions.  All compilers get most of these correct, but once a few
// specializations are added, the full set is required to avoid ambiguities.
 
template <class t_TYPE>
struct is_convertible_dispatch<t_TYPE, const t_TYPE&> : true_type {
};
 
template <class t_TYPE>
struct is_convertible_dispatch<t_TYPE, volatile t_TYPE&> : false_type {
};
 
template <class t_TYPE>
struct is_convertible_dispatch<t_TYPE, const volatile t_TYPE&> : false_type {
};
 
template <class t_TYPE>
struct is_convertible_dispatch<const t_TYPE, t_TYPE&> : false_type {
};
 
template <class t_TYPE>
struct is_convertible_dispatch<const t_TYPE, const t_TYPE&> : true_type {
};
 
template <class t_TYPE>
struct is_convertible_dispatch<const t_TYPE, volatile t_TYPE&> : false_type {
};
 
template <class t_TYPE>
struct is_convertible_dispatch<const t_TYPE, const volatile t_TYPE&>
: false_type {
};
 
template <class t_TYPE>
struct is_convertible_dispatch<volatile t_TYPE, t_TYPE&> : false_type {
};
 
template <class t_TYPE>
struct is_convertible_dispatch<volatile t_TYPE, const t_TYPE&> : false_type {
};
 
template <class t_TYPE>
struct is_convertible_dispatch<volatile t_TYPE, volatile t_TYPE&>
: false_type {
};
 
template <class t_TYPE>
struct is_convertible_dispatch<volatile t_TYPE, const volatile t_TYPE&>
: false_type {
};
 
template <class t_TYPE>
struct is_convertible_dispatch<const volatile t_TYPE, t_TYPE&> : false_type {
};
 
template <class t_TYPE>
struct is_convertible_dispatch<const volatile t_TYPE, const t_TYPE&>
: false_type {
};
 
template <class t_TYPE>
struct is_convertible_dispatch<const volatile t_TYPE, volatile t_TYPE&>
: false_type {
};
 
template <class t_TYPE>
struct is_convertible_dispatch<const volatile t_TYPE, const volatile t_TYPE&>
: false_type {
};
 
// The next group of partial specializations deal with various cases of
// converting to an lvalue-reference, which we make explicitly conform to the
// C++11 idiom of converting from an rvalue (which may be an lvalue-reference).
 
template <class t_TYPE>
struct is_convertible_dispatch<t_TYPE&, t_TYPE&> : true_type {
};
 
template <class t_TYPE>
struct is_convertible_dispatch<t_TYPE&, const t_TYPE&> : true_type {
};
 
template <class t_TYPE>
struct is_convertible_dispatch<t_TYPE&, volatile t_TYPE&> : true_type {
};
 
template <class t_TYPE>
struct is_convertible_dispatch<t_TYPE&, const volatile t_TYPE&> : true_type {
};
 
template <class t_TYPE>
struct is_convertible_dispatch<const t_TYPE&, t_TYPE&> : false_type {
};
 
template <class t_TYPE>
struct is_convertible_dispatch<const t_TYPE&, const t_TYPE&> : true_type {
};
 
template <class t_TYPE>
struct is_convertible_dispatch<const t_TYPE&, volatile t_TYPE&> : false_type {
};
 
template <class t_TYPE>
struct is_convertible_dispatch<const t_TYPE&, const volatile t_TYPE&>
: true_type {
};
 
template <class t_TYPE>
struct is_convertible_dispatch<volatile t_TYPE&, t_TYPE&> : false_type {
};
 
template <class t_TYPE>
struct is_convertible_dispatch<volatile t_TYPE&, const t_TYPE&> : false_type {
};
 
template <class t_TYPE>
struct is_convertible_dispatch<volatile t_TYPE&, volatile t_TYPE&>
: true_type {
};
 
template <class t_TYPE>
struct is_convertible_dispatch<volatile t_TYPE&, const volatile t_TYPE&>
: true_type {
};
 
template <class t_TYPE>
struct is_convertible_dispatch<const volatile t_TYPE&, t_TYPE&> : false_type {
};
 
template <class t_TYPE>
struct is_convertible_dispatch<const volatile t_TYPE&, const t_TYPE&>
: false_type {
};
 
template <class t_TYPE>
struct is_convertible_dispatch<const volatile t_TYPE&, volatile t_TYPE&>
: false_type {
};
 
template <class t_TYPE>
struct is_convertible_dispatch<const volatile t_TYPE&, const volatile t_TYPE&>
: true_type {
};
 
/// Correct handling of non-fundamental volatile conversions to self.  Note
/// that this is not trivially true, but tests that `t_TYPE` is copy (or
/// move) constructible.
template <class t_TYPE>
struct is_convertible_dispatch<volatile t_TYPE, t_TYPE>
: BloombergLP::bslmf::IsConvertible_Conditional<t_TYPE, t_TYPE>::type {
};
 
template <class t_FROM_TYPE, class t_TO_TYPE>
struct is_convertible_dispatch<t_FROM_TYPE, volatile t_TO_TYPE&> : false_type {
};
 
template <class t_FROM_TYPE, class t_TO_TYPE>
struct is_convertible_dispatch<t_FROM_TYPE, const volatile t_TO_TYPE&>
: false_type {
};
 
template <class t_FROM_TYPE, class t_TO_TYPE>
struct is_convertible_dispatch<volatile t_FROM_TYPE&, volatile t_TO_TYPE&>
: is_convertible_dispatch<t_FROM_TYPE *, t_TO_TYPE *>::type {
};
 
template <class t_FROM_TYPE, class t_TO_TYPE>
struct is_convertible_dispatch<volatile t_FROM_TYPE&,
                               const volatile t_TO_TYPE&>
: is_convertible_dispatch<t_FROM_TYPE, const volatile t_TO_TYPE&>::type {
};
 
                         // =====================
                         // struct is_convertible
                         // =====================
 
template <class t_FROM_TYPE>
struct EffectiveFromType : conditional<is_fundamental<t_FROM_TYPE>::value ||
                                           is_pointer<t_FROM_TYPE>::value,
                                       typename remove_cv<t_FROM_TYPE>::type,
                                       t_FROM_TYPE> {
};
 
template <class t_FROM_TYPE, class t_TO_TYPE>
struct is_convertible_dispatch<volatile t_FROM_TYPE&, t_TO_TYPE>
: bsl::conditional<
      bsl::is_fundamental<t_FROM_TYPE>::value,
      typename bsl::is_convertible_dispatch<t_FROM_TYPE, t_TO_TYPE>::type,
      typename BloombergLP::bslmf::IsConvertible_Conditional<
          volatile t_FROM_TYPE,
          t_TO_TYPE>::type>::type {
};
 
/// This `struct` template implements the `is_convertible_dispatch`
/// meta-function defined in the C++11 standard [meta.rel] to determine if
/// the (template parameter) `t_FROM_TYPE` is convertible to the (template
/// parameter) `t_TO_TYPE`.  This `struct` derives from `bsl::true_type` if
/// the `t_FROM_TYPE` is convertible to `t_TO_TYPE`, and from
/// `bsl::false_type` otherwise.  Note that both `t_FROM_TYPE` and
/// `t_TO_TYPE` should be complete types, arrays of unknown bound, or
/// (possibly cv-qualified) `void` types.
template <class t_FROM_TYPE, class t_TO_TYPE>
struct is_convertible
: is_convertible_dispatch<typename EffectiveFromType<t_FROM_TYPE>::type,
                          t_TO_TYPE>::type {
};
 
}  // close namespace bsl
#endif
 
 
namespace bslmf {
 
                         // ====================
                         // struct IsConvertible
                         // ====================
 
/// This `struct` template implements a meta-function to determine if the
/// (template parameter) `t_FROM_TYPE` is convertible to the (template
/// parameter) `t_TO_TYPE`.  This `struct` derives from `bsl::true_type` if
/// the `t_FROM_TYPE` is convertible to `t_TO_TYPE`, and from
/// `bsl::false_type` otherwise.  Note that both `t_FROM_TYPE` and
/// `t_TO_TYPE` should be complete types, arrays of unknown bound, or
/// (possibly cv-qualified) `void` types.
template <class t_FROM_TYPE, class t_TO_TYPE>
struct IsConvertible : bsl::is_convertible<t_FROM_TYPE, t_TO_TYPE>::type {
};
 
}  // close package namespace
 
#ifndef BDE_OPENSOURCE_PUBLICATION  // BACKWARD_COMPATIBILITY
// ============================================================================
//                           BACKWARD COMPATIBILITY
// ============================================================================
 
#ifdef bslmf_IsConvertible
#undef bslmf_IsConvertible
#endif
/// This alias is defined for backward compatibility.
#define bslmf_IsConvertible bslmf::IsConvertible
#endif  // BDE_OPENSOURCE_PUBLICATION -- BACKWARD_COMPATIBILITY
 
 
 
#endif // ! defined(INCLUDED_BSLMF_ISCONVERTIBLE)
 
// ----------------------------------------------------------------------------
// Copyright 2013 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 ----------------------------------
 
/** @} */
/** @} */
/** @} */