Back to home page

EIC code displayed by LXR

 
 

    


File indexing completed on 2025-12-16 09:45:46

0001 /*=============================================================================
0002     Copyright (c) 2001-2009 Joel de Guzman
0003     Copyright (c) 2005-2006 Dan Marsden
0004     Copyright (c) 2010 Christopher Schmidt
0005 
0006     Distributed under the Boost Software License, Version 1.0. (See accompanying
0007     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
0008 ==============================================================================*/
0009 
0010 #ifndef BOOST_FUSION_ADAPTED_ADT_DETAIL_ADAPT_BASE_HPP
0011 #define BOOST_FUSION_ADAPTED_ADT_DETAIL_ADAPT_BASE_HPP
0012 
0013 #include <boost/fusion/support/config.hpp>
0014 #include <boost/fusion/adapted/struct/detail/adapt_auto.hpp>
0015 #include <boost/fusion/adapted/struct/detail/adapt_is_tpl.hpp>
0016 
0017 #include <boost/preprocessor/control/if.hpp>
0018 #include <boost/preprocessor/control/expr_if.hpp>
0019 #include <boost/preprocessor/seq/seq.hpp>
0020 #include <boost/preprocessor/seq/elem.hpp>
0021 #include <boost/preprocessor/tuple/elem.hpp>
0022 #include <boost/mpl/if.hpp>
0023 #include <boost/type_traits/is_const.hpp>
0024 #include <boost/type_traits/remove_const.hpp>
0025 #include <boost/type_traits/remove_reference.hpp>
0026 
0027 #include <boost/typeof/typeof.hpp>
0028 
0029 #define BOOST_FUSION_ADAPT_ADT_GET_IDENTITY_TEMPLATE_IMPL(TEMPLATE_PARAMS_SEQ)  \
0030     typename detail::get_identity<                                              \
0031         lvalue                                                                  \
0032       , BOOST_PP_SEQ_ELEM(1,TEMPLATE_PARAMS_SEQ)                                \
0033     >::type
0034 
0035 #define BOOST_FUSION_ADAPT_ADT_GET_IDENTITY_NON_TEMPLATE_IMPL(                  \
0036     TEMPLATE_PARAMS_SEQ)                                                        \
0037                                                                                 \
0038     boost::remove_const<boost::remove_reference<lvalue>::type>::type
0039 
0040 #define BOOST_FUSION_ADAPT_ADT_ATTRIBUTE_GETEXPR(ATTRIBUTE,                     \
0041     ATTRIBUTE_TUPLE_SIZE, DEDUCE_TYPE)                                          \
0042     BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,                                   \
0043         BOOST_PP_IF(DEDUCE_TYPE, 0, 2), ATTRIBUTE)
0044 
0045 #define BOOST_FUSION_ADAPT_ADT_ATTRIBUTE_SETEXPR(ATTRIBUTE,                     \
0046     ATTRIBUTE_TUPLE_SIZE, DEDUCE_TYPE)                                          \
0047     BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE,                                   \
0048         BOOST_PP_IF(DEDUCE_TYPE, 1, 3), ATTRIBUTE)
0049 
0050 #ifdef BOOST_MSVC
0051 #   define BOOST_FUSION_DEDUCED_ATTR_TYPE(NAME_SEQ, ATTRIBUTE,                  \
0052         ATTRIBUTE_TUPLE_SIZE, PREFIX, TEMPLATE_PARAMS_SEQ)                      \
0053                                                                                 \
0054     BOOST_FUSION_ADAPT_STRUCT_MSVC_REDEFINE_TEMPLATE_PARAMS(                    \
0055         TEMPLATE_PARAMS_SEQ)                                                    \
0056                                                                                 \
0057     struct deduced_attr_type {                                                  \
0058       static const BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)& obj;        \
0059       typedef                                                                   \
0060           BOOST_PP_EXPR_IF(BOOST_FUSION_ADAPT_IS_TPL(TEMPLATE_PARAMS_SEQ),      \
0061                            typename)                                            \
0062           BOOST_TYPEOF( PREFIX() BOOST_FUSION_ADAPT_ADT_ATTRIBUTE_GETEXPR(      \
0063               ATTRIBUTE, ATTRIBUTE_TUPLE_SIZE, 1)) type;                        \
0064     };
0065 
0066 #else
0067 #   define BOOST_FUSION_DEDUCED_ATTR_TYPE(NAME_SEQ, ATTRIBUTE,                  \
0068         ATTRIBUTE_TUPLE_SIZE, PREFIX, TEMPLATE_PARAMS_SEQ)                      \
0069     struct deduced_attr_type {                                                  \
0070       static const BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)& obj;        \
0071       typedef BOOST_TYPEOF( PREFIX() BOOST_FUSION_ADAPT_ADT_ATTRIBUTE_GETEXPR(  \
0072                       ATTRIBUTE, ATTRIBUTE_TUPLE_SIZE, 1)) type;                \
0073     };
0074 
0075 #endif
0076 
0077 #define BOOST_FUSION_ADT_ATTRIBUTE_TYPEOF(                                      \
0078     NAME_SEQ, ATTRIBUTE, ATTRIBUTE_TUPLE_SIZE, PREFIX, TEMPLATE_PARAMS_SEQ)     \
0079                                                                                 \
0080     BOOST_FUSION_DEDUCED_ATTR_TYPE(                                             \
0081         NAME_SEQ, ATTRIBUTE, ATTRIBUTE_TUPLE_SIZE, PREFIX, TEMPLATE_PARAMS_SEQ) \
0082                                                                                 \
0083     typedef                                                                     \
0084         BOOST_PP_EXPR_IF(BOOST_FUSION_ADAPT_IS_TPL(TEMPLATE_PARAMS_SEQ),        \
0085                          typename)                                              \
0086         deduced_attr_type::type type;                                           \
0087     typedef type const_type;
0088 
0089 #define BOOST_FUSION_ADT_ATTRIBUTE_GIVENTYPE(                                   \
0090     NAME_SEQ, ATTRIBUTE, ATTRIBUTE_TUPLE_SIZE, PREFIX, TEMPLATE_PARAMS_SEQ)     \
0091                                                                                 \
0092     typedef BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE, 0, ATTRIBUTE) type;       \
0093     typedef BOOST_PP_TUPLE_ELEM(ATTRIBUTE_TUPLE_SIZE, 1, ATTRIBUTE) const_type;
0094 
0095 
0096 #define BOOST_FUSION_ADAPT_ADT_C_BASE(                                          \
0097     TEMPLATE_PARAMS_SEQ,NAME_SEQ,I,PREFIX,                                      \
0098     ATTRIBUTE,ATTRIBUTE_TUPLE_SIZE, DEDUCE_TYPE)                                \
0099                                                                                 \
0100     template<                                                                   \
0101         BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS(TEMPLATE_PARAMS_SEQ)   \
0102     >                                                                           \
0103     struct access::adt_attribute_access<                                        \
0104         BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)                         \
0105       , I                                                                       \
0106     >                                                                           \
0107     {                                                                           \
0108                                                                                 \
0109         BOOST_PP_IF(DEDUCE_TYPE,                                                \
0110             BOOST_FUSION_ADT_ATTRIBUTE_TYPEOF,                                  \
0111             BOOST_FUSION_ADT_ATTRIBUTE_GIVENTYPE)(                              \
0112                 NAME_SEQ,                                                       \
0113                 ATTRIBUTE,                                                      \
0114                 ATTRIBUTE_TUPLE_SIZE,                                           \
0115                 PREFIX,                                                         \
0116                 TEMPLATE_PARAMS_SEQ)                                            \
0117                                                                                 \
0118         template<class Val>                                                     \
0119         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED                          \
0120         static void                                                             \
0121         boost_fusion_adapt_adt_impl_set(                                        \
0122             BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)& obj,               \
0123             Val const& val)                                                     \
0124         {                                                                       \
0125            PREFIX() BOOST_FUSION_ADAPT_ADT_ATTRIBUTE_SETEXPR(ATTRIBUTE,         \
0126                 ATTRIBUTE_TUPLE_SIZE, DEDUCE_TYPE);                             \
0127         }                                                                       \
0128                                                                                 \
0129         BOOST_FUSION_GPU_ENABLED                                                \
0130         static type                                                             \
0131         boost_fusion_adapt_adt_impl_get(                                        \
0132             BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)& obj)               \
0133         {                                                                       \
0134             return PREFIX() BOOST_FUSION_ADAPT_ADT_ATTRIBUTE_GETEXPR(ATTRIBUTE, \
0135                 ATTRIBUTE_TUPLE_SIZE, DEDUCE_TYPE);                             \
0136         }                                                                       \
0137                                                                                 \
0138         BOOST_FUSION_GPU_ENABLED                                                \
0139         static const_type                                                       \
0140         boost_fusion_adapt_adt_impl_get(                                        \
0141             BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ) const& obj)         \
0142         {                                                                       \
0143             return PREFIX() BOOST_FUSION_ADAPT_ADT_ATTRIBUTE_GETEXPR(ATTRIBUTE, \
0144                 ATTRIBUTE_TUPLE_SIZE, DEDUCE_TYPE);                             \
0145         }                                                                       \
0146     };                                                                          \
0147                                                                                 \
0148     template<                                                                   \
0149         BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS(TEMPLATE_PARAMS_SEQ)   \
0150     >                                                                           \
0151     struct adt_attribute_proxy<                                                 \
0152         BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)                         \
0153       , I                                                                       \
0154       , true                                                                    \
0155     >                                                                           \
0156     {                                                                           \
0157         typedef                                                                 \
0158             BOOST_PP_EXPR_IF(BOOST_PP_SEQ_HEAD(TEMPLATE_PARAMS_SEQ), typename)  \
0159             access::adt_attribute_access<                                       \
0160                 BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)                 \
0161               , I                                                               \
0162             >::const_type type;                                                 \
0163                                                                                 \
0164         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED                                \
0165         explicit                                                                \
0166         adt_attribute_proxy(                                                    \
0167             BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ) const& o)           \
0168           : obj(&o)                                                             \
0169         {}                                                                      \
0170                                                                                 \
0171         BOOST_FUSION_GPU_ENABLED                                                \
0172         type get() const                                                        \
0173         {                                                                       \
0174             return access::adt_attribute_access<                                \
0175                 BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)                 \
0176               , I                                                               \
0177             >::boost_fusion_adapt_adt_impl_get(*obj);                           \
0178         }                                                                       \
0179                                                                                 \
0180         BOOST_FUSION_GPU_ENABLED                                                \
0181         operator type() const                                                   \
0182         {                                                                       \
0183             return get();                                                       \
0184         }                                                                       \
0185                                                                                 \
0186         BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ) const* obj;             \
0187     };                                                                          \
0188                                                                                 \
0189     template<                                                                   \
0190         BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS(TEMPLATE_PARAMS_SEQ)   \
0191     >                                                                           \
0192     struct adt_attribute_proxy<                                                 \
0193         BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)                         \
0194       , I                                                                       \
0195       , false                                                                   \
0196     >                                                                           \
0197     {                                                                           \
0198         typedef                                                                 \
0199             BOOST_PP_EXPR_IF(BOOST_PP_SEQ_HEAD(TEMPLATE_PARAMS_SEQ), typename)  \
0200             access::adt_attribute_access<                                       \
0201                 BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)                 \
0202               , I                                                               \
0203             >::type type;                                                       \
0204                                                                                 \
0205         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED                                \
0206         explicit                                                                \
0207         adt_attribute_proxy(                                                    \
0208             BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)& o)                 \
0209           : obj(&o)                                                             \
0210         {}                                                                      \
0211                                                                                 \
0212         template<class Val>                                                     \
0213         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED                          \
0214         adt_attribute_proxy&                                                    \
0215         operator=(Val const& val)                                               \
0216         {                                                                       \
0217             access::adt_attribute_access<                                       \
0218                 BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)                 \
0219               , I                                                               \
0220             >::boost_fusion_adapt_adt_impl_set(*obj, val);                      \
0221             return *this;                                                       \
0222         }                                                                       \
0223                                                                                 \
0224         BOOST_FUSION_GPU_ENABLED                                                \
0225         type get() const                                                        \
0226         {                                                                       \
0227             return access::adt_attribute_access<                                \
0228                 BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)                 \
0229               , I                                                               \
0230             >::boost_fusion_adapt_adt_impl_get(*obj);                           \
0231         }                                                                       \
0232                                                                                 \
0233         BOOST_FUSION_GPU_ENABLED                                                \
0234         operator type() const                                                   \
0235         {                                                                       \
0236             return get();                                                       \
0237         }                                                                       \
0238                                                                                 \
0239         BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)* obj;                   \
0240     };                                                                          \
0241                                                                                 \
0242     template<                                                                   \
0243         BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS(TEMPLATE_PARAMS_SEQ)   \
0244     >                                                                           \
0245     struct access::struct_member<                                               \
0246         BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)                         \
0247       , I                                                                       \
0248     >                                                                           \
0249     {                                                                           \
0250         typedef BOOST_PP_EXPR_IF(BOOST_PP_SEQ_HEAD(TEMPLATE_PARAMS_SEQ),        \
0251                                  typename)                                      \
0252             adt_attribute_proxy<                                                \
0253                           BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)       \
0254                         , I                                                     \
0255                         , false                                                 \
0256                       >::type lvalue;                                           \
0257                                                                                 \
0258         BOOST_FUSION_ADAPT_STRUCT_MSVC_REDEFINE_TEMPLATE_PARAMS(                \
0259             TEMPLATE_PARAMS_SEQ)                                                \
0260                                                                                 \
0261         typedef                                                                 \
0262             BOOST_PP_IF(                                                        \
0263                 BOOST_PP_SEQ_HEAD(TEMPLATE_PARAMS_SEQ),                         \
0264                 BOOST_FUSION_ADAPT_ADT_GET_IDENTITY_TEMPLATE_IMPL,              \
0265                 BOOST_FUSION_ADAPT_ADT_GET_IDENTITY_NON_TEMPLATE_IMPL)(         \
0266                     TEMPLATE_PARAMS_SEQ)                                        \
0267         type;                                                                   \
0268                                                                                 \
0269         template<typename Seq>                                                  \
0270         struct apply                                                            \
0271         {                                                                       \
0272             typedef                                                             \
0273                 adt_attribute_proxy<                                            \
0274                     BOOST_FUSION_ADAPT_STRUCT_UNPACK_NAME(NAME_SEQ)             \
0275                   , I                                                           \
0276                   , is_const<Seq>::value                                        \
0277                 >                                                               \
0278             type;                                                               \
0279                                                                                 \
0280             BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED                            \
0281             static type                                                         \
0282             call(Seq& obj)                                                      \
0283             {                                                                   \
0284                 return type(obj);                                               \
0285             }                                                                   \
0286         };                                                                      \
0287     };
0288 
0289 #endif