#include <boost/static_assert.hpp>


// helper metafunctions - just to make the solution self-contained

template<typename T, typename U>
struct is_same
{
    static const bool value = false;
};

template<typename T>
struct is_same<T,T>
{
    static const bool value = true;
};


template<typename T, typename U, typename V>
struct is_one_of
{
    static const bool value 
        = is_same<T,U>::value || is_same<T,V>::value;
};


template<bool v, typename T>
struct no_common_type_error
{
    typedef T type;
};

template<typename T>
struct no_common_type_error<true, T>
{
};


template<bool B0, bool B1 = true , bool B2 = true , bool B3 = true, bool B4 = true>
struct multi_and // just syntactic sugar
{
    static const bool value = B0 && B1 && B2 && B3 && B4;
};


// tags

struct default_t;


/*
 *  common_type metafunction
 */

template<
    typename T0, 
    typename T1 = default_t, 
    typename T2 = default_t,
    typename T3 = default_t
>
struct common_type
{
  private:
    template<typename T>
    struct is_T0_or_default
    {
        static const bool value = is_one_of<T, T0, default_t>::value;  
    };

    static const bool value
        = multi_and< is_T0_or_default<T1>::value, 
                     is_T0_or_default<T2>::value,
                     is_T0_or_default<T3>::value
                   >::value;
  public:
    typedef typename no_common_type_error<!value, T0>::type type;
};

template<typename T1, typename T2, typename T3>
struct common_type<default_t, T1, T2, T3>
    : common_type<T1, T2, T3>
{};


// exploiting recursion there would be no need of the following cases

template<typename T2, typename T3>
struct common_type<default_t, default_t, T2, T3>
    : common_type<T2, T3>
{};

template<typename T3>
struct common_type<default_t, default_t, default_t, T3>
{
    typedef T3 type;
};

template<>
struct common_type<default_t, default_t, default_t, default_t>
{
    typedef default_t type;
};



/*
 *  tests
 */

typedef common_type<int, int, int, int>::type C1;
typedef common_type<default_t, int, int, int>::type C2;
typedef common_type<int, default_t, int, default_t>::type C3;
typedef common_type<default_t, int, default_t, int>::type C4;
typedef common_type<default_t, default_t, int, int>::type C5;
typedef common_type<default_t, default_t, int, default_t>::type C6;
typedef common_type<default_t, default_t, default_t, default_t>::type C7;
// uncomment the following typedef to see error notification messages
//typedef common_type<int, int, int, double>::type C8;
//typedef common_type<double, default_t, int, int>::type C9;
//typedef common_type<default_t, default_t, double, int>::type C10;

BOOST_STATIC_ASSERT((is_same<C1, int>::value));
BOOST_STATIC_ASSERT((is_same<C2, int>::value));
BOOST_STATIC_ASSERT((is_same<C3, int>::value));
BOOST_STATIC_ASSERT((is_same<C4, int>::value));
BOOST_STATIC_ASSERT((is_same<C5, int>::value));
BOOST_STATIC_ASSERT((is_same<C6, int>::value));
BOOST_STATIC_ASSERT((is_same<C7, default_t>::value));