| // 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 CLASS_DWA200216_HPP |
| # define CLASS_DWA200216_HPP |
| |
| # include <boost/python/detail/prefix.hpp> |
| |
| # include <boost/noncopyable.hpp> |
| |
| # include <boost/python/class_fwd.hpp> |
| # include <boost/python/object/class.hpp> |
| |
| # include <boost/python/object.hpp> |
| # include <boost/python/type_id.hpp> |
| # include <boost/python/data_members.hpp> |
| # include <boost/python/make_function.hpp> |
| # include <boost/python/signature.hpp> |
| # include <boost/python/init.hpp> |
| # include <boost/python/args_fwd.hpp> |
| |
| # include <boost/python/object/class_metadata.hpp> |
| # include <boost/python/object/pickle_support.hpp> |
| # include <boost/python/object/add_to_namespace.hpp> |
| |
| # include <boost/python/detail/overloads_fwd.hpp> |
| # include <boost/python/detail/operator_id.hpp> |
| # include <boost/python/detail/def_helper.hpp> |
| # include <boost/python/detail/force_instantiate.hpp> |
| # include <boost/python/detail/unwrap_type_id.hpp> |
| # include <boost/python/detail/unwrap_wrapper.hpp> |
| |
| # include <boost/type_traits/is_same.hpp> |
| # include <boost/type_traits/is_member_function_pointer.hpp> |
| # include <boost/type_traits/is_polymorphic.hpp> |
| |
| # include <boost/mpl/size.hpp> |
| # include <boost/mpl/for_each.hpp> |
| # include <boost/mpl/bool.hpp> |
| # include <boost/mpl/not.hpp> |
| |
| # include <boost/detail/workaround.hpp> |
| |
| # if BOOST_WORKAROUND(__MWERKS__, <= 0x3004) \ |
| /* pro9 reintroduced the bug */ \ |
| || (BOOST_WORKAROUND(__MWERKS__, > 0x3100) \ |
| && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3201))) \ |
| || BOOST_WORKAROUND(__GNUC__, < 3) |
| |
| # define BOOST_PYTHON_NO_MEMBER_POINTER_ORDERING 1 |
| |
| # endif |
| |
| # ifdef BOOST_PYTHON_NO_MEMBER_POINTER_ORDERING |
| # include <boost/mpl/and.hpp> |
| # include <boost/type_traits/is_member_pointer.hpp> |
| # endif |
| |
| namespace boost { namespace python { |
| |
| template <class DerivedVisitor> class def_visitor; |
| |
| enum no_init_t { no_init }; |
| |
| namespace detail |
| { |
| // This function object is used with mpl::for_each to write the id |
| // of the type a pointer to which is passed as its 2nd compile-time |
| // argument. into the iterator pointed to by its runtime argument |
| struct write_type_id |
| { |
| write_type_id(type_info**p) : p(p) {} |
| |
| // Here's the runtime behavior |
| template <class T> |
| void operator()(T*) const |
| { |
| *(*p)++ = type_id<T>(); |
| } |
| |
| type_info** p; |
| }; |
| |
| template <class T> |
| struct is_data_member_pointer |
| : mpl::and_< |
| is_member_pointer<T> |
| , mpl::not_<is_member_function_pointer<T> > |
| > |
| {}; |
| |
| # ifdef BOOST_PYTHON_NO_MEMBER_POINTER_ORDERING |
| # define BOOST_PYTHON_DATA_MEMBER_HELPER(D) , detail::is_data_member_pointer<D>() |
| # define BOOST_PYTHON_YES_DATA_MEMBER , mpl::true_ |
| # define BOOST_PYTHON_NO_DATA_MEMBER , mpl::false_ |
| # elif defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) |
| # define BOOST_PYTHON_DATA_MEMBER_HELPER(D) , 0 |
| # define BOOST_PYTHON_YES_DATA_MEMBER , int |
| # define BOOST_PYTHON_NO_DATA_MEMBER , ... |
| # else |
| # define BOOST_PYTHON_DATA_MEMBER_HELPER(D) |
| # define BOOST_PYTHON_YES_DATA_MEMBER |
| # define BOOST_PYTHON_NO_DATA_MEMBER |
| # endif |
| |
| namespace error |
| { |
| // |
| // A meta-assertion mechanism which prints nice error messages and |
| // backtraces on lots of compilers. Usage: |
| // |
| // assertion<C>::failed |
| // |
| // where C is an MPL metafunction class |
| // |
| |
| template <class C> struct assertion_failed { }; |
| template <class C> struct assertion_ok { typedef C failed; }; |
| |
| template <class C> |
| struct assertion |
| : mpl::if_<C, assertion_ok<C>, assertion_failed<C> >::type |
| {}; |
| |
| // |
| // Checks for validity of arguments used to define virtual |
| // functions with default implementations. |
| // |
| |
| template <class Default> |
| void not_a_derived_class_member(Default) {} |
| |
| template <class T, class Fn> |
| struct virtual_function_default |
| { |
| template <class Default> |
| static void |
| must_be_derived_class_member(Default const&) |
| { |
| typedef typename assertion<mpl::not_<is_same<Default,Fn> > >::failed test0; |
| # if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407) |
| typedef typename assertion<is_polymorphic<T> >::failed test1; |
| # endif |
| typedef typename assertion<is_member_function_pointer<Fn> >::failed test2; |
| not_a_derived_class_member<Default>(Fn()); |
| } |
| }; |
| } |
| } |
| |
| // This is the primary mechanism through which users will expose |
| // C++ classes to Python. |
| template < |
| class W // class being wrapped |
| , class X1 // = detail::not_specified |
| , class X2 // = detail::not_specified |
| , class X3 // = detail::not_specified |
| > |
| class class_ : public objects::class_base |
| { |
| public: // types |
| typedef objects::class_base base; |
| typedef class_<W,X1,X2,X3> self; |
| typedef typename objects::class_metadata<W,X1,X2,X3> metadata; |
| typedef W wrapped_type; |
| |
| private: // types |
| |
| // A helper class which will contain an array of id objects to be |
| // passed to the base class constructor |
| struct id_vector |
| { |
| typedef typename metadata::bases bases; |
| |
| id_vector() |
| { |
| // Stick the derived class id into the first element of the array |
| ids[0] = detail::unwrap_type_id((W*)0, (W*)0); |
| |
| // Write the rest of the elements into succeeding positions. |
| type_info* p = ids + 1; |
| mpl::for_each(detail::write_type_id(&p), (bases*)0, (add_pointer<mpl::_>*)0); |
| } |
| |
| BOOST_STATIC_CONSTANT( |
| std::size_t, size = mpl::size<bases>::value + 1); |
| type_info ids[size]; |
| }; |
| friend struct id_vector; |
| |
| public: // constructors |
| |
| // Construct with the class name, with or without docstring, and default __init__() function |
| class_(char const* name, char const* doc = 0); |
| |
| // Construct with class name, no docstring, and an uncallable __init__ function |
| class_(char const* name, no_init_t); |
| |
| // Construct with class name, docstring, and an uncallable __init__ function |
| class_(char const* name, char const* doc, no_init_t); |
| |
| // Construct with class name and init<> function |
| template <class DerivedT> |
| inline class_(char const* name, init_base<DerivedT> const& i) |
| : base(name, id_vector::size, id_vector().ids) |
| { |
| this->initialize(i); |
| } |
| |
| // Construct with class name, docstring and init<> function |
| template <class DerivedT> |
| inline class_(char const* name, char const* doc, init_base<DerivedT> const& i) |
| : base(name, id_vector::size, id_vector().ids, doc) |
| { |
| this->initialize(i); |
| } |
| |
| public: // member functions |
| |
| // Generic visitation |
| template <class Derived> |
| self& def(def_visitor<Derived> const& visitor) |
| { |
| visitor.visit(*this); |
| return *this; |
| } |
| |
| // Wrap a member function or a non-member function which can take |
| // a T, T cv&, or T cv* as its first parameter, a callable |
| // python object, or a generic visitor. |
| template <class F> |
| self& def(char const* name, F f) |
| { |
| this->def_impl( |
| detail::unwrap_wrapper((W*)0) |
| , name, f, detail::def_helper<char const*>(0), &f); |
| return *this; |
| } |
| |
| template <class A1, class A2> |
| self& def(char const* name, A1 a1, A2 const& a2) |
| { |
| this->def_maybe_overloads(name, a1, a2, &a2); |
| return *this; |
| } |
| |
| template <class Fn, class A1, class A2> |
| self& def(char const* name, Fn fn, A1 const& a1, A2 const& a2) |
| { |
| // The arguments are definitely: |
| // def(name, function, policy, doc_string) |
| // def(name, function, doc_string, policy) |
| |
| this->def_impl( |
| detail::unwrap_wrapper((W*)0) |
| , name, fn |
| , detail::def_helper<A1,A2>(a1,a2) |
| , &fn); |
| |
| return *this; |
| } |
| |
| template <class Fn, class A1, class A2, class A3> |
| self& def(char const* name, Fn fn, A1 const& a1, A2 const& a2, A3 const& a3) |
| { |
| this->def_impl( |
| detail::unwrap_wrapper((W*)0) |
| , name, fn |
| , detail::def_helper<A1,A2,A3>(a1,a2,a3) |
| , &fn); |
| |
| return *this; |
| } |
| |
| // |
| // Data member access |
| // |
| template <class D> |
| self& def_readonly(char const* name, D const& d, char const* doc=0) |
| { |
| return this->def_readonly_impl(name, d, doc BOOST_PYTHON_DATA_MEMBER_HELPER(D)); |
| } |
| |
| template <class D> |
| self& def_readwrite(char const* name, D const& d, char const* doc=0) |
| { |
| return this->def_readwrite_impl(name, d, doc BOOST_PYTHON_DATA_MEMBER_HELPER(D)); |
| } |
| |
| template <class D> |
| self& def_readonly(char const* name, D& d, char const* doc=0) |
| { |
| return this->def_readonly_impl(name, d, doc BOOST_PYTHON_DATA_MEMBER_HELPER(D)); |
| } |
| |
| template <class D> |
| self& def_readwrite(char const* name, D& d, char const* doc=0) |
| { |
| return this->def_readwrite_impl(name, d, doc BOOST_PYTHON_DATA_MEMBER_HELPER(D)); |
| } |
| |
| // Property creation |
| # if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) |
| template <class Get> |
| self& add_property(char const* name, Get fget, char const* docstr = 0) |
| { |
| base::add_property(name, this->make_getter(fget), docstr); |
| return *this; |
| } |
| |
| template <class Get, class Set> |
| self& add_property(char const* name, Get fget, Set fset, char const* docstr = 0) |
| { |
| base::add_property( |
| name, this->make_getter(fget), this->make_setter(fset), docstr); |
| return *this; |
| } |
| # else |
| private: |
| template <class Get> |
| self& add_property_impl(char const* name, Get fget, char const* docstr, int) |
| { |
| base::add_property(name, this->make_getter(fget), docstr); |
| return *this; |
| } |
| |
| template <class Get, class Set> |
| self& add_property_impl(char const* name, Get fget, Set fset, ...) |
| { |
| base::add_property( |
| name, this->make_getter(fget), this->make_setter(fset), 0); |
| return *this; |
| } |
| |
| public: |
| template <class Get> |
| self& add_property(char const* name, Get fget) |
| { |
| base::add_property(name, this->make_getter(fget), 0); |
| return *this; |
| } |
| |
| template <class Get, class DocStrOrSet> |
| self& add_property(char const* name, Get fget, DocStrOrSet docstr_or_set) |
| { |
| this->add_property_impl(name, this->make_getter(fget), docstr_or_set, 0); |
| return *this; |
| } |
| |
| template <class Get, class Set> |
| self& |
| add_property(char const* name, Get fget, Set fset, char const* docstr) |
| { |
| base::add_property( |
| name, this->make_getter(fget), this->make_setter(fset), docstr); |
| return *this; |
| } |
| # endif |
| |
| template <class Get> |
| self& add_static_property(char const* name, Get fget) |
| { |
| base::add_static_property(name, object(fget)); |
| return *this; |
| } |
| |
| template <class Get, class Set> |
| self& add_static_property(char const* name, Get fget, Set fset) |
| { |
| base::add_static_property(name, object(fget), object(fset)); |
| return *this; |
| } |
| |
| template <class U> |
| self& setattr(char const* name, U const& x) |
| { |
| this->base::setattr(name, object(x)); |
| return *this; |
| } |
| |
| // Pickle support |
| template <typename PickleSuiteType> |
| self& def_pickle(PickleSuiteType const& x) |
| { |
| error_messages::must_be_derived_from_pickle_suite(x); |
| detail::pickle_suite_finalize<PickleSuiteType>::register_( |
| *this, |
| &PickleSuiteType::getinitargs, |
| &PickleSuiteType::getstate, |
| &PickleSuiteType::setstate, |
| PickleSuiteType::getstate_manages_dict()); |
| return *this; |
| } |
| |
| self& enable_pickling() |
| { |
| this->base::enable_pickling_(false); |
| return *this; |
| } |
| |
| self& staticmethod(char const* name) |
| { |
| this->make_method_static(name); |
| return *this; |
| } |
| private: // helper functions |
| |
| // Builds a method for this class around the given [member] |
| // function pointer or object, appropriately adjusting the type of |
| // the first signature argument so that if f is a member of a |
| // (possibly not wrapped) base class of T, an lvalue argument of |
| // type T will be required. |
| // |
| // @group PropertyHelpers { |
| template <class F> |
| object make_getter(F f) |
| { |
| typedef typename api::is_object_operators<F>::type is_obj_or_proxy; |
| |
| return this->make_fn_impl( |
| detail::unwrap_wrapper((W*)0) |
| , f, is_obj_or_proxy(), (char*)0, detail::is_data_member_pointer<F>() |
| ); |
| } |
| |
| template <class F> |
| object make_setter(F f) |
| { |
| typedef typename api::is_object_operators<F>::type is_obj_or_proxy; |
| |
| return this->make_fn_impl( |
| detail::unwrap_wrapper((W*)0) |
| , f, is_obj_or_proxy(), (int*)0, detail::is_data_member_pointer<F>() |
| ); |
| } |
| |
| template <class T, class F> |
| object make_fn_impl(T*, F const& f, mpl::false_, void*, mpl::false_) |
| { |
| return python::make_function(f, default_call_policies(), detail::get_signature(f, (T*)0)); |
| } |
| |
| template <class T, class D, class B> |
| object make_fn_impl(T*, D B::*pm_, mpl::false_, char*, mpl::true_) |
| { |
| D T::*pm = pm_; |
| return python::make_getter(pm); |
| } |
| |
| template <class T, class D, class B> |
| object make_fn_impl(T*, D B::*pm_, mpl::false_, int*, mpl::true_) |
| { |
| D T::*pm = pm_; |
| return python::make_setter(pm); |
| } |
| |
| template <class T, class F> |
| object make_fn_impl(T*, F const& x, mpl::true_, void*, mpl::false_) |
| { |
| return x; |
| } |
| // } |
| |
| template <class D, class B> |
| self& def_readonly_impl( |
| char const* name, D B::*pm_, char const* doc BOOST_PYTHON_YES_DATA_MEMBER) |
| { |
| return this->add_property(name, pm_, doc); |
| } |
| |
| template <class D, class B> |
| self& def_readwrite_impl( |
| char const* name, D B::*pm_, char const* doc BOOST_PYTHON_YES_DATA_MEMBER) |
| { |
| return this->add_property(name, pm_, pm_, doc); |
| } |
| |
| template <class D> |
| self& def_readonly_impl( |
| char const* name, D& d, char const* BOOST_PYTHON_NO_DATA_MEMBER) |
| { |
| return this->add_static_property(name, python::make_getter(d)); |
| } |
| |
| template <class D> |
| self& def_readwrite_impl( |
| char const* name, D& d, char const* BOOST_PYTHON_NO_DATA_MEMBER) |
| { |
| return this->add_static_property(name, python::make_getter(d), python::make_setter(d)); |
| } |
| |
| template <class DefVisitor> |
| inline void initialize(DefVisitor const& i) |
| { |
| metadata::register_(); // set up runtime metadata/conversions |
| |
| typedef typename metadata::holder holder; |
| this->set_instance_size( objects::additional_instance_size<holder>::value ); |
| |
| this->def(i); |
| } |
| |
| inline void initialize(no_init_t) |
| { |
| metadata::register_(); // set up runtime metadata/conversions |
| this->def_no_init(); |
| } |
| |
| // |
| // These two overloads discriminate between def() as applied to a |
| // generic visitor and everything else. |
| // |
| // @group def_impl { |
| template <class T, class Helper, class LeafVisitor, class Visitor> |
| inline void def_impl( |
| T* |
| , char const* name |
| , LeafVisitor |
| , Helper const& helper |
| , def_visitor<Visitor> const* v |
| ) |
| { |
| v->visit(*this, name, helper); |
| } |
| |
| template <class T, class Fn, class Helper> |
| inline void def_impl( |
| T* |
| , char const* name |
| , Fn fn |
| , Helper const& helper |
| , ... |
| ) |
| { |
| objects::add_to_namespace( |
| *this |
| , name |
| , make_function( |
| fn |
| , helper.policies() |
| , helper.keywords() |
| , detail::get_signature(fn, (T*)0) |
| ) |
| , helper.doc() |
| ); |
| |
| this->def_default(name, fn, helper, mpl::bool_<Helper::has_default_implementation>()); |
| } |
| // } |
| |
| // |
| // These two overloads handle the definition of default |
| // implementation overloads for virtual functions. The second one |
| // handles the case where no default implementation was specified. |
| // |
| // @group def_default { |
| template <class Fn, class Helper> |
| inline void def_default( |
| char const* name |
| , Fn |
| , Helper const& helper |
| , mpl::bool_<true>) |
| { |
| detail::error::virtual_function_default<W,Fn>::must_be_derived_class_member( |
| helper.default_implementation()); |
| |
| objects::add_to_namespace( |
| *this, name, |
| make_function( |
| helper.default_implementation(), helper.policies(), helper.keywords()) |
| ); |
| } |
| |
| template <class Fn, class Helper> |
| inline void def_default(char const*, Fn, Helper const&, mpl::bool_<false>) |
| { } |
| // } |
| |
| // |
| // These two overloads discriminate between def() as applied to |
| // regular functions and def() as applied to the result of |
| // BOOST_PYTHON_FUNCTION_OVERLOADS(). The final argument is used to |
| // discriminate. |
| // |
| // @group def_maybe_overloads { |
| template <class OverloadsT, class SigT> |
| void def_maybe_overloads( |
| char const* name |
| , SigT sig |
| , OverloadsT const& overloads |
| , detail::overloads_base const*) |
| |
| { |
| // convert sig to a type_list (see detail::get_signature in signature.hpp) |
| // before calling detail::define_with_defaults. |
| detail::define_with_defaults( |
| name, overloads, *this, detail::get_signature(sig)); |
| } |
| |
| template <class Fn, class A1> |
| void def_maybe_overloads( |
| char const* name |
| , Fn fn |
| , A1 const& a1 |
| , ...) |
| { |
| this->def_impl( |
| detail::unwrap_wrapper((W*)0) |
| , name |
| , fn |
| , detail::def_helper<A1>(a1) |
| , &fn |
| ); |
| |
| } |
| // } |
| }; |
| |
| |
| // |
| // implementations |
| // |
| |
| template <class W, class X1, class X2, class X3> |
| inline class_<W,X1,X2,X3>::class_(char const* name, char const* doc) |
| : base(name, id_vector::size, id_vector().ids, doc) |
| { |
| this->initialize(init<>()); |
| // select_holder::assert_default_constructible(); |
| } |
| |
| template <class W, class X1, class X2, class X3> |
| inline class_<W,X1,X2,X3>::class_(char const* name, no_init_t) |
| : base(name, id_vector::size, id_vector().ids) |
| { |
| this->initialize(no_init); |
| } |
| |
| template <class W, class X1, class X2, class X3> |
| inline class_<W,X1,X2,X3>::class_(char const* name, char const* doc, no_init_t) |
| : base(name, id_vector::size, id_vector().ids, doc) |
| { |
| this->initialize(no_init); |
| } |
| |
| }} // namespace boost::python |
| |
| # undef BOOST_PYTHON_DATA_MEMBER_HELPER |
| # undef BOOST_PYTHON_YES_DATA_MEMBER |
| # undef BOOST_PYTHON_NO_DATA_MEMBER |
| # undef BOOST_PYTHON_NO_MEMBER_POINTER_ORDERING |
| |
| #endif // CLASS_DWA200216_HPP |