c++20/exercise-2-1.hpp

Go to the documentation of this file.

// ===-- chapter-2/c++20/exercise-2-1.hpp ----------------- -*- C++ -*- --=== //
#ifndef EXERCISE_2_1
#define EXERCISE_2_1
 
#include <cstddef>
#include <type_traits>
 
 
namespace exercise_2_1 {
 
inline namespace cpp20 {
 
template <typename C, typename X, typename Y>
struct replace_type
{
    // If we missed a case, this should give an error about no "type"
};
 
template <typename C, typename X, typename Y, bool Same>
struct replace_type_dispatch
{
    // Really a forward declaration.  "Same" specifications are given below.
};
 
template <typename C, typename X, typename Y>
struct replace_type<C*, X, Y>
{
    using type = std::add_pointer<
        typename replace_type_dispatch<
            C,
            X,
            Y,
            std::is_same<C, X>::value
            >::type
        >::type;
};
 
template <typename C, typename X, typename Y>
struct replace_type<C&, X, Y>
{
    using type = std::add_lvalue_reference<
        typename replace_type_dispatch<
            C,
            X,
            Y,
            std::is_same<C, X>::value
            >::type
        >::type;
};
 
template <typename C, typename X, typename Y, size_t N>
struct replace_type<C[N], X, Y>
{
    using type = replace_type_dispatch<
            C,
            X,
            Y,
            std::is_same<C, X>::value
        >::type [N];
};
 
template <typename Cr, typename... CArgs, typename X, typename Y>
struct replace_type<Cr(*)(CArgs...), X, Y>
{
    using ret_type = replace_type_dispatch<
            Cr,
            X,
            Y,
            std::is_same<Cr, X>::value
        >::type;
 
    using func_type = ret_type(
        typename replace_type_dispatch<
            CArgs,
            X,
            Y,
            std::is_same<CArgs, X>::value
        >::type...);
 
    using type = func_type*;
};
 
template <typename C, typename X, typename Y>
struct replace_type_dispatch<C, X, Y, true>
{
    using type = Y;
};
template <typename C, typename X, typename Y>
struct replace_type_dispatch<C, X, Y, false>
{
    // Do not instantiate templates inside std::conditional by requesting
    // ::type, because replace_type does not provide it (intentionally) in all
    // situations.
    using type = std::conditional<
        std::is_arithmetic<C>::value,
            std::type_identity<C>,
            replace_type<C, X, Y>
        >::type::type;
};
 
} // inline namespace cpp20
} // namespace exercise_2_1
 
#endif // EXERCISE_2_1