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
|
// Tests for the allprotected option
%module(directors="1", allprotected="1") allprotected
%{
#include <string>
%}
%include "std_string.i"
#ifdef SWIGSCILAB
%rename(ProcBase) ProtectedBase;
%rename(PubBase) PublicBase;
#endif
%feature("director") PublicBase;
%feature("director") ProtectedBase;
// protected types not supported (ProtectedEnum, IntegerType). Make sure they can be ignored.
%ignore ProtectedBase::protectedenum;
%ignore ProtectedBase::typedefs;
%inline %{
class Klass {
std::string name;
public:
Klass(const std::string& n) : name(n) {}
std::string getName() { return name; }
};
class PublicBase {
std::string str;
public:
enum AnEnum { EnumVal1, EnumVal2 };
public:
PublicBase(const char* s): str(s), instanceMemberVariable(0), anEnum(EnumVal1), stringMember(0) {}
virtual ~PublicBase() { }
virtual std::string virtualMethod() const { return "PublicBase"; }
Klass instanceMethod(Klass k) const { return k; }
Klass *instanceOverloaded(Klass *k) const { return k; }
Klass *instanceOverloaded(Klass *k, std::string name) const { return new Klass(name); }
static Klass staticMethod(Klass k) { return k; }
static Klass *staticOverloaded(Klass *k) { return k; }
static Klass *staticOverloaded(Klass *k, std::string name) { return new Klass(name); }
int instanceMemberVariable;
static int staticMemberVariable;
static const int staticConstMemberVariable = 20;
AnEnum anEnum;
char *stringMember;
};
int PublicBase::staticMemberVariable = 10;
class ProtectedBase {
std::string str;
public:
enum AnEnum { EnumVal1, EnumVal2 };
std::string getName() { return str; }
protected:
ProtectedBase(const char* s): str(s), instanceMemberVariable(0), anEnum(EnumVal1), stringMember(0), protectedenum(ProtEnumVal1) {}
virtual ~ProtectedBase() { }
virtual std::string virtualMethod() const { return "ProtectedBase"; }
Klass instanceMethod(Klass k) const { return k; }
Klass *instanceOverloaded(Klass *k) const { return k; }
Klass *instanceOverloaded(Klass *k, std::string name) const { return new Klass(name); }
static Klass staticMethod(Klass k) { return k; }
static Klass *staticOverloaded(Klass *k) { return k; }
static Klass *staticOverloaded(Klass *k, std::string name) { return new Klass(name); }
int instanceMemberVariable;
static int staticMemberVariable;
static const int staticConstMemberVariable = 20;
AnEnum anEnum;
char *stringMember;
// unsupported: types defined with protected access and thus methods/variables which use them
enum ProtectedEnum { ProtEnumVal1, ProtEnumVal2 };
typedef int IntegerType;
ProtectedEnum protectedenum;
IntegerType typedefs(IntegerType it) { return it; }
};
int ProtectedBase::staticMemberVariable = 10;
class ProtectedDerived : public ProtectedBase {
public:
ProtectedDerived(const char *s) : ProtectedBase(s) {}
};
%}
%ignore AllProtectedTop;
%feature("director") AllProtectedBottom;
%inline %{
class AllProtectedTop {
public:
virtual ~AllProtectedTop() {}
void doSomething(int row) {}
void doSomething() {}
void usingOverloaded(int row) {}
void usingOverloaded() {}
void usingSingle() {}
void private1() {}
void private2() {}
void private2(int) {}
};
class AllProtectedBottom : public AllProtectedTop {
public:
virtual void apb() {}
protected:
// allprotected makes the following public in the director class
using AllProtectedTop::usingOverloaded;
using AllProtectedTop::usingSingle;
void doSomething(int row) {}
void doSomething() {}
private:
using AllProtectedTop::private1;
using AllProtectedTop::private2;
};
%}
|
