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
|
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
#ifndef VIRTUALMETHODS_H
#define VIRTUALMETHODS_H
#include "point.h"
#include "complex.h"
#include "str.h"
#include "libsamplemacros.h"
#include "strlist.h"
#include <string_view>
#include <string>
class LIBSAMPLE_API VirtualMethods
{
public:
LIBMINIMAL_DEFAULT_COPY_MOVE(VirtualMethods)
explicit VirtualMethods(Str name = "VirtualMethods") : m_name(name) {}
virtual ~VirtualMethods() = default;
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;
int callRecursionOnModifiedVirtual(Str arg) const { return recursionOnModifiedVirtual(arg); }
virtual const Str &returnConstRef() const;
virtual int stringViewLength(std::string_view in) const;
protected:
// PYSIDE-1388: Protected hack with final classes (see VirtualFinalDaughter).
void protectedMethod() {}
private:
Str m_name;
int m_left = 0;
int m_top = 0;
int m_right = 0;
int m_bottom = 0;
};
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:
LIBMINIMAL_DEFAULT_COPY_MOVE(VirtualDtor)
VirtualDtor() noexcept = default;
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
|
