ceph/src/boost/libs/fusion/include/boost/fusion/adapted/adt/detail/adapt_base.hpp

   1 /*=============================================================================
   2     Copyright (c) 2001-2009 Joel de Guzman
   3     Copyright (c) 2005-2006 Dan Marsden
   4     Copyright (c) 2010 Christopher Schmidt
   5
   6     Distributed under the Boost Software License, Version 1.0. (See accompanying
   7     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   8 ==============================================================================*/
   9
  10 #ifndef BOOST_FUSION_ADAPTED_ADT_DETAIL_ADAPT_BASE_HPP
  11 #define BOOST_FUSION_ADAPTED_ADT_DETAIL_ADAPT_BASE_HPP
  12
  13 #include <boost/fusion/support/config.hpp>
  14 #include <boost/fusion/adapted/struct/detail/adapt_auto.hpp>
  15 #include <boost/fusion/adapted/struct/detail/adapt_is_tpl.hpp>
  16
  17 #include <boost/preprocessor/control/if.hpp>
  18 #include <boost/preprocessor/control/expr_if.hpp>
  19 #include <boost/preprocessor/seq/seq.hpp>
  20 #include <boost/preprocessor/seq/elem.hpp>
  21 #include <boost/preprocessor/tuple/elem.hpp>
  22 #include <boost/mpl/if.hpp>
  23 #include <boost/type_traits/is_const.hpp>
  24 #include <boost/type_traits/add_const.hpp>
  25 #include <boost/type_traits/remove_const.hpp>
  26
  27 #include <boost/typeof/typeof.hpp>
  28
  29 #define BOOST_FUSION_ADAPT_ADT_GET_IDENTITY_TEMPLATE_IMPL(TEMPLATE_PARAMS_SEQ)  \
  30     typename detail::get_identity<                                              \
  31         lvalue                                                                  \
  32       , BOOST_PP_SEQ_ELEM(1,TEMPLATE_PARAMS_SEQ)                                \
  33     >::type
  34
  35 #define BOOST_FUSION_ADAPT_ADT_GET_IDENTITY_NON_TEMPLATE_IMPL(                  \
  36     TEMPLATE_PARAMS_SEQ)                                                        \
  37                                                                                 \
  38     boost::remove_const<boost::remove_reference<lvalue>::type>::type
  39
  40 #define BOOST_FUSION_ADAPT_ADT_ATTRIBUTE_GETEXPR(ATTRIBUTE,                     \
  41     ATTRIBUTE_TUPLE_SIZE, DEDUCE_TYPE)                                          \
  42     BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,                                   \
  43         BOOST_PP_IF(DEDUCE_TYPE, 0, 2), ATTRIBUTE)
  44
  45 #define BOOST_FUSION_ADAPT_ADT_ATTRIBUTE_SETEXPR(ATTRIBUTE,                     \
  46     ATTRIBUTE_TUPLE_SIZE, DEDUCE_TYPE)                                          \
  47     BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,                                   \
  48         BOOST_PP_IF(DEDUCE_TYPE, 1, 3), ATTRIBUTE)
  49
  50 #ifdef BOOST_MSVC
  51 #   define BOOST_FUSION_DEDUCED_ATTR_TYPE(NAME_SEQ, ATTRIBUTE,                  \
  52         ATTRIBUTE_TUPLE_SIZE, PREFIX, TEMPLATE_PARAMS_SEQ)                      \
  53                                                                                 \
  54     BOOST_FUSION_ADAPT_STRUCT_MSVC_REDEFINE_TEMPLATE_PARAMS(                    \
  55         TEMPLATE_PARAMS_SEQ)                                                    \
  56                                                                                 \
  57     struct deduced_attr_type {                                                  \
  58       static const BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)& obj;        \
  59       typedef                                                                   \
  60           BOOST_PP_EXPR_IF(BOOST_FUSION_ADAPT_IS_TPL(TEMPLATE_PARAMS_SEQ),      \
  61                            typename)                                            \
  62           BOOST_TYPEOF( PREFIX() BOOST_FUSION_ADAPT_ADT_ATTRIBUTE_GETEXPR(      \
  63               ATTRIBUTE, ATTRIBUTE_TUPLE_SIZE, 1)) type;                        \
  64     };
  65
  66 #else
  67 #   define BOOST_FUSION_DEDUCED_ATTR_TYPE(NAME_SEQ, ATTRIBUTE,                  \
  68         ATTRIBUTE_TUPLE_SIZE, PREFIX, TEMPLATE_PARAMS_SEQ)                      \
  69     struct deduced_attr_type {                                                  \
  70       static const BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)& obj;        \
  71       typedef BOOST_TYPEOF( PREFIX() BOOST_FUSION_ADAPT_ADT_ATTRIBUTE_GETEXPR(  \
  72                       ATTRIBUTE, ATTRIBUTE_TUPLE_SIZE, 1)) type;                \
  73     };
  74
  75 #endif
  76
  77 #define BOOST_FUSION_ADT_ATTRIBUTE_TYPEOF(                                      \
  78     NAME_SEQ, ATTRIBUTE, ATTRIBUTE_TUPLE_SIZE, PREFIX, TEMPLATE_PARAMS_SEQ)     \
  79                                                                                 \
  80     BOOST_FUSION_DEDUCED_ATTR_TYPE(                                             \
  81         NAME_SEQ, ATTRIBUTE, ATTRIBUTE_TUPLE_SIZE, PREFIX, TEMPLATE_PARAMS_SEQ) \
  82                                                                                 \
  83     typedef                                                                     \
  84         BOOST_PP_EXPR_IF(BOOST_FUSION_ADAPT_IS_TPL(TEMPLATE_PARAMS_SEQ),        \
  85                          typename)                                              \
  86         boost::remove_const<                                                    \
  87           BOOST_PP_EXPR_IF(BOOST_FUSION_ADAPT_IS_TPL(TEMPLATE_PARAMS_SEQ),      \
  88                            typename) \
  89           deduced_attr_type::type                                               \
  90         >::type type;                                                           \
  91                                                                                 \
  92     typedef                                                                     \
  93         BOOST_PP_EXPR_IF(BOOST_FUSION_ADAPT_IS_TPL(TEMPLATE_PARAMS_SEQ),        \
  94                          typename)   \
  95         boost::add_const<                                                       \
  96           BOOST_PP_EXPR_IF(BOOST_FUSION_ADAPT_IS_TPL(TEMPLATE_PARAMS_SEQ),      \
  97                            typename) \
  98           deduced_attr_type::type                                               \
  99     >::type const_type;
 100
 101 #define BOOST_FUSION_ADT_ATTRIBUTE_GIVENTYPE(                                   \
 102     NAME_SEQ, ATTRIBUTE, ATTRIBUTE_TUPLE_SIZE, PREFIX, TEMPLATE_PARAMS_SEQ)     \
 103                                                                                 \
 104     typedef BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE, 0, ATTRIBUTE) type;       \
 105     typedef BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE, 1, ATTRIBUTE) const_type;
 106
 107
 108 #define BOOST_FUSION_ADAPT_ADT_C_BASE(                                          \
 109     TEMPLATE_PARAMS_SEQ,NAME_SEQ,I,PREFIX,                                      \
 110     ATTRIBUTE,ATTRIBUTE_TUPLE_SIZE, DEDUCE_TYPE)                                \
 111                                                                                 \
 112     template<                                                                   \
 113         BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS(TEMPLATE_PARAMS_SEQ)   \
 114     >                                                                           \
 115     struct access::adt_attribute_access<                                        \
 116         BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)                         \
 117       , I                                                                       \
 118     >                                                                           \
 119     {                                                                           \
 120                                                                                 \
 121         BOOST_PP_IF(DEDUCE_TYPE,                                                \
 122             BOOST_FUSION_ADT_ATTRIBUTE_TYPEOF,                                  \
 123             BOOST_FUSION_ADT_ATTRIBUTE_GIVENTYPE)(                              \
 124                 NAME_SEQ,                                                       \
 125                 ATTRIBUTE,                                                      \
 126                 ATTRIBUTE_TUPLE_SIZE,                                           \
 127                 PREFIX,                                                         \
 128                 TEMPLATE_PARAMS_SEQ)                                            \
 129                                                                                 \
 130         template<class Val>                                                     \
 131         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED                          \
 132         static void                                                             \
 133         boost_fusion_adapt_adt_impl_set(                                        \
 134             BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)& obj,               \
 135             Val const& val)                                                     \
 136         {                                                                       \
 137            PREFIX() BOOST_FUSION_ADAPT_ADT_ATTRIBUTE_SETEXPR(ATTRIBUTE,         \
 138                 ATTRIBUTE_TUPLE_SIZE, DEDUCE_TYPE);                             \
 139         }                                                                       \
 140                                                                                 \
 141         BOOST_FUSION_GPU_ENABLED                                                \
 142         static type                                                             \
 143         boost_fusion_adapt_adt_impl_get(                                        \
 144             BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)& obj)               \
 145         {                                                                       \
 146             return PREFIX() BOOST_FUSION_ADAPT_ADT_ATTRIBUTE_GETEXPR(ATTRIBUTE, \
 147                 ATTRIBUTE_TUPLE_SIZE, DEDUCE_TYPE);                             \
 148         }                                                                       \
 149                                                                                 \
 150         BOOST_FUSION_GPU_ENABLED                                                \
 151         static const_type                                                       \
 152         boost_fusion_adapt_adt_impl_get(                                        \
 153             BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ) const& obj)         \
 154         {                                                                       \
 155             return PREFIX() BOOST_FUSION_ADAPT_ADT_ATTRIBUTE_GETEXPR(ATTRIBUTE, \
 156                 ATTRIBUTE_TUPLE_SIZE, DEDUCE_TYPE);                             \
 157         }                                                                       \
 158     };                                                                          \
 159                                                                                 \
 160     template<                                                                   \
 161         BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS(TEMPLATE_PARAMS_SEQ)   \
 162     >                                                                           \
 163     struct adt_attribute_proxy<                                                 \
 164         BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)                         \
 165       , I                                                                       \
 166       , true                                                                    \
 167     >                                                                           \
 168     {                                                                           \
 169         typedef                                                                 \
 170             BOOST_PP_EXPR_IF(BOOST_PP_SEQ_HEAD(TEMPLATE_PARAMS_SEQ), typename)  \
 171             access::adt_attribute_access<                                       \
 172                 BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)                 \
 173               , I                                                               \
 174             >::const_type type;                                                 \
 175                                                                                 \
 176         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED                                \
 177         explicit                                                                \
 178         adt_attribute_proxy(                                                    \
 179             BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ) const& o)           \
 180           : obj(&o)                                                             \
 181         {}                                                                      \
 182                                                                                 \
 183         BOOST_FUSION_GPU_ENABLED                                                \
 184         type get() const                                                        \
 185         {                                                                       \
 186             return access::adt_attribute_access<                                \
 187                 BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)                 \
 188               , I                                                               \
 189             >::boost_fusion_adapt_adt_impl_get(*obj);                           \
 190         }                                                                       \
 191                                                                                 \
 192         BOOST_FUSION_GPU_ENABLED                                                \
 193         operator type() const                                                   \
 194         {                                                                       \
 195             return get();                                                       \
 196         }                                                                       \
 197                                                                                 \
 198         BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ) const* obj;             \
 199     };                                                                          \
 200                                                                                 \
 201     template<                                                                   \
 202         BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS(TEMPLATE_PARAMS_SEQ)   \
 203     >                                                                           \
 204     struct adt_attribute_proxy<                                                 \
 205         BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)                         \
 206       , I                                                                       \
 207       , false                                                                   \
 208     >                                                                           \
 209     {                                                                           \
 210         typedef                                                                 \
 211             BOOST_PP_EXPR_IF(BOOST_PP_SEQ_HEAD(TEMPLATE_PARAMS_SEQ), typename)  \
 212             access::adt_attribute_access<                                       \
 213                 BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)                 \
 214               , I                                                               \
 215             >::type type;                                                       \
 216                                                                                 \
 217         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED                                \
 218         explicit                                                                \
 219         adt_attribute_proxy(                                                    \
 220             BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)& o)                 \
 221           : obj(&o)                                                             \
 222         {}                                                                      \
 223                                                                                 \
 224         template<class Val>                                                     \
 225         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED                          \
 226         adt_attribute_proxy&                                                    \
 227         operator=(Val const& val)                                               \
 228         {                                                                       \
 229             access::adt_attribute_access<                                       \
 230                 BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)                 \
 231               , I                                                               \
 232             >::boost_fusion_adapt_adt_impl_set(*obj, val);                      \
 233             return *this;                                                       \
 234         }                                                                       \
 235                                                                                 \
 236         BOOST_FUSION_GPU_ENABLED                                                \
 237         type get() const                                                        \
 238         {                                                                       \
 239             return access::adt_attribute_access<                                \
 240                 BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)                 \
 241               , I                                                               \
 242             >::boost_fusion_adapt_adt_impl_get(*obj);                           \
 243         }                                                                       \
 244                                                                                 \
 245         BOOST_FUSION_GPU_ENABLED                                                \
 246         operator type() const                                                   \
 247         {                                                                       \
 248             return get();                                                       \
 249         }                                                                       \
 250                                                                                 \
 251         BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)* obj;                   \
 252     };                                                                          \
 253                                                                                 \
 254     template<                                                                   \
 255         BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS(TEMPLATE_PARAMS_SEQ)   \
 256     >                                                                           \
 257     struct access::struct_member<                                               \
 258         BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)                         \
 259       , I                                                                       \
 260     >                                                                           \
 261     {                                                                           \
 262         typedef BOOST_PP_EXPR_IF(BOOST_PP_SEQ_HEAD(TEMPLATE_PARAMS_SEQ),        \
 263                                  typename)                                      \
 264             adt_attribute_proxy<                                                \
 265                           BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)       \
 266                         , I                                                     \
 267                         , false                                                 \
 268                       >::type lvalue;                                           \
 269                                                                                 \
 270         BOOST_FUSION_ADAPT_STRUCT_MSVC_REDEFINE_TEMPLATE_PARAMS(                \
 271             TEMPLATE_PARAMS_SEQ)                                                \
 272                                                                                 \
 273         typedef                                                                 \
 274             BOOST_PP_IF(                                                        \
 275                 BOOST_PP_SEQ_HEAD(TEMPLATE_PARAMS_SEQ),                         \
 276                 BOOST_FUSION_ADAPT_ADT_GET_IDENTITY_TEMPLATE_IMPL,              \
 277                 BOOST_FUSION_ADAPT_ADT_GET_IDENTITY_NON_TEMPLATE_IMPL)(         \
 278                     TEMPLATE_PARAMS_SEQ)                                        \
 279         type;                                                                   \
 280                                                                                 \
 281         template<typename Seq>                                                  \
 282         struct apply                                                            \
 283         {                                                                       \
 284             typedef                                                             \
 285                 adt_attribute_proxy<                                            \
 286                     BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)             \
 287                   , I                                                           \
 288                   , is_const<Seq>::value                                        \
 289                 >                                                               \
 290             type;                                                               \
 291                                                                                 \
 292             BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED                            \
 293             static type                                                         \
 294             call(Seq& obj)                                                      \
 295             {                                                                   \
 296                 return type(obj);                                               \
 297             }                                                                   \
 298         };                                                                      \
 299     };
 300
 301 #endif