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
|
%module refcount
#warnfilter(362);
%{
#include <iostream>
#include "refcount.h"
%}
#if 0
//
// the old macro way
//
%define RefCount(...)
%typemap(newfree) __VA_ARGS__* { $1->ref(); }
%newobject __VA_ARGS__::clone();
%extend __VA_ARGS__ { ~__VA_ARGS__() { self->unref(); } }
%ignore __VA_ARGS__::~__VA_ARGS__();
%enddef
//
// you need to apply the RefCount macro to all the RCObj derived
// classes.
//
RefCount(RCObj);
RefCount(A);
RefCount(A1);
RefCount(A2);
RefCount(A3);
RefCount(B);
#else
//
// using the ref/unref features you can active the ref. counting
// for RCObj and all its descendents at once
//
%feature("ref") RCObj "$this->ref();"
%feature("unref") RCObj "$this->unref();"
#endif
%include "refcount.h"
%newobject B::create(A* a);
%newobject B::cloner();
%inline %{
struct A : RCObj
{
A() {}
~A()
{
// std::cout << "deleting a" << std::endl;
}
#ifdef SWIGRUBY
// fix strange ruby + virtual derivation problem
using RCObjBase::ref_count;
#endif
};
struct A1 : A
{
protected:
A1() {}
};
struct A2 : A
{
};
struct A3 : A1, private A2
{
};
struct B : RCObj
{
B(A* a) : _a(a) {}
A* get_a()
{
return _a;
}
static B* create(A* a)
{
return new B(a);
}
B* cloner()
{
return new B(_a);
}
~B()
{
// std::cout << "deleting b" << std::endl;
}
private:
RCPtr<A> _a;
};
%}
/* Other ref/unref uses:
// deactive the refcounting for A1 and its descendents
%feature("noref") A1;
%feature("nounref") A1;
*/
|
