Changeset 44721


Ignore:
Timestamp:
Apr 22, 2008, 4:16:19 PM (10 years ago)
Author:
Eric Niebler
Message:

default expression evaluators handle member object pointers

Location:
branches/proto/v4/boost/proto
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • branches/proto/v4/boost/proto/context/default.hpp

    r44712 r44721  
    2222    #include <boost/type_traits/remove_reference.hpp>
    2323    #include <boost/type_traits/is_member_pointer.hpp>
     24    #include <boost/type_traits/is_member_object_pointer.hpp>
     25    #include <boost/type_traits/is_member_function_pointer.hpp>
    2426    #include <boost/proto/proto_fwd.hpp>
    2527    #include <boost/proto/tags.hpp>
     
    240242            #define EVAL_TYPE(Z, N, DATA)                                                           \
    241243                typename proto::result_of::eval<                                                    \
    242                     typename remove_reference<typename proto::result_of::child_c<DATA, N>::type>::type\
     244                    typename remove_reference<                                                      \
     245                        typename proto::result_of::child_c<DATA, N>::type                           \
     246                    >::type                                                                         \
    243247                  , Context                                                                         \
    244                 >::type
     248                >::type                                                                             \
     249                /**/
    245250
    246251            #define EVAL(Z, N, DATA)                                                                \
    247                 proto::eval(proto::child_c<N>(DATA), context)
    248 
    249             #define BOOST_PP_ITERATION_PARAMS_1 (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/context/default.hpp>))
     252                proto::eval(proto::child_c<N>(DATA), context)                                       \
     253                /**/
     254
     255            template<typename Expr, typename Context>
     256            struct default_eval<Expr, Context, proto::tag::function, 1>
     257            {
     258                typedef
     259                    typename proto::detail::result_of_fixup<EVAL_TYPE(~, 0, Expr)>::type
     260                function_type;
     261
     262                typedef
     263                    typename boost::result_of<function_type()>::type
     264                result_type;
     265
     266                result_type operator ()(Expr &expr, Context &context) const
     267                {
     268                    return EVAL(~, 0, expr)();
     269                }
     270            };
     271
     272            template<typename Expr, typename Context>
     273            struct default_eval<Expr, Context, proto::tag::function, 2>
     274            {
     275                typedef
     276                    typename proto::detail::result_of_fixup<EVAL_TYPE(~, 0, Expr)>::type
     277                function_type;
     278
     279                typedef
     280                    typename detail::result_of_<function_type(EVAL_TYPE(~, 1, Expr))>::type
     281                result_type;
     282
     283                result_type operator ()(Expr &expr, Context &context) const
     284                {
     285                    return this->invoke(
     286                        expr
     287                      , context
     288                      , is_member_function_pointer<function_type>()
     289                      , is_member_object_pointer<function_type>()
     290                    );
     291                }
     292
     293            private:
     294                result_type invoke(Expr &expr, Context &context, mpl::false_, mpl::false_) const
     295                {
     296                    return EVAL(~, 0, expr)(EVAL(~, 1, expr));
     297                }
     298
     299                result_type invoke(Expr &expr, Context &context, mpl::true_, mpl::false_) const
     300                {
     301                    return (detail::deref(EVAL(~, 1, expr)) .* EVAL(~, 0, expr))();
     302                }
     303
     304                result_type invoke(Expr &expr, Context &context, mpl::false_, mpl::true_) const
     305                {
     306                    return (detail::deref(EVAL(~, 1, expr)) .* EVAL(~, 0, expr));
     307                }
     308            };
     309
     310            #define BOOST_PP_ITERATION_PARAMS_1 (3, (3, BOOST_PROTO_MAX_ARITY, <boost/proto/context/default.hpp>))
    250311            #include BOOST_PP_ITERATE()
    251312
     
    290351            result_type;
    291352
    292             #if N == 1
    293353            result_type operator ()(Expr &expr, Context &context) const
    294354            {
    295                 return EVAL(~, 0, expr)(BOOST_PP_ENUM_SHIFTED(N, EVAL, expr));
     355                return this->invoke(expr, context, is_member_function_pointer<function_type>());
    296356            }
    297             #else
    298             result_type operator ()(Expr &expr, Context &context) const
    299             {
    300                 return this->invoke(expr, context, is_member_pointer<function_type>());
    301             }
    302 
     357
     358        private:
    303359            result_type invoke(Expr &expr, Context &context, mpl::false_) const
    304360            {
     
    314370                #undef M0
    315371            }
    316             #endif
    317372        };
    318373
  • branches/proto/v4/boost/proto/detail/decltype.hpp

    r44712 r44721  
    134134
    135135        ////////////////////////////////////////////////////////////////////////////////////////////
     136        template<typename T>
     137        struct result_of_
     138          : boost::result_of<T>
     139        {};
     140
     141        template<typename T, typename U, typename V>
     142        struct result_of_<T U::*(V)>
     143        {
     144            typedef T type;
     145        };
     146
     147        ////////////////////////////////////////////////////////////////////////////////////////////
    136148        template<typename T, typename U = T>
    137149        struct result_of_fixup
  • branches/proto/v4/boost/proto/transform/default.hpp

    r44712 r44721  
    2020    #include <boost/utility/enable_if.hpp>
    2121    #include <boost/type_traits/is_member_pointer.hpp>
     22    #include <boost/type_traits/is_member_object_pointer.hpp>
     23    #include <boost/type_traits/is_member_function_pointer.hpp>
    2224    #include <boost/proto/proto_fwd.hpp>
    2325    #include <boost/proto/traits.hpp>
     
    275277                /**/
    276278
    277             #define BOOST_PP_ITERATION_PARAMS_1 (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/default.hpp>))
     279            template<typename Expr, typename State, typename Data>
     280            struct impl2<Expr, State, Data, tag::function, 1>
     281              : transform_impl<Expr, State, Data>
     282            {
     283                EVAL_TYPE(~, 0, Expr)
     284
     285                typedef
     286                    typename proto::detail::result_of_fixup<r0>::type
     287                function_type;
     288
     289                typedef
     290                    typename boost::result_of<function_type()>::type
     291                result_type;
     292
     293                result_type operator ()(
     294                    typename impl2::expr_param expr
     295                  , typename impl2::state_param state
     296                  , typename impl2::data_param data
     297                ) const
     298                {
     299                    return EVAL(~, 0, expr)();
     300                }
     301            };
     302
     303            template<typename Expr, typename State, typename Data>
     304            struct impl2<Expr, State, Data, tag::function, 2>
     305              : transform_impl<Expr, State, Data>
     306            {
     307                EVAL_TYPE(~, 0, Expr)
     308                EVAL_TYPE(~, 1, Expr)
     309
     310                typedef
     311                    typename proto::detail::result_of_fixup<r0>::type
     312                function_type;
     313
     314                typedef
     315                    typename detail::result_of_<function_type(r1)>::type
     316                result_type;
     317
     318                result_type operator ()(
     319                    typename impl2::expr_param expr
     320                  , typename impl2::state_param state
     321                  , typename impl2::data_param data
     322                ) const
     323                {
     324                    return this->invoke(
     325                        expr
     326                      , state
     327                      , data
     328                      , is_member_function_pointer<function_type>()
     329                      , is_member_object_pointer<function_type>()
     330                    );
     331                }
     332
     333            private:
     334                result_type invoke(
     335                    typename impl2::expr_param expr
     336                  , typename impl2::state_param state
     337                  , typename impl2::data_param data
     338                  , mpl::false_
     339                  , mpl::false_
     340                ) const
     341                {
     342                    return EVAL(~, 0, expr)(EVAL(~, 1, expr));
     343                }
     344
     345                result_type invoke(
     346                    typename impl2::expr_param expr
     347                  , typename impl2::state_param state
     348                  , typename impl2::data_param data
     349                  , mpl::true_
     350                  , mpl::false_
     351                ) const
     352                {
     353                    return (detail::deref(EVAL(~, 1, expr)) .* EVAL(~, 0, expr))();
     354                }
     355
     356                result_type invoke(
     357                    typename impl2::expr_param expr
     358                  , typename impl2::state_param state
     359                  , typename impl2::data_param data
     360                  , mpl::false_
     361                  , mpl::true_
     362                ) const
     363                {
     364                    return (detail::deref(EVAL(~, 1, expr)) .* EVAL(~, 0, expr));
     365                }
     366            };
     367
     368            #define BOOST_PP_ITERATION_PARAMS_1 (3, (3, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/default.hpp>))
    278369            #include BOOST_PP_ITERATE()
    279370
     
    322413            result_type;
    323414
    324             #if N == 1
    325415            result_type operator ()(
    326416                typename impl2::expr_param expr
     
    329419            ) const
    330420            {
    331                 return EVAL(~, 0, expr)(BOOST_PP_ENUM_SHIFTED(N, EVAL, expr));
     421                return this->invoke(expr, state, data, is_member_function_pointer<function_type>());
    332422            }
    333             #else
    334             result_type operator ()(
    335                 typename impl2::expr_param expr
    336               , typename impl2::state_param state
    337               , typename impl2::data_param data
    338             ) const
    339             {
    340                 return this->invoke(expr, state, data, is_member_pointer<function_type>());
    341             }
    342 
     423
     424        private:
    343425            result_type invoke(
    344426                typename impl2::expr_param expr
     
    364446                #undef M0
    365447            }
    366             #endif
    367448        };
    368449
Note: See TracChangeset for help on using the changeset viewer.