Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 1 | /* |
Dean Moldovan | a0c1ccf | 2016-08-12 13:50:00 +0200 | [diff] [blame] | 2 | tests/test_smart_ptr.cpp -- binding classes with custom reference counting, |
Wenzel Jakob | a576e6a | 2015-07-29 17:51:54 +0200 | [diff] [blame] | 3 | implicit conversions between types |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 4 | |
Wenzel Jakob | 8cb6cb3 | 2016-04-17 20:21:41 +0200 | [diff] [blame] | 5 | Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch> |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 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 | |
Dean Moldovan | a0c1ccf | 2016-08-12 13:50:00 +0200 | [diff] [blame] | 11 | #include "pybind11_tests.h" |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 12 | #include "object.h" |
| 13 | |
Wenzel Jakob | b2c2c79 | 2016-01-17 22:36:40 +0100 | [diff] [blame] | 14 | /// Custom object with builtin reference counting (see 'object.h' for the implementation) |
| 15 | class MyObject1 : public Object { |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 16 | public: |
Wenzel Jakob | b2c2c79 | 2016-01-17 22:36:40 +0100 | [diff] [blame] | 17 | MyObject1(int value) : value(value) { |
Jason Rhinelander | 3f58937 | 2016-08-07 13:05:26 -0400 | [diff] [blame] | 18 | print_created(this, toString()); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 19 | } |
| 20 | |
| 21 | std::string toString() const { |
Wenzel Jakob | b2c2c79 | 2016-01-17 22:36:40 +0100 | [diff] [blame] | 22 | return "MyObject1[" + std::to_string(value) + "]"; |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 23 | } |
| 24 | |
| 25 | protected: |
Wenzel Jakob | b2c2c79 | 2016-01-17 22:36:40 +0100 | [diff] [blame] | 26 | virtual ~MyObject1() { |
Jason Rhinelander | 3f58937 | 2016-08-07 13:05:26 -0400 | [diff] [blame] | 27 | print_destroyed(this); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 28 | } |
| 29 | |
| 30 | private: |
| 31 | int value; |
| 32 | }; |
| 33 | |
Wenzel Jakob | b2c2c79 | 2016-01-17 22:36:40 +0100 | [diff] [blame] | 34 | /// Object managed by a std::shared_ptr<> |
| 35 | class MyObject2 { |
Wenzel Jakob | 6e213c9 | 2015-11-24 23:05:58 +0100 | [diff] [blame] | 36 | public: |
| 37 | MyObject2(int value) : value(value) { |
Jason Rhinelander | 3f58937 | 2016-08-07 13:05:26 -0400 | [diff] [blame] | 38 | print_created(this, toString()); |
Wenzel Jakob | 6e213c9 | 2015-11-24 23:05:58 +0100 | [diff] [blame] | 39 | } |
| 40 | |
| 41 | std::string toString() const { |
| 42 | return "MyObject2[" + std::to_string(value) + "]"; |
| 43 | } |
| 44 | |
| 45 | virtual ~MyObject2() { |
Jason Rhinelander | 3f58937 | 2016-08-07 13:05:26 -0400 | [diff] [blame] | 46 | print_destroyed(this); |
Wenzel Jakob | 6e213c9 | 2015-11-24 23:05:58 +0100 | [diff] [blame] | 47 | } |
| 48 | |
| 49 | private: |
| 50 | int value; |
| 51 | }; |
| 52 | |
Wenzel Jakob | b2c2c79 | 2016-01-17 22:36:40 +0100 | [diff] [blame] | 53 | /// Object managed by a std::shared_ptr<>, additionally derives from std::enable_shared_from_this<> |
| 54 | class MyObject3 : public std::enable_shared_from_this<MyObject3> { |
| 55 | public: |
| 56 | MyObject3(int value) : value(value) { |
Jason Rhinelander | 3f58937 | 2016-08-07 13:05:26 -0400 | [diff] [blame] | 57 | print_created(this, toString()); |
Wenzel Jakob | b2c2c79 | 2016-01-17 22:36:40 +0100 | [diff] [blame] | 58 | } |
| 59 | |
| 60 | std::string toString() const { |
| 61 | return "MyObject3[" + std::to_string(value) + "]"; |
| 62 | } |
| 63 | |
| 64 | virtual ~MyObject3() { |
Jason Rhinelander | 3f58937 | 2016-08-07 13:05:26 -0400 | [diff] [blame] | 65 | print_destroyed(this); |
Wenzel Jakob | b2c2c79 | 2016-01-17 22:36:40 +0100 | [diff] [blame] | 66 | } |
| 67 | |
| 68 | private: |
| 69 | int value; |
| 70 | }; |
| 71 | |
Jason Rhinelander | a6495af | 2016-09-04 18:23:55 -0400 | [diff] [blame] | 72 | class MyObject4 { |
| 73 | public: |
| 74 | MyObject4(int value) : value{value} { |
| 75 | print_created(this); |
| 76 | } |
| 77 | int value; |
| 78 | private: |
| 79 | ~MyObject4() { |
| 80 | print_destroyed(this); |
| 81 | } |
| 82 | }; |
| 83 | |
Jason Rhinelander | e45c211 | 2017-02-22 21:36:09 -0500 | [diff] [blame] | 84 | /// This is just a wrapper around unique_ptr, but with extra fields to deliberately bloat up the |
| 85 | /// holder size to trigger the non-simple-layout internal instance layout for single inheritance with |
| 86 | /// large holder type. |
| 87 | template <typename T> class huge_unique_ptr { |
| 88 | std::unique_ptr<T> ptr; |
| 89 | uint64_t padding[10]; |
| 90 | public: |
| 91 | huge_unique_ptr(T *p) : ptr(p) {}; |
| 92 | T *get() { return ptr.get(); } |
| 93 | }; |
| 94 | |
| 95 | class MyObject5 { // managed by huge_unique_ptr |
| 96 | public: |
| 97 | MyObject5(int value) : value{value} { |
| 98 | print_created(this); |
| 99 | } |
| 100 | int value; |
| 101 | ~MyObject5() { |
| 102 | print_destroyed(this); |
| 103 | } |
| 104 | }; |
| 105 | |
Wenzel Jakob | b2c2c79 | 2016-01-17 22:36:40 +0100 | [diff] [blame] | 106 | /// Make pybind aware of the ref-counted wrapper type (s) |
Wenzel Jakob | 2029171 | 2016-12-15 23:44:23 +0100 | [diff] [blame] | 107 | |
| 108 | // ref<T> is a wrapper for 'Object' which uses intrusive reference counting |
| 109 | // It is always possible to construct a ref<T> from an Object* pointer without |
| 110 | // possible incosistencies, hence the 'true' argument at the end. |
| 111 | PYBIND11_DECLARE_HOLDER_TYPE(T, ref<T>, true); |
Dean Moldovan | 5d28dd1 | 2016-10-18 13:56:33 +0200 | [diff] [blame] | 112 | PYBIND11_DECLARE_HOLDER_TYPE(T, std::shared_ptr<T>); // Not required any more for std::shared_ptr, |
| 113 | // but it should compile without error |
Jason Rhinelander | e45c211 | 2017-02-22 21:36:09 -0500 | [diff] [blame] | 114 | PYBIND11_DECLARE_HOLDER_TYPE(T, huge_unique_ptr<T>); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 115 | |
Dean Moldovan | ec009a7 | 2017-01-31 17:05:44 +0100 | [diff] [blame] | 116 | // Make pybind11 aware of the non-standard getter member function |
| 117 | namespace pybind11 { namespace detail { |
| 118 | template <typename T> |
| 119 | struct holder_helper<ref<T>> { |
| 120 | static const T *get(const ref<T> &p) { return p.get_ptr(); } |
| 121 | }; |
| 122 | }} |
| 123 | |
Wenzel Jakob | b2c2c79 | 2016-01-17 22:36:40 +0100 | [diff] [blame] | 124 | Object *make_object_1() { return new MyObject1(1); } |
| 125 | ref<Object> make_object_2() { return new MyObject1(2); } |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 126 | |
Wenzel Jakob | b2c2c79 | 2016-01-17 22:36:40 +0100 | [diff] [blame] | 127 | MyObject1 *make_myobject1_1() { return new MyObject1(4); } |
| 128 | ref<MyObject1> make_myobject1_2() { return new MyObject1(5); } |
| 129 | |
| 130 | MyObject2 *make_myobject2_1() { return new MyObject2(6); } |
| 131 | std::shared_ptr<MyObject2> make_myobject2_2() { return std::make_shared<MyObject2>(7); } |
| 132 | |
| 133 | MyObject3 *make_myobject3_1() { return new MyObject3(8); } |
| 134 | std::shared_ptr<MyObject3> make_myobject3_2() { return std::make_shared<MyObject3>(9); } |
Wenzel Jakob | 6e213c9 | 2015-11-24 23:05:58 +0100 | [diff] [blame] | 135 | |
Dean Moldovan | 81511be | 2016-09-07 00:50:10 +0200 | [diff] [blame] | 136 | void print_object_1(const Object *obj) { py::print(obj->toString()); } |
| 137 | void print_object_2(ref<Object> obj) { py::print(obj->toString()); } |
| 138 | void print_object_3(const ref<Object> &obj) { py::print(obj->toString()); } |
| 139 | void print_object_4(const ref<Object> *obj) { py::print((*obj)->toString()); } |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 140 | |
Dean Moldovan | 81511be | 2016-09-07 00:50:10 +0200 | [diff] [blame] | 141 | void print_myobject1_1(const MyObject1 *obj) { py::print(obj->toString()); } |
| 142 | void print_myobject1_2(ref<MyObject1> obj) { py::print(obj->toString()); } |
| 143 | void print_myobject1_3(const ref<MyObject1> &obj) { py::print(obj->toString()); } |
| 144 | void print_myobject1_4(const ref<MyObject1> *obj) { py::print((*obj)->toString()); } |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 145 | |
Dean Moldovan | 81511be | 2016-09-07 00:50:10 +0200 | [diff] [blame] | 146 | void print_myobject2_1(const MyObject2 *obj) { py::print(obj->toString()); } |
| 147 | void print_myobject2_2(std::shared_ptr<MyObject2> obj) { py::print(obj->toString()); } |
| 148 | void print_myobject2_3(const std::shared_ptr<MyObject2> &obj) { py::print(obj->toString()); } |
| 149 | void print_myobject2_4(const std::shared_ptr<MyObject2> *obj) { py::print((*obj)->toString()); } |
Wenzel Jakob | 6e213c9 | 2015-11-24 23:05:58 +0100 | [diff] [blame] | 150 | |
Dean Moldovan | 81511be | 2016-09-07 00:50:10 +0200 | [diff] [blame] | 151 | void print_myobject3_1(const MyObject3 *obj) { py::print(obj->toString()); } |
| 152 | void print_myobject3_2(std::shared_ptr<MyObject3> obj) { py::print(obj->toString()); } |
| 153 | void print_myobject3_3(const std::shared_ptr<MyObject3> &obj) { py::print(obj->toString()); } |
| 154 | void print_myobject3_4(const std::shared_ptr<MyObject3> *obj) { py::print((*obj)->toString()); } |
Wenzel Jakob | b2c2c79 | 2016-01-17 22:36:40 +0100 | [diff] [blame] | 155 | |
Jason Rhinelander | 52f4be8 | 2016-09-03 14:54:22 -0400 | [diff] [blame] | 156 | test_initializer smart_ptr([](py::module &m) { |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 157 | py::class_<Object, ref<Object>> obj(m, "Object"); |
| 158 | obj.def("getRefCount", &Object::getRefCount); |
| 159 | |
Wenzel Jakob | b2c2c79 | 2016-01-17 22:36:40 +0100 | [diff] [blame] | 160 | py::class_<MyObject1, ref<MyObject1>>(m, "MyObject1", obj) |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 161 | .def(py::init<int>()); |
| 162 | |
Wenzel Jakob | 2029171 | 2016-12-15 23:44:23 +0100 | [diff] [blame] | 163 | m.def("test_object1_refcounting", |
| 164 | []() -> bool { |
| 165 | ref<MyObject1> o = new MyObject1(0); |
| 166 | bool good = o->getRefCount() == 1; |
| 167 | py::object o2 = py::cast(o, py::return_value_policy::reference); |
| 168 | // always request (partial) ownership for objects with intrusive |
| 169 | // reference counting even when using the 'reference' RVP |
| 170 | good &= o->getRefCount() == 2; |
| 171 | return good; |
| 172 | } |
| 173 | ); |
| 174 | |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 175 | m.def("make_object_1", &make_object_1); |
| 176 | m.def("make_object_2", &make_object_2); |
Wenzel Jakob | b2c2c79 | 2016-01-17 22:36:40 +0100 | [diff] [blame] | 177 | m.def("make_myobject1_1", &make_myobject1_1); |
| 178 | m.def("make_myobject1_2", &make_myobject1_2); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 179 | m.def("print_object_1", &print_object_1); |
| 180 | m.def("print_object_2", &print_object_2); |
| 181 | m.def("print_object_3", &print_object_3); |
| 182 | m.def("print_object_4", &print_object_4); |
Wenzel Jakob | b2c2c79 | 2016-01-17 22:36:40 +0100 | [diff] [blame] | 183 | m.def("print_myobject1_1", &print_myobject1_1); |
| 184 | m.def("print_myobject1_2", &print_myobject1_2); |
| 185 | m.def("print_myobject1_3", &print_myobject1_3); |
| 186 | m.def("print_myobject1_4", &print_myobject1_4); |
Wenzel Jakob | 38bd711 | 2015-07-05 20:05:44 +0200 | [diff] [blame] | 187 | |
Wenzel Jakob | 6e213c9 | 2015-11-24 23:05:58 +0100 | [diff] [blame] | 188 | py::class_<MyObject2, std::shared_ptr<MyObject2>>(m, "MyObject2") |
| 189 | .def(py::init<int>()); |
| 190 | m.def("make_myobject2_1", &make_myobject2_1); |
| 191 | m.def("make_myobject2_2", &make_myobject2_2); |
| 192 | m.def("print_myobject2_1", &print_myobject2_1); |
| 193 | m.def("print_myobject2_2", &print_myobject2_2); |
| 194 | m.def("print_myobject2_3", &print_myobject2_3); |
| 195 | m.def("print_myobject2_4", &print_myobject2_4); |
| 196 | |
Wenzel Jakob | b2c2c79 | 2016-01-17 22:36:40 +0100 | [diff] [blame] | 197 | py::class_<MyObject3, std::shared_ptr<MyObject3>>(m, "MyObject3") |
| 198 | .def(py::init<int>()); |
| 199 | m.def("make_myobject3_1", &make_myobject3_1); |
| 200 | m.def("make_myobject3_2", &make_myobject3_2); |
| 201 | m.def("print_myobject3_1", &print_myobject3_1); |
| 202 | m.def("print_myobject3_2", &print_myobject3_2); |
| 203 | m.def("print_myobject3_3", &print_myobject3_3); |
| 204 | m.def("print_myobject3_4", &print_myobject3_4); |
| 205 | |
Jason Rhinelander | a6495af | 2016-09-04 18:23:55 -0400 | [diff] [blame] | 206 | py::class_<MyObject4, std::unique_ptr<MyObject4, py::nodelete>>(m, "MyObject4") |
| 207 | .def(py::init<int>()) |
| 208 | .def_readwrite("value", &MyObject4::value); |
| 209 | |
Jason Rhinelander | e45c211 | 2017-02-22 21:36:09 -0500 | [diff] [blame] | 210 | py::class_<MyObject5, huge_unique_ptr<MyObject5>>(m, "MyObject5") |
| 211 | .def(py::init<int>()) |
| 212 | .def_readwrite("value", &MyObject5::value); |
| 213 | |
Wenzel Jakob | b2c2c79 | 2016-01-17 22:36:40 +0100 | [diff] [blame] | 214 | py::implicitly_convertible<py::int_, MyObject1>(); |
Jason Rhinelander | 3f58937 | 2016-08-07 13:05:26 -0400 | [diff] [blame] | 215 | |
| 216 | // Expose constructor stats for the ref type |
| 217 | m.def("cstats_ref", &ConstructorStats::get<ref_tag>); |
Jason Rhinelander | 52f4be8 | 2016-09-03 14:54:22 -0400 | [diff] [blame] | 218 | }); |
Dean Moldovan | ab90ec6 | 2016-12-07 02:36:44 +0100 | [diff] [blame] | 219 | |
| 220 | struct SharedPtrRef { |
| 221 | struct A { |
| 222 | A() { print_created(this); } |
| 223 | A(const A &) { print_copy_created(this); } |
| 224 | A(A &&) { print_move_created(this); } |
| 225 | ~A() { print_destroyed(this); } |
| 226 | }; |
| 227 | |
| 228 | A value = {}; |
| 229 | std::shared_ptr<A> shared = std::make_shared<A>(); |
| 230 | }; |
| 231 | |
| 232 | struct SharedFromThisRef { |
| 233 | struct B : std::enable_shared_from_this<B> { |
| 234 | B() { print_created(this); } |
| 235 | B(const B &) : std::enable_shared_from_this<B>() { print_copy_created(this); } |
| 236 | B(B &&) : std::enable_shared_from_this<B>() { print_move_created(this); } |
| 237 | ~B() { print_destroyed(this); } |
| 238 | }; |
| 239 | |
| 240 | B value = {}; |
| 241 | std::shared_ptr<B> shared = std::make_shared<B>(); |
| 242 | }; |
| 243 | |
Jason Rhinelander | b8ac438 | 2017-05-19 13:34:55 -0400 | [diff] [blame] | 244 | // Issue #865: shared_from_this doesn't work with virtual inheritance |
| 245 | struct SharedFromThisVBase : std::enable_shared_from_this<SharedFromThisVBase> { |
| 246 | virtual ~SharedFromThisVBase() = default; |
| 247 | }; |
| 248 | struct SharedFromThisVirt : virtual SharedFromThisVBase {}; |
| 249 | |
Dean Moldovan | ec009a7 | 2017-01-31 17:05:44 +0100 | [diff] [blame] | 250 | template <typename T> |
| 251 | class CustomUniquePtr { |
| 252 | std::unique_ptr<T> impl; |
| 253 | |
| 254 | public: |
| 255 | CustomUniquePtr(T* p) : impl(p) { } |
| 256 | T* get() const { return impl.get(); } |
| 257 | T* release_ptr() { return impl.release(); } |
| 258 | }; |
| 259 | |
| 260 | PYBIND11_DECLARE_HOLDER_TYPE(T, CustomUniquePtr<T>); |
| 261 | |
Dean Moldovan | bdfb50f | 2017-06-07 16:52:50 +0200 | [diff] [blame] | 262 | struct ElementBase { virtual void foo() { } /* Force creation of virtual table */ }; |
| 263 | struct ElementA : ElementBase { |
| 264 | ElementA(int v) : v(v) { } |
| 265 | int value() { return v; } |
| 266 | int v; |
| 267 | }; |
| 268 | |
| 269 | struct ElementList { |
| 270 | void add(std::shared_ptr<ElementBase> e) { l.push_back(e); } |
| 271 | std::vector<std::shared_ptr<ElementBase>> l; |
| 272 | }; |
| 273 | |
Dean Moldovan | ab90ec6 | 2016-12-07 02:36:44 +0100 | [diff] [blame] | 274 | test_initializer smart_ptr_and_references([](py::module &pm) { |
| 275 | auto m = pm.def_submodule("smart_ptr"); |
| 276 | |
| 277 | using A = SharedPtrRef::A; |
| 278 | py::class_<A, std::shared_ptr<A>>(m, "A"); |
| 279 | |
| 280 | py::class_<SharedPtrRef>(m, "SharedPtrRef") |
| 281 | .def(py::init<>()) |
| 282 | .def_readonly("ref", &SharedPtrRef::value) |
| 283 | .def_property_readonly("copy", [](const SharedPtrRef &s) { return s.value; }, |
| 284 | py::return_value_policy::copy) |
| 285 | .def_readonly("holder_ref", &SharedPtrRef::shared) |
| 286 | .def_property_readonly("holder_copy", [](const SharedPtrRef &s) { return s.shared; }, |
| 287 | py::return_value_policy::copy) |
| 288 | .def("set_ref", [](SharedPtrRef &, const A &) { return true; }) |
| 289 | .def("set_holder", [](SharedPtrRef &, std::shared_ptr<A>) { return true; }); |
| 290 | |
| 291 | using B = SharedFromThisRef::B; |
| 292 | py::class_<B, std::shared_ptr<B>>(m, "B"); |
| 293 | |
| 294 | py::class_<SharedFromThisRef>(m, "SharedFromThisRef") |
| 295 | .def(py::init<>()) |
| 296 | .def_readonly("bad_wp", &SharedFromThisRef::value) |
| 297 | .def_property_readonly("ref", [](const SharedFromThisRef &s) -> const B & { return *s.shared; }) |
| 298 | .def_property_readonly("copy", [](const SharedFromThisRef &s) { return s.value; }, |
| 299 | py::return_value_policy::copy) |
| 300 | .def_readonly("holder_ref", &SharedFromThisRef::shared) |
| 301 | .def_property_readonly("holder_copy", [](const SharedFromThisRef &s) { return s.shared; }, |
| 302 | py::return_value_policy::copy) |
| 303 | .def("set_ref", [](SharedFromThisRef &, const B &) { return true; }) |
| 304 | .def("set_holder", [](SharedFromThisRef &, std::shared_ptr<B>) { return true; }); |
Dean Moldovan | ec009a7 | 2017-01-31 17:05:44 +0100 | [diff] [blame] | 305 | |
Jason Rhinelander | b8ac438 | 2017-05-19 13:34:55 -0400 | [diff] [blame] | 306 | // Issue #865: shared_from_this doesn't work with virtual inheritance |
| 307 | static std::shared_ptr<SharedFromThisVirt> sft(new SharedFromThisVirt()); |
| 308 | py::class_<SharedFromThisVirt, std::shared_ptr<SharedFromThisVirt>>(m, "SharedFromThisVirt") |
| 309 | .def_static("get", []() { return sft.get(); }); |
| 310 | |
Dean Moldovan | ec009a7 | 2017-01-31 17:05:44 +0100 | [diff] [blame] | 311 | struct C { |
| 312 | C() { print_created(this); } |
| 313 | ~C() { print_destroyed(this); } |
| 314 | }; |
| 315 | |
| 316 | py::class_<C, CustomUniquePtr<C>>(m, "TypeWithMoveOnlyHolder") |
| 317 | .def_static("make", []() { return CustomUniquePtr<C>(new C); }); |
Dean Moldovan | cd3d1fc | 2017-03-20 21:53:24 +0100 | [diff] [blame] | 318 | |
| 319 | struct HeldByDefaultHolder { }; |
| 320 | |
| 321 | py::class_<HeldByDefaultHolder>(m, "HeldByDefaultHolder") |
| 322 | .def(py::init<>()) |
| 323 | .def_static("load_shared_ptr", [](std::shared_ptr<HeldByDefaultHolder>) {}); |
Dean Moldovan | bdfb50f | 2017-06-07 16:52:50 +0200 | [diff] [blame] | 324 | |
| 325 | // #187: issue involving std::shared_ptr<> return value policy & garbage collection |
| 326 | py::class_<ElementBase, std::shared_ptr<ElementBase>>(m, "ElementBase"); |
| 327 | |
| 328 | py::class_<ElementA, ElementBase, std::shared_ptr<ElementA>>(m, "ElementA") |
| 329 | .def(py::init<int>()) |
| 330 | .def("value", &ElementA::value); |
| 331 | |
| 332 | py::class_<ElementList, std::shared_ptr<ElementList>>(m, "ElementList") |
| 333 | .def(py::init<>()) |
| 334 | .def("add", &ElementList::add) |
| 335 | .def("get", [](ElementList &el) { |
| 336 | py::list list; |
| 337 | for (auto &e : el.l) |
| 338 | list.append(py::cast(e)); |
| 339 | return list; |
| 340 | }); |
Dean Moldovan | ab90ec6 | 2016-12-07 02:36:44 +0100 | [diff] [blame] | 341 | }); |