template<typename Domain, typename Super = typename Domain::proto_super_domain>
struct super_domain;

struct dummy_domain;
struct default_domain;

struct not_a_domain
{
    typedef not_a_domain proto_super_domain;
};

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

template<>
struct domain<default_domain>
{
    typedef dummy_domain proto_super_domain;
};

struct dummy_domain
  : domain<>
{};

struct default_domain
  : domain<>
{};

struct not_a_domain_base {};
struct default_domain_base {};
struct dummy_domain_base : default_domain_base {};

template<>
struct super_domain<not_a_domain, not_a_domain>
  : not_a_domain_base
{
    super_domain test(...);
    not_a_domain get_super();
};

template<>
struct super_domain<default_domain, not_a_domain>
  : default_domain_base
{
    template<typename T> T test(T);
    default_domain get_super();
};

template<typename Domain>
struct super_domain<Domain, dummy_domain>
  : dummy_domain_base
{
    super_domain<default_domain> test(...);
    super_domain test(default_domain_base);
    super_domain<not_a_domain> test(dummy_domain_base);
    super_domain test(super_domain);
    Domain get_super();
};

template<typename Domain, typename SuperDomain>
struct super_domain
  : super_domain<SuperDomain>
{
    using super_domain<SuperDomain>::test;
    super_domain test(super_domain);
    super_domain test(default_domain_base);
    Domain get_super();
};

template<typename A0, typename A1, typename A2>
struct deduce_domain3
{
    static super_domain<A0> & d0;
    static super_domain<A1> & d1;
    static super_domain<A2> & d2;
    typedef decltype(d0.test(d1).test(d1).test(d2).test(d2).get_super()) type;
};

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

struct D0 : domain<>
{
};

struct D1 : domain<D0>
{
};

struct D2 : domain<D0>
{
};

struct D3 : domain<>
{
};

struct DD0 : domain<default_domain>
{
};

struct DD1 : domain<default_domain>
{
};

struct DD2 : domain<default_domain>
{
};

struct DD3 : domain<DD2>
{
};

struct DD4 : domain<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>));

    // 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>));

    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>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<DD3, DD4, DD4>::type, DD2>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<DD4, DD3, DD4>::type, DD2>));
    BOOST_MPL_ASSERT((is_same<deduce_domain3<DD4, DD4, DD3>::type, DD2>));
    //*/
}