test_smart_ptr.cpp revision 11986:c12e4625ab56 
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)
85PYBIND11_DECLARE_HOLDER_TYPE(T, ref<T>); // Required for custom holder type
86PYBIND11_DECLARE_HOLDER_TYPE(T, std::shared_ptr<T>); // Not required any more for std::shared_ptr,
87                                                     // but it should compile without error
88
89Object *make_object_1() { return new MyObject1(1); }
90ref<Object> make_object_2() { return new MyObject1(2); }
91
92MyObject1 *make_myobject1_1() { return new MyObject1(4); }
93ref<MyObject1> make_myobject1_2() { return new MyObject1(5); }
94
95MyObject2 *make_myobject2_1() { return new MyObject2(6); }
96std::shared_ptr<MyObject2> make_myobject2_2() { return std::make_shared<MyObject2>(7); }
97
98MyObject3 *make_myobject3_1() { return new MyObject3(8); }
99std::shared_ptr<MyObject3> make_myobject3_2() { return std::make_shared<MyObject3>(9); }
100
101void print_object_1(const Object *obj) { py::print(obj->toString()); }
102void print_object_2(ref<Object> obj) { py::print(obj->toString()); }
103void print_object_3(const ref<Object> &obj) { py::print(obj->toString()); }
104void print_object_4(const ref<Object> *obj) { py::print((*obj)->toString()); }
105
106void print_myobject1_1(const MyObject1 *obj) { py::print(obj->toString()); }
107void print_myobject1_2(ref<MyObject1> obj) { py::print(obj->toString()); }
108void print_myobject1_3(const ref<MyObject1> &obj) { py::print(obj->toString()); }
109void print_myobject1_4(const ref<MyObject1> *obj) { py::print((*obj)->toString()); }
110
111void print_myobject2_1(const MyObject2 *obj) { py::print(obj->toString()); }
112void print_myobject2_2(std::shared_ptr<MyObject2> obj) { py::print(obj->toString()); }
113void print_myobject2_3(const std::shared_ptr<MyObject2> &obj) { py::print(obj->toString()); }
114void print_myobject2_4(const std::shared_ptr<MyObject2> *obj) { py::print((*obj)->toString()); }
115
116void print_myobject3_1(const MyObject3 *obj) { py::print(obj->toString()); }
117void print_myobject3_2(std::shared_ptr<MyObject3> obj) { py::print(obj->toString()); }
118void print_myobject3_3(const std::shared_ptr<MyObject3> &obj) { py::print(obj->toString()); }
119void print_myobject3_4(const std::shared_ptr<MyObject3> *obj) { py::print((*obj)->toString()); }
120
121test_initializer smart_ptr([](py::module &m) {
122    py::class_<Object, ref<Object>> obj(m, "Object");
123    obj.def("getRefCount", &Object::getRefCount);
124
125    py::class_<MyObject1, ref<MyObject1>>(m, "MyObject1", obj)
126        .def(py::init<int>());
127
128    m.def("make_object_1", &make_object_1);
129    m.def("make_object_2", &make_object_2);
130    m.def("make_myobject1_1", &make_myobject1_1);
131    m.def("make_myobject1_2", &make_myobject1_2);
132    m.def("print_object_1", &print_object_1);
133    m.def("print_object_2", &print_object_2);
134    m.def("print_object_3", &print_object_3);
135    m.def("print_object_4", &print_object_4);
136    m.def("print_myobject1_1", &print_myobject1_1);
137    m.def("print_myobject1_2", &print_myobject1_2);
138    m.def("print_myobject1_3", &print_myobject1_3);
139    m.def("print_myobject1_4", &print_myobject1_4);
140
141    py::class_<MyObject2, std::shared_ptr<MyObject2>>(m, "MyObject2")
142        .def(py::init<int>());
143    m.def("make_myobject2_1", &make_myobject2_1);
144    m.def("make_myobject2_2", &make_myobject2_2);
145    m.def("print_myobject2_1", &print_myobject2_1);
146    m.def("print_myobject2_2", &print_myobject2_2);
147    m.def("print_myobject2_3", &print_myobject2_3);
148    m.def("print_myobject2_4", &print_myobject2_4);
149
150    py::class_<MyObject3, std::shared_ptr<MyObject3>>(m, "MyObject3")
151        .def(py::init<int>());
152    m.def("make_myobject3_1", &make_myobject3_1);
153    m.def("make_myobject3_2", &make_myobject3_2);
154    m.def("print_myobject3_1", &print_myobject3_1);
155    m.def("print_myobject3_2", &print_myobject3_2);
156    m.def("print_myobject3_3", &print_myobject3_3);
157    m.def("print_myobject3_4", &print_myobject3_4);
158
159    py::class_<MyObject4, std::unique_ptr<MyObject4, py::nodelete>>(m, "MyObject4")
160        .def(py::init<int>())
161        .def_readwrite("value", &MyObject4::value);
162
163    py::implicitly_convertible<py::int_, MyObject1>();
164
165    // Expose constructor stats for the ref type
166    m.def("cstats_ref", &ConstructorStats::get<ref_tag>);
167});
168
169struct SharedPtrRef {
170    struct A {
171        A() { print_created(this); }
172        A(const A &) { print_copy_created(this); }
173        A(A &&) { print_move_created(this); }
174        ~A() { print_destroyed(this); }
175    };
176
177    A value = {};
178    std::shared_ptr<A> shared = std::make_shared<A>();
179};
180
181struct SharedFromThisRef {
182    struct B : std::enable_shared_from_this<B> {
183        B() { print_created(this); }
184        B(const B &) : std::enable_shared_from_this<B>() { print_copy_created(this); }
185        B(B &&) : std::enable_shared_from_this<B>() { print_move_created(this); }
186        ~B() { print_destroyed(this); }
187    };
188
189    B value = {};
190    std::shared_ptr<B> shared = std::make_shared<B>();
191};
192
193test_initializer smart_ptr_and_references([](py::module &pm) {
194    auto m = pm.def_submodule("smart_ptr");
195
196    using A = SharedPtrRef::A;
197    py::class_<A, std::shared_ptr<A>>(m, "A");
198
199    py::class_<SharedPtrRef>(m, "SharedPtrRef")
200        .def(py::init<>())
201        .def_readonly("ref", &SharedPtrRef::value)
202        .def_property_readonly("copy", [](const SharedPtrRef &s) { return s.value; },
203                               py::return_value_policy::copy)
204        .def_readonly("holder_ref", &SharedPtrRef::shared)
205        .def_property_readonly("holder_copy", [](const SharedPtrRef &s) { return s.shared; },
206                               py::return_value_policy::copy)
207        .def("set_ref", [](SharedPtrRef &, const A &) { return true; })
208        .def("set_holder", [](SharedPtrRef &, std::shared_ptr<A>) { return true; });
209
210    using B = SharedFromThisRef::B;
211    py::class_<B, std::shared_ptr<B>>(m, "B");
212
213    py::class_<SharedFromThisRef>(m, "SharedFromThisRef")
214        .def(py::init<>())
215        .def_readonly("bad_wp", &SharedFromThisRef::value)
216        .def_property_readonly("ref", [](const SharedFromThisRef &s) -> const B & { return *s.shared; })
217        .def_property_readonly("copy", [](const SharedFromThisRef &s) { return s.value; },
218                               py::return_value_policy::copy)
219        .def_readonly("holder_ref", &SharedFromThisRef::shared)
220        .def_property_readonly("holder_copy", [](const SharedFromThisRef &s) { return s.shared; },
221                               py::return_value_policy::copy)
222        .def("set_ref", [](SharedFromThisRef &, const B &) { return true; })
223        .def("set_holder", [](SharedFromThisRef &, std::shared_ptr<B>) { return true; });
224});
225