epoc32/include/stdapis/boost/variant/detail/initializer.hpp
author William Roberts <williamr@symbian.org>
Wed, 31 Mar 2010 12:27:01 +0100
branchSymbian2
changeset 3 e1b950c65cb4
permissions -rw-r--r--
Attempt to represent the S^2->S^3 header reorganisation as a series of "hg rename" operations
williamr@2
     1
//-----------------------------------------------------------------------------
williamr@2
     2
// boost variant/detail/initializer.hpp header file
williamr@2
     3
// See http://www.boost.org for updates, documentation, and revision history.
williamr@2
     4
//-----------------------------------------------------------------------------
williamr@2
     5
//
williamr@2
     6
// Copyright (c) 2002-2003
williamr@2
     7
// Eric Friedman, Itay Maman
williamr@2
     8
//
williamr@2
     9
// Distributed under the Boost Software License, Version 1.0. (See
williamr@2
    10
// accompanying file LICENSE_1_0.txt or copy at
williamr@2
    11
// http://www.boost.org/LICENSE_1_0.txt)
williamr@2
    12
williamr@2
    13
#ifndef BOOST_VARIANT_DETAIL_INITIALIZER_HPP
williamr@2
    14
#define BOOST_VARIANT_DETAIL_INITIALIZER_HPP
williamr@2
    15
williamr@2
    16
#include <new> // for placement new
williamr@2
    17
williamr@2
    18
#include "boost/config.hpp"
williamr@2
    19
williamr@2
    20
#include "boost/call_traits.hpp"
williamr@2
    21
#include "boost/detail/reference_content.hpp"
williamr@2
    22
#include "boost/variant/recursive_wrapper_fwd.hpp"
williamr@2
    23
williamr@2
    24
#if !defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
williamr@2
    25
#   include "boost/mpl/aux_/value_wknd.hpp"
williamr@2
    26
#   include "boost/mpl/int.hpp"
williamr@2
    27
#   include "boost/mpl/iter_fold.hpp"
williamr@2
    28
#   include "boost/mpl/next.hpp"
williamr@2
    29
#   include "boost/mpl/deref.hpp"
williamr@2
    30
#   include "boost/mpl/pair.hpp"
williamr@2
    31
#   include "boost/mpl/protect.hpp"
williamr@2
    32
#else
williamr@2
    33
#   include "boost/variant/variant_fwd.hpp"
williamr@2
    34
#   include "boost/preprocessor/cat.hpp"
williamr@2
    35
#   include "boost/preprocessor/enum.hpp"
williamr@2
    36
#   include "boost/preprocessor/repeat.hpp"
williamr@2
    37
#endif
williamr@2
    38
williamr@2
    39
