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
|
/*
* This file is part of the Shiboken Python Binding Generator project.
*
* Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
*
* Contact: PySide team <contact@pyside.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef PROTECTED_H
#define PROTECTED_H
#include "libsamplemacros.h"
#include <string>
class ProtectedNonPolymorphic
{
public:
explicit ProtectedNonPolymorphic(const char *name) : m_name(name) {}
~ProtectedNonPolymorphic() {}
inline const char* publicName() { return m_name.c_str(); }
inline static ProtectedNonPolymorphic* create() { return new ProtectedNonPolymorphic("created"); }
protected:
inline const char* protectedName() { return m_name.c_str(); }
inline int protectedSum(int a0, int a1) { return a0 + a1; }
inline int modifiedProtectedSum(int a0, int a1) { return a0 + a1; }
inline static const char* protectedStatic() { return "protectedStatic"; }
inline const char* dataTypeName(void *data = 0) const { return "pointer"; }
inline const char* dataTypeName(int data) const { return "integer"; }
private:
std::string m_name;
};
class ProtectedPolymorphic
{
public:
explicit ProtectedPolymorphic(const char *name) : m_name(name) {}
virtual ~ProtectedPolymorphic() {}
inline static ProtectedPolymorphic* create() { return new ProtectedPolymorphic("created"); }
inline const char* publicName() { return m_name.c_str(); }
inline const char* callProtectedName() { return protectedName(); }
protected:
virtual const char* protectedName() { return m_name.c_str(); }
private:
std::string m_name;
};
class ProtectedPolymorphicDaughter : public ProtectedPolymorphic
{
public:
explicit ProtectedPolymorphicDaughter(const char *name) : ProtectedPolymorphic(name) {}
inline static ProtectedPolymorphicDaughter* create() { return new ProtectedPolymorphicDaughter("created"); }
};
class ProtectedPolymorphicGrandDaughter: public ProtectedPolymorphicDaughter
{
public:
explicit ProtectedPolymorphicGrandDaughter(const char *name) : ProtectedPolymorphicDaughter(name) {}
inline static ProtectedPolymorphicGrandDaughter* create() { return new ProtectedPolymorphicGrandDaughter("created"); }
};
class LIBSAMPLE_API ProtectedVirtualDestructor
{
public:
ProtectedVirtualDestructor() {}
inline static ProtectedVirtualDestructor* create() { return new ProtectedVirtualDestructor(); }
inline static int dtorCalled() { return dtor_called; }
inline static void resetDtorCounter() { dtor_called = 0; }
protected:
virtual ~ProtectedVirtualDestructor() { dtor_called++; }
private:
static int dtor_called;
};
class ProtectedEnumClass
{
public:
ProtectedEnumClass() {}
virtual ~ProtectedEnumClass() {}
enum PublicEnum {
PublicItem0,
PublicItem1
};
protected:
enum ProtectedEnum {
ProtectedItem0,
ProtectedItem1
};
ProtectedEnum callProtectedEnumMethod(ProtectedEnum in) { return protectedEnumMethod(in); }
inline PublicEnum callPublicEnumMethod(PublicEnum in) { return publicEnumMethod(in); }
virtual ProtectedEnum protectedEnumMethod(ProtectedEnum in) { return in; }
virtual PublicEnum publicEnumMethod(PublicEnum in) { return in; }
};
class ProtectedProperty
{
public:
ProtectedProperty() : protectedProperty(0) {}
protected:
int protectedProperty;
};
#endif // PROTECTED_H
|
