diff options
Diffstat (limited to '')
-rw-r--r-- | src/boost/libs/python/test/shared_ptr.hpp | 206 |
1 files changed, 206 insertions, 0 deletions
diff --git a/src/boost/libs/python/test/shared_ptr.hpp b/src/boost/libs/python/test/shared_ptr.hpp new file mode 100644 index 000000000..9f9a4b69e --- /dev/null +++ b/src/boost/libs/python/test/shared_ptr.hpp @@ -0,0 +1,206 @@ +// Copyright David Abrahams 2002. +// Copyright Stefan Seefeld 2016. +// 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) + +#include "test_class.hpp" + +using namespace boost::python; + +typedef test_class<> X; +typedef test_class<1> Y; + +template <class T> +struct functions +{ + static int look(shared_ptr<T> const& x) + { + return (x.get()) ? x->value() : -1; + } + + static void store(shared_ptr<T> x) + { + storage = x; + } + + static void release_store() + { + store(shared_ptr<T>()); + } + + static void modify(shared_ptr<T>& x) + { + x.reset(); + } + + static shared_ptr<T> get() { return storage; } + static shared_ptr<T> &get1() { return storage; } + + static int look_store() + { + return look(get()); + } + + template <class C> + static void expose(C const& c) + { + def("look", &look); + def("store", &store); + def("modify", &modify); + def("identity", &identity); + def("null", &null); + + const_cast<C&>(c) + .def("look", &look) + .staticmethod("look") + .def("store", &store) + .staticmethod("store") + .def("modify", &modify) + .staticmethod("modify") + .def("look_store", &look_store) + .staticmethod("look_store") + .def("identity", &identity) + .staticmethod("identity") + .def("null", &null) + .staticmethod("null") + .def("get1", &get1, return_internal_reference<>()) + .staticmethod("get1") + .def("get", &get) + .staticmethod("get") + .def("count", &T::count) + .staticmethod("count") + .def("release", &release_store) + .staticmethod("release") + ; + } + + static shared_ptr<T> identity(shared_ptr<T> x) { return x; } + static shared_ptr<T> null(T const&) { return shared_ptr<T>(); } + + + static shared_ptr<T> storage; +}; + +template <class T> shared_ptr<T> functions<T>::storage; + +struct Z : test_class<2> +{ + Z(int x) : test_class<2>(x) {} + virtual int v() { return this->value(); } +}; + +struct ZWrap : Z +{ + ZWrap(PyObject* self, int x) + : Z(x), m_self(self) {} + + + virtual int v() { return call_method<int>(m_self, "v"); } + int default_v() { return Z::v(); } + + + PyObject* m_self; +}; + +struct YY : Y +{ + YY(int n) : Y(n) {} +}; + +struct YYY : Y +{ + YYY(int n) : Y(n) {} +}; + +shared_ptr<Y> factory(int n) +{ + return shared_ptr<Y>(n < 42 ? new Y(n) : new YY(n)); +} + +// regressions from Nicodemus + struct A + { + virtual ~A() {}; // silence compiler warnings + virtual int f() = 0; + static int call_f(shared_ptr<A>& a) { return a->f(); } + }; + + struct B: A + { + int f() { return 1; } + }; + + shared_ptr<A> New(bool make) + { + return shared_ptr<A>( make ? new B() : 0 ); + } + + struct A_Wrapper: A + { + A_Wrapper(PyObject* self_): + A(), self(self_) {} + + int f() { + return call_method< int >(self, "f"); + } + + PyObject* self; + }; + +// ------ + +// from Neal Becker + +struct Test { + shared_ptr<X> x; +}; +// ------ + + +BOOST_PYTHON_MODULE(MODULE) +{ + class_<A, shared_ptr<A_Wrapper>, boost::noncopyable>("A") + .def("call_f", &A::call_f) + .staticmethod("call_f") + ; + + // This is the ugliness required to register a to-python converter + // for shared_ptr<A>. + objects::class_value_wrapper< + shared_ptr<A> + , objects::make_ptr_instance<A, objects::pointer_holder<shared_ptr<A>,A> > + >(); + + def("New", &New); + + def("factory", factory); + + functions<X>::expose( + class_<X, boost::noncopyable>("X", init<int>()) + .def("value", &X::value) + ); + + functions<Y>::expose( + class_<Y, shared_ptr<Y> >("Y", init<int>()) + .def("value", &Y::value) + ); + + class_<YY, bases<Y>, boost::noncopyable>("YY", init<int>()) + ; + + class_<YYY, shared_ptr<YYY>, bases<Y> >("YYY", init<int>()) + ; + + functions<Z>::expose( + class_<Z, ZWrap>("Z", init<int>()) + .def("value", &Z::value) + .def("v", &Z::v, &ZWrap::default_v) + ); + +// from Neal Becker + class_<Test> ("Test") + .def_readonly ("x", &Test::x, "x") + ; +// ------ +} |