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
|
/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the test suite of PySide2.
**
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef VIRTUALMETHODS_H
#define VIRTUALMETHODS_H
#include "point.h"
#include "complex.h"
#include "str.h"
#include "libsamplemacros.h"
#include "strlist.h"
class LIBSAMPLE_API VirtualMethods
{
public:
VirtualMethods(Str name = "VirtualMethods") : m_name(name)
{
m_left = m_top = m_right = m_bottom = 0;
}
virtual ~VirtualMethods() {}
virtual double virtualMethod0(Point pt, int val, Complex cpx, bool b);
double callVirtualMethod0(Point pt, int val, Complex cpx, bool b)
{
return virtualMethod0(pt, val, cpx, b);
}
// Binding modification: rename.
virtual int sum0(int a0, int a1, int a2) { return a0 + a1 + a2; }
int callSum0(int a0, int a1, int a2) { return sum0(a0, a1, a2); }
// Binding modification: set default value for the last argument.
virtual int sum1(int a0, int a1, int a2) { return a0 + a1 + a2; }
int callSum1(int a0, int a1, int a2) { return sum1(a0, a1, a2); }
// Binding modification: remove the last argument and set a default value for it.
virtual int sum2(int a0, int a1, int a2) { return a0 + a1 + a2; }
int callSum2(int a0, int a1, int a2) { return sum2(a0, a1, a2); }
// Binding modification: remove the second argument.
virtual int sum3(int a0, int a1, int a2) { return a0 + a1 + a2; }
int callSum3(int a0, int a1, int a2) { return sum3(a0, a1, a2); }
// Binding modification: remove the second argument and set its default
// value, then inject code on the binding reimplementation of the virtual
// (with a native inject-code) to sum the value of the removed
// argument to the first argument before the method is called.
virtual int sum4(int a0, int a1, int a2) { return a0 + a1 + a2; }
int callSum4(int a0, int a1, int a2) { return sum4(a0, a1, a2); }
// Binding modification: prepend a string to the results of a Python override.
virtual Str name() { return m_name; }
Str callName() { return name(); }
// Binding modification: code injection that calls the Python override by itself.
virtual void callMe() {}
void callCallMe() { callMe(); }
// Passing reference to pointers.
virtual bool createStr(const char* text, Str*& ret);
bool callCreateStr(const char* text, Str*& ret) { return createStr(text, ret); }
// Return a non-binded method
std::list<Str> callStrListToStdList(const StrList& strList) { return strListToStdList(strList); }
virtual std::list<Str> strListToStdList(const StrList& strList ) { return strList; }
void setMargins(int left, int top, int right, int bottom)
{
m_left = left;
m_top = top;
m_right = right;
m_bottom = bottom;
}
virtual void getMargins(int* left, int* top, int* right, int* bottom) const;
void callGetMargins(int* left, int* top, int* right, int* bottom) const
{
getMargins(left, top, right, bottom);
}
virtual int recursionOnModifiedVirtual(Str arg) const { return 0; }
int callRecursionOnModifiedVirtual(Str arg) const { return recursionOnModifiedVirtual(arg); }
private:
Str m_name;
int m_left;
int m_top;
int m_right;
int m_bottom;
};
class LIBSAMPLE_API VirtualDaughter : public VirtualMethods
{
public:
VirtualDaughter() : VirtualMethods() {}
VirtualDaughter(Str name) : VirtualMethods(name) {}
};
class LIBSAMPLE_API VirtualDaughter2 : public VirtualMethods
{
public:
VirtualDaughter2() : VirtualMethods("VirtualDaughter2") {}
double virtualMethod0(Point pt, int val, Complex cpx, bool b) override;
int sum0(int a0, int a1, int a2) final;
};
class LIBSAMPLE_API VirtualFinalDaughter final : public VirtualMethods
{
public:
VirtualFinalDaughter() : VirtualMethods("VirtualFinalDaughter") {}
double virtualMethod0(Point pt, int val, Complex cpx, bool b) override;
int sum0(int a0, int a1, int a2) override;
};
class LIBSAMPLE_API VirtualDtor
{
public:
VirtualDtor() {}
virtual ~VirtualDtor() { dtor_called++; }
static VirtualDtor* create() { return new VirtualDtor(); }
static int dtorCalled() { return dtor_called; }
static void resetDtorCounter() { dtor_called = 0; }
private:
static int dtor_called;
};
#endif // VIRTUALMETHODS_H
|
