| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // 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) |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| #if !defined(BOOST_PP_IS_ITERATING) |
| |
| #ifndef DEFAULTS_DEF_JDG20020811_HPP |
| #define DEFAULTS_DEF_JDG20020811_HPP |
| |
| #include <boost/python/detail/defaults_gen.hpp> |
| #include <boost/type_traits.hpp> |
| #include <boost/mpl/front.hpp> |
| #include <boost/mpl/size.hpp> |
| #include <boost/static_assert.hpp> |
| #include <boost/preprocessor/iterate.hpp> |
| #include <boost/python/class_fwd.hpp> |
| #include <boost/python/scope.hpp> |
| #include <boost/preprocessor/debug/line.hpp> |
| #include <boost/python/detail/scope.hpp> |
| #include <boost/python/detail/make_keyword_range_fn.hpp> |
| #include <boost/python/object/add_to_namespace.hpp> |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| namespace boost { namespace python { |
| |
| struct module; |
| |
| namespace objects |
| { |
| struct class_base; |
| } |
| |
| namespace detail |
| { |
| // Called as:: |
| // |
| // name_space_def(ns, "func", func, kw, policies, docstring, &ns) |
| // |
| // Dispatch to properly add f to namespace ns. |
| // |
| // @group define_stub_function helpers { |
| template <class Func, class CallPolicies, class NameSpaceT> |
| static void name_space_def( |
| NameSpaceT& name_space |
| , char const* name |
| , Func f |
| , keyword_range const& kw |
| , CallPolicies const& policies |
| , char const* doc |
| , objects::class_base* |
| ) |
| { |
| typedef typename NameSpaceT::wrapped_type wrapped_type; |
| |
| objects::add_to_namespace( |
| name_space, name, |
| detail::make_keyword_range_function( |
| f, policies, kw, get_signature(f, (wrapped_type*)0)) |
| , doc |
| ); |
| } |
| |
| template <class Func, class CallPolicies> |
| static void name_space_def( |
| object& name_space |
| , char const* name |
| , Func f |
| , keyword_range const& kw |
| , CallPolicies const& policies |
| , char const* doc |
| , ... |
| ) |
| { |
| scope within(name_space); |
| |
| detail::scope_setattr_doc( |
| name |
| , detail::make_keyword_range_function(f, policies, kw) |
| , doc); |
| } |
| |
| // For backward compatibility -- is this obsolete? |
| template <class Func, class CallPolicies, class NameSpaceT> |
| static void name_space_def( |
| NameSpaceT& name_space |
| , char const* name |
| , Func f |
| , keyword_range const& kw // ignored |
| , CallPolicies const& policies |
| , char const* doc |
| , module* |
| ) |
| { |
| name_space.def(name, f, policies, doc); |
| } |
| // } |
| |
| |
| // Expansions of :: |
| // |
| // template <typename OverloadsT, typename NameSpaceT> |
| // inline void |
| // define_stub_function( |
| // char const* name, OverloadsT s, NameSpaceT& name_space, mpl::int_<N>) |
| // { |
| // name_space.def(name, &OverloadsT::func_N); |
| // } |
| // |
| // where N runs from 0 to BOOST_PYTHON_MAX_ARITY. |
| // |
| // The set of overloaded functions (define_stub_function) expects: |
| // |
| // 1. char const* name: function name that will be visible to python |
| // 2. OverloadsT: a function overloads struct (see defaults_gen.hpp) |
| // 3. NameSpaceT& name_space: a python::class_ or python::module instance |
| // 4. int_t<N>: the Nth overloaded function (OverloadsT::func_N) |
| // (see defaults_gen.hpp) |
| // 5. char const* name: doc string |
| // |
| // @group define_stub_function<N> { |
| template <int N> |
| struct define_stub_function {}; |
| |
| #define BOOST_PP_ITERATION_PARAMS_1 \ |
| (3, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/detail/defaults_def.hpp>)) |
| |
| #include BOOST_PP_ITERATE() |
| |
| // } |
| |
| // This helper template struct does the actual recursive |
| // definition. There's a generic version |
| // define_with_defaults_helper<N> and a terminal case |
| // define_with_defaults_helper<0>. The struct and its |
| // specialization has a sole static member function def that |
| // expects: |
| // |
| // 1. char const* name: function name that will be |
| // visible to python |
| // |
| // 2. OverloadsT: a function overloads struct |
| // (see defaults_gen.hpp) |
| // |
| // 3. NameSpaceT& name_space: a python::class_ or |
| // python::module instance |
| // |
| // 4. char const* name: doc string |
| // |
| // The def static member function calls a corresponding |
| // define_stub_function<N>. The general case recursively calls |
| // define_with_defaults_helper<N-1>::def until it reaches the |
| // terminal case case define_with_defaults_helper<0>. |
| template <int N> |
| struct define_with_defaults_helper { |
| |
| template <class StubsT, class CallPolicies, class NameSpaceT> |
| static void |
| def( |
| char const* name, |
| StubsT stubs, |
| keyword_range kw, |
| CallPolicies const& policies, |
| NameSpaceT& name_space, |
| char const* doc) |
| { |
| // define the NTH stub function of stubs |
| define_stub_function<N>::define(name, stubs, kw, policies, name_space, doc); |
| |
| if (kw.second > kw.first) |
| --kw.second; |
| |
| // call the next define_with_defaults_helper |
| define_with_defaults_helper<N-1>::def(name, stubs, kw, policies, name_space, doc); |
| } |
| }; |
| |
| template <> |
| struct define_with_defaults_helper<0> { |
| |
| template <class StubsT, class CallPolicies, class NameSpaceT> |
| static void |
| def( |
| char const* name, |
| StubsT stubs, |
| keyword_range const& kw, |
| CallPolicies const& policies, |
| NameSpaceT& name_space, |
| char const* doc) |
| { |
| // define the Oth stub function of stubs |
| define_stub_function<0>::define(name, stubs, kw, policies, name_space, doc); |
| // return |
| } |
| }; |
| |
| // define_with_defaults |
| // |
| // 1. char const* name: function name that will be |
| // visible to python |
| // |
| // 2. OverloadsT: a function overloads struct |
| // (see defaults_gen.hpp) |
| // |
| // 3. CallPolicies& policies: Call policies |
| // 4. NameSpaceT& name_space: a python::class_ or |
| // python::module instance |
| // |
| // 5. SigT sig: Function signature typelist |
| // (see defaults_gen.hpp) |
| // |
| // 6. char const* name: doc string |
| // |
| // This is the main entry point. This function recursively |
| // defines all stub functions of StubT (see defaults_gen.hpp) in |
| // NameSpaceT name_space which can be either a python::class_ or |
| // a python::module. The sig argument is a typelist that |
| // specifies the return type, the class (for member functions, |
| // and the arguments. Here are some SigT examples: |
| // |
| // int foo(int) mpl::vector<int, int> |
| // void bar(int, int) mpl::vector<void, int, int> |
| // void C::foo(int) mpl::vector<void, C, int> |
| // |
| template <class OverloadsT, class NameSpaceT, class SigT> |
| inline void |
| define_with_defaults( |
| char const* name, |
| OverloadsT const& overloads, |
| NameSpaceT& name_space, |
| SigT const&) |
| { |
| typedef typename mpl::front<SigT>::type return_type; |
| typedef typename OverloadsT::void_return_type void_return_type; |
| typedef typename OverloadsT::non_void_return_type non_void_return_type; |
| |
| typedef typename mpl::if_c< |
| boost::is_same<void, return_type>::value |
| , void_return_type |
| , non_void_return_type |
| >::type stubs_type; |
| |
| BOOST_STATIC_ASSERT( |
| (stubs_type::max_args) <= mpl::size<SigT>::value); |
| |
| typedef typename stubs_type::template gen<SigT> gen_type; |
| define_with_defaults_helper<stubs_type::n_funcs-1>::def( |
| name |
| , gen_type() |
| , overloads.keywords() |
| , overloads.call_policies() |
| , name_space |
| , overloads.doc_string()); |
| } |
| |
| } // namespace detail |
| |
| }} // namespace boost::python |
| |
| #endif // DEFAULTS_DEF_JDG20020811_HPP |
| |
| #else // defined(BOOST_PP_IS_ITERATING) |
| // PP vertical iteration code |
| |
| |
| template <> |
| struct define_stub_function<BOOST_PP_ITERATION()> { |
| template <class StubsT, class CallPolicies, class NameSpaceT> |
| static void define( |
| char const* name |
| , StubsT const& |
| , keyword_range const& kw |
| , CallPolicies const& policies |
| , NameSpaceT& name_space |
| , char const* doc) |
| { |
| detail::name_space_def( |
| name_space |
| , name |
| , &StubsT::BOOST_PP_CAT(func_, BOOST_PP_ITERATION()) |
| , kw |
| , policies |
| , doc |
| , &name_space); |
| } |
| }; |
| |
| #endif // !defined(BOOST_PP_IS_ITERATING) |