/*============================================================================= | |
Copyright (c) 2006-2007 Tobias Schwinger | |
Use modification and distribution are subject to the Boost Software | |
License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at | |
http://www.boost.org/LICENSE_1_0.txt). | |
==============================================================================*/ | |
#if !defined(BOOST_FUSION_FUNCTIONAL_ADAPTER_UNFUSED_TYPED_HPP_INCLUDED) | |
#if !defined(BOOST_PP_IS_ITERATING) | |
#include <boost/preprocessor/cat.hpp> | |
#include <boost/preprocessor/iteration/iterate.hpp> | |
#include <boost/preprocessor/repetition/enum.hpp> | |
#include <boost/preprocessor/repetition/enum_params.hpp> | |
#include <boost/preprocessor/repetition/enum_trailing_params.hpp> | |
#include <boost/config.hpp> | |
#include <boost/utility/result_of.hpp> | |
#include <boost/fusion/support/detail/access.hpp> | |
#include <boost/fusion/sequence/intrinsic/value_at.hpp> | |
#include <boost/fusion/sequence/intrinsic/size.hpp> | |
#include <boost/fusion/container/vector/vector.hpp> | |
#include <boost/fusion/container/vector/convert.hpp> | |
#include <boost/fusion/functional/adapter/limits.hpp> | |
#include <boost/fusion/functional/adapter/detail/access.hpp> | |
#if defined (BOOST_MSVC) | |
# pragma warning(push) | |
# pragma warning (disable: 4512) // assignment operator could not be generated. | |
#endif | |
namespace boost { namespace fusion | |
{ | |
template <class Function, class Sequence> class unfused_typed; | |
//----- ---- --- -- - - - - | |
namespace detail | |
{ | |
template <class Derived, class Function, | |
class Sequence, long Arity> | |
struct unfused_typed_impl; | |
} | |
template <class Function, class Sequence> | |
class unfused_typed | |
: public detail::unfused_typed_impl | |
< unfused_typed<Function,Sequence>, Function, Sequence, | |
result_of::size<Sequence>::value > | |
{ | |
Function fnc_transformed; | |
template <class D, class F, class S, long A> | |
friend struct detail::unfused_typed_impl; | |
typedef typename detail::call_param<Function>::type func_const_fwd_t; | |
public: | |
inline explicit unfused_typed(func_const_fwd_t f = Function()) | |
: fnc_transformed(f) | |
{ } | |
}; | |
#define BOOST_PP_FILENAME_1 <boost/fusion/functional/adapter/unfused_typed.hpp> | |
#define BOOST_PP_ITERATION_LIMITS (0,BOOST_FUSION_UNFUSED_TYPED_MAX_ARITY) | |
#include BOOST_PP_ITERATE() | |
}} | |
#if defined (BOOST_MSVC) | |
# pragma warning(pop) | |
#endif | |
namespace boost | |
{ | |
template<class F, class Seq> | |
struct result_of< boost::fusion::unfused_typed<F,Seq> const () > | |
: boost::fusion::unfused_typed<F,Seq>::template result< | |
boost::fusion::unfused_typed<F,Seq> const () > | |
{ }; | |
template<class F, class Seq> | |
struct result_of< boost::fusion::unfused_typed<F,Seq>() > | |
: boost::fusion::unfused_typed<F,Seq>::template result< | |
boost::fusion::unfused_typed<F,Seq> () > | |
{ }; | |
} | |
#define BOOST_FUSION_FUNCTIONAL_ADAPTER_UNFUSED_TYPED_HPP_INCLUDED | |
#else // defined(BOOST_PP_IS_ITERATING) | |
/////////////////////////////////////////////////////////////////////////////// | |
// | |
// Preprocessor vertical repetition code | |
// | |
/////////////////////////////////////////////////////////////////////////////// | |
#define N BOOST_PP_ITERATION() | |
namespace detail | |
{ | |
template <class Derived, class Function, class Sequence> | |
struct unfused_typed_impl<Derived,Function,Sequence,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; | |
public: | |
#define M(z,i,s) \ | |
typename call_param<typename result_of::value_at_c<s,i>::type>::type a##i | |
inline typename boost::result_of< | |
function_c(arg_vector_t &) >::type | |
operator()(BOOST_PP_ENUM(N,M,arg_vector_t)) const | |
{ | |
#if N > 0 | |
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); | |
} | |
inline typename boost::result_of< | |
function(arg_vector_t &) >::type | |
operator()(BOOST_PP_ENUM(N,M,arg_vector_t)) | |
{ | |
#if N > 0 | |
arg_vector_t arg(BOOST_PP_ENUM_PARAMS(N,a)); | |
#else | |
arg_vector_t arg; | |
#endif | |
return static_cast<Derived *>(this)->fnc_transformed(arg); | |
} | |
#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 | |
#undef N | |
#endif // defined(BOOST_PP_IS_ITERATING) | |
#endif | |