diff -r 666f914201fb -r 2fe1408b6811 epoc32/include/stdapis/boost/variant/recursive_variant.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/epoc32/include/stdapis/boost/variant/recursive_variant.hpp Tue Mar 16 16:12:26 2010 +0000 @@ -0,0 +1,182 @@ +//----------------------------------------------------------------------------- +// boost variant/recursive_variant.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_RECURSIVE_VARIANT_HPP +#define BOOST_VARIANT_RECURSIVE_VARIANT_HPP + +#include "boost/variant/variant_fwd.hpp" +#include "boost/variant/detail/enable_recursive.hpp" +#include "boost/variant/detail/substitute_fwd.hpp" +#include "boost/variant/detail/make_variant_list.hpp" +#include "boost/variant/detail/over_sequence.hpp" + +#include "boost/mpl/aux_/lambda_arity_param.hpp" + +#if !defined(BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT) +# include "boost/mpl/eval_if.hpp" +# include "boost/mpl/identity.hpp" +# include "boost/mpl/protect.hpp" +# include "boost/mpl/transform.hpp" +#else +# include "boost/preprocessor/cat.hpp" +# include "boost/preprocessor/repeat.hpp" +#endif + +#include "boost/mpl/bool.hpp" +#include "boost/mpl/is_sequence.hpp" +#include "boost/variant/variant.hpp" + +namespace boost { + +namespace detail { namespace variant { + +/////////////////////////////////////////////////////////////////////////////// +// (detail) metafunction specialization substitute +// +// Handles embedded variant types when substituting for recursive_variant_. +// + +#if !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE) + +template < + BOOST_VARIANT_ENUM_PARAMS(typename T) + , typename RecursiveVariant + BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(typename Arity) + > +struct substitute< + ::boost::variant< + recursive_flag< T0 > + , BOOST_VARIANT_ENUM_SHIFTED_PARAMS(T) + > + , RecursiveVariant + , ::boost::recursive_variant_ + BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(Arity) + > +{ + typedef ::boost::variant< + recursive_flag< T0 > + , BOOST_VARIANT_ENUM_SHIFTED_PARAMS(T) + > type; +}; + +template < + BOOST_VARIANT_ENUM_PARAMS(typename T) + , typename RecursiveVariant + BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(typename Arity) + > +struct substitute< + ::boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) > + , RecursiveVariant + , ::boost::recursive_variant_ + BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(Arity) + > +{ + +#if !defined(BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT) + +private: // helpers, for metafunction result (below) + + typedef typename mpl::eval_if< + ::boost::detail::variant::is_over_sequence + , mpl::identity< T0 > + , make_variant_list< BOOST_VARIANT_ENUM_PARAMS(T) > + >::type initial_types; + + typedef typename mpl::transform< + initial_types + , mpl::protect< quoted_enable_recursive > + >::type types; + +public: // metafunction result + + typedef ::boost::variant< types > type; + +#else // defined(BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT) + +private: // helpers, for metafunction result (below) + + #define BOOST_VARIANT_AUX_ENABLE_RECURSIVE_TYPEDEFS(z,N,_) \ + typedef typename enable_recursive< \ + BOOST_PP_CAT(T,N) \ + , RecursiveVariant \ + , mpl::true_ \ + >::type BOOST_PP_CAT(wknd_T,N); \ + /**/ + + BOOST_PP_REPEAT( + BOOST_VARIANT_LIMIT_TYPES + , BOOST_VARIANT_AUX_ENABLE_RECURSIVE_TYPEDEFS + , _ + ) + + #undef BOOST_VARIANT_AUX_ENABLE_RECURSIVE_TYPEDEFS + +public: // metafunction result + + typedef ::boost::variant< BOOST_VARIANT_ENUM_PARAMS(wknd_T) > type; + +#endif // BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT workaround + +}; + +#else // defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE) + +// +// no specializations: embedded variants unsupported on these compilers! +// + +#endif // !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE) + +}} // namespace detail::variant + +/////////////////////////////////////////////////////////////////////////////// +// metafunction make_recursive_variant +// +// See docs and boost/variant/variant_fwd.hpp for more information. +// +template < BOOST_VARIANT_ENUM_PARAMS(typename T) > +struct make_recursive_variant +{ +public: // metafunction result + + typedef boost::variant< + detail::variant::recursive_flag< T0 > + , BOOST_VARIANT_ENUM_SHIFTED_PARAMS(T) + > type; + +}; + +/////////////////////////////////////////////////////////////////////////////// +// metafunction make_recursive_variant_over +// +// See docs and boost/variant/variant_fwd.hpp for more information. +// +template +struct make_recursive_variant_over +{ +private: // precondition assertions + +#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) + BOOST_STATIC_ASSERT(( ::boost::mpl::is_sequence::value )); +#endif + +public: // metafunction result + + typedef typename make_recursive_variant< + detail::variant::over_sequence< Types > + >::type type; + +}; + +} // namespace boost + +#endif // BOOST_VARIANT_RECURSIVE_VARIANT_HPP