1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
|
%module li_boost_shared_ptr_bits
#if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGPYTHON) || defined(SWIGD) || defined(SWIGOCTAVE) || defined(SWIGRUBY)
#define SHARED_PTR_WRAPPERS_IMPLEMENTED
#endif
#if defined(SHARED_PTR_WRAPPERS_IMPLEMENTED)
%include <boost_shared_ptr.i>
%shared_ptr(NonDynamic)
#endif
#if defined(SWIGPYTHON)
%pythonnondynamic NonDynamic;
#endif
%inline %{
#include <boost/shared_ptr.hpp>
struct NonDynamic {
int i;
};
boost::shared_ptr<NonDynamic> boing(boost::shared_ptr<NonDynamic> b) { return b; }
%}
// vector of shared_ptr
%include "std_vector.i"
#if defined(SHARED_PTR_WRAPPERS_IMPLEMENTED)
%shared_ptr(IntHolder);
#endif
%inline %{
#include "boost/shared_ptr.hpp"
struct IntHolder {
int val;
IntHolder(int a) : val(a) {}
};
int sum(std::vector< boost::shared_ptr<IntHolder> > v) {
int sum = 0;
for (size_t i=0; i<v.size(); ++i)
sum += v[i]->val;
return sum;
}
%}
%template(VectorIntHolder) std::vector< boost::shared_ptr<IntHolder> >;
/////////////////////////////////////////////////
// Test non public destructor - was leading to memory leaks as the destructor was not wrapped
// Bug 3024875
/////////////////////////////////////////////////
#if defined(SHARED_PTR_WRAPPERS_IMPLEMENTED)
%shared_ptr(HiddenDestructor)
#endif
%inline %{
class HiddenDestructor;
typedef boost::shared_ptr< HiddenDestructor > FooPtr;
class HiddenDestructor {
public:
static FooPtr create();
virtual void doit();
protected:
HiddenDestructor();
static void Foo_body( FooPtr self );
virtual ~HiddenDestructor();
private:
HiddenDestructor( const HiddenDestructor& );
class Impl;
Impl* impl_;
class FooDeleter {
public:
void operator()(HiddenDestructor* hidden) {
delete hidden;
}
};
};
%}
%{
#include <iostream>
using namespace std;
/* Impl would generally hold a weak_ptr to HiddenDestructor a.s.o, but this stripped down example should suffice */
class HiddenDestructor::Impl {
public:
int mymember;
};
FooPtr HiddenDestructor::create()
{
FooPtr hidden( new HiddenDestructor(), HiddenDestructor::FooDeleter() );
Foo_body( hidden );
return hidden;
}
void HiddenDestructor::doit()
{
// whatever
}
HiddenDestructor::HiddenDestructor()
{
// cout << "HiddenDestructor::HiddenDestructor()" << endl;
// always empty
}
void HiddenDestructor::Foo_body( FooPtr self )
{
// init self as you would do in ctor
self->impl_ = new Impl();
}
HiddenDestructor::~HiddenDestructor()
{
// cout << "HiddenDestructor::~HiddenDestructor()" << endl;
// destruct (e.g. delete Pimpl object)
delete impl_;
}
%}
////////////////////////////
// As above but private instead of protected destructor
////////////////////////////
#if defined(SHARED_PTR_WRAPPERS_IMPLEMENTED)
%shared_ptr(HiddenPrivateDestructor)
#endif
%inline %{
class HiddenPrivateDestructor {
private:
HiddenPrivateDestructor() {}
virtual ~HiddenPrivateDestructor() {
DeleteCount++;
}
class Deleter {
public:
void operator()(HiddenPrivateDestructor *hidden) {
delete hidden;
}
};
public:
static boost::shared_ptr<HiddenPrivateDestructor> create() {
boost::shared_ptr<HiddenPrivateDestructor> hidden( new HiddenPrivateDestructor(), HiddenPrivateDestructor::Deleter() );
return hidden;
}
static int DeleteCount;
};
int HiddenPrivateDestructor::DeleteCount = 0;
%}
/////////////////////////////////////////////////
// Non-public inheritance and shared_ptr
/////////////////////////////////////////////////
#if defined(SHARED_PTR_WRAPPERS_IMPLEMENTED)
%shared_ptr(Base)
// No %shared_ptr(DerivedPrivate1) to check Warning 520 does not appear
// No %shared_ptr(DerivedProtected1) to check Warning 520 does not appear
%shared_ptr(DerivedPrivate2)
%shared_ptr(DerivedProtected2)
%ignore Base2;
%shared_ptr(DerivedPublic)
#endif
%inline %{
class Base {
public:
virtual int b() = 0;
virtual ~Base() {}
};
class DerivedProtected1 : protected Base {
public:
virtual int b() { return 20; }
};
class DerivedPrivate1 : private Base {
public:
virtual int b() { return 20; }
};
class DerivedProtected2 : protected Base {
public:
virtual int b() { return 20; }
};
class DerivedPrivate2 : private Base {
public:
virtual int b() { return 20; }
};
class Base2 {
public:
virtual int b2() = 0;
virtual ~Base2() {}
};
class DerivedPublic : public Base2 {
public:
virtual int b2() { return 20; }
};
%}
|
