{

PyObject_HEAD

simple x;

: to_python_converter<simple, simple_to_python, true>

//, boost::python::converter::wrap_pytype<&SimpleType>

{

static PyObject* convert(simple const& x)

{

SimpleObject* p = PyObject_New(SimpleObject, &SimpleType);

p->x = x;

return (PyObject*)p;

}

static PyTypeObject const *get_pytype(){return &SimpleType; }

{

static int& execute(NoddyObject& p)

{

return p.x;

}

{

A() : x(0) {}

virtual ~A() {}

char const* name() { return "A"; }

int x;

{

B() : x(1) {}

static char const* name(B*) { return "B"; }

int x;

{

C() : x(2) {}

char const* name() { return "C"; }

virtual ~C() {}

int x;

{

D() : x(3) {}

char const* name() { return "D"; }

int x;

{

using namespace boost::python;

using boost::shared_ptr;

simple_to_python();

lvalue_from_pytype<int_from_noddy,&NoddyType>();

lvalue_from_pytype<

#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300 // doesn't support non-type member pointer parameters

extract_member<SimpleObject, simple, &SimpleObject::x>

#else

extract_simple_object

#endif

, &SimpleType

>();

lvalue_from_pytype<extract_identity<SimpleObject>,&SimpleType>();

def("new_noddy", new_noddy);

def("new_simple", new_simple);

def("make_unregistered", make_unregistered);

def("make_unregistered2", make_unregistered2, return_value_policy<manage_new_object>());

// Expose f() in all its variations

def("f", f);

def("f_mutable_ref", f_mutable_ref);

def("f_mutable_ptr", f_mutable_ptr);

def("f_const_ptr", f_const_ptr);

def("f2", f2);

// Expose g()

def("g", g , return_value_policy<copy_const_reference>()

);

def("take_a", take_a);

def("take_b", take_b);

def("take_c", take_c);

def("take_d", take_d);

def("take_d_shared_ptr", take_d_shared_ptr);

def("d_factory", d_factory);

class_<A, shared_ptr<A> >("A")

.def("name", &A::name)

;

// sequence points don't ensure that "A" is constructed before "B"

// or "C" below if we make them part of the same chain

class_<B,bases<A> >("B")

.def("name", &B::name)

;

class_<C,bases<A> >("C")

.def("name", &C::name)

;

class_<D, bases<B,C> >("D")

.def("name", &D::name)

;

class_<complicated>("complicated",

init<simple const&,int>())

.def(init<simple const&>())

.def("get_n", &complicated::get_n)

;