proto/transform/impl.hpp

0001 ///////////////////////////////////////////////////////////////////////////////
0002 /// \file impl.hpp
0003 /// Contains definition of transform<> and transform_impl<> helpers.
0004 //
0005 //  Copyright 2008 Eric Niebler. Distributed under the Boost
0006 //  Software License, Version 1.0. (See accompanying file
0007 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
0008
0009 #ifndef BOOST_PROTO_TRANSFORM_IMPL_HPP_EAN_04_03_2008
0010 #define BOOST_PROTO_TRANSFORM_IMPL_HPP_EAN_04_03_2008
0011
0012 #include <boost/config.hpp>
0013 #include <boost/mpl/bool.hpp>
0014 #include <boost/type_traits/add_const.hpp>
0015 #include <boost/type_traits/add_reference.hpp>
0016 #include <boost/proto/proto_fwd.hpp>
0017 #include <boost/proto/detail/any.hpp>
0018 #include <boost/proto/detail/static_const.hpp>
0019
0020 #if defined(_MSC_VER)
0021 # pragma warning(push)
0022 # pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined
0023 #endif
0024
0025 namespace boost { namespace proto
0026 {
0027     namespace envns_
0028     {
0029         ////////////////////////////////////////////////////////////////////////////////////////////
0030         struct key_not_found
0031         {};
0032
0033         ////////////////////////////////////////////////////////////////////////////////////////////
0034         // empty_env
0035         struct empty_env
0036         {
0037             typedef void proto_environment_;
0038
0039             template<typename OtherTag, typename OtherValue = key_not_found>
0040             struct lookup
0041             {
0042                 typedef OtherValue type;
0043                 typedef
0044                     typename add_reference<typename add_const<OtherValue>::type>::type
0045                 const_reference;
0046             };
0047
0048             key_not_found operator[](detail::any) const
0049             {
0050                 return key_not_found();
0051             }
0052
0053             template<typename T>
0054             T const &at(detail::any, T const &t) const
0055             {
0056                 return t;
0057             }
0058         };
0059     }
0060
0061     ////////////////////////////////////////////////////////////////////////////////////////////
0062     // is_env
0063     template<typename T, typename Void>
0064     struct is_env
0065       : mpl::false_
0066     {};
0067
0068     template<typename T>
0069     struct is_env<T, typename T::proto_environment_>
0070       : mpl::true_
0071     {};
0072
0073     template<typename T>
0074     struct is_env<T &, void>
0075       : is_env<T>
0076     {};
0077
0078 #ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
0079
0080     /// INTERNAL ONLY
0081     ///
0082     #define BOOST_PROTO_TRANSFORM_(PrimitiveTransform, X)                                                       \
0083     BOOST_PROTO_CALLABLE()                                                                                      \
0084     typedef X proto_is_transform_;                                                                              \
0085     typedef PrimitiveTransform transform_type;                                                                  \
0086                                                                                                                 \
0087     template<typename Sig>                                                                                      \
0088     struct result                                                                                               \
0089     {                                                                                                           \
0090         typedef typename boost::proto::detail::apply_transform<Sig>::result_type type;                          \
0091     };                                                                                                          \
0092                                                                                                                 \
0093     template<typename Expr>                                                                                     \
0094     BOOST_FORCEINLINE                                                                                           \
0095     typename boost::proto::detail::apply_transform<transform_type(Expr &)>::result_type                         \
0096     operator ()(Expr &e) const                                                                                  \
0097     {                                                                                                           \
0098         boost::proto::empty_state s = 0;                                                                        \
0099         boost::proto::empty_env d;                                                                              \
0100         return boost::proto::detail::apply_transform<transform_type(Expr &)>()(e, s, d);                        \
0101     }                                                                                                           \
0102                                                                                                                 \
0103     template<typename Expr>                                                                                     \
0104     BOOST_FORCEINLINE                                                                                           \
0105     typename boost::proto::detail::apply_transform<transform_type(Expr const &)>::result_type                   \
0106     operator ()(Expr const &e) const                                                                            \
0107     {                                                                                                           \
0108         boost::proto::empty_state s = 0;                                                                        \
0109         boost::proto::empty_env d;                                                                              \
0110         return boost::proto::detail::apply_transform<transform_type(Expr const &)>()(e, s, d);                  \
0111     }                                                                                                           \
0112                                                                                                                 \
0113     template<typename Expr, typename State>                                                                     \
0114     BOOST_FORCEINLINE                                                                                           \
0115     typename boost::proto::detail::apply_transform<transform_type(Expr &, State &)>::result_type                \
0116     operator ()(Expr &e, State &s) const                                                                        \
0117     {                                                                                                           \
0118         boost::proto::empty_env d;                                                                              \
0119         return boost::proto::detail::apply_transform<transform_type(Expr &, State &)>()(e, s, d);               \
0120     }                                                                                                           \
0121                                                                                                                 \
0122     template<typename Expr, typename State>                                                                     \
0123     BOOST_FORCEINLINE                                                                                           \
0124     typename boost::proto::detail::apply_transform<transform_type(Expr const &, State &)>::result_type          \
0125     operator ()(Expr const &e, State &s) const                                                                  \
0126     {                                                                                                           \
0127         boost::proto::empty_env d;                                                                              \
0128         return boost::proto::detail::apply_transform<transform_type(Expr const &, State &)>()(e, s, d);         \
0129     }                                                                                                           \
0130                                                                                                                 \
0131     template<typename Expr, typename State>                                                                     \
0132     BOOST_FORCEINLINE                                                                                           \
0133     typename boost::proto::detail::apply_transform<transform_type(Expr &, State const &)>::result_type          \
0134     operator ()(Expr &e, State const &s) const                                                                  \
0135     {                                                                                                           \
0136         boost::proto::empty_env d;                                                                              \
0137         return boost::proto::detail::apply_transform<transform_type(Expr &, State const &)>()(e, s, d);         \
0138     }                                                                                                           \
0139                                                                                                                 \
0140     template<typename Expr, typename State>                                                                     \
0141     BOOST_FORCEINLINE                                                                                           \
0142     typename boost::proto::detail::apply_transform<transform_type(Expr const &, State const &)>::result_type    \
0143     operator ()(Expr const &e, State const &s) const                                                            \
0144     {                                                                                                           \
0145         boost::proto::empty_env d;                                                                              \
0146         return boost::proto::detail::apply_transform<transform_type(Expr const &, State const &)>()(e, s, d);   \
0147     }                                                                                                           \
0148                                                                                                                 \
0149     template<typename Expr, typename State, typename Data>                                                      \
0150     BOOST_FORCEINLINE                                                                                           \
0151     typename boost::proto::detail::apply_transform<transform_type(Expr &, State &, Data &)>::result_type        \
0152     operator ()(Expr &e, State &s, Data &d) const                                                               \
0153     {                                                                                                           \
0154         return boost::proto::detail::apply_transform<transform_type(Expr &, State &, Data &)>()(e, s, d);       \
0155     }                                                                                                           \
0156                                                                                                                 \
0157     template<typename Expr, typename State, typename Data>                                                      \
0158     BOOST_FORCEINLINE                                                                                           \
0159     typename boost::proto::detail::apply_transform<transform_type(Expr const &, State &, Data &)>::result_type  \
0160     operator ()(Expr const &e, State &s, Data &d) const                                                         \
0161     {                                                                                                           \
0162         return boost::proto::detail::apply_transform<transform_type(Expr const &, State &, Data &)>()(e, s, d); \
0163     }                                                                                                           \
0164                                                                                                                 \
0165     template<typename Expr, typename State, typename Data>                                                      \
0166     BOOST_FORCEINLINE                                                                                           \
0167     typename boost::proto::detail::apply_transform<transform_type(Expr &, State const &, Data &)>::result_type  \
0168     operator ()(Expr &e, State const &s, Data &d) const                                                         \
0169     {                                                                                                           \
0170         return boost::proto::detail::apply_transform<transform_type(Expr &, State const &, Data &)>()(e, s, d); \
0171     }                                                                                                           \
0172                                                                                                                 \
0173     template<typename Expr, typename State, typename Data>                                                      \
0174     BOOST_FORCEINLINE                                                                                           \
0175     typename boost::proto::detail::apply_transform<transform_type(Expr const &, State const &, Data &)>::result_type  \
0176     operator ()(Expr const &e, State const &s, Data &d) const                                                   \
0177     {                                                                                                           \
0178         return boost::proto::detail::apply_transform<transform_type(Expr const &, State const &, Data &)>()(e, s, d); \
0179     }                                                                                                           \
0180     /**/
0181
0182 #else
0183
0184     /// INTERNAL ONLY
0185     ///
0186     #define BOOST_PROTO_TRANSFORM_(PrimitiveTransform, X)                                                       \
0187     BOOST_PROTO_CALLABLE()                                                                                      \
0188     typedef X proto_is_transform_;                                                                              \
0189     typedef PrimitiveTransform transform_type;                                                                  \
0190                                                                                                                 \
0191     template<typename Sig>                                                                                      \
0192     struct result                                                                                               \
0193     {                                                                                                           \
0194         typedef typename boost::proto::detail::apply_transform<Sig>::result_type type;                          \
0195     };                                                                                                          \
0196                                                                                                                 \
0197     template<typename Expr>                                                                                     \
0198     BOOST_FORCEINLINE                                                                                           \
0199     typename boost::proto::detail::apply_transform<transform_type(Expr const &)>::result_type                   \
0200     operator ()(Expr &&e) const                                                                                 \
0201     {                                                                                                           \
0202         boost::proto::empty_state s = 0;                                                                        \
0203         boost::proto::empty_env d;                                                                              \
0204         return boost::proto::detail::apply_transform<transform_type(Expr const &)>()(e, s, d);                  \
0205     }                                                                                                           \
0206                                                                                                                 \
0207     template<typename Expr, typename State>                                                                     \
0208     BOOST_FORCEINLINE                                                                                           \
0209     typename boost::proto::detail::apply_transform<transform_type(Expr const &, State const &)>::result_type    \
0210     operator ()(Expr &&e, State &&s) const                                                                      \
0211     {                                                                                                           \
0212         boost::proto::empty_env d;                                                                              \
0213         return boost::proto::detail::apply_transform<transform_type(Expr const &, State const &)>()(e, s, d);   \
0214     }                                                                                                           \
0215                                                                                                                 \
0216     template<typename Expr, typename State, typename Data>                                                      \
0217     BOOST_FORCEINLINE                                                                                           \
0218     typename boost::proto::detail::apply_transform<transform_type(Expr const &, State const &, Data const &)>::result_type \
0219     operator ()(Expr &&e, State &&s, Data &&d) const                                                            \
0220     {                                                                                                           \
0221         return boost::proto::detail::apply_transform<transform_type(Expr const &, State const &, Data const &)>()(e, s, d); \
0222     }                                                                                                           \
0223     /**/
0224
0225 #endif
0226
0227     #define BOOST_PROTO_TRANSFORM(PrimitiveTransform)                                                           \
0228         BOOST_PROTO_TRANSFORM_(PrimitiveTransform, void)                                                        \
0229         /**/
0230
0231     namespace detail
0232     {
0233         template<typename Sig>
0234         struct apply_transform;
0235
0236         template<typename PrimitiveTransform, typename Expr>
0237         struct apply_transform<PrimitiveTransform(Expr)>
0238           : PrimitiveTransform::template impl<Expr, empty_state, empty_env>
0239         {};
0240
0241         template<typename PrimitiveTransform, typename Expr, typename State>
0242         struct apply_transform<PrimitiveTransform(Expr, State)>
0243           : PrimitiveTransform::template impl<Expr, State, empty_env>
0244         {};
0245
0246         template<typename PrimitiveTransform, typename Expr, typename State, typename Data>
0247         struct apply_transform<PrimitiveTransform(Expr, State, Data)>
0248           : PrimitiveTransform::template impl<Expr, State, Data>
0249         {};
0250     }
0251
0252     template<typename PrimitiveTransform, typename X>
0253     struct transform
0254     {
0255         BOOST_PROTO_TRANSFORM_(PrimitiveTransform, X)
0256     };
0257
0258     template<typename Expr, typename State, typename Data>
0259     struct transform_impl
0260     {
0261         typedef Expr const expr;
0262         typedef Expr const &expr_param;
0263         typedef State const state;
0264         typedef State const &state_param;
0265         typedef Data const data;
0266         typedef Data const &data_param;
0267     };
0268
0269     template<typename Expr, typename State, typename Data>
0270     struct transform_impl<Expr &, State, Data>
0271     {
0272         typedef Expr expr;
0273         typedef Expr &expr_param;
0274         typedef State const state;
0275         typedef State const &state_param;
0276         typedef Data const data;
0277         typedef Data const &data_param;
0278     };
0279
0280     template<typename Expr, typename State, typename Data>
0281     struct transform_impl<Expr, State &, Data>
0282     {
0283         typedef Expr const expr;
0284         typedef Expr const &expr_param;
0285         typedef State state;
0286         typedef State &state_param;
0287         typedef Data const data;
0288         typedef Data const &data_param;
0289     };
0290
0291     template<typename Expr, typename State, typename Data>
0292     struct transform_impl<Expr, State, Data &>
0293     {
0294         typedef Expr const expr;
0295         typedef Expr const &expr_param;
0296         typedef State const state;
0297         typedef State const &state_param;
0298         typedef Data data;
0299         typedef Data &data_param;
0300     };
0301
0302     template<typename Expr, typename State, typename Data>
0303     struct transform_impl<Expr &, State &, Data>
0304     {
0305         typedef Expr expr;
0306         typedef Expr &expr_param;
0307         typedef State state;
0308         typedef State &state_param;
0309         typedef Data const data;
0310         typedef Data const &data_param;
0311     };
0312
0313     template<typename Expr, typename State, typename Data>
0314     struct transform_impl<Expr &, State, Data &>
0315     {
0316         typedef Expr expr;
0317         typedef Expr &expr_param;
0318         typedef State const state;
0319         typedef State const &state_param;
0320         typedef Data data;
0321         typedef Data &data_param;
0322     };
0323
0324     template<typename Expr, typename State, typename Data>
0325     struct transform_impl<Expr, State &, Data &>
0326     {
0327         typedef Expr const expr;
0328         typedef Expr const &expr_param;
0329         typedef State state;
0330         typedef State &state_param;
0331         typedef Data data;
0332         typedef Data &data_param;
0333     };
0334
0335     template<typename Expr, typename State, typename Data>
0336     struct transform_impl<Expr &, State &, Data &>
0337     {
0338         typedef Expr expr;
0339         typedef Expr &expr_param;
0340         typedef State state;
0341         typedef State &state_param;
0342         typedef Data data;
0343         typedef Data &data_param;
0344     };
0345
0346 }} // namespace boost::proto
0347
0348 #if defined(_MSC_VER)
0349 # pragma warning(pop)
0350 #endif
0351
0352 #endif