exercise-2-1.hpp

Go to the documentation of this file.

// ===-- chapter-2/exercise-2-1.hpp ----------------------- -*- C++ -*- --=== //
#ifndef EXERCISE_2_1
#define EXERCISE_2_1
 
#include <boost/type_traits/add_pointer.hpp>
#include <boost/type_traits/add_reference.hpp>
 
#include <boost/type_traits/is_same.hpp>
 
 
namespace exercise_2_1 {
 
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>
{
    typedef
    typename boost::add_pointer<
        typename replace_type_dispatch<
            C,
            X,
            Y,
            boost::is_same<C, X>::value
            >::type
        >::type
    type;
};
 
template <typename C, typename X, typename Y>
struct replace_type<C&, X, Y>
{
    typedef
    typename boost::add_reference<
        typename replace_type_dispatch<
            C,
            X,
            Y,
            boost::is_same<C, X>::value
            >::type
        >::type
    type;
};
 
template <typename C, typename X, typename Y, size_t N>
struct replace_type<C[N], X, Y>
{
    typedef
    typename replace_type_dispatch<
        C,
        X,
        Y,
        boost::is_same<C, X>::value
        >::type
    type [N];
};
 
// Going to get tedious for multiple arguments... Could variadic templates help
// here?
template <typename Cr, typename X, typename Y>
struct replace_type<Cr(*)(), X, Y>
{
    typedef
    typename replace_type_dispatch<
        Cr,
        X,
        Y,
        boost::is_same<Cr, X>::value
        >::type
    (*type)();
};
template <typename Cr, typename C0, typename X, typename Y>
struct replace_type<Cr(*)(C0), X, Y>
{
    typedef
    typename replace_type_dispatch<
        Cr,
        X,
        Y,
        boost::is_same<Cr, X>::value
        >::type
    (*type)(
        typename replace_type_dispatch<
            C0,
            X,
            Y,
            boost::is_same<C0, X>::value
            >::type
        );
};
template <typename Cr, typename C0, typename C1, typename X, typename Y>
struct replace_type<Cr(*)(C0,C1), X, Y>
{
    typedef
    typename replace_type_dispatch<
        Cr,
        X,
        Y,
        boost::is_same<Cr, X>::value
        >::type
    (*type)(
        typename replace_type_dispatch<
            C0,
            X,
            Y,
            boost::is_same<C0, X>::value
            >::type,
        typename replace_type_dispatch<
            C1,
            X,
            Y,
            boost::is_same<C1, X>::value
            >::type
        );
};
 
template <typename C, typename X, typename Y>
struct replace_type_dispatch<C, X, Y, true>
{
    typedef Y type;
};
template <typename C, typename X, typename Y>
struct replace_type_dispatch<C, X, Y, false>
{
    typedef typename replace_type<C, X, Y>::type type;
};
 
} // namespace exercise_2_1
 
#endif // EXERCISE_2_1