// 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