| /////////////////////////////////////////////////////////////////////////////// |
| /// \file deduce_domain.hpp |
| /// Contains definition of deduce_domain\<\> class templates |
| /// for finding the domain that is common among the specified |
| /// domains |
| // |
| // Copyright 2010 Daniel Wallin, Eric Niebler. Distributed under the Boost |
| // Software License, Version 1.0. (See accompanying file |
| // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) |
| // |
| // Many thanks to Daniel Wallin who first implemented this code. Thanks |
| // also to Jeremiah Willcock, John Bytheway and Krishna Achuthan who |
| // offered alternate solutions to this tricky programming problem. |
| |
| #ifndef BOOST_PROTO_DEDUCE_DOMAIN_HPP_EAN_05_22_2010 |
| #define BOOST_PROTO_DEDUCE_DOMAIN_HPP_EAN_05_22_2010 |
| |
| #include <boost/config.hpp> |
| #include <boost/preprocessor/cat.hpp> |
| #include <boost/preprocessor/facilities/intercept.hpp> |
| #include <boost/preprocessor/iteration/local.hpp> |
| #include <boost/preprocessor/repetition/enum_params.hpp> |
| #include <boost/preprocessor/repetition/enum_binary_params.hpp> |
| #include <boost/preprocessor/repetition/repeat_from_to.hpp> |
| #include <boost/preprocessor/arithmetic/inc.hpp> |
| #include <boost/mpl/assert.hpp> |
| #include <boost/type_traits/is_same.hpp> |
| #include <boost/proto/proto_fwd.hpp> |
| |
| #ifndef BOOST_PROTO_ASSERT_VALID_DOMAIN |
| # define BOOST_PROTO_ASSERT_VALID_DOMAIN(DOM) BOOST_MPL_ASSERT_NOT((boost::is_same<DOM, boost::proto::detail::not_a_domain>)) |
| #endif |
| |
| namespace boost |
| { |
| namespace proto |
| { |
| namespace detail |
| { |
| template<int N> |
| struct sized_type |
| { |
| typedef char (&type)[N]; |
| }; |
| |
| template<typename Domain> |
| struct domain_ |
| : domain_<typename Domain::proto_super_domain> |
| { |
| typedef Domain type; |
| typedef domain_<typename Domain::proto_super_domain> base; |
| #ifdef BOOST_NO_DECLTYPE |
| using base::deduce98; |
| static int const index = base::index + 1; |
| static typename sized_type<index>::type deduce98(domain_<Domain>*); |
| #else |
| using base::deduce0x; |
| static Domain deduce0x(domain_<Domain>*); |
| #endif |
| }; |
| |
| template<> |
| struct domain_<not_a_domain> |
| { |
| typedef not_a_domain type; |
| #ifdef BOOST_NO_DECLTYPE |
| static int const index = 1; |
| static sized_type<1>::type deduce98(void*); |
| #else |
| static not_a_domain deduce0x(void*); |
| #endif |
| }; |
| |
| template<> |
| struct domain_<default_domain> |
| : domain_<not_a_domain> |
| {}; |
| |
| sized_type<1>::type default_test(void*, void*); |
| sized_type<2>::type default_test(domain_<default_domain>*, void*); |
| sized_type<3>::type default_test(void*, domain_<default_domain>*); |
| sized_type<4>::type default_test(domain_<default_domain>*, domain_<default_domain>*); |
| |
| #ifdef BOOST_NO_DECLTYPE |
| template<int N, typename Domain> |
| struct nth_domain |
| : nth_domain<N - 1, typename Domain::base> |
| {}; |
| |
| template<typename Domain> |
| struct nth_domain<0, Domain> |
| : Domain |
| {}; |
| #endif |
| |
| template<typename D0> |
| struct common_domain1 |
| { |
| typedef D0 type; |
| }; |
| |
| template<typename E0> |
| struct deduce_domain1 |
| : domain_of<E0> |
| {}; |
| |
| template< |
| typename D0 |
| , typename D1 |
| , int DefaultCase = sizeof(proto::detail::default_test((domain_<D0>*)0, (domain_<D1>*)0)) |
| > |
| struct common_domain2 |
| { |
| #ifdef BOOST_NO_DECLTYPE |
| static int const index = domain_<D0>::index - sizeof(domain_<D0>::deduce98((domain_<D1>*)0)); |
| typedef typename nth_domain<index, domain_<D0> >::type type; |
| #else |
| typedef decltype(domain_<D0>::deduce0x((domain_<D1>*)0)) type; |
| #endif |
| }; |
| |
| template<typename D0, typename D1> |
| struct common_domain2<D0, D1, 2> |
| { |
| typedef D1 type; |
| }; |
| |
| template<typename D0, typename D1> |
| struct common_domain2<D0, D1, 3> |
| { |
| typedef D0 type; |
| }; |
| |
| template<typename D0> |
| struct common_domain2<D0, default_domain, 4> |
| { |
| typedef D0 type; |
| }; |
| |
| template<typename D1> |
| struct common_domain2<default_domain, D1, 4> |
| { |
| typedef D1 type; |
| }; |
| |
| template<> |
| struct common_domain2<default_domain, default_domain, 4> |
| { |
| typedef default_domain type; |
| }; |
| |
| template<typename E0, typename E1> |
| struct deduce_domain2 |
| : common_domain2< |
| typename domain_of<E0>::type |
| , typename domain_of<E1>::type |
| > |
| {}; |
| |
| #define M0(Z, N, DATA) \ |
| typedef \ |
| typename common_domain2<common ## N, A ## N>::type \ |
| BOOST_PP_CAT(common, BOOST_PP_INC(N)); \ |
| /**/ |
| |
| #define BOOST_PP_LOCAL_MACRO(N) \ |
| template<BOOST_PP_ENUM_PARAMS(N, typename A)> \ |
| struct BOOST_PP_CAT(common_domain, N) \ |
| { \ |
| typedef A0 common1; \ |
| BOOST_PP_REPEAT_FROM_TO(1, N, M0, ~) \ |
| typedef common ## N type; \ |
| BOOST_PROTO_ASSERT_VALID_DOMAIN(type); \ |
| }; \ |
| \ |
| template<BOOST_PP_ENUM_PARAMS(N, typename E)> \ |
| struct BOOST_PP_CAT(deduce_domain, N) \ |
| : BOOST_PP_CAT(common_domain, N)< \ |
| BOOST_PP_ENUM_BINARY_PARAMS( \ |
| N \ |
| , typename domain_of<E, >::type BOOST_PP_INTERCEPT \ |
| ) \ |
| > \ |
| {}; \ |
| /**/ |
| |
| #define BOOST_PP_LOCAL_LIMITS (3, BOOST_PROTO_MAX_ARITY) |
| #include BOOST_PP_LOCAL_ITERATE() |
| |
| #undef M0 |
| } |
| } |
| } |
| |
| #endif // BOOST_PROTO_DEDUCE_DOMAIN_HPP_EAN_05_22_2010 |