#if !defined(BOOST_PP_IS_ITERATING) ///// header body //----------------------------------------------------------------------------- // boost variant/detail/substitute.hpp header file // See http://www.boost.org for updates, documentation, and revision history. //----------------------------------------------------------------------------- // // Copyright (c) 2003 // Eric Friedman // // 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_SUBSTITUTE_HPP #define BOOST_VARIANT_DETAIL_SUBSTITUTE_HPP #include "boost/mpl/aux_/config/ctps.hpp" #include "boost/variant/detail/substitute_fwd.hpp" #include "boost/mpl/aux_/lambda_arity_param.hpp" #include "boost/mpl/aux_/preprocessor/params.hpp" #include "boost/mpl/aux_/preprocessor/repeat.hpp" #include "boost/mpl/int_fwd.hpp" #include "boost/mpl/limits/arity.hpp" #include "boost/preprocessor/cat.hpp" #include "boost/preprocessor/empty.hpp" #include "boost/preprocessor/arithmetic/inc.hpp" #include "boost/preprocessor/iterate.hpp" namespace boost { namespace detail { namespace variant { #if !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE) /////////////////////////////////////////////////////////////////////////////// // (detail) metafunction substitute // // Substitutes one type for another in the given type expression. // // // primary template // template < typename T, typename Dest, typename Source BOOST_MPL_AUX_LAMBDA_ARITY_PARAM( typename Arity /* = ... (see substitute_fwd.hpp) */ ) > struct substitute { typedef T type; }; // // tag substitution specializations // #define BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_SUBSTITUTE_TAG(CV_) \ template <typename Dest, typename Source> \ struct substitute< \ CV_ Source \ , Dest \ , Source \ BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(mpl::int_<-1>) \ > \ { \ typedef CV_ Dest type; \ }; \ /**/ BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_SUBSTITUTE_TAG( BOOST_PP_EMPTY() ) BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_SUBSTITUTE_TAG(const) BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_SUBSTITUTE_TAG(volatile) BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_SUBSTITUTE_TAG(const volatile) #undef BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_SUBSTITUTE_TAG // // pointer specializations // #define BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_HANDLE_POINTER(CV_) \ template <typename T, typename Dest, typename Source> \ struct substitute< \ T * CV_ \ , Dest \ , Source \ BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(mpl::int_<-1>) \ > \ { \ typedef typename substitute< \ T, Dest, Source \ >::type * CV_ type; \ }; \ /**/ BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_HANDLE_POINTER( BOOST_PP_EMPTY() ) BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_HANDLE_POINTER(const) BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_HANDLE_POINTER(volatile) BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_HANDLE_POINTER(const volatile) #undef BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_HANDLE_POINTER // // reference specializations // template <typename T, typename Dest, typename Source> struct substitute< T& , Dest , Source BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(mpl::int_<-1>) > { typedef typename substitute< T, Dest, Source >::type & type; }; // // template expression (i.e., F<...>) specializations // #define BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF_IMPL(N) \ typedef typename substitute< \ BOOST_PP_CAT(U,N), Dest, Source \ >::type BOOST_PP_CAT(u,N); \ /**/ #define BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF(z, N, _) \ BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF_IMPL( BOOST_PP_INC(N) ) \ /**/ #define BOOST_PP_ITERATION_LIMITS (0,BOOST_MPL_LIMIT_METAFUNCTION_ARITY) #define BOOST_PP_FILENAME_1 "boost/variant/detail/substitute.hpp" #include BOOST_PP_ITERATE() #undef BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF_IMPL #undef BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF #endif // !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE) }} // namespace detail::variant } // namespace boost #endif // BOOST_VARIANT_DETAIL_SUBSTITUTE_HPP ///// iteration, depth == 1 #elif BOOST_PP_ITERATION_DEPTH() == 1 #define i BOOST_PP_FRAME_ITERATION(1) #if i > 0 // // template specializations // template < template < BOOST_MPL_PP_PARAMS(i,typename P) > class T , BOOST_MPL_PP_PARAMS(i,typename U) , typename Dest , typename Source > struct substitute< T< BOOST_MPL_PP_PARAMS(i,U) > , Dest , Source BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(mpl::int_<( i )>) > { private: BOOST_MPL_PP_REPEAT(i, BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF, _) public: typedef T< BOOST_MPL_PP_PARAMS(i,u) > type; }; // // function specializations // template < typename R , BOOST_MPL_PP_PARAMS(i,typename U) , typename Dest , typename Source > struct substitute< R (*)( BOOST_MPL_PP_PARAMS(i,U) ) , Dest , Source BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(mpl::int_<-1>) > { private: typedef typename substitute< R, Dest, Source >::type r; BOOST_MPL_PP_REPEAT(i, BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF, _) public: typedef r (*type)( BOOST_MPL_PP_PARAMS(i,u) ); }; #elif i == 0 // // zero-arg function specialization // template < typename R, typename Dest, typename Source > struct substitute< R (*)( void ) , Dest , Source BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(mpl::int_<-1>) > { private: typedef typename substitute< R, Dest, Source >::type r; public: typedef r (*type)( void ); }; #endif // i #undef i #endif // BOOST_PP_IS_ITERATING