| #if !defined(BOOST_PP_IS_ITERATING) |
| |
| // Copyright David Abrahams 2002. |
| // Distributed under 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) |
| |
| # ifndef CALLER_DWA20021121_HPP |
| # define CALLER_DWA20021121_HPP |
| |
| # include <boost/python/type_id.hpp> |
| # include <boost/python/handle.hpp> |
| |
| # include <boost/detail/indirect_traits.hpp> |
| |
| # include <boost/python/detail/invoke.hpp> |
| # include <boost/python/detail/signature.hpp> |
| # include <boost/python/detail/preprocessor.hpp> |
| |
| # include <boost/python/arg_from_python.hpp> |
| # include <boost/python/converter/context_result_converter.hpp> |
| # include <boost/python/converter/builtin_converters.hpp> |
| |
| # include <boost/preprocessor/iterate.hpp> |
| # include <boost/preprocessor/cat.hpp> |
| # include <boost/preprocessor/dec.hpp> |
| # include <boost/preprocessor/if.hpp> |
| # include <boost/preprocessor/iteration/local.hpp> |
| # include <boost/preprocessor/repetition/enum_trailing_params.hpp> |
| # include <boost/preprocessor/repetition/repeat.hpp> |
| |
| # include <boost/compressed_pair.hpp> |
| |
| # include <boost/type_traits/is_same.hpp> |
| # include <boost/type_traits/is_convertible.hpp> |
| |
| # include <boost/mpl/apply.hpp> |
| # include <boost/mpl/eval_if.hpp> |
| # include <boost/mpl/identity.hpp> |
| # include <boost/mpl/size.hpp> |
| # include <boost/mpl/at.hpp> |
| # include <boost/mpl/int.hpp> |
| # include <boost/mpl/next.hpp> |
| |
| namespace boost { namespace python { namespace detail { |
| |
| template <int N> |
| inline PyObject* get(mpl::int_<N>, PyObject* const& args_) |
| { |
| return PyTuple_GET_ITEM(args_,N); |
| } |
| |
| inline unsigned arity(PyObject* const& args_) |
| { |
| return PyTuple_GET_SIZE(args_); |
| } |
| |
| // This "result converter" is really just used as |
| // a dispatch tag to invoke(...), selecting the appropriate |
| // implementation |
| typedef int void_result_to_python; |
| |
| // Given a model of CallPolicies and a C++ result type, this |
| // metafunction selects the appropriate converter to use for |
| // converting the result to python. |
| template <class Policies, class Result> |
| struct select_result_converter |
| : mpl::eval_if< |
| is_same<Result,void> |
| , mpl::identity<void_result_to_python> |
| , mpl::apply1<typename Policies::result_converter,Result> |
| > |
| { |
| }; |
| |
| template <class ArgPackage, class ResultConverter> |
| inline ResultConverter create_result_converter( |
| ArgPackage const& args_ |
| , ResultConverter* |
| , converter::context_result_converter* |
| ) |
| { |
| return ResultConverter(args_); |
| } |
| |
| template <class ArgPackage, class ResultConverter> |
| inline ResultConverter create_result_converter( |
| ArgPackage const& |
| , ResultConverter* |
| , ... |
| ) |
| { |
| return ResultConverter(); |
| } |
| |
| #ifndef BOOST_PYTHON_NO_PY_SIGNATURES |
| template <class ResultConverter> |
| struct converter_target_type |
| { |
| static PyTypeObject const *get_pytype() |
| { |
| return create_result_converter((PyObject*)0, (ResultConverter *)0, (ResultConverter *)0).get_pytype(); |
| } |
| }; |
| |
| template < > |
| struct converter_target_type <void_result_to_python > |
| { |
| static PyTypeObject const *get_pytype() |
| { |
| return 0; |
| } |
| }; |
| #endif |
| |
| |
| template <unsigned> struct caller_arity; |
| |
| template <class F, class CallPolicies, class Sig> |
| struct caller; |
| |
| # define BOOST_PYTHON_NEXT(init,name,n) \ |
| typedef BOOST_PP_IF(n,typename mpl::next< BOOST_PP_CAT(name,BOOST_PP_DEC(n)) >::type, init) name##n; |
| |
| # define BOOST_PYTHON_ARG_CONVERTER(n) \ |
| BOOST_PYTHON_NEXT(typename mpl::next<first>::type, arg_iter,n) \ |
| typedef arg_from_python<BOOST_DEDUCED_TYPENAME arg_iter##n::type> c_t##n; \ |
| c_t##n c##n(get(mpl::int_<n>(), inner_args)); \ |
| if (!c##n.convertible()) \ |
| return 0; |
| |
| # define BOOST_PP_ITERATION_PARAMS_1 \ |
| (3, (0, BOOST_PYTHON_MAX_ARITY + 1, <boost/python/detail/caller.hpp>)) |
| # include BOOST_PP_ITERATE() |
| |
| # undef BOOST_PYTHON_ARG_CONVERTER |
| # undef BOOST_PYTHON_NEXT |
| |
| // A metafunction returning the base class used for caller<class F, |
| // class ConverterGenerators, class CallPolicies, class Sig>. |
| template <class F, class CallPolicies, class Sig> |
| struct caller_base_select |
| { |
| enum { arity = mpl::size<Sig>::value - 1 }; |
| typedef typename caller_arity<arity>::template impl<F,CallPolicies,Sig> type; |
| }; |
| |
| // A function object type which wraps C++ objects as Python callable |
| // objects. |
| // |
| // Template Arguments: |
| // |
| // F - |
| // the C++ `function object' that will be called. Might |
| // actually be any data for which an appropriate invoke_tag() can |
| // be generated. invoke(...) takes care of the actual invocation syntax. |
| // |
| // CallPolicies - |
| // The precall, postcall, and what kind of resultconverter to |
| // generate for mpl::front<Sig>::type |
| // |
| // Sig - |
| // The `intended signature' of the function. An MPL sequence |
| // beginning with a result type and continuing with a list of |
| // argument types. |
| template <class F, class CallPolicies, class Sig> |
| struct caller |
| : caller_base_select<F,CallPolicies,Sig>::type |
| { |
| typedef typename caller_base_select< |
| F,CallPolicies,Sig |
| >::type base; |
| |
| typedef PyObject* result_type; |
| |
| caller(F f, CallPolicies p) : base(f,p) {} |
| |
| }; |
| |
| }}} // namespace boost::python::detail |
| |
| # endif // CALLER_DWA20021121_HPP |
| |
| #else |
| |
| # define N BOOST_PP_ITERATION() |
| |
| template <> |
| struct caller_arity<N> |
| { |
| template <class F, class Policies, class Sig> |
| struct impl |
| { |
| impl(F f, Policies p) : m_data(f,p) {} |
| |
| PyObject* operator()(PyObject* args_, PyObject*) // eliminate |
| // this |
| // trailing |
| // keyword dict |
| { |
| typedef typename mpl::begin<Sig>::type first; |
| typedef typename first::type result_t; |
| typedef typename select_result_converter<Policies, result_t>::type result_converter; |
| typedef typename Policies::argument_package argument_package; |
| |
| argument_package inner_args(args_); |
| |
| # if N |
| # define BOOST_PP_LOCAL_MACRO(i) BOOST_PYTHON_ARG_CONVERTER(i) |
| # define BOOST_PP_LOCAL_LIMITS (0, N-1) |
| # include BOOST_PP_LOCAL_ITERATE() |
| # endif |
| // all converters have been checked. Now we can do the |
| // precall part of the policy |
| if (!m_data.second().precall(inner_args)) |
| return 0; |
| |
| PyObject* result = detail::invoke( |
| detail::invoke_tag<result_t,F>() |
| , create_result_converter(args_, (result_converter*)0, (result_converter*)0) |
| , m_data.first() |
| BOOST_PP_ENUM_TRAILING_PARAMS(N, c) |
| ); |
| |
| return m_data.second().postcall(inner_args, result); |
| } |
| |
| static unsigned min_arity() { return N; } |
| |
| static py_func_sig_info signature() |
| { |
| const signature_element * sig = detail::signature<Sig>::elements(); |
| #ifndef BOOST_PYTHON_NO_PY_SIGNATURES |
| |
| typedef BOOST_DEDUCED_TYPENAME Policies::template extract_return_type<Sig>::type rtype; |
| typedef typename select_result_converter<Policies, rtype>::type result_converter; |
| |
| static const signature_element ret = { |
| (boost::is_void<rtype>::value ? "void" : type_id<rtype>().name()) |
| , &detail::converter_target_type<result_converter>::get_pytype |
| , boost::detail::indirect_traits::is_reference_to_non_const<rtype>::value |
| }; |
| py_func_sig_info res = {sig, &ret }; |
| #else |
| py_func_sig_info res = {sig, sig }; |
| #endif |
| |
| return res; |
| } |
| private: |
| compressed_pair<F,Policies> m_data; |
| }; |
| }; |
| |
| |
| |
| #endif // BOOST_PP_IS_ITERATING |
| |
| |