feedc0de/boost_fusion
1
0
Fork 0
forked from boostorg/fusion
Code Pull Requests Activity

adds const correctness, simplifies code, fixes nullary member function invocation

Browse Source 
[SVN r38204]
This commit is contained in:
Tobias Schwinger
2007-07-13 16:29:45 +00:00
parent 685d26c847
commit c57e840377
1 changed files with 62 additions and 85 deletions
Download Patch File Download Diff File Expand all files Collapse all files

147
include/boost/fusion/functional/invocation/invoke.hpp
View File

@ -22,15 +22,9 @@
#include <boost/mpl/if.hpp> #include <boost/mpl/if.hpp>
#include <boost/mpl/eval_if.hpp> #include <boost/mpl/eval_if.hpp>
#include <boost/mpl/or.hpp> #include <boost/mpl/or.hpp>
#include <boost/mpl/and.hpp>
#include <boost/mpl/less.hpp>
#include <boost/mpl/equal_to.hpp>
#include <boost/mpl/size_t.hpp>
#include <boost/mpl/front.hpp> #include <boost/mpl/front.hpp>
#include <boost/mpl/identity.hpp> #include <boost/mpl/identity.hpp>
#include <boost/blank.hpp>
#include <boost/type_traits/add_const.hpp> #include <boost/type_traits/add_const.hpp>
#include <boost/type_traits/remove_cv.hpp> #include <boost/type_traits/remove_cv.hpp>
#include <boost/type_traits/add_reference.hpp> #include <boost/type_traits/add_reference.hpp>
@ -39,10 +33,10 @@
#include <boost/function_types/is_function.hpp> #include <boost/function_types/is_function.hpp>
#include <boost/function_types/is_callable_builtin.hpp> #include <boost/function_types/is_callable_builtin.hpp>
#include <boost/function_types/is_member_pointer.hpp>
#include <boost/function_types/is_member_function_pointer.hpp> #include <boost/function_types/is_member_function_pointer.hpp>
#include <boost/function_types/result_type.hpp> #include <boost/function_types/result_type.hpp>
#include <boost/function_types/parameter_types.hpp> #include <boost/function_types/parameter_types.hpp>
#include <boost/function_types/function_arity.hpp>
#include <boost/utility/result_of.hpp> #include <boost/utility/result_of.hpp>
@ -81,45 +75,53 @@ namespace boost { namespace fusion
typename Function, class Sequence, typename Function, class Sequence,
int N = result_of::size<Sequence>::value, int N = result_of::size<Sequence>::value,
bool CBI = ft::is_callable_builtin<Function>::value, bool CBI = ft::is_callable_builtin<Function>::value,
bool MFP = ft::is_member_function_pointer<Function>::value,
bool RandomAccess = traits::is_random_access<Sequence>::value bool RandomAccess = traits::is_random_access<Sequence>::value
> >
struct invoke_impl struct invoke_impl;
{
typedef boost::blank result;
};
template <class Sequence, int N> struct invoke_param_types; template <class Sequence, int N>
struct invoke_param_types;
template <typename Func, class N, bool CBI = true, typename Sig = void> template <typename T, class Sequence>
// contains type member with the result, empty on error struct invoke_data_member;
struct invoke_result
: mpl::if_<
mpl::or_<
mpl::equal_to< ft::function_arity<Func>, N >,
mpl::and_< ft::is_callable_builtin<Func, ft::variadic>,
mpl::less< ft::function_arity<Func>, N > >
>, ft::result_type<Func>, boost::blank
>::type
{ };
template <typename Func, class N, typename Sig>
struct invoke_result<Func,N,false,Sig>
: boost::result_of<Sig>
{ };
// Transform for F so that boost::result_of< F(...) > works template <typename Function, class Sequence, int N, bool RandomAccess>
template <typename F> struct invoke_result_of_prep struct invoke_mem_fn;
: mpl::if_< ft::is_function<F>, boost::add_reference<F>,
boost::remove_cv<F>
>::type
{ };
#define BOOST_PP_FILENAME_1 <boost/fusion/functional/invocation/invoke.hpp> #define BOOST_PP_FILENAME_1 <boost/fusion/functional/invocation/invoke.hpp>
#define BOOST_PP_ITERATION_LIMITS (0, BOOST_FUSION_INVOKE_MAX_ARITY) #define BOOST_PP_ITERATION_LIMITS (0, BOOST_FUSION_INVOKE_MAX_ARITY)
#include BOOST_PP_ITERATE() #include BOOST_PP_ITERATE()
template <typename F, class Sequence, int N, bool RandomAccess>
struct invoke_nonmember_builtin
// use same implementation as for function objects but...
: invoke_impl< // ...work around boost::result_of bugs
typename mpl::eval_if< ft::is_function<F>,
boost::add_reference<F>, boost::remove_cv<F> >::type,
Sequence, N, false, RandomAccess >
{ };
template <typename Function, class Sequence, int N, bool RandomAccess>
struct invoke_impl<Function,Sequence,N,true,RandomAccess>
: mpl::if_< ft::is_member_function_pointer<Function>,
invoke_mem_fn<Function,Sequence,N,RandomAccess>,
invoke_nonmember_builtin<Function,Sequence,N,RandomAccess>
>::type
{ };
template <typename Function, class Sequence, bool RandomAccess>
struct invoke_impl<Function,Sequence,1,true,RandomAccess>
: mpl::eval_if< ft::is_member_pointer<Function>,
mpl::if_< ft::is_member_function_pointer<Function>,
invoke_mem_fn<Function,Sequence,1,RandomAccess>,
invoke_data_member<Function, Sequence> >,
mpl::identity< invoke_nonmember_builtin<
Function,Sequence,1,RandomAccess> >
>::type
{ };
template <typename T, class C, class Sequence> template <typename T, class C, class Sequence>
struct invoke_data_member struct invoke_data_member< T C::*, Sequence >
{ {
private: private:
@ -137,37 +139,25 @@ namespace boost { namespace fusion
public: public:
template <typename _ = void> typedef typename boost::add_reference<qualified_type>::type
struct result result_type;
: boost::add_reference<qualified_type>
{ };
static inline typename result<>::type call(T C::* f, Sequence & s) static inline result_type call(T C::* f, Sequence & s)
{ {
typename result_of::front<Sequence>::type c = fusion::front(s); typename result_of::front<Sequence>::type c = fusion::front(s);
return that_ptr<qualified_class>::get(c)->*f; return that_ptr<qualified_class>::get(c)->*f;
} }
}; };
template <typename T, class C, class Sequence>
struct invoke_impl<T C::*, Sequence, 1, true, false, false>
: detail::invoke_data_member<T, C, Sequence>
{ };
template <typename T, class C, class Sequence>
struct invoke_impl<T C::*, Sequence, 1, true, false, true>
: detail::invoke_data_member<T, C, Sequence>
{ };
} }
namespace result_of namespace result_of
{ {
template <typename Function, class Sequence> struct invoke template <typename Function, class Sequence> struct invoke
: detail::invoke_impl< {
typedef typename detail::invoke_impl<
typename boost::remove_reference<Function>::type, Sequence typename boost::remove_reference<Function>::type, Sequence
>::template result<> >::result_type type;
{ }; };
} }
template <typename Function, class Sequence> template <typename Function, class Sequence>
@ -199,23 +189,18 @@ namespace boost { namespace fusion
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
#define N BOOST_PP_ITERATION() #define N BOOST_PP_ITERATION()
template <typename Function, class Sequence, bool CBI> template <typename Function, class Sequence>
struct invoke_impl<Function,Sequence,N,CBI,false,true> struct invoke_impl<Function,Sequence,N,false,true>
{ {
private:
typedef typename invoke_result_of_prep<Function>::type func;
public: public:
template <typename _ = void> typedef typename boost::result_of<
struct result
: invoke_result< Function, mpl::size_t<N>, CBI,
#define M(z,j,data) typename result_of::at_c<Sequence,j>::type #define M(z,j,data) typename result_of::at_c<Sequence,j>::type
func(BOOST_PP_ENUM(N,M,~)) > Function(BOOST_PP_ENUM(N,M,~)) >::type result_type;
#undef M #undef M
{ };
template <typename F> template <typename F>
static inline typename result<F>::type static inline result_type
call(F & f, Sequence & s) call(F & f, Sequence & s)
{ {
#define M(z,j,data) fusion::at_c<j>(s) #define M(z,j,data) fusion::at_c<j>(s)
@ -223,19 +208,17 @@ namespace boost { namespace fusion
} }
}; };
#if N > 0 #if N > 0
template <typename Function, class Sequence> template <typename Function, class Sequence>
struct invoke_impl<Function,Sequence,N,true,true,true> struct invoke_mem_fn<Function,Sequence,N,true>
{ {
public: public:
template <typename _ = void> typedef typename ft::result_type<Function>::type result_type;
struct result
: invoke_result< Function, mpl::size_t<N> >
{ };
template <typename F> template <typename F>
static inline typename result<F>::type static inline result_type
call(F & f, Sequence & s) call(F & f, Sequence & s)
{ {
return (that_ptr<typename mpl::front< return (that_ptr<typename mpl::front<
@ -251,22 +234,19 @@ namespace boost { namespace fusion
typename seq::I##j i##j = \ typename seq::I##j i##j = \
fusion::next(BOOST_PP_CAT(i,BOOST_PP_DEC(j))); fusion::next(BOOST_PP_CAT(i,BOOST_PP_DEC(j)));
template <typename Function, class Sequence, bool CBI> template <typename Function, class Sequence>
struct invoke_impl<Function,Sequence,N,CBI,false,false> struct invoke_impl<Function,Sequence,N,false,false>
{ {
private: private:
typedef typename invoke_result_of_prep<Function>::type func;
typedef invoke_param_types<Sequence,N> seq; typedef invoke_param_types<Sequence,N> seq;
public: public:
template <typename _ = void> typedef typename boost::result_of<
struct result Function(BOOST_PP_ENUM_PARAMS(N,typename seq::T))
: invoke_result< Function, mpl::size_t<N>, CBI, >::type result_type;
func(BOOST_PP_ENUM_PARAMS(N,typename seq::T)) >
{ };
template <typename F> template <typename F>
static inline typename result<F>::type static inline result_type
call(F & f, Sequence & s) call(F & f, Sequence & s)
{ {
#if N > 0 #if N > 0
@ -279,19 +259,16 @@ namespace boost { namespace fusion
#if N > 0 #if N > 0
template <typename Function, class Sequence> template <typename Function, class Sequence>
struct invoke_impl<Function,Sequence,N,true,true,false> struct invoke_mem_fn<Function,Sequence,N,false>
{ {
private: private:
typedef invoke_param_types<Sequence,N> seq; typedef invoke_param_types<Sequence,N> seq;
public: public:
template <typename _ = void> typedef typename ft::result_type<Function>::type result_type;
struct result
: invoke_result< Function, mpl::size_t<N> >
{ };
template <typename F> template <typename F>
static inline typename result<F>::type static inline result_type
call(F & f, Sequence & s) call(F & f, Sequence & s)
{ {
typename seq::I0 i0 = fusion::begin(s); typename seq::I0 i0 = fusion::begin(s);