template <int N>
struct sized_type
{
    typedef char (&type)[N];
};

struct not_a_domain
{};

template<typename Domain = not_a_domain>
struct domain
{
    typedef Domain proto_super_domain;
};

struct default_domain
  : domain<>
{};

template<typename Domain>
struct wrap
  : wrap<typename Domain::proto_super_domain>
{
    typedef Domain type;
    typedef wrap<typename Domain::proto_super_domain> base;
    using base::deduce0x;
    using base::deduce98;
    static int const index = base::index + 1;
    static Domain deduce0x(wrap<Domain>*);
    static typename sized_type<index>::type deduce98(wrap<Domain>*);
};

template<>
struct wrap<not_a_domain>
{
    typedef not_a_domain type;
    static int const index = 1;
    static not_a_domain deduce0x(void*);
    static sized_type<1>::type deduce98(void*);
};

template<>
struct wrap<default_domain>
  : wrap<not_a_domain>
{};

sized_type<1>::type default_case(void*, void*);
sized_type<2>::type default_case(wrap<default_domain>*, void*);
sized_type<3>::type default_case(void*, wrap<default_domain>*);
sized_type<4>::type default_case(wrap<default_domain>*, wrap<default_domain>*);

template <int N, class Wrap>
struct nth_domain
  : nth_domain<N - 2, typename Wrap::base::base>
{};

template <class Wrap>
struct nth_domain<0, Wrap>
  : Wrap
{};

template <class Wrap>
struct nth_domain<1, Wrap>
  : Wrap::base
{};

template <
    class D0
  , class D1
  , int DefaultCase = sizeof(default_case((wrap<D0>*)0, (wrap<D1>*)0))
>
struct deduce_common
{
    static int const index = wrap<D0>::index - sizeof(wrap<D0>::deduce98((wrap<D1>*)0));
    typedef typename nth_domain<index, wrap<D0> >::type type;
    // the following line does the same as above with decltype
    // without instantiating unnecessary templates.
    //typedef decltype(wrap<D0>::deduce0x((wrap<D1>*)0)) type;
};

template <class D0, class D1>
struct deduce_common<D0, D1, 2>
{
    typedef D1 type;
};

template <class D0, class D1>
struct deduce_common<D0, D1, 3>
{
    typedef D0 type;
};

template <class D0>
struct deduce_common<D0, default_domain, 4>
{
    typedef D0 type;
};

template <class D1>
struct deduce_common<default_domain, D1, 4>
{
    typedef D1 type;
};

template <>
struct deduce_common<default_domain, default_domain, 4>
{
    typedef default_domain type;
};

template<typename A0, typename A1, typename A2>
struct deduce_domain3
{
    typedef A0 common1;
    typedef typename deduce_common<common1, A1>::type common2;
    typedef typename deduce_common<common2, A2>::type common3;
    typedef common3 type;
};

////////////////////////////////////////////////////
// Begin test code
#include <boost/mpl/assert.hpp>
#include <boost/type_traits/is_same.hpp>

struct D0 : domain<>
{
};

struct D1 : domain<D0> // a sub-domain of D0
{
};

struct D2 : domain<D0> // a sub-domain of D0
{
};

struct D3 : domain<>
{
};

struct DD0 : domain<default_domain> // a sub-domain of default_domain
{
};

struct DD1 : domain<default_domain> // a sub-domain of default_domain
{
};

struct DD2 : domain<default_domain> // a sub-domain of default_domain
{
};

struct DD3 : domain<DD2> // a sub-domain of DD2
{
};

int main()
{
    using boost::is_same;

    BOOST_MPL_ASSERT((is_same<deduce_domain3<D0, D0, D0>::type, D0>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<default_domain, D0, D0>::type, D0>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<D0, default_domain, D0>::type, D0>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<D0, D0, default_domain>::type, D0>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<D0, default_domain, default_domain>::type, D0>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<default_domain, D0, default_domain>::type, D0>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<default_domain, default_domain, D0>::type, D0>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<default_domain, default_domain, default_domain>::type, default_domain>));

    BOOST_MPL_ASSERT((is_same<deduce_domain3<DD0, D0, D0>::type, D0>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<D0, DD0, D0>::type, D0>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<D0, D0, DD0>::type, D0>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<D0, DD0, DD0>::type, D0>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<DD0, D0, DD0>::type, D0>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<DD0, DD0, D0>::type, D0>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<default_domain, DD0, DD0>::type, DD0>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<DD0, default_domain, DD0>::type, DD0>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<DD0, DD0, default_domain>::type, DD0>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<default_domain, default_domain, DD0>::type, DD0>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<default_domain, DD0, default_domain>::type, DD0>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<DD0, DD0, default_domain>::type, DD0>));

    BOOST_MPL_ASSERT((is_same<deduce_domain3<D0, D0, D1>::type, D0>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<D0, D1, D0>::type, D0>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<D0, D1, D1>::type, D0>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<D1, D0, D0>::type, D0>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<D1, D0, D1>::type, D0>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<D1, D1, D0>::type, D0>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<D1, D1, D1>::type, D1>));

    // Very tricky to get right
    BOOST_MPL_ASSERT((is_same<deduce_domain3<D2, D2, D1>::type, D0>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<D2, D1, D2>::type, D0>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<D2, D1, D1>::type, D0>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<D1, D2, D2>::type, D0>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<D1, D2, D1>::type, D0>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<D1, D1, D2>::type, D0>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<D1, D1, D1>::type, D1>));

    BOOST_MPL_ASSERT((is_same<deduce_domain3<D3, D0, D0>::type, not_a_domain>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<D0, D3, D0>::type, not_a_domain>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<D0, D0, D3>::type, not_a_domain>));

    BOOST_MPL_ASSERT((is_same<deduce_domain3<D3, D1, D0>::type, not_a_domain>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<D3, D0, D1>::type, not_a_domain>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<D1, D3, D0>::type, not_a_domain>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<D0, D3, D1>::type, not_a_domain>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<D0, D1, D3>::type, not_a_domain>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<D1, D0, D3>::type, not_a_domain>));

    BOOST_MPL_ASSERT((is_same<deduce_domain3<D3, D1, D2>::type, not_a_domain>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<D3, D2, D1>::type, not_a_domain>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<D1, D3, D2>::type, not_a_domain>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<D2, D3, D1>::type, not_a_domain>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<D2, D1, D3>::type, not_a_domain>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<D1, D2, D3>::type, not_a_domain>));

    BOOST_MPL_ASSERT((is_same<deduce_domain3<DD3, DD2, DD2>::type, DD2>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<DD2, DD3, DD2>::type, DD2>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<DD2, DD2, DD3>::type, DD2>));

    // These should be ambiguous.
    BOOST_MPL_ASSERT((is_same<deduce_domain3<DD1, DD0, DD0>::type, not_a_domain>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<DD0, DD1, DD0>::type, not_a_domain>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<DD0, DD0, DD1>::type, not_a_domain>));
}