← Back
Editing: init.hpp
/////////////////////////////////////////////////////////////////////////////// // // Copyright David Abrahams 2002. // Copyright 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 INIT_JDG20020820_HPP #define INIT_JDG20020820_HPP # include <boost/python/detail/prefix.hpp> #include <boost/python/detail/type_list.hpp> #include <boost/python/args_fwd.hpp> #include <boost/python/detail/make_keyword_range_fn.hpp> #include <boost/python/def_visitor.hpp> #include <boost/mpl/if.hpp> #include <boost/mpl/eval_if.hpp> #include <boost/mpl/size.hpp> #include <boost/mpl/iterator_range.hpp> #include <boost/mpl/empty.hpp> #include <boost/mpl/begin_end.hpp> #include <boost/mpl/bool.hpp> #include <boost/mpl/prior.hpp> #include <boost/mpl/joint_view.hpp> #include <boost/mpl/back.hpp> #include <boost/python/detail/type_traits.hpp> #include <boost/preprocessor/enum_params_with_a_default.hpp> #include <boost/preprocessor/enum_params.hpp> #include <utility> /////////////////////////////////////////////////////////////////////////////// #define BOOST_PYTHON_OVERLOAD_TYPES_WITH_DEFAULT \ BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT( \ BOOST_PYTHON_MAX_ARITY, \ class T, \ mpl::void_) \ #define BOOST_PYTHON_OVERLOAD_TYPES \ BOOST_PP_ENUM_PARAMS_Z(1, \ BOOST_PYTHON_MAX_ARITY, \ class T) \ #define BOOST_PYTHON_OVERLOAD_ARGS \ BOOST_PP_ENUM_PARAMS_Z(1, \ BOOST_PYTHON_MAX_ARITY, \ T) \ /////////////////////////////////////////////////////////////////////////////// namespace boost { namespace python { template <BOOST_PYTHON_OVERLOAD_TYPES_WITH_DEFAULT> class init; // forward declaration template <BOOST_PYTHON_OVERLOAD_TYPES_WITH_DEFAULT> struct optional; // forward declaration namespace detail { namespace error { template <int keywords, int init_args> struct more_keywords_than_init_arguments { typedef char too_many_keywords[init_args - keywords >= 0 ? 1 : -1] BOOST_ATTRIBUTE_UNUSED; }; } // is_optional<T>::value // // This metaprogram checks if T is an optional // template <class T> struct is_optional : mpl::false_ {}; template <BOOST_PYTHON_OVERLOAD_TYPES> struct is_optional<optional<BOOST_PYTHON_OVERLOAD_ARGS> > : mpl::true_ {}; template <int NDefaults> struct define_class_init_helper; } // namespace detail template <class DerivedT> struct init_base : def_visitor<DerivedT> { init_base(char const* doc_, detail::keyword_range const& keywords_) : m_doc(doc_), m_keywords(keywords_) {} init_base(char const* doc_) : m_doc(doc_) {} DerivedT const& derived() const { return *static_cast<DerivedT const*>(this); } char const* doc_string() const { return m_doc; } detail::keyword_range const& keywords() const { return m_keywords; } static default_call_policies call_policies() { return default_call_policies(); } private: // visit // // Defines a set of n_defaults + 1 constructors for its // class_<...> argument. Each constructor after the first has // one less argument to its right. Example: // // init<int, optional<char, long, double> > // // Defines: // // __init__(int, char, long, double) // __init__(int, char, long) // __init__(int, char) // __init__(int) template <class classT> void visit(classT& cl) const { typedef typename DerivedT::signature signature; typedef typename DerivedT::n_arguments n_arguments; typedef typename DerivedT::n_defaults n_defaults; detail::define_class_init_helper<n_defaults::value>::apply( cl , derived().call_policies() , signature() , n_arguments() , derived().doc_string() , derived().keywords()); } friend class python::def_visitor_access; private: // data members char const* m_doc; detail::keyword_range m_keywords; }; template <class CallPoliciesT, class InitT> class init_with_call_policies : public init_base<init_with_call_policies<CallPoliciesT, InitT> > { typedef init_base<init_with_call_policies<CallPoliciesT, InitT> > base; public: typedef typename InitT::n_arguments n_arguments; typedef typename InitT::n_defaults n_defaults; typedef typename InitT::signature signature; init_with_call_policies( CallPoliciesT const& policies_ , char const* doc_ , detail::keyword_range const& keywords ) : base(doc_, keywords) , m_policies(policies_) {} CallPoliciesT const& call_policies() const { return this->m_policies; } private: // data members CallPoliciesT m_policies; }; // // drop1<S> is the initial length(S) elements of S // namespace detail { template <class S> struct drop1 : mpl::iterator_range< typename mpl::begin<S>::type , typename mpl::prior< typename mpl::end<S>::type >::type > {}; } template <BOOST_PYTHON_OVERLOAD_TYPES> class init : public init_base<init<BOOST_PYTHON_OVERLOAD_ARGS> > { typedef init_base<init<BOOST_PYTHON_OVERLOAD_ARGS> > base; public: typedef init<BOOST_PYTHON_OVERLOAD_ARGS> self_t; init(char const* doc_ = 0) : base(doc_) { } template <std::size_t N> init(char const* doc_, detail::keywords<N> const& kw) : base(doc_, kw.range()) { typedef typename detail::error::more_keywords_than_init_arguments< N, n_arguments::value + 1 >::too_many_keywords assertion BOOST_ATTRIBUTE_UNUSED; } template <std::size_t N> init(detail::keywords<N> const& kw, char const* doc_ = 0) : base(doc_, kw.range()) { typedef typename detail::error::more_keywords_than_init_arguments< N, n_arguments::value + 1 >::too_many_keywords assertion BOOST_ATTRIBUTE_UNUSED; } template <class CallPoliciesT> init_with_call_policies<CallPoliciesT, self_t> operator[](CallPoliciesT const& policies) const { return init_with_call_policies<CallPoliciesT, self_t>( policies, this->doc_string(), this->keywords()); } typedef detail::type_list<BOOST_PYTHON_OVERLOAD_ARGS> signature_; typedef detail::is_optional< typename mpl::eval_if< mpl::empty<signature_> , mpl::false_ , mpl::back<signature_> >::type > back_is_optional; typedef typename mpl::eval_if< back_is_optional , mpl::back<signature_> , mpl::vector0<> >::type optional_args; typedef typename mpl::eval_if< back_is_optional , mpl::if_< mpl::empty<optional_args> , detail::drop1<signature_> , mpl::joint_view< detail::drop1<signature_> , optional_args > > , signature_ >::type signature; // TODO: static assert to make sure there are no other optional elements // Count the number of default args typedef mpl::size<optional_args> n_defaults; typedef mpl::size<signature> n_arguments; }; /////////////////////////////////////////////////////////////////////////////// // // optional // // optional<T0...TN>::type returns a typelist. // /////////////////////////////////////////////////////////////////////////////// template <BOOST_PYTHON_OVERLOAD_TYPES> struct optional : detail::type_list<BOOST_PYTHON_OVERLOAD_ARGS> { }; namespace detail { template <class ClassT, class CallPoliciesT, class Signature, class NArgs> inline void def_init_aux( ClassT& cl , Signature const& , NArgs , CallPoliciesT const& policies , char const* doc , detail::keyword_range const& keywords_ ) { cl.def( "__init__" , detail::make_keyword_range_constructor<Signature,NArgs>( policies , keywords_ , (typename ClassT::metadata::holder*)0 ) , doc ); } /////////////////////////////////////////////////////////////////////////////// // // define_class_init_helper<N>::apply // // General case // // Accepts a class_ and an arguments list. Defines a constructor // for the class given the arguments and recursively calls // define_class_init_helper<N-1>::apply with one fewer argument (the // rightmost argument is shaved off) // /////////////////////////////////////////////////////////////////////////////// template <int NDefaults> struct define_class_init_helper { template <class ClassT, class CallPoliciesT, class Signature, class NArgs> static void apply( ClassT& cl , CallPoliciesT const& policies , Signature const& args , NArgs , char const* doc , detail::keyword_range keywords) { detail::def_init_aux(cl, args, NArgs(), policies, doc, keywords); if (keywords.second > keywords.first) --keywords.second; typedef typename mpl::prior<NArgs>::type next_nargs; define_class_init_helper<NDefaults-1>::apply( cl, policies, Signature(), next_nargs(), doc, keywords); } }; /////////////////////////////////////////////////////////////////////////////// // // define_class_init_helper<0>::apply // // Terminal case // // Accepts a class_ and an arguments list. Defines a constructor // for the class given the arguments. // /////////////////////////////////////////////////////////////////////////////// template <> struct define_class_init_helper<0> { template <class ClassT, class CallPoliciesT, class Signature, class NArgs> static void apply( ClassT& cl , CallPoliciesT const& policies , Signature const& args , NArgs , char const* doc , detail::keyword_range const& keywords) { detail::def_init_aux(cl, args, NArgs(), policies, doc, keywords); } }; } }} // namespace boost::python #undef BOOST_PYTHON_OVERLOAD_TYPES_WITH_DEFAULT #undef BOOST_PYTHON_OVERLOAD_TYPES #undef BOOST_PYTHON_OVERLOAD_ARGS #undef BOOST_PYTHON_IS_OPTIONAL_VALUE #undef BOOST_PYTHON_APPEND_TO_INIT /////////////////////////////////////////////////////////////////////////////// #endif // INIT_JDG20020820_HPP
Save File
Cancel