| //----------------------------------------------------------------------------- |
| // boost variant/detail/initializer.hpp header file |
| // See http://www.boost.org for updates, documentation, and revision history. |
| //----------------------------------------------------------------------------- |
| // |
| // Copyright (c) 2002-2003 |
| // Eric Friedman, Itay Maman |
| // |
| // 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) |
| |
| #ifndef BOOST_VARIANT_DETAIL_INITIALIZER_HPP |
| #define BOOST_VARIANT_DETAIL_INITIALIZER_HPP |
| |
| #include <new> // for placement new |
| |
| #include "boost/config.hpp" |
| |
| #include "boost/call_traits.hpp" |
| #include "boost/detail/reference_content.hpp" |
| #include "boost/variant/recursive_wrapper_fwd.hpp" |
| |
| #if !defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE) |
| # include "boost/mpl/aux_/value_wknd.hpp" |
| # include "boost/mpl/int.hpp" |
| # include "boost/mpl/iter_fold.hpp" |
| # include "boost/mpl/next.hpp" |
| # include "boost/mpl/deref.hpp" |
| # include "boost/mpl/pair.hpp" |
| # include "boost/mpl/protect.hpp" |
| #else |
| # include "boost/variant/variant_fwd.hpp" |
| # include "boost/preprocessor/cat.hpp" |
| # include "boost/preprocessor/enum.hpp" |
| # include "boost/preprocessor/repeat.hpp" |
| #endif |
| |
| namespace boost { |
| namespace detail { namespace variant { |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // (detail) support to simulate standard overload resolution rules |
| // |
| // The below initializers allows variant to follow standard overload |
| // resolution rules over the specified set of bounded types. |
| // |
| // On compilers where using declarations in class templates can correctly |
| // avoid name hiding, use an optimal solution based on the variant's typelist. |
| // |
| // Otherwise, use a preprocessor workaround based on knowledge of the fixed |
| // size of the variant's psuedo-variadic template parameter list. |
| // |
| |
| #if !defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE) |
| |
| // (detail) quoted metafunction make_initializer_node |
| // |
| // Exposes a pair whose first type is a node in the initializer hierarchy. |
| // |
| struct make_initializer_node |
| { |
| template <typename BaseIndexPair, typename Iterator> |
| struct apply |
| { |
| private: // helpers, for metafunction result (below) |
| |
| typedef typename BaseIndexPair::first |
| base; |
| typedef typename BaseIndexPair::second |
| index; |
| |
| class initializer_node |
| : public base |
| { |
| private: // helpers, for static functions (below) |
| |
| typedef typename mpl::deref<Iterator>::type |
| recursive_enabled_T; |
| typedef typename unwrap_recursive<recursive_enabled_T>::type |
| public_T; |
| typedef typename call_traits<public_T>::param_type |
| param_T; |
| |
| public: // static functions |
| |
| using base::initialize; |
| |
| static int initialize(void* dest, param_T operand) |
| { |
| typedef typename boost::detail::make_reference_content< |
| recursive_enabled_T |
| >::type internal_T; |
| |
| new(dest) internal_T(operand); |
| return BOOST_MPL_AUX_VALUE_WKND(index)::value; // which |
| } |
| |
| }; |
| |
| friend class initializer_node; |
| |
| public: // metafunction result |
| |
| typedef mpl::pair< |
| initializer_node |
| , typename mpl::next< index >::type |
| > type; |
| |
| }; |
| }; |
| |
| // (detail) class initializer_root |
| // |
| // Every level of the initializer hierarchy must expose the name |
| // "initialize," so initializer_root provides a dummy function: |
| // |
| class initializer_root |
| { |
| public: // static functions |
| |
| static void initialize(); |
| |
| }; |
| |
| #else // defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE) |
| |
| # if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) |
| |
| #define BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_PARAMS \ |
| BOOST_VARIANT_ENUM_PARAMS(typename recursive_enabled_T) \ |
| /**/ |
| |
| #define BOOST_VARIANT_AUX_PP_INITIALIZER_DEFINE_PARAM_T(N) \ |
| typedef typename unwrap_recursive< \ |
| BOOST_PP_CAT(recursive_enabled_T,N) \ |
| >::type BOOST_PP_CAT(public_T,N); \ |
| typedef typename call_traits< \ |
| BOOST_PP_CAT(public_T,N) \ |
| >::param_type BOOST_PP_CAT(param_T,N); \ |
| /**/ |
| |
| # else // MSVC7 and below |
| |
| #define BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_PARAMS \ |
| BOOST_VARIANT_ENUM_PARAMS(typename recursive_enabled_T) \ |
| , BOOST_VARIANT_ENUM_PARAMS(typename param_T) \ |
| /**/ |
| |
| #define BOOST_VARIANT_AUX_PP_INITIALIZER_DEFINE_PARAM_T(N) \ |
| /**/ |
| |
| # endif // MSVC7 and below workaround |
| |
| template < BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_PARAMS > |
| struct preprocessor_list_initializer |
| { |
| public: // static functions |
| |
| #define BOOST_VARIANT_AUX_PP_INITIALIZE_FUNCTION(z,N,_) \ |
| BOOST_VARIANT_AUX_PP_INITIALIZER_DEFINE_PARAM_T(N) \ |
| static int initialize( \ |
| void* dest \ |
| , BOOST_PP_CAT(param_T,N) operand \ |
| ) \ |
| { \ |
| typedef typename boost::detail::make_reference_content< \ |
| BOOST_PP_CAT(recursive_enabled_T,N) \ |
| >::type internal_T; \ |
| \ |
| new(dest) internal_T(operand); \ |
| return (N); /*which*/ \ |
| } \ |
| /**/ |
| |
| BOOST_PP_REPEAT( |
| BOOST_VARIANT_LIMIT_TYPES |
| , BOOST_VARIANT_AUX_PP_INITIALIZE_FUNCTION |
| , _ |
| ) |
| |
| #undef BOOST_VARIANT_AUX_PP_INITIALIZE_FUNCTION |
| |
| }; |
| |
| # if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) |
| |
| #if !defined(BOOST_VARIANT_AUX_ECHO) |
| # define BOOST_VARIANT_AUX_ECHO(z,N,token) token |
| #endif |
| |
| template <> |
| struct preprocessor_list_initializer< |
| BOOST_PP_ENUM(BOOST_VARIANT_LIMIT_TYPES, BOOST_VARIANT_AUX_ECHO, int) |
| , BOOST_PP_ENUM(BOOST_VARIANT_LIMIT_TYPES, BOOST_VARIANT_AUX_ECHO, const int) |
| > |
| { |
| }; |
| |
| # endif // BOOST_MPL_CFG_MSVC_60_ETI_BUG workaround |
| |
| #endif // BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE workaround |
| |
| }} // namespace detail::variant |
| } // namespace boost |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // macro BOOST_VARIANT_AUX_INITIALIZER_T |
| // |
| // Given both the variant's typelist and a basename for forming the list of |
| // bounded types (i.e., T becomes T1, T2, etc.), exposes the initializer |
| // most appropriate to the current compiler. |
| // |
| |
| #if !defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE) |
| |
| #define BOOST_VARIANT_AUX_INITIALIZER_T( mpl_seq, typename_base ) \ |
| ::boost::mpl::iter_fold< \ |
| mpl_seq \ |
| , ::boost::mpl::pair< \ |
| ::boost::detail::variant::initializer_root \ |
| , ::boost::mpl::int_<0> \ |
| > \ |
| , ::boost::mpl::protect< \ |
| ::boost::detail::variant::make_initializer_node \ |
| > \ |
| >::type::first \ |
| /**/ |
| |
| #else // defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE) |
| |
| # if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) |
| |
| #define BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_ARGS(typename_base) \ |
| BOOST_VARIANT_ENUM_PARAMS(typename_base) \ |
| /**/ |
| |
| # else // MSVC7 and below |
| |
| #define BOOST_VARIANT_AUX_PP_INITIALIZER_ENUM_PARAM_TYPE(z,N,T) \ |
| ::boost::call_traits< \ |
| ::boost::unwrap_recursive<BOOST_PP_CAT(T,N)>::type \ |
| >::param_type \ |
| /**/ |
| |
| #define BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_ARGS(typename_base) \ |
| BOOST_VARIANT_ENUM_PARAMS(typename_base) \ |
| , BOOST_PP_ENUM( \ |
| BOOST_VARIANT_LIMIT_TYPES \ |
| , BOOST_VARIANT_AUX_PP_INITIALIZER_ENUM_PARAM_TYPE \ |
| , typename_base \ |
| ) \ |
| /**/ |
| |
| # endif // MSVC7 workaround |
| |
| #define BOOST_VARIANT_AUX_INITIALIZER_T( mpl_seq, typename_base ) \ |
| ::boost::detail::variant::preprocessor_list_initializer< \ |
| BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_ARGS(typename_base) \ |
| > \ |
| /**/ |
| |
| #endif // BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE workaround |
| |
| #endif // BOOST_VARIANT_DETAIL_INITIALIZER_HPP |