Changeset 44723


Ignore:
Timestamp:
Apr 22, 2008, 5:33:34 PM (10 years ago)
Author:
Eric Niebler
Message:

special handling for operator->* when right operand is a member function pointer

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

Legend:

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

    r44721 r44723  
    119119            BOOST_PROTO_BINARY_OP_RESULT(|, proto::tag::bitwise_or, make, make)
    120120            BOOST_PROTO_BINARY_OP_RESULT(^, proto::tag::bitwise_xor, make, make)
    121             BOOST_PROTO_BINARY_OP_RESULT(->*, proto::tag::mem_ptr, make_mutable, make)
    122121
    123122            BOOST_PROTO_BINARY_OP_RESULT(=, proto::tag::assign, make_mutable, make)
     
    136135        #undef BOOST_PROTO_BINARY_OP_RESULT
    137136
     137            /// INTERNAL ONLY
     138            template<typename Expr, typename Context>
     139            struct is_member_function_eval
     140            {
     141                typedef typename proto::result_of::child_c<Expr, 1>::type e1;
     142                typedef typename proto::result_of::eval<UNREF(e1), Context>::type r1;
     143                typedef typename remove_const<typename remove_reference<r1>::type>::type uncvref_r1;
     144                typedef typename is_member_function_pointer<uncvref_r1>::type type;
     145                BOOST_STATIC_CONSTANT(bool, value = type::value);
     146            };
     147
     148            /// INTERNAL ONLY
     149            template<typename Expr, typename Context, bool IsMemFunCall>
     150            struct memfun_eval
     151            {
     152            private:
     153                typedef typename result_of::child_c<Expr, 0>::type e0;
     154                typedef typename result_of::child_c<Expr, 1>::type e1;
     155                typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0;
     156                typedef typename proto::result_of::eval<UNREF(e1), Context>::type r1;
     157            public:
     158                BOOST_PROTO_DECLTYPE_(
     159                    proto::detail::make_mutable<r0>() ->* proto::detail::make<r1>()
     160                  , result_type
     161                )
     162                result_type operator ()(Expr &expr, Context &ctx) const
     163                {
     164                    return proto::eval(proto::child_c<0>(expr), ctx)
     165                       ->* proto::eval(proto::child_c<1>(expr), ctx);
     166                }
     167            };
     168
     169            /// INTERNAL ONLY
     170            template<typename Expr, typename Context>
     171            struct memfun_eval<Expr, Context, true>
     172            {
     173            private:
     174                typedef typename result_of::child_c<Expr, 0>::type e0;
     175                typedef typename result_of::child_c<Expr, 1>::type e1;
     176                typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0;
     177                typedef typename proto::result_of::eval<UNREF(e1), Context>::type r1;
     178            public:
     179                typedef detail::memfun<r0, r1> result_type;
     180                result_type const operator ()(Expr &expr, Context &ctx) const
     181                {
     182                    return detail::memfun<r0, r1>(
     183                        proto::eval(proto::child_c<0>(expr), ctx)
     184                      , proto::eval(proto::child_c<1>(expr), ctx)
     185                    );
     186                }
     187            };
     188
     189            template<typename Expr, typename Context>
     190            struct default_eval<Expr, Context, tag::mem_ptr, 2>
     191              : memfun_eval<Expr, Context, is_member_function_eval<Expr, Context>::value>
     192            {};
     193
    138194            template<typename Expr, typename Context>
    139195            struct default_eval<Expr, Context, proto::tag::terminal, 0>
  • branches/proto/v4/boost/proto/detail/decltype.hpp

    r44721 r44723  
    1313#include <boost/config.hpp>
    1414#include <boost/preprocessor/cat.hpp>
     15#include <boost/preprocessor/repetition/enum_params.hpp>
     16#include <boost/preprocessor/repetition/enum_binary_params.hpp>
     17#include <boost/preprocessor/repetition/repeat_from_to.hpp>
    1518#include <boost/mpl/if.hpp>
    1619#include <boost/type_traits/is_function.hpp>
    1720#include <boost/typeof/typeof.hpp>
     21#include <boost/utility/result_of.hpp>
    1822#include <boost/proto/detail/suffix.hpp> // must be last include
    1923
     
    188192        //BOOST_MPL_ASSERT((is_same<void(*)(),  result_of_fixup<void(&)()>::type>));
    189193
     194        template<typename T, typename PMF>
     195        struct memfun
     196        {
     197            typedef typename remove_const<typename remove_reference<PMF>::type>::type pmf_type;
     198            typedef typename boost::result_of<pmf_type(T)>::type result_type;
     199
     200            memfun(T t, PMF pmf)
     201              : obj(t)
     202              , pmf(pmf)
     203            {}
     204
     205            result_type operator()() const
     206            {
     207                return (detail::deref(obj).*pmf)();
     208            }
     209
     210            #define M0(Z, N, DATA)                                                                  \
     211            template<BOOST_PP_ENUM_PARAMS_Z(Z, N, typename A)>                                      \
     212            result_type operator()(BOOST_PP_ENUM_BINARY_PARAMS_Z(Z, N, A, const &a)) const          \
     213            {                                                                                       \
     214                return (detail::deref(obj).*pmf)(BOOST_PP_ENUM_PARAMS_Z(Z, N, a));                  \
     215            }                                                                                       \
     216            /**/
     217            BOOST_PP_REPEAT_FROM_TO(1, BOOST_PROTO_MAX_ARITY, M0, ~)
     218            #undef M0
     219
     220        private:
     221            T obj;
     222            PMF pmf;           
     223        };
     224
    190225    } // namespace detail
    191226}}
  • branches/proto/v4/boost/proto/proto_fwd.hpp

    r44677 r44723  
    725725
    726726    template<typename Fun>
    727     struct bind;
     727    struct lazy;
    728728
    729729    template<typename Sequence, typename State, typename Fun>
  • branches/proto/v4/boost/proto/transform/default.hpp

    r44721 r44723  
    121121            BOOST_PROTO_BINARY_OP_RESULT(|, tag::bitwise_or, make, make)
    122122            BOOST_PROTO_BINARY_OP_RESULT(^, tag::bitwise_xor, make, make)
    123             BOOST_PROTO_BINARY_OP_RESULT(->*, tag::mem_ptr, make_mutable, make)
    124123
    125124            BOOST_PROTO_BINARY_OP_RESULT(=, tag::assign, make_mutable, make)
     
    137136            #undef BOOST_PROTO_UNARY_OP_RESULT
    138137            #undef BOOST_PROTO_BINARY_OP_RESULT
     138           
     139            /// INTERNAL ONLY
     140            template<typename Expr, typename State, typename Data>
     141            struct is_member_function_invocation
     142            {
     143                typedef typename result_of::child_c<Expr, 1>::type e1;
     144                typedef typename Grammar::template impl<e1, State, Data>::result_type r1;
     145                typedef typename remove_const<typename remove_reference<r1>::type>::type uncvref_r1;
     146                typedef typename is_member_function_pointer<uncvref_r1>::type type;
     147                BOOST_STATIC_CONSTANT(bool, value = type::value);
     148            };
     149
     150            /// INTERNAL ONLY
     151            template<typename Expr, typename State, typename Data, bool IsMemFunCall>
     152            struct memfun_impl
     153              : transform_impl<Expr, State, Data>
     154            {
     155            private:
     156                typedef typename result_of::child_c<Expr, 0>::type e0;
     157                typedef typename result_of::child_c<Expr, 1>::type e1;
     158                typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
     159                typedef typename Grammar::template impl<e1, State, Data>::result_type r1;
     160            public:
     161                BOOST_PROTO_DECLTYPE_(
     162                    proto::detail::make_mutable<r0>() ->* proto::detail::make<r1>()
     163                  , result_type
     164                )
     165                result_type operator ()(
     166                    typename memfun_impl::expr_param expr
     167                  , typename memfun_impl::state_param state
     168                  , typename memfun_impl::data_param data
     169                ) const
     170                {
     171                    typename Grammar::template impl<e0, State, Data> t0;
     172                    typename Grammar::template impl<e1, State, Data> t1;
     173                    return t0(proto::child_c<0>(expr), state, data)
     174                       ->* t1(proto::child_c<1>(expr), state, data);
     175                }
     176            };
     177
     178            /// INTERNAL ONLY
     179            template<typename Expr, typename State, typename Data>
     180            struct memfun_impl<Expr, State, Data, true>
     181              : transform_impl<Expr, State, Data>
     182            {
     183            private:
     184                typedef typename result_of::child_c<Expr, 0>::type e0;
     185                typedef typename result_of::child_c<Expr, 1>::type e1;
     186                typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
     187                typedef typename Grammar::template impl<e1, State, Data>::result_type r1;
     188            public:
     189                typedef detail::memfun<r0, r1> result_type;
     190                result_type const operator ()(
     191                    typename memfun_impl::expr_param expr
     192                  , typename memfun_impl::state_param state
     193                  , typename memfun_impl::data_param data
     194                ) const
     195                {
     196                    typename Grammar::template impl<e0, State, Data> t0;
     197                    typename Grammar::template impl<e1, State, Data> t1;
     198                    return detail::memfun<r0, r1>(
     199                        t0(proto::child_c<0>(expr), state, data)
     200                      , t1(proto::child_c<1>(expr), state, data)
     201                    );
     202                }
     203            };
     204
     205            template<typename Expr, typename State, typename Data>
     206            struct impl2<Expr, State, Data, tag::mem_ptr, 2>
     207              : memfun_impl<Expr, State, Data, is_member_function_invocation<Expr, State, Data>::value>
     208            {};
    139209
    140210            template<typename Expr, typename State, typename Data>
Note: See TracChangeset for help on using the changeset viewer.