epoc32/include/stdapis/boost/variant/variant_fwd.hpp
author William Roberts <williamr@symbian.org>
Wed, 31 Mar 2010 12:33:34 +0100
branchSymbian3
changeset 4 837f303aceeb
permissions -rw-r--r--
Current Symbian^3 public API header files (from PDK 3.0.h)
This is the epoc32/include tree with the "platform" subtrees removed, and
all but a selected few mbg and rsg files removed.
     1 //-----------------------------------------------------------------------------
     2 // boost variant/variant_fwd.hpp header file
     3 // See http://www.boost.org for updates, documentation, and revision history.
     4 //-----------------------------------------------------------------------------
     5 //
     6 // Copyright (c) 2003
     7 // Eric Friedman, Itay Maman
     8 //
     9 // Distributed under the Boost Software License, Version 1.0. (See
    10 // accompanying file LICENSE_1_0.txt or copy at
    11 // http://www.boost.org/LICENSE_1_0.txt)
    12 
    13 #ifndef BOOST_VARIANT_VARIANT_FWD_HPP
    14 #define BOOST_VARIANT_VARIANT_FWD_HPP
    15 
    16 #include "boost/variant/detail/config.hpp"
    17 
    18 #include "boost/blank_fwd.hpp"
    19 #include "boost/mpl/arg.hpp"
    20 #include "boost/mpl/limits/arity.hpp"
    21 #include "boost/mpl/aux_/na.hpp"
    22 #include "boost/preprocessor/cat.hpp"
    23 #include "boost/preprocessor/enum.hpp"
    24 #include "boost/preprocessor/enum_params.hpp"
    25 #include "boost/preprocessor/enum_shifted_params.hpp"
    26 #include "boost/preprocessor/repeat.hpp"
    27 
    28 ///////////////////////////////////////////////////////////////////////////////
    29 // macro BOOST_VARIANT_LIMIT_TYPES
    30 //
    31 // Implementation-defined preprocessor symbol describing the actual
    32 // length of variant's pseudo-variadic template parameter list.
    33 //
    34 #include "boost/mpl/limits/list.hpp"
    35 #define BOOST_VARIANT_LIMIT_TYPES \
    36     BOOST_MPL_LIMIT_LIST_SIZE
    37 
    38 ///////////////////////////////////////////////////////////////////////////////
    39 // macro BOOST_VARIANT_NO_REFERENCE_SUPPORT
    40 //
    41 // Defined if variant does not support references as bounded types. 
    42 //
    43 #if defined(BOOST_VARIANT_AUX_BROKEN_CONSTRUCTOR_TEMPLATE_ORDERING) \
    44  && !defined(BOOST_VARIANT_AUX_HAS_CONSTRUCTOR_TEMPLATE_ORDERING_SFINAE_WKND) \
    45  && !defined(BOOST_VARIANT_NO_REFERENCE_SUPPORT)
    46 #   define BOOST_VARIANT_NO_REFERENCE_SUPPORT
    47 #endif
    48 
    49 ///////////////////////////////////////////////////////////////////////////////
    50 // macro BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT
    51 //
    52 // Defined if variant does not support make_variant_over (see below). 
    53 //
    54 #if defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
    55 #   define BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT
    56 #endif
    57 
    58 ///////////////////////////////////////////////////////////////////////////////
    59 // macro BOOST_VARIANT_NO_FULL_RECURSIVE_VARIANT_SUPPORT
    60 //
    61 // Defined if make_recursive_variant cannot be supported as documented.
    62 //
    63 // Note: Currently, MPL lambda facility is used as workaround if defined, and
    64 // so only types declared w/ MPL lambda workarounds will work.
    65 //
    66 
    67 #include "boost/variant/detail/substitute_fwd.hpp"
    68 
    69 #if defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE) \
    70  && !defined(BOOST_VARIANT_NO_FULL_RECURSIVE_VARIANT_SUPPORT)
    71 #   define BOOST_VARIANT_NO_FULL_RECURSIVE_VARIANT_SUPPORT
    72 #endif
    73 
    74 ///////////////////////////////////////////////////////////////////////////////
    75 // macro BOOST_VARIANT_RECURSIVE_VARIANT_MAX_ARITY
    76 //
    77 // Exposes maximum allowed arity of class templates with recursive_variant
    78 // arguments. That is,
    79 //   make_recursive_variant< ..., T<[1], recursive_variant_, ... [N]> >.
    80 //
    81 #include "boost/mpl/limits/arity.hpp"
    82 #define BOOST_VARIANT_RECURSIVE_VARIANT_MAX_ARITY \
    83     BOOST_MPL_LIMIT_METAFUNCTION_ARITY
    84 
    85 ///////////////////////////////////////////////////////////////////////////////
    86 // macro BOOST_VARIANT_ENUM_PARAMS
    87 //
    88 // Convenience macro for enumeration of BOOST_VARIANT_LIMIT_TYPES params.
    89 //
    90 // Rationale: Cleaner, simpler code for clients of variant library.
    91 //
    92 #define BOOST_VARIANT_ENUM_PARAMS( param )  \
    93     BOOST_PP_ENUM_PARAMS(BOOST_VARIANT_LIMIT_TYPES, param)
    94 
    95 ///////////////////////////////////////////////////////////////////////////////
    96 // macro BOOST_VARIANT_ENUM_SHIFTED_PARAMS
    97 //
    98 // Convenience macro for enumeration of BOOST_VARIANT_LIMIT_TYPES-1 params.
    99 //
   100 #define BOOST_VARIANT_ENUM_SHIFTED_PARAMS( param )  \
   101     BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_VARIANT_LIMIT_TYPES, param)
   102 
   103 
   104 namespace boost {
   105 
   106 namespace detail { namespace variant {
   107 
   108 ///////////////////////////////////////////////////////////////////////////////
   109 // (detail) class void_ and class template convert_void
   110 // 
   111 // Provides the mechanism by which void(NN) types are converted to
   112 // mpl::void_ (and thus can be passed to mpl::list).
   113 //
   114 // Rationale: This is particularly needed for the using-declarations
   115 // workaround (below), but also to avoid associating mpl namespace with
   116 // variant in argument dependent lookups (which used to happen because of
   117 // defaulting of template parameters to mpl::void_).
   118 //
   119 
   120 struct void_;
   121 
   122 template <typename T>
   123 struct convert_void
   124 {
   125     typedef T type;
   126 };
   127 
   128 template <>
   129 struct convert_void< void_ >
   130 {
   131     typedef mpl::na type;
   132 };
   133 
   134 ///////////////////////////////////////////////////////////////////////////////
   135 // (workaround) BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE
   136 //
   137 // Needed to work around compilers that don't support using-declaration
   138 // overloads. (See the variant::initializer workarounds below.)
   139 //
   140 
   141 #if defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
   142 
   143 // (detail) tags voidNN -- NN defined on [0, BOOST_VARIANT_LIMIT_TYPES)
   144 //
   145 // Defines void types that are each unique and specializations of
   146 // convert_void that yields mpl::na for each voidNN type.
   147 //
   148 
   149 #define BOOST_VARIANT_DETAIL_DEFINE_VOID_N(z,N,_)          \
   150     struct BOOST_PP_CAT(void,N);                           \
   151                                                            \
   152     template <>                                            \
   153     struct convert_void< BOOST_PP_CAT(void,N) >            \
   154     {                                                      \
   155         typedef mpl::na type;                              \
   156     };                                                     \
   157     /**/
   158 
   159 BOOST_PP_REPEAT(
   160       BOOST_VARIANT_LIMIT_TYPES
   161     , BOOST_VARIANT_DETAIL_DEFINE_VOID_N
   162     , _
   163     )
   164 
   165 #undef BOOST_VARIANT_DETAIL_DEFINE_VOID_N
   166 
   167 #endif // BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE workaround
   168 
   169 }} // namespace detail::variant
   170 
   171 ///////////////////////////////////////////////////////////////////////////////
   172 // (detail) macro BOOST_VARIANT_AUX_DECLARE_PARAM
   173 //
   174 // Template parameter list for variant and recursive_variant declarations.
   175 //
   176 
   177 #if !defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
   178 
   179 #   define BOOST_VARIANT_AUX_DECLARE_PARAMS_IMPL(z, N, T) \
   180     typename BOOST_PP_CAT(T,N) = detail::variant::void_ \
   181     /**/
   182 
   183 #else // defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
   184 
   185 #   define BOOST_VARIANT_AUX_DECLARE_PARAMS_IMPL(z, N, T) \
   186     typename BOOST_PP_CAT(T,N) = BOOST_PP_CAT(detail::variant::void,N) \
   187     /**/
   188 
   189 #endif // BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE workaround
   190 
   191 #define BOOST_VARIANT_AUX_DECLARE_PARAMS \
   192     BOOST_PP_ENUM( \
   193           BOOST_VARIANT_LIMIT_TYPES \
   194         , BOOST_VARIANT_AUX_DECLARE_PARAMS_IMPL \
   195         , T \
   196         ) \
   197     /**/
   198 
   199 ///////////////////////////////////////////////////////////////////////////////
   200 // class template variant (concept inspired by Andrei Alexandrescu)
   201 //
   202 // Efficient, type-safe bounded discriminated union.
   203 //
   204 // Preconditions:
   205 //  - Each type must be unique.
   206 //  - No type may be const-qualified.
   207 //
   208 // Proper declaration form:
   209 //   variant<types>    (where types is a type-sequence)
   210 // or
   211 //   variant<T0,T1,...,Tn>  (where T0 is NOT a type-sequence)
   212 //
   213 template < BOOST_VARIANT_AUX_DECLARE_PARAMS > class variant;
   214 
   215 ///////////////////////////////////////////////////////////////////////////////
   216 // metafunction make_recursive_variant
   217 //
   218 // Exposes a boost::variant with recursive_variant_ tags (below) substituted
   219 // with the variant itself (wrapped as needed with boost::recursive_wrapper).
   220 //
   221 template < BOOST_VARIANT_AUX_DECLARE_PARAMS > struct make_recursive_variant;
   222 
   223 #undef BOOST_VARIANT_AUX_DECLARE_PARAMS_IMPL
   224 #undef BOOST_VARIANT_AUX_DECLARE_PARAMS
   225 
   226 ///////////////////////////////////////////////////////////////////////////////
   227 // type recursive_variant_
   228 //
   229 // Tag type indicates where recursive variant substitution should occur.
   230 //
   231 #if !defined(BOOST_VARIANT_NO_FULL_RECURSIVE_VARIANT_SUPPORT)
   232     struct recursive_variant_;
   233 #else
   234     typedef mpl::arg<1> recursive_variant_;
   235 #endif
   236 
   237 ///////////////////////////////////////////////////////////////////////////////
   238 // metafunction make_variant_over
   239 //
   240 // Result is a variant w/ types of the specified type sequence.
   241 //
   242 template <typename Types> struct make_variant_over;
   243 
   244 ///////////////////////////////////////////////////////////////////////////////
   245 // metafunction make_recursive_variant_over
   246 //
   247 // Result is a recursive variant w/ types of the specified type sequence.
   248 //
   249 template <typename Types> struct make_recursive_variant_over;
   250 
   251 } // namespace boost
   252 
   253 #endif // BOOST_VARIANT_VARIANT_FWD_HPP