| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // Copyright David Abrahams 2002, Joel de Guzman, 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 DEFAULTS_GEN_JDG20020807_HPP |
| #define DEFAULTS_GEN_JDG20020807_HPP |
| |
| #include <boost/python/detail/preprocessor.hpp> |
| #include <boost/preprocessor/repeat.hpp> |
| #include <boost/preprocessor/repeat_from_to.hpp> |
| #include <boost/preprocessor/enum.hpp> |
| #include <boost/preprocessor/enum_params.hpp> |
| #include <boost/preprocessor/repetition/enum_binary_params.hpp> |
| #include <boost/preprocessor/tuple.hpp> |
| #include <boost/preprocessor/cat.hpp> |
| #include <boost/preprocessor/arithmetic/sub.hpp> |
| #include <boost/preprocessor/stringize.hpp> |
| #include <boost/preprocessor/inc.hpp> |
| #include <boost/preprocessor/empty.hpp> |
| #include <boost/preprocessor/comma_if.hpp> |
| #include <boost/config.hpp> |
| #include <boost/mpl/begin_end.hpp> |
| #include <boost/mpl/next.hpp> |
| #include <boost/mpl/deref.hpp> |
| #include <cstddef> |
| |
| namespace boost { namespace python { |
| |
| namespace detail |
| { |
| // overloads_base is used as a base class for all function |
| // stubs. This class holds the doc_string of the stubs. |
| struct overloads_base |
| { |
| overloads_base(char const* doc_) |
| : m_doc(doc_) {} |
| |
| overloads_base(char const* doc_, detail::keyword_range const& kw) |
| : m_doc(doc_), m_keywords(kw) {} |
| |
| char const* doc_string() const |
| { |
| return m_doc; |
| } |
| |
| detail::keyword_range const& keywords() const |
| { |
| return m_keywords; |
| } |
| |
| private: |
| char const* m_doc; |
| detail::keyword_range m_keywords; |
| }; |
| |
| // overloads_proxy is generated by the overloads_common operator[] (see |
| // below). This class holds a user defined call policies of the stubs. |
| template <class CallPoliciesT, class OverloadsT> |
| struct overloads_proxy |
| : public overloads_base |
| { |
| typedef typename OverloadsT::non_void_return_type non_void_return_type; |
| typedef typename OverloadsT::void_return_type void_return_type; |
| |
| overloads_proxy( |
| CallPoliciesT const& policies_ |
| , char const* doc |
| , keyword_range const& kw |
| ) |
| : overloads_base(doc, kw) |
| , policies(policies_) |
| {} |
| |
| CallPoliciesT |
| call_policies() const |
| { |
| return policies; |
| } |
| |
| CallPoliciesT policies; |
| }; |
| |
| // overloads_common is our default function stubs base class. This |
| // class returns the default_call_policies in its call_policies() |
| // member function. It can generate a overloads_proxy however through |
| // its operator[] |
| template <class DerivedT> |
| struct overloads_common |
| : public overloads_base |
| { |
| overloads_common(char const* doc) |
| : overloads_base(doc) {} |
| |
| overloads_common(char const* doc, keyword_range const& kw) |
| : overloads_base(doc, kw) {} |
| |
| default_call_policies |
| call_policies() const |
| { |
| return default_call_policies(); |
| } |
| |
| template <class CallPoliciesT> |
| overloads_proxy<CallPoliciesT, DerivedT> |
| operator[](CallPoliciesT const& policies) const |
| { |
| return overloads_proxy<CallPoliciesT, DerivedT>( |
| policies, this->doc_string(), this->keywords()); |
| } |
| }; |
| |
| }}} // namespace boost::python::detail |
| |
| |
| #define BOOST_PYTHON_TYPEDEF_GEN(z, index, data) \ |
| typedef typename ::boost::mpl::next<BOOST_PP_CAT(iter, index)>::type \ |
| BOOST_PP_CAT(iter, BOOST_PP_INC(index)); \ |
| typedef typename ::boost::mpl::deref<BOOST_PP_CAT(iter, index)>::type \ |
| BOOST_PP_CAT(T, index); |
| |
| #define BOOST_PYTHON_FUNC_WRAPPER_GEN(z, index, data) \ |
| static RT BOOST_PP_CAT(func_, \ |
| BOOST_PP_SUB_D(1, index, BOOST_PP_TUPLE_ELEM(3, 1, data))) ( \ |
| BOOST_PP_ENUM_BINARY_PARAMS_Z( \ |
| 1, index, T, arg)) \ |
| { \ |
| BOOST_PP_TUPLE_ELEM(3, 2, data) \ |
| BOOST_PP_TUPLE_ELEM(3, 0, data)( \ |
| BOOST_PP_ENUM_PARAMS( \ |
| index, \ |
| arg)); \ |
| } |
| |
| #define BOOST_PYTHON_GEN_FUNCTION(fname, fstubs_name, n_args, n_dflts, ret) \ |
| struct fstubs_name \ |
| { \ |
| BOOST_STATIC_CONSTANT(int, n_funcs = BOOST_PP_INC(n_dflts)); \ |
| BOOST_STATIC_CONSTANT(int, max_args = n_funcs); \ |
| \ |
| template <typename SigT> \ |
| struct gen \ |
| { \ |
| typedef typename ::boost::mpl::begin<SigT>::type rt_iter; \ |
| typedef typename ::boost::mpl::deref<rt_iter>::type RT; \ |
| typedef typename ::boost::mpl::next<rt_iter>::type iter0; \ |
| \ |
| BOOST_PP_REPEAT_2ND( \ |
| n_args, \ |
| BOOST_PYTHON_TYPEDEF_GEN, \ |
| 0) \ |
| \ |
| BOOST_PP_REPEAT_FROM_TO_2( \ |
| BOOST_PP_SUB_D(1, n_args, n_dflts), \ |
| BOOST_PP_INC(n_args), \ |
| BOOST_PYTHON_FUNC_WRAPPER_GEN, \ |
| (fname, BOOST_PP_SUB_D(1, n_args, n_dflts), ret)) \ |
| }; \ |
| }; \ |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #define BOOST_PYTHON_MEM_FUNC_WRAPPER_GEN(z, index, data) \ |
| static RT BOOST_PP_CAT(func_, \ |
| BOOST_PP_SUB_D(1, index, BOOST_PP_TUPLE_ELEM(3, 1, data))) ( \ |
| ClassT obj BOOST_PP_COMMA_IF(index) \ |
| BOOST_PP_ENUM_BINARY_PARAMS_Z(1, index, T, arg) \ |
| ) \ |
| { \ |
| BOOST_PP_TUPLE_ELEM(3, 2, data) obj.BOOST_PP_TUPLE_ELEM(3, 0, data)( \ |
| BOOST_PP_ENUM_PARAMS(index, arg) \ |
| ); \ |
| } |
| |
| #define BOOST_PYTHON_GEN_MEM_FUNCTION(fname, fstubs_name, n_args, n_dflts, ret) \ |
| struct fstubs_name \ |
| { \ |
| BOOST_STATIC_CONSTANT(int, n_funcs = BOOST_PP_INC(n_dflts)); \ |
| BOOST_STATIC_CONSTANT(int, max_args = n_funcs + 1); \ |
| \ |
| template <typename SigT> \ |
| struct gen \ |
| { \ |
| typedef typename ::boost::mpl::begin<SigT>::type rt_iter; \ |
| typedef typename ::boost::mpl::deref<rt_iter>::type RT; \ |
| \ |
| typedef typename ::boost::mpl::next<rt_iter>::type class_iter; \ |
| typedef typename ::boost::mpl::deref<class_iter>::type ClassT; \ |
| typedef typename ::boost::mpl::next<class_iter>::type iter0; \ |
| \ |
| BOOST_PP_REPEAT_2ND( \ |
| n_args, \ |
| BOOST_PYTHON_TYPEDEF_GEN, \ |
| 0) \ |
| \ |
| BOOST_PP_REPEAT_FROM_TO_2( \ |
| BOOST_PP_SUB_D(1, n_args, n_dflts), \ |
| BOOST_PP_INC(n_args), \ |
| BOOST_PYTHON_MEM_FUNC_WRAPPER_GEN, \ |
| (fname, BOOST_PP_SUB_D(1, n_args, n_dflts), ret)) \ |
| }; \ |
| }; |
| |
| #define BOOST_PYTHON_OVERLOAD_CONSTRUCTORS(fstubs_name, n_args, n_dflts) \ |
| fstubs_name(char const* doc = 0) \ |
| : ::boost::python::detail::overloads_common<fstubs_name>(doc) {} \ |
| template <std::size_t N> \ |
| fstubs_name(char const* doc, ::boost::python::detail::keywords<N> const& keywords) \ |
| : ::boost::python::detail::overloads_common<fstubs_name>( \ |
| doc, keywords.range()) \ |
| { \ |
| typedef typename ::boost::python::detail:: \ |
| error::more_keywords_than_function_arguments< \ |
| N,n_args>::too_many_keywords assertion; \ |
| } \ |
| template <std::size_t N> \ |
| fstubs_name(::boost::python::detail::keywords<N> const& keywords, char const* doc = 0) \ |
| : ::boost::python::detail::overloads_common<fstubs_name>( \ |
| doc, keywords.range()) \ |
| { \ |
| typedef typename ::boost::python::detail:: \ |
| error::more_keywords_than_function_arguments< \ |
| N,n_args>::too_many_keywords assertion; \ |
| } |
| |
| # if defined(BOOST_NO_VOID_RETURNS) |
| |
| # define BOOST_PYTHON_GEN_FUNCTION_STUB(fname, fstubs_name, n_args, n_dflts) \ |
| struct fstubs_name \ |
| : public ::boost::python::detail::overloads_common<fstubs_name> \ |
| { \ |
| BOOST_PYTHON_GEN_FUNCTION( \ |
| fname, non_void_return_type, n_args, n_dflts, return) \ |
| BOOST_PYTHON_GEN_FUNCTION( \ |
| fname, void_return_type, n_args, n_dflts, ;) \ |
| \ |
| BOOST_PYTHON_OVERLOAD_CONSTRUCTORS(fstubs_name, n_args, n_dflts) \ |
| }; |
| |
| # define BOOST_PYTHON_GEN_MEM_FUNCTION_STUB(fname, fstubs_name, n_args, n_dflts) \ |
| struct fstubs_name \ |
| : public ::boost::python::detail::overloads_common<fstubs_name> \ |
| { \ |
| BOOST_PYTHON_GEN_MEM_FUNCTION( \ |
| fname, non_void_return_type, n_args, n_dflts, return) \ |
| BOOST_PYTHON_GEN_MEM_FUNCTION( \ |
| fname, void_return_type, n_args, n_dflts, ;) \ |
| \ |
| BOOST_PYTHON_OVERLOAD_CONSTRUCTORS(fstubs_name, n_args + 1, n_dflts) \ |
| }; |
| |
| # else // !defined(BOOST_NO_VOID_RETURNS) |
| |
| # define BOOST_PYTHON_GEN_FUNCTION_STUB(fname, fstubs_name, n_args, n_dflts) \ |
| struct fstubs_name \ |
| : public ::boost::python::detail::overloads_common<fstubs_name> \ |
| { \ |
| BOOST_PYTHON_GEN_FUNCTION( \ |
| fname, non_void_return_type, n_args, n_dflts, return) \ |
| \ |
| typedef non_void_return_type void_return_type; \ |
| BOOST_PYTHON_OVERLOAD_CONSTRUCTORS(fstubs_name, n_args, n_dflts) \ |
| }; |
| |
| |
| # define BOOST_PYTHON_GEN_MEM_FUNCTION_STUB(fname, fstubs_name, n_args, n_dflts) \ |
| struct fstubs_name \ |
| : public ::boost::python::detail::overloads_common<fstubs_name> \ |
| { \ |
| BOOST_PYTHON_GEN_MEM_FUNCTION( \ |
| fname, non_void_return_type, n_args, n_dflts, return) \ |
| \ |
| typedef non_void_return_type void_return_type; \ |
| BOOST_PYTHON_OVERLOAD_CONSTRUCTORS(fstubs_name, n_args + 1, n_dflts) \ |
| }; |
| |
| # endif // !defined(BOOST_NO_VOID_RETURNS) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // MAIN MACROS |
| // |
| // Given generator_name, fname, min_args and max_args, These macros |
| // generate function stubs that forward to a function or member function |
| // named fname. max_args is the arity of the function or member function |
| // fname. fname can have default arguments. min_args is the minimum |
| // arity that fname can accept. |
| // |
| // There are two versions: |
| // |
| // 1. BOOST_PYTHON_FUNCTION_OVERLOADS for free functions |
| // 2. BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS for member functions. |
| // |
| // For instance, given a function: |
| // |
| // int |
| // foo(int a, char b = 1, unsigned c = 2, double d = 3) |
| // { |
| // return a + b + c + int(d); |
| // } |
| // |
| // The macro invocation: |
| // |
| // BOOST_PYTHON_FUNCTION_OVERLOADS(foo_stubs, foo, 1, 4) |
| // |
| // Generates this code: |
| // |
| // struct foo_stubsNonVoid |
| // { |
| // static const int n_funcs = 4; |
| // static const int max_args = n_funcs; |
| // |
| // template <typename SigT> |
| // struct gen |
| // { |
| // typedef typename ::boost::mpl::begin<SigT>::type rt_iter; |
| // typedef typename rt_iter::type RT; |
| // typedef typename rt_iter::next iter0; |
| // typedef typename iter0::type T0; |
| // typedef typename iter0::next iter1; |
| // typedef typename iter1::type T1; |
| // typedef typename iter1::next iter2; |
| // typedef typename iter2::type T2; |
| // typedef typename iter2::next iter3; |
| // typedef typename iter3::type T3; |
| // typedef typename iter3::next iter4; |
| // |
| // static RT func_0(T0 arg0) |
| // { return foo(arg0); } |
| // |
| // static RT func_1(T0 arg0, T1 arg1) |
| // { return foo(arg0, arg1); } |
| // |
| // static RT func_2(T0 arg0, T1 arg1, T2 arg2) |
| // { return foo(arg0, arg1, arg2); } |
| // |
| // static RT func_3(T0 arg0, T1 arg1, T2 arg2, T3 arg3) |
| // { return foo(arg0, arg1, arg2, arg3); } |
| // }; |
| // }; |
| // |
| // struct foo_overloads |
| // : public boost::python::detail::overloads_common<foo_overloads> |
| // { |
| // typedef foo_overloadsNonVoid non_void_return_type; |
| // typedef foo_overloadsNonVoid void_return_type; |
| // |
| // foo_overloads(char const* doc = 0) |
| // : boost::python::detail::overloads_common<foo_overloads>(doc) {} |
| // }; |
| // |
| // The typedefs non_void_return_type and void_return_type are |
| // used to handle compilers that do not support void returns. The |
| // example above typedefs non_void_return_type and |
| // void_return_type to foo_overloadsNonVoid. On compilers that do |
| // not support void returns, there are two versions: |
| // foo_overloadsNonVoid and foo_overloadsVoid. The "Void" |
| // version is almost identical to the "NonVoid" version except |
| // for the return type (void) and the lack of the return keyword. |
| // |
| // See the overloads_common above for a description of the |
| // foo_overloads' base class. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| #define BOOST_PYTHON_FUNCTION_OVERLOADS(generator_name, fname, min_args, max_args) \ |
| BOOST_PYTHON_GEN_FUNCTION_STUB( \ |
| fname, \ |
| generator_name, \ |
| max_args, \ |
| BOOST_PP_SUB_D(1, max_args, min_args)) |
| |
| #define BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(generator_name, fname, min_args, max_args) \ |
| BOOST_PYTHON_GEN_MEM_FUNCTION_STUB( \ |
| fname, \ |
| generator_name, \ |
| max_args, \ |
| BOOST_PP_SUB_D(1, max_args, min_args)) |
| |
| // deprecated macro names (to be removed) |
| #define BOOST_PYTHON_FUNCTION_GENERATOR BOOST_PYTHON_FUNCTION_OVERLOADS |
| #define BOOST_PYTHON_MEM_FUN_GENERATOR BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #endif // DEFAULTS_GEN_JDG20020807_HPP |
| |
| |