boostorg/fusion
1
0
Fork 1
mirror of https://github.com/boostorg/fusion.git synced 2025-07-16 22:02:13 +02:00
Code Issues Packages Projects Releases Wiki Activity

changes semantics to contain only operator() overloads for one arity

Browse Source 
[SVN r38268]
This commit is contained in:
Tobias Schwinger
2007-07-22 08:30:58 +00:00
parent 1484ae8e06
commit f6b7afa277
1 changed files with 37 additions and 95 deletions
Download Patch File Download Diff File Expand all files Collapse all files

132
include/boost/fusion/functional/adapter/unfused_typed.hpp
View File

@ -13,9 +13,9 @@
#include <boost/preprocessor/iteration/iterate.hpp> #include <boost/preprocessor/iteration/iterate.hpp>
#include <boost/preprocessor/repetition/enum.hpp> #include <boost/preprocessor/repetition/enum.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
#include <boost/config.hpp> #include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/utility/result_of.hpp> #include <boost/utility/result_of.hpp>
@ -24,7 +24,6 @@
#include <boost/fusion/sequence/intrinsic/size.hpp> #include <boost/fusion/sequence/intrinsic/size.hpp>
#include <boost/fusion/sequence/container/vector/vector.hpp> #include <boost/fusion/sequence/container/vector/vector.hpp>
#include <boost/fusion/sequence/conversion/as_vector.hpp> #include <boost/fusion/sequence/conversion/as_vector.hpp>
#include <boost/fusion/algorithm/transformation/pop_back.hpp>
#include <boost/fusion/functional/adapter/limits.hpp> #include <boost/fusion/functional/adapter/limits.hpp>
#include <boost/fusion/functional/adapter/detail/access.hpp> #include <boost/fusion/functional/adapter/detail/access.hpp>
@ -39,7 +38,7 @@ namespace boost { namespace fusion
namespace detail namespace detail
{ {
template <class Derived, class FunctionC, class Function, template <class Derived, class Function,
class Sequence, long Arity> class Sequence, long Arity>
struct unfused_typed_impl; struct unfused_typed_impl;
} }
@ -47,71 +46,25 @@ namespace boost { namespace fusion
template <class Function, class Sequence> template <class Function, class Sequence>
class unfused_typed class unfused_typed
: public detail::unfused_typed_impl : public detail::unfused_typed_impl
< unfused_typed<Function,Sequence>, typename detail::qf_c<Function>::type, < unfused_typed<Function,Sequence>, Function, Sequence,
typename detail::qf<Function>::type, Sequence, result_of::size<Sequence>::value > result_of::size<Sequence>::value >
{ {
Function fnc_transformed; Function fnc_transformed;
typedef typename detail::qf_c<Function>::type function_c; template <class D, class F, class S, long A>
typedef typename detail::qf<Function>::type function; friend struct detail::unfused_typed_impl;
typedef typename detail::call_param<Function>::type func_const_fwd_t; typedef typename detail::call_param<Function>::type func_const_fwd_t;
typedef typename detail::unfused_typed_impl<
unfused_typed<Function,Sequence>,function_c,function,Sequence,
result_of::size<Sequence>::value > base;
template <class D, class FC, class F, class S, long A>
friend struct detail::unfused_typed_impl;
public: public:
inline explicit unfused_typed(func_const_fwd_t f = Function()) inline explicit unfused_typed(func_const_fwd_t f = Function())
: fnc_transformed(f) : fnc_transformed(f)
{ } { }
template <typename Sig>
struct result;
}; };
namespace detail
{
template <class Derived, class FunctionC, class Function,
class Sequence>
struct unfused_typed_impl<Derived,FunctionC,Function,Sequence,0>
{
typedef fusion::vector0 arg_vector_t;
public:
typedef typename boost::result_of<
FunctionC (arg_vector_t &) > call_const_0_result;
typedef typename boost::result_of<
Function(arg_vector_t &) > call_0_result;
inline typename boost::result_of<
FunctionC (arg_vector_t &) >::type
operator()() const
{
arg_vector_t arg;
return static_cast<Derived const *>(this)->fnc_transformed(arg);
}
#if !BOOST_WORKAROUND(BOOST_MSVC, < 1400)
inline typename boost::result_of<
Function (arg_vector_t &) >::type
operator()()
{
arg_vector_t arg;
return static_cast<Derived *>(this)->fnc_transformed(arg);
}
#endif
};
}
#define BOOST_PP_FILENAME_1 <boost/fusion/functional/adapter/unfused_typed.hpp> #define BOOST_PP_FILENAME_1 <boost/fusion/functional/adapter/unfused_typed.hpp>
#define BOOST_PP_ITERATION_LIMITS (1,BOOST_FUSION_UNFUSED_TYPED_MAX_ARITY) #define BOOST_PP_ITERATION_LIMITS (0,BOOST_FUSION_UNFUSED_TYPED_MAX_ARITY)
#include BOOST_PP_ITERATE() #include BOOST_PP_ITERATE()
}} }}
@ -120,11 +73,13 @@ namespace boost
{ {
template<class F, class Seq> template<class F, class Seq>
struct result_of< boost::fusion::unfused_typed<F,Seq> const () > struct result_of< boost::fusion::unfused_typed<F,Seq> const () >
: boost::fusion::unfused_typed<F,Seq>::call_const_0_result : boost::fusion::unfused_typed<F,Seq>::template result<
boost::fusion::unfused_typed<F,Seq> const () >
{ }; { };
template<class F, class Seq> template<class F, class Seq>
struct result_of< boost::fusion::unfused_typed<F,Seq>() > struct result_of< boost::fusion::unfused_typed<F,Seq>() >
: boost::fusion::unfused_typed<F,Seq>::call_0_result : boost::fusion::unfused_typed<F,Seq>::template result<
boost::fusion::unfused_typed<F,Seq> () >
{ }; { };
} }
@ -141,72 +96,59 @@ namespace boost
namespace detail namespace detail
{ {
template <class Derived, class FunctionC, class Function, template <class Derived, class Function, class Sequence>
class Sequence> struct unfused_typed_impl<Derived,Function,Sequence,N>
struct unfused_typed_impl<Derived,FunctionC,Function,Sequence,N>
: unfused_typed_impl<Derived,FunctionC,Function,
typename result_of::pop_back<Sequence>::type, BOOST_PP_DEC(N) >
{ {
typedef typename detail::qf_c<Function>::type function_c;
typedef typename detail::qf<Function>::type function;
typedef typename result_of::as_vector<Sequence>::type arg_vector_t; typedef typename result_of::as_vector<Sequence>::type arg_vector_t;
protected:
typedef typename boost::result_of<
FunctionC(arg_vector_t &) > BOOST_PP_CAT(rc,N);
typedef typename boost::result_of<
Function(arg_vector_t &) > BOOST_PP_CAT(r,N);
public: public:
using unfused_typed_impl< Derived,FunctionC,Function,
typename result_of::pop_back<Sequence>::type, BOOST_PP_DEC(N)
>::operator();
#define M(z,i,s) \ #define M(z,i,s) \
typename call_param<typename result_of::value_at_c<s,i>::type>::type a##i typename call_param<typename result_of::value_at_c<s,i>::type>::type a##i
inline typename boost::result_of< inline typename boost::result_of<
FunctionC(arg_vector_t &) >::type function_c(arg_vector_t &) >::type
operator()(BOOST_PP_ENUM(N,M,arg_vector_t)) const operator()(BOOST_PP_ENUM(N,M,arg_vector_t)) const
{ {
#if N > 0
arg_vector_t arg(BOOST_PP_ENUM_PARAMS(N,a)); arg_vector_t arg(BOOST_PP_ENUM_PARAMS(N,a));
#else
arg_vector_t arg;
#endif
return static_cast<Derived const *>(this)->fnc_transformed(arg); return static_cast<Derived const *>(this)->fnc_transformed(arg);
} }
#if !BOOST_WORKAROUND(BOOST_MSVC, < 1400)
inline typename boost::result_of< inline typename boost::result_of<
Function(arg_vector_t &) >::type function(arg_vector_t &) >::type
operator()(BOOST_PP_ENUM(N,M,arg_vector_t)) operator()(BOOST_PP_ENUM(N,M,arg_vector_t))
{ {
#if N > 0
arg_vector_t arg(BOOST_PP_ENUM_PARAMS(N,a)); arg_vector_t arg(BOOST_PP_ENUM_PARAMS(N,a));
#else
arg_vector_t arg;
#endif
return static_cast<Derived *>(this)->fnc_transformed(arg); return static_cast<Derived *>(this)->fnc_transformed(arg);
} }
#endif
#undef M #undef M
template <typename Sig> struct result { typedef void type; };
template <class Self BOOST_PP_ENUM_TRAILING_PARAMS(N,typename T)>
struct result< Self const (BOOST_PP_ENUM_PARAMS(N,T)) >
: boost::result_of< function_c(arg_vector_t &) >
{ };
template <class Self BOOST_PP_ENUM_TRAILING_PARAMS(N,typename T)>
struct result< Self (BOOST_PP_ENUM_PARAMS(N,T)) >
: boost::result_of< function(arg_vector_t &) >
{ };
}; };
} // namespace detail } // namespace detail
#if N > 0
template <class Function, class Sequence>
template <class Self, BOOST_PP_ENUM_PARAMS(N,typename T)>
struct unfused_typed<Function,Sequence>::result<
Self const (BOOST_PP_ENUM_PARAMS(N,T)) >
: BOOST_PP_CAT(base::rc,N)
{ };
# if !BOOST_WORKAROUND(BOOST_MSVC, < 1400)
template <class Function, class Sequence>
template <class Self, BOOST_PP_ENUM_PARAMS(N,typename T)>
struct unfused_typed<Function,Sequence>::result<
Self (BOOST_PP_ENUM_PARAMS(N,T)) >
: BOOST_PP_CAT(base::r,N)
{ };
# endif
#endif
#undef N #undef N
#endif // defined(BOOST_PP_IS_ITERATING) #endif // defined(BOOST_PP_IS_ITERATING)
#endif #endif