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
|
%module li_attribute
%include <exception.i>
//#define SWIG_ATTRIBUTE_TEMPLATE
%include <attribute.i>
%{
// forward reference needed if using SWIG_ATTRIBUTE_TEMPLATE
struct A;
struct MyFoo; // %attribute2 does not work with templates
%}
%attribute(A, int, a, get_a, set_a);
%attributeref(A, int, b);
%attributeref(Param<int>, int, value);
%attribute(A, int, c, get_c); /* read-only */
%attributeref(A, int, d, b); /* renames accessor method 'b' to attribute name 'd' */
%attributeref(B, A*, a)
%inline
{
struct A
{
A(int a, int b, int c) : _a(a), _b(b), _c(c)
{
}
int get_a() const
{
return _a;
}
void set_a(int aa)
{
_a = aa;
}
/* only one ref method */
int& b()
{
return _b;
}
int get_c() const
{
return _c;
}
private:
int _a;
int _b;
int _c;
};
template <class C>
struct Param
{
Param(C v) : _v(v)
{
}
const int& value() const
{
return _v;
}
int& value()
{
return _v;
}
private:
C _v;
};
struct B {
B(A *a) : mA(a)
{
}
A*& a() { return mA; }
protected:
A* mA;
};
}
%template(Param_i) Param<int>;
// class/struct attribute with get/set methods using return/pass by reference
%attribute2(MyClass, MyFoo, Foo, GetFoo, SetFoo);
%attribute2ref(MyClass, MyFoo, Foo2);
%inline %{
struct MyFoo {
MyFoo() : x(-1) {}
int x;
};
class MyClass {
MyFoo foo;
MyFoo foo2;
public:
MyFoo& GetFoo() { return foo; }
void SetFoo(const MyFoo& other) { foo = other; }
MyFoo& Foo2() { return foo2; }
};
%}
// class/struct attribute with get/set methods using return/pass by value
%attributeval(MyClassVal, MyFoo, ReadWriteFoo, GetFoo, SetFoo);
%attributeval(MyClassVal, MyFoo, ReadOnlyFoo, GetFoo);
%inline %{
class MyClassVal {
MyFoo foo;
public:
MyFoo GetFoo() { return foo; }
void SetFoo(MyFoo other) { foo = other; }
};
%}
// string attribute with get/set methods using return/pass by value
%include <std_string.i>
%attributestring(MyStringyClass, std::string, ReadWriteString, GetString, SetString);
%attributestring(MyStringyClass, std::string, ReadOnlyString, GetString);
%inline %{
class MyStringyClass {
std::string str;
public:
MyStringyClass(const std::string &val) : str(val) {}
std::string GetString() { return str; }
void SetString(std::string other) { str = other; }
};
%}
|
