test_smart_ptr.cpp revision 12037
1/* 2 tests/test_smart_ptr.cpp -- binding classes with custom reference counting, 3 implicit conversions between types 4 5 Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch> 6 7 All rights reserved. Use of this source code is governed by a 8 BSD-style license that can be found in the LICENSE file. 9*/ 10 11#include "pybind11_tests.h" 12#include "object.h" 13 14/// Custom object with builtin reference counting (see 'object.h' for the implementation) 15class MyObject1 : public Object { 16public: 17 MyObject1(int value) : value(value) { 18 print_created(this, toString()); 19 } 20 21 std::string toString() const { 22 return "MyObject1[" + std::to_string(value) + "]"; 23 } 24 25protected: 26 virtual ~MyObject1() { 27 print_destroyed(this); 28 } 29 30private: 31 int value; 32}; 33 34/// Object managed by a std::shared_ptr<> 35class MyObject2 { 36public: 37 MyObject2(int value) : value(value) { 38 print_created(this, toString()); 39 } 40 41 std::string toString() const { 42 return "MyObject2[" + std::to_string(value) + "]"; 43 } 44 45 virtual ~MyObject2() { 46 print_destroyed(this); 47 } 48 49private: 50 int value; 51}; 52 53/// Object managed by a std::shared_ptr<>, additionally derives from std::enable_shared_from_this<> 54class MyObject3 : public std::enable_shared_from_this<MyObject3> { 55public: 56 MyObject3(int value) : value(value) { 57 print_created(this, toString()); 58 } 59 60 std::string toString() const { 61 return "MyObject3[" + std::to_string(value) + "]"; 62 } 63 64 virtual ~MyObject3() { 65 print_destroyed(this); 66 } 67 68private: 69 int value; 70}; 71 72class MyObject4 { 73public: 74 MyObject4(int value) : value{value} { 75 print_created(this); 76 } 77 int value; 78private: 79 ~MyObject4() { 80 print_destroyed(this); 81 } 82}; 83 84/// Make pybind aware of the ref-counted wrapper type (s) 85 86// ref<T> is a wrapper for 'Object' which uses intrusive reference counting 87// It is always possible to construct a ref<T> from an Object* pointer without 88// possible incosistencies, hence the 'true' argument at the end. 89PYBIND11_DECLARE_HOLDER_TYPE(T, ref<T>, true); 90PYBIND11_DECLARE_HOLDER_TYPE(T, std::shared_ptr<T>); // Not required any more for std::shared_ptr, 91 // but it should compile without error 92 93// Make pybind11 aware of the non-standard getter member function 94namespace pybind11 { namespace detail { 95 template <typename T> 96 struct holder_helper<ref<T>> { 97 static const T *get(const ref<T> &p) { return p.get_ptr(); } 98 }; 99}} 100 101Object *make_object_1() { return new MyObject1(1); } 102ref<Object> make_object_2() { return new MyObject1(2); } 103 104MyObject1 *make_myobject1_1() { return new MyObject1(4); } 105ref<MyObject1> make_myobject1_2() { return new MyObject1(5); } 106 107MyObject2 *make_myobject2_1() { return new MyObject2(6); } 108std::shared_ptr<MyObject2> make_myobject2_2() { return std::make_shared<MyObject2>(7); } 109 110MyObject3 *make_myobject3_1() { return new MyObject3(8); } 111std::shared_ptr<MyObject3> make_myobject3_2() { return std::make_shared<MyObject3>(9); } 112 113void print_object_1(const Object *obj) { py::print(obj->toString()); } 114void print_object_2(ref<Object> obj) { py::print(obj->toString()); } 115void print_object_3(const ref<Object> &obj) { py::print(obj->toString()); } 116void print_object_4(const ref<Object> *obj) { py::print((*obj)->toString()); } 117 118void print_myobject1_1(const MyObject1 *obj) { py::print(obj->toString()); } 119void print_myobject1_2(ref<MyObject1> obj) { py::print(obj->toString()); } 120void print_myobject1_3(const ref<MyObject1> &obj) { py::print(obj->toString()); } 121void print_myobject1_4(const ref<MyObject1> *obj) { py::print((*obj)->toString()); } 122 123void print_myobject2_1(const MyObject2 *obj) { py::print(obj->toString()); } 124void print_myobject2_2(std::shared_ptr<MyObject2> obj) { py::print(obj->toString()); } 125void print_myobject2_3(const std::shared_ptr<MyObject2> &obj) { py::print(obj->toString()); } 126void print_myobject2_4(const std::shared_ptr<MyObject2> *obj) { py::print((*obj)->toString()); } 127 128void print_myobject3_1(const MyObject3 *obj) { py::print(obj->toString()); } 129void print_myobject3_2(std::shared_ptr<MyObject3> obj) { py::print(obj->toString()); } 130void print_myobject3_3(const std::shared_ptr<MyObject3> &obj) { py::print(obj->toString()); } 131void print_myobject3_4(const std::shared_ptr<MyObject3> *obj) { py::print((*obj)->toString()); } 132 133test_initializer smart_ptr([](py::module &m) { 134 py::class_<Object, ref<Object>> obj(m, "Object"); 135 obj.def("getRefCount", &Object::getRefCount); 136 137 py::class_<MyObject1, ref<MyObject1>>(m, "MyObject1", obj) 138 .def(py::init<int>()); 139 140 m.def("test_object1_refcounting", 141 []() -> bool { 142 ref<MyObject1> o = new MyObject1(0); 143 bool good = o->getRefCount() == 1; 144 py::object o2 = py::cast(o, py::return_value_policy::reference); 145 // always request (partial) ownership for objects with intrusive 146 // reference counting even when using the 'reference' RVP 147 good &= o->getRefCount() == 2; 148 return good; 149 } 150 ); 151 152 m.def("make_object_1", &make_object_1); 153 m.def("make_object_2", &make_object_2); 154 m.def("make_myobject1_1", &make_myobject1_1); 155 m.def("make_myobject1_2", &make_myobject1_2); 156 m.def("print_object_1", &print_object_1); 157 m.def("print_object_2", &print_object_2); 158 m.def("print_object_3", &print_object_3); 159 m.def("print_object_4", &print_object_4); 160 m.def("print_myobject1_1", &print_myobject1_1); 161 m.def("print_myobject1_2", &print_myobject1_2); 162 m.def("print_myobject1_3", &print_myobject1_3); 163 m.def("print_myobject1_4", &print_myobject1_4); 164 165 py::class_<MyObject2, std::shared_ptr<MyObject2>>(m, "MyObject2") 166 .def(py::init<int>()); 167 m.def("make_myobject2_1", &make_myobject2_1); 168 m.def("make_myobject2_2", &make_myobject2_2); 169 m.def("print_myobject2_1", &print_myobject2_1); 170 m.def("print_myobject2_2", &print_myobject2_2); 171 m.def("print_myobject2_3", &print_myobject2_3); 172 m.def("print_myobject2_4", &print_myobject2_4); 173 174 py::class_<MyObject3, std::shared_ptr<MyObject3>>(m, "MyObject3") 175 .def(py::init<int>()); 176 m.def("make_myobject3_1", &make_myobject3_1); 177 m.def("make_myobject3_2", &make_myobject3_2); 178 m.def("print_myobject3_1", &print_myobject3_1); 179 m.def("print_myobject3_2", &print_myobject3_2); 180 m.def("print_myobject3_3", &print_myobject3_3); 181 m.def("print_myobject3_4", &print_myobject3_4); 182 183 py::class_<MyObject4, std::unique_ptr<MyObject4, py::nodelete>>(m, "MyObject4") 184 .def(py::init<int>()) 185 .def_readwrite("value", &MyObject4::value); 186 187 py::implicitly_convertible<py::int_, MyObject1>(); 188 189 // Expose constructor stats for the ref type 190 m.def("cstats_ref", &ConstructorStats::get<ref_tag>); 191}); 192 193struct SharedPtrRef { 194 struct A { 195 A() { print_created(this); } 196 A(const A &) { print_copy_created(this); } 197 A(A &&) { print_move_created(this); } 198 ~A() { print_destroyed(this); } 199 }; 200 201 A value = {}; 202 std::shared_ptr<A> shared = std::make_shared<A>(); 203}; 204 205struct SharedFromThisRef { 206 struct B : std::enable_shared_from_this<B> { 207 B() { print_created(this); } 208 B(const B &) : std::enable_shared_from_this<B>() { print_copy_created(this); } 209 B(B &&) : std::enable_shared_from_this<B>() { print_move_created(this); } 210 ~B() { print_destroyed(this); } 211 }; 212 213 B value = {}; 214 std::shared_ptr<B> shared = std::make_shared<B>(); 215}; 216 217template <typename T> 218class CustomUniquePtr { 219 std::unique_ptr<T> impl; 220 221public: 222 CustomUniquePtr(T* p) : impl(p) { } 223 T* get() const { return impl.get(); } 224 T* release_ptr() { return impl.release(); } 225}; 226 227PYBIND11_DECLARE_HOLDER_TYPE(T, CustomUniquePtr<T>); 228 229test_initializer smart_ptr_and_references([](py::module &pm) { 230 auto m = pm.def_submodule("smart_ptr"); 231 232 using A = SharedPtrRef::A; 233 py::class_<A, std::shared_ptr<A>>(m, "A"); 234 235 py::class_<SharedPtrRef>(m, "SharedPtrRef") 236 .def(py::init<>()) 237 .def_readonly("ref", &SharedPtrRef::value) 238 .def_property_readonly("copy", [](const SharedPtrRef &s) { return s.value; }, 239 py::return_value_policy::copy) 240 .def_readonly("holder_ref", &SharedPtrRef::shared) 241 .def_property_readonly("holder_copy", [](const SharedPtrRef &s) { return s.shared; }, 242 py::return_value_policy::copy) 243 .def("set_ref", [](SharedPtrRef &, const A &) { return true; }) 244 .def("set_holder", [](SharedPtrRef &, std::shared_ptr<A>) { return true; }); 245 246 using B = SharedFromThisRef::B; 247 py::class_<B, std::shared_ptr<B>>(m, "B"); 248 249 py::class_<SharedFromThisRef>(m, "SharedFromThisRef") 250 .def(py::init<>()) 251 .def_readonly("bad_wp", &SharedFromThisRef::value) 252 .def_property_readonly("ref", [](const SharedFromThisRef &s) -> const B & { return *s.shared; }) 253 .def_property_readonly("copy", [](const SharedFromThisRef &s) { return s.value; }, 254 py::return_value_policy::copy) 255 .def_readonly("holder_ref", &SharedFromThisRef::shared) 256 .def_property_readonly("holder_copy", [](const SharedFromThisRef &s) { return s.shared; }, 257 py::return_value_policy::copy) 258 .def("set_ref", [](SharedFromThisRef &, const B &) { return true; }) 259 .def("set_holder", [](SharedFromThisRef &, std::shared_ptr<B>) { return true; }); 260 261 struct C { 262 C() { print_created(this); } 263 ~C() { print_destroyed(this); } 264 }; 265 266 py::class_<C, CustomUniquePtr<C>>(m, "TypeWithMoveOnlyHolder") 267 .def_static("make", []() { return CustomUniquePtr<C>(new C); }); 268 269 struct HeldByDefaultHolder { }; 270 271 py::class_<HeldByDefaultHolder>(m, "HeldByDefaultHolder") 272 .def(py::init<>()) 273 .def_static("load_shared_ptr", [](std::shared_ptr<HeldByDefaultHolder>) {}); 274}); 275