namespace boost {
williamr@2
    40
namespace detail { namespace variant {
williamr@2
    41
williamr@2
    42
///////////////////////////////////////////////////////////////////////////////
williamr@2
    43
// (detail) support to simulate standard overload resolution rules
williamr@2
    44
//
williamr@2
    45
// The below initializers allows variant to follow standard overload
williamr@2
    46
// resolution rules over the specified set of bounded types.
williamr@2
    47
//
williamr@2
    48
// On compilers where using declarations in class templates can correctly
williamr@2
    49
// avoid name hiding, use an optimal solution based on the variant's typelist.
williamr@2
    50
//
williamr@2
    51
// Otherwise, use a preprocessor workaround based on knowledge of the fixed
williamr@2
    52
// size of the variant's psuedo-variadic template parameter list.
williamr@2
    53
//
williamr@2
    54
williamr@2
    55
#if !defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
williamr@2
    56
williamr@2
    57
// (detail) quoted metafunction make_initializer_node
williamr@2
    58
//
williamr@2
    59
// Exposes a pair whose first type is a node in the initializer hierarchy.
williamr@2
    60
//
williamr@2
    61
struct make_initializer_node
williamr@2
    62
{
williamr@2
    63
    template <typename BaseIndexPair, typename Iterator>
williamr@2
    64
    struct apply
williamr@2
    65
    {
williamr@2
    66
    private: // helpers, for metafunction result (below)
williamr@2
    67
williamr@2
    68
        typedef typename BaseIndexPair::first
williamr@2
    69
            base;
williamr@2
    70
        typedef typename BaseIndexPair::second
williamr@2
    71
            index;
williamr@2
    72
williamr@2
    73
        class initializer_node
williamr@2
    74
            : public base
williamr@2
    75
        {
williamr@2
    76
        private: // helpers, for static functions (below)
williamr@2
    77
williamr@2
    78
            typedef typename mpl::deref<Iterator>::type
williamr@2
    79
                recursive_enabled_T;
williamr@2
    80
            typedef typename unwrap_recursive<recursive_enabled_T>::type
williamr@2
    81
                public_T;
williamr@2
    82
            typedef typename call_traits<public_T>::param_type
williamr@2
    83
                param_T;
williamr@2
    84
williamr@2
    85
        public: // static functions
williamr@2
    86
williamr@2
    87
            using base::initialize;
williamr@2
    88
williamr@2
    89
            static int initialize(void* dest, param_T operand)
williamr@2
    90
            {
williamr@2
    91
                typedef typename boost::detail::make_reference_content<
williamr@2
    92
                      recursive_enabled_T
williamr@2
    93
                    >::type internal_T;
williamr@2
    94
williamr@2
    95
                new(dest) internal_T(operand);
williamr@2
    96
                return BOOST_MPL_AUX_VALUE_WKND(index)::value; // which
williamr@2
    97
            }
williamr@2
    98
williamr@2
    99
        };
williamr@2
   100
williamr@2
   101
        friend class initializer_node;
williamr@2
   102
williamr@2
   103
    public: // metafunction result
williamr@2
   104
williamr@2
   105
        typedef mpl::pair<
williamr@2
   106
              initializer_node
williamr@2
   107
            , typename mpl::next< index >::type
williamr@2
   108
            > type;
williamr@2
   109
williamr@2
   110
    };
williamr@2
   111
};
williamr@2
   112
williamr@2
   113
// (detail) class initializer_root
williamr@2
   114
//
williamr@2
   115
// Every level of the initializer hierarchy must expose the name
williamr@2
   116
// "initialize," so initializer_root provides a dummy function:
williamr@2
   117
//
williamr@2
   118
class initializer_root
williamr@2
   119
{
williamr@2
   120
public: // static functions
williamr@2
   121
williamr@2
   122
    static void initialize();
williamr@2
   123
williamr@2
   124
};
williamr@2
   125
williamr@2
   126
#else // defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
williamr@2
   127
williamr@2
   128
#   if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) 
williamr@2
   129
williamr@2
   130
    #define BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_PARAMS \
williamr@2
   131
          BOOST_VARIANT_ENUM_PARAMS(typename recursive_enabled_T) \
williamr@2
   132
    /**/
williamr@2
   133
williamr@2
   134
    #define BOOST_VARIANT_AUX_PP_INITIALIZER_DEFINE_PARAM_T(N) \
williamr@2
   135
        typedef typename unwrap_recursive< \
williamr@2
   136
              BOOST_PP_CAT(recursive_enabled_T,N) \
williamr@2
   137
            >::type BOOST_PP_CAT(public_T,N); \
williamr@2
   138
        typedef typename call_traits< \
williamr@2
   139
              BOOST_PP_CAT(public_T,N) \
williamr@2
   140
            >::param_type BOOST_PP_CAT(param_T,N); \
williamr@2
   141
    /**/
williamr@2
   142
williamr@2
   143
#   else // MSVC7 and below
williamr@2
   144
williamr@2
   145
    #define BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_PARAMS \
williamr@2
   146
          BOOST_VARIANT_ENUM_PARAMS(typename recursive_enabled_T) \
williamr@2
   147
        , BOOST_VARIANT_ENUM_PARAMS(typename param_T) \
williamr@2
   148
    /**/
williamr@2
   149
williamr@2
   150
    #define BOOST_VARIANT_AUX_PP_INITIALIZER_DEFINE_PARAM_T(N) \
williamr@2
   151
    /**/
williamr@2
   152
williamr@2
   153
#   endif // MSVC7 and below workaround
williamr@2
   154
williamr@2
   155
template < BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_PARAMS >
williamr@2
   156
struct preprocessor_list_initializer
williamr@2
   157
{
williamr@2
   158
public: // static functions
williamr@2
   159
williamr@2
   160
    #define BOOST_VARIANT_AUX_PP_INITIALIZE_FUNCTION(z,N,_) \
williamr@2
   161
        BOOST_VARIANT_AUX_PP_INITIALIZER_DEFINE_PARAM_T(N) \
williamr@2
   162
        static int initialize( \
williamr@2
   163
              void* dest \
williamr@2
   164
            , BOOST_PP_CAT(param_T,N) operand \
williamr@2
   165
            ) \
williamr@2
   166
        { \
williamr@2
   167
            typedef typename boost::detail::make_reference_content< \
williamr@2
   168
                  BOOST_PP_CAT(recursive_enabled_T,N) \
williamr@2
   169
                >::type internal_T; \
williamr@2
   170
            \
williamr@2
   171
            new(dest) internal_T(operand); \
williamr@2
   172
            return (N); /*which*/ \
williamr@2
   173
        } \
williamr@2
   174
        /**/
williamr@2
   175
williamr@2
   176
    BOOST_PP_REPEAT(
williamr@2
   177
          BOOST_VARIANT_LIMIT_TYPES
williamr@2
   178
        , BOOST_VARIANT_AUX_PP_INITIALIZE_FUNCTION
williamr@2
   179
        , _
williamr@2
   180
        )
williamr@2
   181
williamr@2
   182
    #undef BOOST_VARIANT_AUX_PP_INITIALIZE_FUNCTION
williamr@2
   183
williamr@2
   184
};
williamr@2
   185
williamr@2
   186
#   if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG)
williamr@2
   187
williamr@2
   188
#if !defined(BOOST_VARIANT_AUX_ECHO)
williamr@2
   189
#   define BOOST_VARIANT_AUX_ECHO(z,N,token) token
williamr@2
   190
#endif
williamr@2
   191
williamr@2
   192
template <>
williamr@2
   193
struct preprocessor_list_initializer<
williamr@2
   194
      BOOST_PP_ENUM(BOOST_VARIANT_LIMIT_TYPES, BOOST_VARIANT_AUX_ECHO, int)
williamr@2
   195
    , BOOST_PP_ENUM(BOOST_VARIANT_LIMIT_TYPES, BOOST_VARIANT_AUX_ECHO, const int)
williamr@2
   196
    >
williamr@2
   197
{
williamr@2
   198
};
williamr@2
   199
williamr@2
   200
#   endif // BOOST_MPL_CFG_MSVC_60_ETI_BUG workaround
williamr@2
   201
williamr@2
   202
#endif // BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE workaround
williamr@2
   203
williamr@2
   204
}} // namespace detail::variant
williamr@2
   205
} // namespace boost
williamr@2
   206
