Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2025-12-15 10:01:32 

0001 /*==============================================================================
0002     Copyright (c) 2005-2010 Joel de Guzman
0003     Copyright (c) 2010-2011 Thomas Heller
0004 
0005     Distributed under the Boost Software License, Version 1.0. (See accompanying
0006     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
0007 ==============================================================================*/
0008 #ifndef BOOST_PHOENIX_CORE_ENVIRONMENT_HPP
0009 #define BOOST_PHOENIX_CORE_ENVIRONMENT_HPP
0010 
0011 #include <boost/phoenix/core/limits.hpp>
0012 #include <boost/fusion/sequence/intrinsic/at.hpp>
0013 #include <boost/fusion/support/is_sequence.hpp>
0014 #include <boost/phoenix/support/vector.hpp>
0015 #include <boost/proto/transform/impl.hpp>
0016 #include <boost/utility/enable_if.hpp>
0017 #include <boost/utility/result_of.hpp>
0018 
0019 #include <typeinfo>
0020 
0021 namespace boost { namespace phoenix 
0022 {
0023     struct unused {};
0024 
0025     namespace result_of
0026     {
0027         template <typename Env, typename Actions>
0028         struct context
0029         {
0030             typedef vector2<Env, Actions> type;
0031         };
0032         
0033         template <typename Env, typename Actions>
0034         struct make_context
0035             : context<Env, Actions>
0036         {};
0037 
0038         template <typename Context>
0039         struct env
0040         {
0041             typedef
0042                 typename fusion::result_of::at_c<
0043                     typename boost::remove_reference<Context>::type
0044                   , 0
0045                 >::type
0046                 type;
0047         };
0048         
0049         template <typename Context>
0050         struct actions
0051         {
0052             typedef
0053                 typename fusion::result_of::at_c<
0054                     typename boost::remove_reference<Context>::type
0055                   , 1
0056                 >::type
0057                 type;
0058         };
0059     }
0060 
0061     namespace functional
0062     {
0063         struct context
0064         {
0065             BOOST_PROTO_CALLABLE()
0066 
0067             template <typename Sig>
0068             struct result;
0069 
0070             template <typename This, typename Env, typename Actions>
0071             struct result<This(Env, Actions)>
0072                 : result<This(Env const &, Actions const &)>
0073             {};
0074 
0075             template <typename This, typename Env, typename Actions>
0076             struct result<This(Env &, Actions)>
0077                 : result<This(Env &, Actions const &)>
0078             {};
0079 
0080             template <typename This, typename Env, typename Actions>
0081             struct result<This(Env, Actions &)>
0082                 : result<This(Env const &, Actions &)>
0083             {};
0084 
0085             template <typename This, typename Env, typename Actions>
0086             struct result<This(Env &, Actions &)>
0087                 : result_of::context<Env &, Actions &>
0088             {};
0089 
0090             template <typename Env, typename Actions>
0091             typename result_of::context<Env &, Actions &>::type
0092             operator()(Env & env, Actions & actions) const
0093             {
0094                 vector2<Env &, Actions &> e = {env, actions};
0095                 return e;
0096             }
0097 
0098             template <typename Env, typename Actions>
0099             typename result_of::context<Env const &, Actions &>::type
0100             operator()(Env const & env, Actions & actions) const
0101             {
0102                 vector2<Env const &, Actions &> e = {env, actions};
0103                 return e;
0104             }
0105 
0106             template <typename Env, typename Actions>
0107             typename result_of::context<Env &, Actions const &>::type
0108             operator()(Env & env, Actions const & actions) const
0109             {
0110                 vector2<Env &, Actions const &> e = {env, actions};
0111                 return e;
0112             }
0113 
0114             template <typename Env, typename Actions>
0115             typename result_of::context<Env const &, Actions const &>::type
0116             operator()(Env const & env, Actions const & actions) const
0117             {
0118                 vector2<Env const&, Actions const &> e = {env, actions};
0119                 return e;
0120             }
0121         };
0122 
0123         struct make_context
0124             : context
0125         {};
0126 
0127         struct env
0128         {
0129             BOOST_PROTO_CALLABLE()
0130 
0131             template <typename Sig>
0132             struct result;
0133 
0134             template <typename This, typename Context>
0135             struct result<This(Context)>
0136                 : result<This(Context const &)>
0137             {};
0138 
0139             template <typename This, typename Context>
0140             struct result<This(Context &)>
0141                 : result_of::env<Context>
0142             {};
0143 
0144             template <typename Context>
0145             typename result_of::env<Context const>::type
0146             operator()(Context const & ctx) const
0147             {
0148                 return fusion::at_c<0>(ctx);
0149             }
0150 
0151             template <typename Context>
0152             typename result_of::env<Context>::type
0153             operator()(Context & ctx) const
0154             {
0155                 return fusion::at_c<0>(ctx);
0156             }
0157         };
0158         
0159         struct actions
0160         {
0161             BOOST_PROTO_CALLABLE()
0162 
0163             template <typename Sig>
0164             struct result;
0165 
0166             template <typename This, typename Context>
0167             struct result<This(Context)>
0168                 : result<This(Context const &)>
0169             {};
0170 
0171             template <typename This, typename Context>
0172             struct result<This(Context &)>
0173                 : result_of::actions<Context>
0174             {};
0175 
0176             template <typename Context>
0177             typename result_of::actions<Context const>::type
0178             operator()(Context const & ctx) const
0179             {
0180                 return fusion::at_c<1>(ctx);
0181             }
0182 
0183             template <typename Context>
0184             typename result_of::actions<Context>::type
0185             operator()(Context & ctx) const
0186             {
0187                 return fusion::at_c<1>(ctx);
0188             }
0189         };
0190 
0191     }
0192 
0193     struct _context
0194         : proto::transform<_context>
0195     {
0196         template <typename Expr, typename State, typename Data>
0197         struct impl
0198             : proto::transform_impl<Expr, State, Data>
0199         {
0200             typedef vector2<State, Data> result_type;
0201 
0202             result_type operator()(
0203                 typename impl::expr_param
0204               , typename impl::state_param s
0205               , typename impl::data_param d
0206             ) const
0207             {
0208                 vector2<State, Data> e = {s, d};
0209                 return e;
0210             }
0211         };
0212     };
0213 
0214     template <typename Env, typename Actions>
0215     inline
0216     typename result_of::context<Env const &, Actions const&>::type const
0217     context(Env const& env, Actions const& actions)
0218     {
0219         vector2<Env const&, Actions const &> e = {env, actions};
0220         return e;
0221     }
0222 
0223     template <typename Env, typename Actions>
0224     inline
0225     typename result_of::context<Env const &, Actions const&>::type const
0226     make_context(Env const& env, Actions const& actions)
0227     {
0228         return context(env, actions);
0229     }
0230 
0231     template <typename Env, typename Actions>
0232     inline
0233     typename result_of::context<Env &, Actions const&>::type const
0234     context(Env & env, Actions const& actions)
0235     {
0236         vector2<Env &, Actions const &> e = {env, actions};
0237         return e;
0238     }
0239     
0240     template <typename Env, typename Actions>
0241     inline
0242     typename result_of::context<Env &, Actions const&>::type const
0243     make_context(Env & env, Actions const& actions)
0244     {
0245         return context(env, actions);
0246     }
0247 
0248     template <typename Env, typename Actions>
0249     inline
0250     typename result_of::context<Env const &, Actions &>::type const
0251     context(Env const& env, Actions & actions)
0252     {
0253         vector2<Env const&, Actions &> e = {env, actions};
0254         return e;
0255     }
0256     
0257     template <typename Env, typename Actions>
0258     inline
0259     typename result_of::context<Env const &, Actions &>::type const
0260     make_context(Env const& env, Actions & actions)
0261     {
0262         return context(env, actions);
0263     }
0264     
0265     template <typename Env, typename Actions>
0266     inline
0267     typename result_of::context<Env &, Actions &>::type const
0268     context(Env & env, Actions & actions)
0269     {
0270         vector2<Env &, Actions &> e = {env, actions};
0271         return e;
0272     }
0273     
0274     template <typename Env, typename Actions>
0275     inline
0276     typename result_of::context<Env &, Actions &>::type const
0277     make_context(Env & env, Actions & actions)
0278     {
0279         return context(env, actions);
0280     }
0281 
0282     struct _env
0283         : proto::transform<_env>
0284     {
0285         template <typename Expr, typename State, typename Data>
0286         struct impl
0287             : proto::transform_impl<Expr, State, Data>
0288         {
0289             typedef State result_type;
0290 
0291             result_type operator()(
0292                 typename impl::expr_param
0293               , typename impl::state_param s
0294               , typename impl::data_param
0295             ) const
0296             {
0297                 return s;
0298             }
0299         };
0300     };
0301 
0302     template <typename Expr, typename State>
0303     struct _env::impl<Expr, State, proto::empty_env>
0304         : proto::transform_impl<Expr, State, proto::empty_env>
0305     {
0306             typedef
0307                 typename fusion::result_of::at_c<
0308                     typename boost::remove_reference<State>::type
0309                   , 0
0310                 >::type
0311                 result_type;
0312 
0313             result_type operator()(
0314                 typename impl::expr_param
0315               , typename impl::state_param s
0316               , typename impl::data_param
0317             ) const
0318             {
0319                 return fusion::at_c<0>(s);
0320             }
0321     };
0322 
0323     template <typename Expr, typename State>
0324     struct _env::impl<Expr, State, unused>
0325         : _env::impl<Expr, State, proto::empty_env>
0326     {};
0327 
0328     template <typename Context>
0329     inline
0330     typename fusion::result_of::at_c<Context, 0>::type
0331     env(Context & ctx)
0332     {
0333         return fusion::at_c<0>(ctx);
0334     }
0335 
0336     template <typename Context>
0337     inline
0338     typename fusion::result_of::at_c<Context const, 0>::type
0339     env(Context const & ctx)
0340     {
0341         return fusion::at_c<0>(ctx);
0342     }
0343 
0344     struct _actions
0345         : proto::transform<_actions>
0346     {
0347         template <typename Expr, typename State, typename Data>
0348         struct impl
0349             : proto::transform_impl<Expr, State, Data>
0350         {
0351             typedef Data result_type;
0352 
0353             result_type operator()(
0354                 typename impl::expr_param
0355               , typename impl::state_param
0356               , typename impl::data_param d
0357             ) const
0358             {
0359                 return d;
0360             }
0361         };
0362     };
0363 
0364     template <typename Expr, typename State>
0365     struct _actions::impl<Expr, State, proto::empty_env>
0366         : proto::transform_impl<Expr, State, proto::empty_env>
0367     {
0368             typedef
0369                 typename fusion::result_of::at_c<
0370                     typename boost::remove_reference<State>::type
0371                   , 1
0372                 >::type
0373                 result_type;
0374 
0375             result_type operator()(
0376                 typename impl::expr_param
0377               , typename impl::state_param s
0378               , typename impl::data_param
0379             ) const
0380             {
0381                 return fusion::at_c<1>(s);
0382             }
0383     };
0384 
0385     template <typename Expr, typename State>
0386     struct _actions::impl<Expr, State, unused>
0387         : _actions::impl<Expr, State, proto::empty_env>
0388     {};
0389 
0390     template <typename Context>
0391     inline
0392     typename fusion::result_of::at_c<Context, 1>::type
0393     actions(Context & ctx)
0394     {
0395         return fusion::at_c<1>(ctx);
0396     }
0397 
0398     template <typename Context>
0399     inline
0400     typename fusion::result_of::at_c<Context const, 1>::type
0401     actions(Context const & ctx)
0402     {
0403         return fusion::at_c<1>(ctx);
0404     }
0405 
0406     namespace result_of
0407     {
0408         template <
0409             BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
0410                 BOOST_PHOENIX_LIMIT
0411               , typename A
0412               , mpl::void_
0413             )
0414           , typename Dummy = void
0415         >
0416         struct make_env;
0417         
0418     #define M0(Z, N, D)                                                         \
0419         template <BOOST_PHOENIX_typename_A(N)>                                  \
0420         struct make_env<BOOST_PHOENIX_A(N)>                                     \
0421         {                                                                       \
0422             typedef BOOST_PP_CAT(vector, N)<BOOST_PHOENIX_A(N)> type;           \
0423         };                                                                      \
0424     /**/
0425         BOOST_PP_REPEAT_FROM_TO(1, BOOST_PHOENIX_LIMIT, M0, _)
0426     #undef M0
0427     }
0428 
0429     inline
0430     result_of::make_env<>::type
0431     make_env()
0432     {
0433         return result_of::make_env<>::type();
0434     }
0435 #define M0(Z, N, D)                                                             \
0436     template <BOOST_PHOENIX_typename_A(N)>                                      \
0437     inline                                                                      \
0438     typename result_of::make_env<BOOST_PHOENIX_A_ref(N)>::type                  \
0439     make_env(BOOST_PHOENIX_A_ref_a(N))                                          \
0440     {                                                                           \
0441         typename result_of::make_env<BOOST_PHOENIX_A_ref(N)>::type              \
0442             env =                                                               \
0443             {                                                                   \
0444                 BOOST_PHOENIX_a(N)                                              \
0445             };                                                                  \
0446         return env;                                                             \
0447     }                                                                           \
0448     template <BOOST_PHOENIX_typename_A(N)>                                      \
0449     inline                                                                      \
0450     typename result_of::make_env<BOOST_PHOENIX_A_const_ref(N)>::type            \
0451     make_env(BOOST_PHOENIX_A_const_ref_a(N))                                    \
0452     {                                                                           \
0453         typename result_of::make_env<BOOST_PHOENIX_A_const_ref(N)>::type        \
0454             env =                                                               \
0455             {                                                                   \
0456                 BOOST_PHOENIX_a(N)                                              \
0457             };                                                                  \
0458         return env;                                                             \
0459     }                                                                           \
0460     /**/
0461         BOOST_PP_REPEAT_FROM_TO(1, BOOST_PHOENIX_LIMIT, M0, _)
0462     #undef M0
0463 
0464     template <typename T, typename Enable = void>
0465     struct is_environment : fusion::traits::is_sequence<T> {};
0466 }}
0467 
0468 #endif
0469
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!