Mercurial > hg > vamp-build-and-test
diff DEPENDENCIES/generic/include/boost/python/detail/defaults_def.hpp @ 16:2665513ce2d3
Add boost headers
| author | Chris Cannam |
|---|---|
| date | Tue, 05 Aug 2014 11:11:38 +0100 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/DEPENDENCIES/generic/include/boost/python/detail/defaults_def.hpp Tue Aug 05 11:11:38 2014 +0100 @@ -0,0 +1,291 @@ +/////////////////////////////////////////////////////////////////////////////// +// +// 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)