williamr@2
   207
///////////////////////////////////////////////////////////////////////////////
williamr@2
   208
// macro BOOST_VARIANT_AUX_INITIALIZER_T
williamr@2
   209
//
williamr@2
   210
// Given both the variant's typelist and a basename for forming the list of
williamr@2
   211
// bounded types (i.e., T becomes T1, T2, etc.), exposes the initializer
williamr@2
   212
// most appropriate to the current compiler.
williamr@2
   213
//
williamr@2
   214
williamr@2
   215
#if !defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
williamr@2
   216
williamr@2
   217
#define BOOST_VARIANT_AUX_INITIALIZER_T( mpl_seq, typename_base ) \
williamr@2
   218
    ::boost::mpl::iter_fold< \
williamr@2
   219
          mpl_seq \
williamr@2
   220
        , ::boost::mpl::pair< \
williamr@2
   221
              ::boost::detail::variant::initializer_root \
williamr@2
   222
            , ::boost::mpl::int_<0> \
williamr@2
   223
            > \
williamr@2
   224
        , ::boost::mpl::protect< \
williamr@2
   225
              ::boost::detail::variant::make_initializer_node \
williamr@2
   226
            > \
williamr@2
   227
        >::type::first \
williamr@2
   228
    /**/
williamr@2
   229
williamr@2
   230
#else // defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
williamr@2
   231
williamr@2
   232
#   if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
williamr@2
   233
williamr@2
   234
    #define BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_ARGS(typename_base) \
williamr@2
   235
          BOOST_VARIANT_ENUM_PARAMS(typename_base) \
williamr@2
   236
        /**/
williamr@2
   237
williamr@2
   238
#   else // MSVC7 and below
williamr@2
   239
williamr@2
   240
    #define BOOST_VARIANT_AUX_PP_INITIALIZER_ENUM_PARAM_TYPE(z,N,T) \
williamr@2
   241
        ::boost::call_traits< \
williamr@2
   242
              ::boost::unwrap_recursive<BOOST_PP_CAT(T,N)>::type \
williamr@2
   243
            >::param_type \
williamr@2
   244
        /**/
williamr@2
   245
williamr@2
   246
    #define BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_ARGS(typename_base) \
williamr@2
   247
          BOOST_VARIANT_ENUM_PARAMS(typename_base) \
williamr@2
   248
        , BOOST_PP_ENUM( \
williamr@2
   249
              BOOST_VARIANT_LIMIT_TYPES \
williamr@2
   250
            , BOOST_VARIANT_AUX_PP_INITIALIZER_ENUM_PARAM_TYPE \
williamr@2
   251
            , typename_base \
williamr@2
   252
            ) \
williamr@2
   253
        /**/
williamr@2
   254
williamr@2
   255
#   endif // MSVC7 workaround
williamr@2
   256
williamr@2
   257
#define BOOST_VARIANT_AUX_INITIALIZER_T( mpl_seq, typename_base ) \
williamr@2
   258
    ::boost::detail::variant::preprocessor_list_initializer< \
williamr@2
   259
          BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_ARGS(typename_base) \
williamr@2
   260
        > \
williamr@2
   261
    /**/
williamr@2
   262
williamr@2
   263
#endif // BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE workaround
williamr@2
   264
williamr@2
   265
#endif // BOOST_VARIANT_DETAIL_INITIALIZER_HPP