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
|
/* -----------------------------------------------------------------------------
* See the LICENSE file for information on copyright, usage and redistribution
* of SWIG, and the README file for authors - http://www.swig.org/release.html.
*
* attribute.swg
*
* Attribute implementation
* ----------------------------------------------------------------------------- */
/*
The following macros convert a pair of set/get methods
into a "native" attribute.
Use %attribute when you have a pair of get/set methods
like in:
%attribute(A, int, a, get_a, set_a);
struct A
{
int get_a() const;
void set_a(int aa);
};
If you don't provide a 'set' method, a 'read-only' attribute
is generated, ie, like in:
%attribute(A, int, c, get_c);
Use %attributeref when you have const/non-const reference
access methods, like in:
%attributeref(A, int, b);
struct A
{
const int& b() const;
int& b();
};
%attributeref(B, int, c);
struct B
{
int& c();
};
You can also use
%attributeref(Class, AttributeType, AttributeName, AccessorMethod)
if the internal C++ reference methods have a different name from the
attribute you want, so
%attributeref(B, int, d, c);
is the same as the last example, but instead of the attribute 'c' being
called 'c', it is called 'd'.
Now you can use the attributes like so:
x = A()
x.a = 3 # calls A::set_a
print x.a # calls A::get_a
x.b = 3 # calls A::b()
print x.b # calls A::b() const
Use %attribute2 instead of %attribute to indicate that reference-pointer
translation is required. You use %attribute2 instead of %attribute in
cases like this:
%attribute2(MyClass, MyFoo, Foo, GetFoo, SetFoo);
%inline %{
struct MyFoo {
int x;
};
class MyClass {
MyFoo foo;
public:
MyFoo& GetFoo() { return foo; }
void SetFoo(const MyFoo& other) { foo = other; }
};
%}
Here, the data type of the property is a wrapped type (MyFoo) and on the
C++ side it is passed by reference. The problem is that the SWIG wrapper will
pass around a pointer (MyFoo *) which is not compatible with the reference
type of the accessors (MyFoo &). Therefore, if you use %attribute, you'll get
an error from your C/C++ compiler. %attribute2 translates between a pointer
and a reference to eliminate the error. In case you're confused, let's make it
simple: just use %attribute at first, but if the C/C++ compiler gives an error
while compiling the wrapper, try %attribute2 instead.
NOTE: remember that if the type contains commas, such as 'std::pair<int,int>',
you need to use the macro like:
%attributeref(A, %arg(std::pair<int,int>), pval);
where %arg() 'normalizes' the type to be understood as a single
argument, otherwise the macro will get confused by the comma.
*/
//
// Define SWIG_ATTRIBUTE_TEMPLATE if you want to use templates instead of macros for the C++ get and set wrapper methods
// Does not always generate compileable code, use at your peril!
//
//#define SWIG_ATTRIBUTE_TEMPLATE
%define %attribute_custom(Class, AttributeType, AttributeName, GetMethod, SetMethod, GetMethodCall, SetMethodCall)
%ignore Class::GetMethod();
%ignore Class::GetMethod() const;
#if #SetMethod != #AttributeName
%ignore Class::SetMethod;
#endif
%extend Class {
AttributeType AttributeName;
}
#if defined(__cplusplus) && defined(SWIG_ATTRIBUTE_TEMPLATE)
%{
template < class C > inline AttributeType %mangle(Class) ##_## AttributeName ## _get(const C* self_) {
return GetMethodCall;
}
template < class C > inline AttributeType %mangle(Class) ##_## AttributeName ## _get(C* self_) {
return GetMethodCall;
}
template < class C > inline void %mangle(Class) ##_## AttributeName ## _set(C* self_, AttributeType val_) {
SetMethodCall;
}
%}
#else
%{
#define %mangle(Class) ##_## AttributeName ## _get(self_) GetMethodCall
#define %mangle(Class) ##_## AttributeName ## _set(self_, val_) SetMethodCall
%}
#endif
%enddef
%define %attribute_readonly(Class, AttributeType, AttributeName, GetMethod, GetMethodCall)
%ignore Class::GetMethod();
%ignore Class::GetMethod() const;
%immutable Class::AttributeName;
%extend Class {
AttributeType AttributeName;
}
#if defined(__cplusplus) && defined(SWIG_ATTRIBUTE_TEMPLATE)
%{
template < class C > inline AttributeType %mangle(Class) ##_## AttributeName ## _get(const C* self_) {
return GetMethodCall;
}
template < class C > inline AttributeType %mangle(Class) ##_## AttributeName ## _get(C* self_) {
return GetMethodCall;
}
%}
#else
%{
#define %mangle(Class) ##_## AttributeName ## _get(self_) GetMethodCall
%}
#endif
%enddef
// User macros
%define %attribute(Class, AttributeType, AttributeName, GetMethod, SetMethod...)
#if #SetMethod != ""
%attribute_custom(Class, AttributeType, AttributeName, GetMethod, SetMethod, self_->GetMethod(), self_->SetMethod(val_))
#else
%attribute_readonly(Class, AttributeType, AttributeName, GetMethod, self_->GetMethod())
#endif
%enddef
%define %attribute2(Class, AttributeType, AttributeName, GetMethod, SetMethod...)
#if #SetMethod != ""
%attribute_custom(Class, AttributeType, AttributeName, GetMethod, SetMethod, &self_->GetMethod(), self_->SetMethod(*val_))
#else
%attribute_readonly(Class, AttributeType, AttributeName, GetMethod, &self_->GetMethod())
#endif
%enddef
%define %attributeref(Class, AttributeType, AttributeName, AccessorMethod...)
#if #AccessorMethod != ""
%attribute_custom(Class, AttributeType, AttributeName, AccessorMethod, AccessorMethod, self_->AccessorMethod(), self_->AccessorMethod() = val_)
#else
%attribute_custom(Class, AttributeType, AttributeName, AttributeName, AttributeName, self_->AttributeName(), self_->AttributeName() = val_)
#endif
%enddef
%define %attribute2ref(Class, AttributeType, AttributeName, AccessorMethod...)
#if #AccessorMethod != ""
%attribute_custom(Class, AttributeType, AttributeName, AccessorMethod, AccessorMethod, &self_->AccessorMethod(), self_->AccessorMethod() = *val_)
#else
%attribute_custom(Class, AttributeType, AccessorMethod, AccessorMethod, AccessorMethod, &self_->AccessorMethod(), self_->AccessorMethod() = *val_)
#endif
%enddef
// deprecated (same as %attributeref, but there is an argument order inconsistency)
%define %attribute_ref(Class, AttributeType, AccessorMethod, AttributeName...)
#if #AttributeName != ""
%attribute_custom(Class, AttributeType, AttributeName, AccessorMethod, AccessorMethod, self_->AccessorMethod(), self_->AccessorMethod() = val_)
#else
%attribute_custom(Class, AttributeType, AccessorMethod, AccessorMethod, AccessorMethod, self_->AccessorMethod(), self_->AccessorMethod() = val_)
#endif
%enddef
|