{

explicit X(int x) : x(x), magic(7654321) { ++counter; }

X(X const& rhs) : x(rhs.x), magic(7654321) { ++counter; }

~X() { BOOST_ASSERT(magic == 7654321); magic = 6666666; x = 9999; --counter; }

void set(int _x) { BOOST_ASSERT(magic == 7654321); this->x = _x; }

int value() const { BOOST_ASSERT(magic == 7654321); return x; }

static int count() { return counter; }

private:

void operator=(X const&);

private:

int x;

long magic;

static int counter;

{

// Tests that we can return handle<> from a callback and that we

// can pass arbitrary handle<T>.

return call<handle<> >(x.get(), type_handle(borrowed(x->ob_type)));

{

def("apply_object_object", apply_object_object);

def("apply_to_own_type", apply_to_own_type);

def("apply_int_int", apply_int_int);

def("apply_void_int", apply_void_int);

def("apply_X_X", apply_X_X);

def("apply_void_X_ref", apply_void_X_ref);

def("apply_void_X_cref", apply_void_X_cref);

def("apply_void_X_ptr", apply_void_X_ptr);

def("apply_void_X_deep_ptr", apply_void_X_deep_ptr);

def("apply_X_ptr_handle_cref", apply_X_ptr_handle_cref

, return_value_policy<reference_existing_object>());

def("apply_X_ref_handle", apply_X_ref_handle

, return_value_policy<reference_existing_object>());

def("apply_cstring_cstring", apply_cstring_cstring);

def("apply_cstring_pyobject", apply_cstring_pyobject);

def("apply_char_char", apply_char_char);

def("apply_to_string_literal", apply_to_string_literal);

class_<X>("X", init<int>())

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

.def("value", &X::value)

.def("set", &X::set)

;

def("x_count", &X::count);