blob: 5f29850649992eae7e39d5971ee039a2c850c0c6 [file] [log] [blame]
Wenzel Jakob38bd7112015-07-05 20:05:44 +02001/*
Dean Moldovana0c1ccf2016-08-12 13:50:00 +02002 tests/test_smart_ptr.cpp -- binding classes with custom reference counting,
Wenzel Jakoba576e6a2015-07-29 17:51:54 +02003 implicit conversions between types
Wenzel Jakob38bd7112015-07-05 20:05:44 +02004
Wenzel Jakob8cb6cb32016-04-17 20:21:41 +02005 Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
Wenzel Jakob38bd7112015-07-05 20:05:44 +02006
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 Moldovanb33475d2017-08-23 17:18:57 +020011#if defined(_MSC_VER) && _MSC_VER < 1910
12# pragma warning(disable: 4702) // unreachable code in system header
13#endif
14
Dean Moldovana0c1ccf2016-08-12 13:50:00 +020015#include "pybind11_tests.h"
Wenzel Jakob38bd7112015-07-05 20:05:44 +020016#include "object.h"
17
Jason Rhinelander391c7542017-07-25 16:47:36 -040018// Make pybind aware of the ref-counted wrapper type (s):
Wenzel Jakob20291712016-12-15 23:44:23 +010019
20// ref<T> is a wrapper for 'Object' which uses intrusive reference counting
21// It is always possible to construct a ref<T> from an Object* pointer without
22// possible incosistencies, hence the 'true' argument at the end.
23PYBIND11_DECLARE_HOLDER_TYPE(T, ref<T>, true);
Dean Moldovanec009a72017-01-31 17:05:44 +010024// Make pybind11 aware of the non-standard getter member function
25namespace pybind11 { namespace detail {
26 template <typename T>
27 struct holder_helper<ref<T>> {
28 static const T *get(const ref<T> &p) { return p.get_ptr(); }
29 };
30}}
31
Jason Rhinelander391c7542017-07-25 16:47:36 -040032// The following is not required anymore for std::shared_ptr, but it should compile without error:
33PYBIND11_DECLARE_HOLDER_TYPE(T, std::shared_ptr<T>);
Wenzel Jakob38bd7112015-07-05 20:05:44 +020034
Jason Rhinelander391c7542017-07-25 16:47:36 -040035// This is just a wrapper around unique_ptr, but with extra fields to deliberately bloat up the
36// holder size to trigger the non-simple-layout internal instance layout for single inheritance with
37// large holder type:
38template <typename T> class huge_unique_ptr {
39 std::unique_ptr<T> ptr;
40 uint64_t padding[10];
41public:
42 huge_unique_ptr(T *p) : ptr(p) {};
43 T *get() { return ptr.get(); }
44};
45PYBIND11_DECLARE_HOLDER_TYPE(T, huge_unique_ptr<T>);
Wenzel Jakobb2c2c792016-01-17 22:36:40 +010046
Jason Rhinelander391c7542017-07-25 16:47:36 -040047// Simple custom holder that works like unique_ptr
48template <typename T>
49class custom_unique_ptr {
50 std::unique_ptr<T> impl;
51public:
52 custom_unique_ptr(T* p) : impl(p) { }
53 T* get() const { return impl.get(); }
54 T* release_ptr() { return impl.release(); }
55};
56PYBIND11_DECLARE_HOLDER_TYPE(T, custom_unique_ptr<T>);
Wenzel Jakobb2c2c792016-01-17 22:36:40 +010057
Wenzel Jakob6e213c92015-11-24 23:05:58 +010058
Jason Rhinelander391c7542017-07-25 16:47:36 -040059TEST_SUBMODULE(smart_ptr, m) {
Wenzel Jakob38bd7112015-07-05 20:05:44 +020060
Jason Rhinelander391c7542017-07-25 16:47:36 -040061 // test_smart_ptr
Wenzel Jakob38bd7112015-07-05 20:05:44 +020062
Jason Rhinelander391c7542017-07-25 16:47:36 -040063 // Object implementation in `object.h`
Wenzel Jakob38bd7112015-07-05 20:05:44 +020064 py::class_<Object, ref<Object>> obj(m, "Object");
65 obj.def("getRefCount", &Object::getRefCount);
66
Jason Rhinelander391c7542017-07-25 16:47:36 -040067 // Custom object with builtin reference counting (see 'object.h' for the implementation)
68 class MyObject1 : public Object {
69 public:
70 MyObject1(int value) : value(value) { print_created(this, toString()); }
71 std::string toString() const { return "MyObject1[" + std::to_string(value) + "]"; }
72 protected:
73 virtual ~MyObject1() { print_destroyed(this); }
74 private:
75 int value;
76 };
Wenzel Jakobb2c2c792016-01-17 22:36:40 +010077 py::class_<MyObject1, ref<MyObject1>>(m, "MyObject1", obj)
Wenzel Jakob38bd7112015-07-05 20:05:44 +020078 .def(py::init<int>());
Jason Rhinelander391c7542017-07-25 16:47:36 -040079 py::implicitly_convertible<py::int_, MyObject1>();
Wenzel Jakob38bd7112015-07-05 20:05:44 +020080
Jason Rhinelander391c7542017-07-25 16:47:36 -040081 m.def("make_object_1", []() -> Object * { return new MyObject1(1); });
82 m.def("make_object_2", []() -> ref<Object> { return new MyObject1(2); });
83 m.def("make_myobject1_1", []() -> MyObject1 * { return new MyObject1(4); });
84 m.def("make_myobject1_2", []() -> ref<MyObject1> { return new MyObject1(5); });
85 m.def("print_object_1", [](const Object *obj) { py::print(obj->toString()); });
86 m.def("print_object_2", [](ref<Object> obj) { py::print(obj->toString()); });
87 m.def("print_object_3", [](const ref<Object> &obj) { py::print(obj->toString()); });
88 m.def("print_object_4", [](const ref<Object> *obj) { py::print((*obj)->toString()); });
89 m.def("print_myobject1_1", [](const MyObject1 *obj) { py::print(obj->toString()); });
90 m.def("print_myobject1_2", [](ref<MyObject1> obj) { py::print(obj->toString()); });
91 m.def("print_myobject1_3", [](const ref<MyObject1> &obj) { py::print(obj->toString()); });
92 m.def("print_myobject1_4", [](const ref<MyObject1> *obj) { py::print((*obj)->toString()); });
Wenzel Jakob20291712016-12-15 23:44:23 +010093
Jason Rhinelander391c7542017-07-25 16:47:36 -040094 // Expose constructor stats for the ref type
95 m.def("cstats_ref", &ConstructorStats::get<ref_tag>);
Wenzel Jakob38bd7112015-07-05 20:05:44 +020096
Jason Rhinelander391c7542017-07-25 16:47:36 -040097
98 // Object managed by a std::shared_ptr<>
99 class MyObject2 {
100 public:
Francesco Biscaniba33b2f2017-11-20 14:19:53 +0100101 MyObject2(const MyObject2 &) = default;
Jason Rhinelander391c7542017-07-25 16:47:36 -0400102 MyObject2(int value) : value(value) { print_created(this, toString()); }
103 std::string toString() const { return "MyObject2[" + std::to_string(value) + "]"; }
104 virtual ~MyObject2() { print_destroyed(this); }
105 private:
106 int value;
107 };
Wenzel Jakob6e213c92015-11-24 23:05:58 +0100108 py::class_<MyObject2, std::shared_ptr<MyObject2>>(m, "MyObject2")
109 .def(py::init<int>());
Jason Rhinelander391c7542017-07-25 16:47:36 -0400110 m.def("make_myobject2_1", []() { return new MyObject2(6); });
111 m.def("make_myobject2_2", []() { return std::make_shared<MyObject2>(7); });
112 m.def("print_myobject2_1", [](const MyObject2 *obj) { py::print(obj->toString()); });
113 m.def("print_myobject2_2", [](std::shared_ptr<MyObject2> obj) { py::print(obj->toString()); });
114 m.def("print_myobject2_3", [](const std::shared_ptr<MyObject2> &obj) { py::print(obj->toString()); });
115 m.def("print_myobject2_4", [](const std::shared_ptr<MyObject2> *obj) { py::print((*obj)->toString()); });
Wenzel Jakob6e213c92015-11-24 23:05:58 +0100116
Jason Rhinelander391c7542017-07-25 16:47:36 -0400117 // Object managed by a std::shared_ptr<>, additionally derives from std::enable_shared_from_this<>
118 class MyObject3 : public std::enable_shared_from_this<MyObject3> {
119 public:
Francesco Biscaniba33b2f2017-11-20 14:19:53 +0100120 MyObject3(const MyObject3 &) = default;
Jason Rhinelander391c7542017-07-25 16:47:36 -0400121 MyObject3(int value) : value(value) { print_created(this, toString()); }
122 std::string toString() const { return "MyObject3[" + std::to_string(value) + "]"; }
123 virtual ~MyObject3() { print_destroyed(this); }
124 private:
125 int value;
126 };
Wenzel Jakobb2c2c792016-01-17 22:36:40 +0100127 py::class_<MyObject3, std::shared_ptr<MyObject3>>(m, "MyObject3")
128 .def(py::init<int>());
Jason Rhinelander391c7542017-07-25 16:47:36 -0400129 m.def("make_myobject3_1", []() { return new MyObject3(8); });
130 m.def("make_myobject3_2", []() { return std::make_shared<MyObject3>(9); });
131 m.def("print_myobject3_1", [](const MyObject3 *obj) { py::print(obj->toString()); });
132 m.def("print_myobject3_2", [](std::shared_ptr<MyObject3> obj) { py::print(obj->toString()); });
133 m.def("print_myobject3_3", [](const std::shared_ptr<MyObject3> &obj) { py::print(obj->toString()); });
134 m.def("print_myobject3_4", [](const std::shared_ptr<MyObject3> *obj) { py::print((*obj)->toString()); });
Wenzel Jakobb2c2c792016-01-17 22:36:40 +0100135
Jason Rhinelander391c7542017-07-25 16:47:36 -0400136 // test_smart_ptr_refcounting
137 m.def("test_object1_refcounting", []() {
138 ref<MyObject1> o = new MyObject1(0);
139 bool good = o->getRefCount() == 1;
140 py::object o2 = py::cast(o, py::return_value_policy::reference);
141 // always request (partial) ownership for objects with intrusive
142 // reference counting even when using the 'reference' RVP
143 good &= o->getRefCount() == 2;
144 return good;
145 });
146
147 // test_unique_nodelete
148 // Object with a private destructor
149 class MyObject4 {
150 public:
151 MyObject4(int value) : value{value} { print_created(this); }
152 int value;
153 private:
154 ~MyObject4() { print_destroyed(this); }
155 };
Jason Rhinelandera6495af2016-09-04 18:23:55 -0400156 py::class_<MyObject4, std::unique_ptr<MyObject4, py::nodelete>>(m, "MyObject4")
157 .def(py::init<int>())
158 .def_readwrite("value", &MyObject4::value);
159
Jason Rhinelander391c7542017-07-25 16:47:36 -0400160 // test_large_holder
161 class MyObject5 { // managed by huge_unique_ptr
162 public:
163 MyObject5(int value) : value{value} { print_created(this); }
164 ~MyObject5() { print_destroyed(this); }
165 int value;
166 };
Jason Rhinelandere45c2112017-02-22 21:36:09 -0500167 py::class_<MyObject5, huge_unique_ptr<MyObject5>>(m, "MyObject5")
168 .def(py::init<int>())
169 .def_readwrite("value", &MyObject5::value);
170
Jason Rhinelander391c7542017-07-25 16:47:36 -0400171 // test_shared_ptr_and_references
172 struct SharedPtrRef {
173 struct A {
174 A() { print_created(this); }
175 A(const A &) { print_copy_created(this); }
176 A(A &&) { print_move_created(this); }
177 ~A() { print_destroyed(this); }
178 };
Jason Rhinelander3f589372016-08-07 13:05:26 -0400179
Jason Rhinelander391c7542017-07-25 16:47:36 -0400180 A value = {};
181 std::shared_ptr<A> shared = std::make_shared<A>();
Dean Moldovanab90ec62016-12-07 02:36:44 +0100182 };
Dean Moldovanab90ec62016-12-07 02:36:44 +0100183 using A = SharedPtrRef::A;
184 py::class_<A, std::shared_ptr<A>>(m, "A");
Dean Moldovanab90ec62016-12-07 02:36:44 +0100185 py::class_<SharedPtrRef>(m, "SharedPtrRef")
186 .def(py::init<>())
187 .def_readonly("ref", &SharedPtrRef::value)
188 .def_property_readonly("copy", [](const SharedPtrRef &s) { return s.value; },
189 py::return_value_policy::copy)
190 .def_readonly("holder_ref", &SharedPtrRef::shared)
191 .def_property_readonly("holder_copy", [](const SharedPtrRef &s) { return s.shared; },
192 py::return_value_policy::copy)
193 .def("set_ref", [](SharedPtrRef &, const A &) { return true; })
194 .def("set_holder", [](SharedPtrRef &, std::shared_ptr<A>) { return true; });
195
Jason Rhinelander391c7542017-07-25 16:47:36 -0400196 // test_shared_ptr_from_this_and_references
197 struct SharedFromThisRef {
198 struct B : std::enable_shared_from_this<B> {
199 B() { print_created(this); }
200 B(const B &) : std::enable_shared_from_this<B>() { print_copy_created(this); }
201 B(B &&) : std::enable_shared_from_this<B>() { print_move_created(this); }
202 ~B() { print_destroyed(this); }
203 };
204
205 B value = {};
206 std::shared_ptr<B> shared = std::make_shared<B>();
207 };
Dean Moldovanab90ec62016-12-07 02:36:44 +0100208 using B = SharedFromThisRef::B;
209 py::class_<B, std::shared_ptr<B>>(m, "B");
Dean Moldovanab90ec62016-12-07 02:36:44 +0100210 py::class_<SharedFromThisRef>(m, "SharedFromThisRef")
211 .def(py::init<>())
212 .def_readonly("bad_wp", &SharedFromThisRef::value)
213 .def_property_readonly("ref", [](const SharedFromThisRef &s) -> const B & { return *s.shared; })
214 .def_property_readonly("copy", [](const SharedFromThisRef &s) { return s.value; },
215 py::return_value_policy::copy)
216 .def_readonly("holder_ref", &SharedFromThisRef::shared)
217 .def_property_readonly("holder_copy", [](const SharedFromThisRef &s) { return s.shared; },
218 py::return_value_policy::copy)
219 .def("set_ref", [](SharedFromThisRef &, const B &) { return true; })
220 .def("set_holder", [](SharedFromThisRef &, std::shared_ptr<B>) { return true; });
Dean Moldovanec009a72017-01-31 17:05:44 +0100221
Jason Rhinelanderb8ac4382017-05-19 13:34:55 -0400222 // Issue #865: shared_from_this doesn't work with virtual inheritance
Jason Rhinelander391c7542017-07-25 16:47:36 -0400223 struct SharedFromThisVBase : std::enable_shared_from_this<SharedFromThisVBase> {
Francesco Biscaniba33b2f2017-11-20 14:19:53 +0100224 SharedFromThisVBase() = default;
225 SharedFromThisVBase(const SharedFromThisVBase &) = default;
Jason Rhinelander391c7542017-07-25 16:47:36 -0400226 virtual ~SharedFromThisVBase() = default;
227 };
228 struct SharedFromThisVirt : virtual SharedFromThisVBase {};
Jason Rhinelanderb8ac4382017-05-19 13:34:55 -0400229 static std::shared_ptr<SharedFromThisVirt> sft(new SharedFromThisVirt());
230 py::class_<SharedFromThisVirt, std::shared_ptr<SharedFromThisVirt>>(m, "SharedFromThisVirt")
231 .def_static("get", []() { return sft.get(); });
232
Jason Rhinelander391c7542017-07-25 16:47:36 -0400233 // test_move_only_holder
Dean Moldovanec009a72017-01-31 17:05:44 +0100234 struct C {
235 C() { print_created(this); }
236 ~C() { print_destroyed(this); }
237 };
Jason Rhinelander391c7542017-07-25 16:47:36 -0400238 py::class_<C, custom_unique_ptr<C>>(m, "TypeWithMoveOnlyHolder")
239 .def_static("make", []() { return custom_unique_ptr<C>(new C); });
Dean Moldovanec009a72017-01-31 17:05:44 +0100240
Jason Rhinelander391c7542017-07-25 16:47:36 -0400241 // test_smart_ptr_from_default
Dean Moldovancd3d1fc2017-03-20 21:53:24 +0100242 struct HeldByDefaultHolder { };
Dean Moldovancd3d1fc2017-03-20 21:53:24 +0100243 py::class_<HeldByDefaultHolder>(m, "HeldByDefaultHolder")
244 .def(py::init<>())
245 .def_static("load_shared_ptr", [](std::shared_ptr<HeldByDefaultHolder>) {});
Dean Moldovanbdfb50f2017-06-07 16:52:50 +0200246
Jason Rhinelander391c7542017-07-25 16:47:36 -0400247 // test_shared_ptr_gc
Dean Moldovanbdfb50f2017-06-07 16:52:50 +0200248 // #187: issue involving std::shared_ptr<> return value policy & garbage collection
Jason Rhinelander391c7542017-07-25 16:47:36 -0400249 struct ElementBase { virtual void foo() { } /* Force creation of virtual table */ };
Dean Moldovanbdfb50f2017-06-07 16:52:50 +0200250 py::class_<ElementBase, std::shared_ptr<ElementBase>>(m, "ElementBase");
251
Jason Rhinelander391c7542017-07-25 16:47:36 -0400252 struct ElementA : ElementBase {
253 ElementA(int v) : v(v) { }
254 int value() { return v; }
255 int v;
256 };
Dean Moldovanbdfb50f2017-06-07 16:52:50 +0200257 py::class_<ElementA, ElementBase, std::shared_ptr<ElementA>>(m, "ElementA")
258 .def(py::init<int>())
259 .def("value", &ElementA::value);
260
Jason Rhinelander391c7542017-07-25 16:47:36 -0400261 struct ElementList {
262 void add(std::shared_ptr<ElementBase> e) { l.push_back(e); }
263 std::vector<std::shared_ptr<ElementBase>> l;
264 };
Dean Moldovanbdfb50f2017-06-07 16:52:50 +0200265 py::class_<ElementList, std::shared_ptr<ElementList>>(m, "ElementList")
266 .def(py::init<>())
267 .def("add", &ElementList::add)
268 .def("get", [](ElementList &el) {
269 py::list list;
270 for (auto &e : el.l)
271 list.append(py::cast(e));
272 return list;
273 });
Jason Rhinelander391c7542017-07-25 16:47:36 -0400274}