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
|
// Test C++11 virtual specifier sequences (final and/or override on methods)
// Also check final/override - the two 'identifiers with special meaning' work as normal identifiers
%module cpp11_final_override
%warnfilter(SWIGWARN_PARSE_KEYWORD) final; // 'final' is a java keyword, renaming to '_final'
%warnfilter(SWIGWARN_PARSE_KEYWORD) override; // 'override' is a C# keyword, renaming to '_override'
// throw is invalid in C++17 and later, only SWIG to use it
#define TESTCASE_THROW1(T1) throw(T1)
%{
#define TESTCASE_THROW1(T1)
%}
%inline %{
struct Base {
virtual void stuff() const {}
virtual void override1() const {}
virtual void override2() const {}
virtual void finaloverride1() {}
virtual void finaloverride2() {}
virtual void finaloverride3() {}
virtual void finaloverride4() const {}
virtual void finaloverride5() {}
virtual void finaloverride6() const {}
virtual ~Base() {}
};
struct Derived /*final*/ : Base {
virtual void stuff() const noexcept override final {}
virtual void override1() const noexcept override;
virtual void override2() const noexcept override;
virtual void final1() final {}
virtual void final2() noexcept final {}
virtual void final4() const final {}
virtual void final5() const noexcept final {}
virtual void finaloverride1() final override {}
virtual void finaloverride2() override final {}
virtual void finaloverride3() noexcept override final {}
virtual void finaloverride4() const noexcept override final {}
virtual void finaloverride5() TESTCASE_THROW1(int) override final {}
virtual void finaloverride6() const TESTCASE_THROW1(int) override final {}
virtual ~Derived() override final {}
};
void Derived::override2() const noexcept {}
// Pure virtual methods
struct PureBase {
virtual void pure1(int) const = 0;
virtual void pure2(int) const = 0;
virtual void pure3(int) const = 0;
virtual void pure4(int) const = 0;
virtual void pure5(int) const = 0;
virtual ~PureBase() {}
};
struct PureDerived : PureBase {
virtual void pure1(int) const override = 0;
virtual void pure2(int) const final = 0;
virtual void pure3(int) const override final = 0;
virtual void pure4(int) const final override = 0;
virtual void pure5(int) const noexcept final override = 0;
virtual ~PureDerived() override final;
};
void PureDerived::pure1(int) const {}
void PureDerived::pure2(int) const {}
void PureDerived::pure3(int) const {}
void PureDerived::pure4(int) const {}
void PureDerived::pure5(int) const noexcept {}
PureDerived::~PureDerived() {}
// Destructors and virtual specifier sequences (final/override)
struct Destructors1 : Base {
virtual ~Destructors1() override {}
};
struct Destructors2 : Base {
virtual ~Destructors2() final {}
};
struct Destructors3 : Base {
virtual ~Destructors3() noexcept final override {}
};
struct Destructors4 : Base {
virtual ~Destructors4() noexcept override final {}
};
// Check the two 'identifiers with special meaning' work as normal identifiers
struct FinalOverrideMethods {
virtual void final() {}
virtual void override(int) {}
virtual ~FinalOverrideMethods() = default;
};
struct FinalOverrideVariables {
int final;
double override;
};
void final(int) {}
void override() {}
%}
%{
void Derived::override1() const noexcept {}
%}
// Example in documentation ... declarations only
%inline %{
struct BaseStruct {
virtual void ab() const = 0;
virtual void cd();
virtual void ef();
virtual ~BaseStruct();
};
struct DerivedStruct : BaseStruct {
virtual void ab() const override;
virtual void cd() final;
virtual void ef() final override;
virtual ~DerivedStruct() override;
};
struct DerivedNoVirtualStruct : BaseStruct {
void ab() const override;
void cd() final;
void ef() final override;
~DerivedNoVirtualStruct() override;
};
%}
%{
void BaseStruct::cd() {}
void BaseStruct::ef() {}
BaseStruct::~BaseStruct() {}
void DerivedStruct::ab() const {}
void DerivedStruct::cd() {}
void DerivedStruct::ef() {}
DerivedStruct::~DerivedStruct() {}
void DerivedNoVirtualStruct::ab() const {}
void DerivedNoVirtualStruct::cd() {}
void DerivedNoVirtualStruct::ef() {}
DerivedNoVirtualStruct::~DerivedNoVirtualStruct() {}
%}
%inline %{
namespace Outer {
namespace final {
template <typename T> struct smart_ptr {
typedef T type;
};
}
namespace override {
template <typename T> struct dumb_ptr {
typedef T type;
};
}
}
%}
%template(SmartPtrBaseStruct) Outer::final::smart_ptr<DerivedStruct>;
%inline %{
class ObjectDB
{
public:
static void smart1(typename Outer::final::smart_ptr<DerivedStruct>::type *objectT) {}
static void smart2(Outer::final::smart_ptr<DerivedStruct>::type *objectT) {}
static void dumb1(typename Outer::override::dumb_ptr<DerivedStruct>::type *objectT) {}
static void dumb2(Outer::override::dumb_ptr<DerivedStruct>::type *objectT) {}
static Outer::final::smart_ptr<DerivedStruct>::type get() { return DerivedStruct(); }
};
%}
|
