#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/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/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();

 }

 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 signature_element const* signature()

         {

             return detail::signature<Sig>::elements();

         }

      private:

         compressed_pair<F,Policies> m_data;

     };

 };

 #endif // BOOST_PP_IS_ITERATING