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
|
// 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 SAMPLENAMESPACE_H
#define SAMPLENAMESPACE_H
#include "libsamplemacros.h"
#include "str.h"
#include "point.h"
#include "objecttype.h"
#include <list>
// Anonymous global enum
enum {
AnonymousGlobalEnum_Value0,
AnonymousGlobalEnum_Value1
};
namespace SampleNamespace
{
inline namespace InlineNamespace
{
enum EnumWithinInlineNamespace { EWIN_Value0, EWIN_Value1 };
class LIBSAMPLE_API ClassWithinInlineNamespace {
public:
LIBMINIMAL_DEFAULT_COPY_MOVE(ClassWithinInlineNamespace)
ClassWithinInlineNamespace() noexcept = default;
~ClassWithinInlineNamespace() = default;
void setValue(EnumWithinInlineNamespace v) { m_value = v; }
EnumWithinInlineNamespace value() const { return m_value; }
private:
EnumWithinInlineNamespace m_value = EWIN_Value0;
};
} // inline ns
enum Option {
None_,
RandomNumber,
UnixTime
};
enum InValue {
ZeroIn,
OneIn,
TwoIn
};
enum OutValue {
ZeroOut,
OneOut,
TwoOut
};
// Anonymous non-global enum.
// This counts as a class enum, since C++ namespaces
// are represented as classes in Python.
enum {
AnonymousClassEnum_Value0,
AnonymousClassEnum_Value1
};
LIBSAMPLE_API OutValue enumInEnumOut(InValue in);
LIBSAMPLE_API Option enumArgumentWithDefaultValue(Option opt = UnixTime);
LIBSAMPLE_API int getNumber(Option opt);
inline double powerOfTwo(double num) {
return num * num;
}
LIBSAMPLE_API void doSomethingWithArray(const unsigned char *data, unsigned int size,
const char *format = nullptr);
LIBSAMPLE_API int enumItemAsDefaultValueToIntArgument(int value = ZeroIn);
class LIBSAMPLE_API SomeClass
{
public:
enum class PublicScopedEnum { v1, v2 };
class SomeInnerClass
{
public:
class OkThisIsRecursiveEnough
{
public:
LIBMINIMAL_DISABLE_COPY_MOVE(OkThisIsRecursiveEnough)
OkThisIsRecursiveEnough() noexcept = default;
virtual ~OkThisIsRecursiveEnough() = default;
enum NiceEnum {
NiceValue1, NiceValue2
};
enum class NiceEnumClass {
NiceClassValue1, NiceClassValue2
};
inline int someMethod(SomeInnerClass *) { return 0; }
virtual OkThisIsRecursiveEnough *someVirtualMethod(OkThisIsRecursiveEnough *arg)
{ return arg; }
};
protected:
enum ProtectedEnum {
ProtectedItem0,
ProtectedItem1
};
};
struct SomeOtherInnerClass {
std::list<SomeInnerClass> someInnerClasses;
};
protected:
enum ProtectedEnum {
ProtectedItem0,
ProtectedItem1
};
PublicScopedEnum protectedMethodReturningPublicScopedEnum() const;
};
LIBSAMPLE_API inline int enumAsInt(SomeClass::PublicScopedEnum value)
{ return static_cast<int>(value); }
class DerivedFromNamespace : public SomeClass::SomeInnerClass::OkThisIsRecursiveEnough
{
public:
// FIXME Uncomment this when the fix for MSVC is available
// only to cause namespace confusion
// enum SampleNamespace {
// };
virtual OkThisIsRecursiveEnough *someVirtualMethod(OkThisIsRecursiveEnough *arg) { return arg; }
inline OkThisIsRecursiveEnough *methodReturningTypeFromParentScope() { return nullptr; }
};
// The combination of the following two overloaded methods could trigger a
// problematic behaviour on the overload decisor, if it isn't working properly.
LIBSAMPLE_API void forceDecisorSideA(ObjectType *object = nullptr);
LIBSAMPLE_API void forceDecisorSideA(const Point &pt, const Str &text,
ObjectType *object = nullptr);
// The combination of the following two overloaded methods could trigger a
// problematic behaviour on the overload decisor, if it isn't working properly.
// This is a variation of forceDecisorSideB.
LIBSAMPLE_API void forceDecisorSideB(int a, ObjectType *object = nullptr);
LIBSAMPLE_API void forceDecisorSideB(int a, const Point &pt, const Str &text,
ObjectType *object = nullptr);
// Add a new signature on type system with only a Point value as parameter.
LIBSAMPLE_API double passReferenceToValueType(const Point &point, double multiplier);
// Add a new signature on type system with only a ObjectType pointer as parameter.
LIBSAMPLE_API int passReferenceToObjectType(const ObjectType &obj, int multiplier);
extern LIBSAMPLE_API int variableInNamespace;
} // namespace SampleNamespace
#endif // SAMPLENAMESPACE_H
|
