umbrello 25.04.1
Umbrello UML Modeller is a Unified Modelling Language (UML) diagram program based on KDE Technology
moc_classifier.cpp
Go to the documentation of this file.
1/****************************************************************************
2** Meta object code from reading C++ file 'classifier.h'
3**
4** Created by: The Qt Meta Object Compiler version 67 (Qt 5.15.13)
5**
6** WARNING! All changes made in this file will be lost!
7*****************************************************************************/
8
9#include <memory>
10#include "../../../../umbrello/umlmodel/classifier.h"
11#include <QtCore/qbytearray.h>
12#include <QtCore/qmetatype.h>
13#if !defined(Q_MOC_OUTPUT_REVISION)
14#error "The header file 'classifier.h' doesn't include <QObject>."
15#elif Q_MOC_OUTPUT_REVISION != 67
16#error "This file was generated using the moc from 5.15.13. It"
17#error "cannot be used with the include files from this version of Qt."
18#error "(The moc has changed too much.)"
19#endif
20
21QT_BEGIN_MOC_NAMESPACE
22QT_WARNING_PUSH
23QT_WARNING_DISABLE_DEPRECATED
25 QByteArrayData data[9];
26 char stringdata0[132];
27};
28#define QT_MOC_LITERAL(idx, ofs, len) \
29 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
30 qptrdiff(offsetof(qt_meta_stringdata_UMLClassifier_t, stringdata0) + ofs \
31 - idx * sizeof(QByteArrayData)) \
32 )
34 {
35QT_MOC_LITERAL(0, 0, 13), // "UMLClassifier"
36QT_MOC_LITERAL(1, 14, 14), // "operationAdded"
37QT_MOC_LITERAL(2, 29, 0), // ""
38QT_MOC_LITERAL(3, 30, 22), // "UMLClassifierListItem*"
39QT_MOC_LITERAL(4, 53, 16), // "operationRemoved"
40QT_MOC_LITERAL(5, 70, 13), // "templateAdded"
41QT_MOC_LITERAL(6, 84, 15), // "templateRemoved"
42QT_MOC_LITERAL(7, 100, 14), // "attributeAdded"
43QT_MOC_LITERAL(8, 115, 16) // "attributeRemoved"
44
45 },
46 "UMLClassifier\0operationAdded\0\0"
47 "UMLClassifierListItem*\0operationRemoved\0"
48 "templateAdded\0templateRemoved\0"
49 "attributeAdded\0attributeRemoved"
50};
51#undef QT_MOC_LITERAL
52
53static const uint qt_meta_data_UMLClassifier[] = {
54
55 // content:
56 8, // revision
57 0, // classname
58 0, 0, // classinfo
59 6, 14, // methods
60 0, 0, // properties
61 0, 0, // enums/sets
62 0, 0, // constructors
63 0, // flags
64 6, // signalCount
65
66 // signals: name, argc, parameters, tag, flags
67 1, 1, 44, 2, 0x06 /* Public */,
68 4, 1, 47, 2, 0x06 /* Public */,
69 5, 1, 50, 2, 0x06 /* Public */,
70 6, 1, 53, 2, 0x06 /* Public */,
71 7, 1, 56, 2, 0x06 /* Public */,
72 8, 1, 59, 2, 0x06 /* Public */,
73
74 // signals: parameters
75 QMetaType::Void, 0x80000000 | 3, 2,
76 QMetaType::Void, 0x80000000 | 3, 2,
77 QMetaType::Void, 0x80000000 | 3, 2,
78 QMetaType::Void, 0x80000000 | 3, 2,
79 QMetaType::Void, 0x80000000 | 3, 2,
80 QMetaType::Void, 0x80000000 | 3, 2,
81
82 0 // eod
83};
84
85void UMLClassifier::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
86{
87 if (_c == QMetaObject::InvokeMetaMethod) {
88 auto *_t = static_cast<UMLClassifier *>(_o);
89 (void)_t;
90 switch (_id) {
91 case 0: _t->operationAdded((*reinterpret_cast< UMLClassifierListItem*(*)>(_a[1]))); break;
92 case 1: _t->operationRemoved((*reinterpret_cast< UMLClassifierListItem*(*)>(_a[1]))); break;
93 case 2: _t->templateAdded((*reinterpret_cast< UMLClassifierListItem*(*)>(_a[1]))); break;
94 case 3: _t->templateRemoved((*reinterpret_cast< UMLClassifierListItem*(*)>(_a[1]))); break;
95 case 4: _t->attributeAdded((*reinterpret_cast< UMLClassifierListItem*(*)>(_a[1]))); break;
96 case 5: _t->attributeRemoved((*reinterpret_cast< UMLClassifierListItem*(*)>(_a[1]))); break;
97 default: ;
98 }
99 } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
100 switch (_id) {
101 default: *reinterpret_cast<int*>(_a[0]) = -1; break;
102 case 0:
103 switch (*reinterpret_cast<int*>(_a[1])) {
104 default: *reinterpret_cast<int*>(_a[0]) = -1; break;
105 case 0:
106 *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< UMLClassifierListItem* >(); break;
107 }
108 break;
109 case 1:
110 switch (*reinterpret_cast<int*>(_a[1])) {
111 default: *reinterpret_cast<int*>(_a[0]) = -1; break;
112 case 0:
113 *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< UMLClassifierListItem* >(); break;
114 }
115 break;
116 case 2:
117 switch (*reinterpret_cast<int*>(_a[1])) {
118 default: *reinterpret_cast<int*>(_a[0]) = -1; break;
119 case 0:
120 *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< UMLClassifierListItem* >(); break;
121 }
122 break;
123 case 3:
124 switch (*reinterpret_cast<int*>(_a[1])) {
125 default: *reinterpret_cast<int*>(_a[0]) = -1; break;
126 case 0:
127 *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< UMLClassifierListItem* >(); break;
128 }
129 break;
130 case 4:
131 switch (*reinterpret_cast<int*>(_a[1])) {
132 default: *reinterpret_cast<int*>(_a[0]) = -1; break;
133 case 0:
134 *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< UMLClassifierListItem* >(); break;
135 }
136 break;
137 case 5:
138 switch (*reinterpret_cast<int*>(_a[1])) {
139 default: *reinterpret_cast<int*>(_a[0]) = -1; break;
140 case 0:
141 *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< UMLClassifierListItem* >(); break;
142 }
143 break;
144 }
145 } else if (_c == QMetaObject::IndexOfMethod) {
146 int *result = reinterpret_cast<int *>(_a[0]);
147 {
148 using _t = void (UMLClassifier::*)(UMLClassifierListItem * );
149 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&UMLClassifier::operationAdded)) {
150 *result = 0;
151 return;
152 }
153 }
154 {
155 using _t = void (UMLClassifier::*)(UMLClassifierListItem * );
156 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&UMLClassifier::operationRemoved)) {
157 *result = 1;
158 return;
159 }
160 }
161 {
162 using _t = void (UMLClassifier::*)(UMLClassifierListItem * );
163 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&UMLClassifier::templateAdded)) {
164 *result = 2;
165 return;
166 }
167 }
168 {
169 using _t = void (UMLClassifier::*)(UMLClassifierListItem * );
170 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&UMLClassifier::templateRemoved)) {
171 *result = 3;
172 return;
173 }
174 }
175 {
176 using _t = void (UMLClassifier::*)(UMLClassifierListItem * );
177 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&UMLClassifier::attributeAdded)) {
178 *result = 4;
179 return;
180 }
181 }
182 {
183 using _t = void (UMLClassifier::*)(UMLClassifierListItem * );
184 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&UMLClassifier::attributeRemoved)) {
185 *result = 5;
186 return;
187 }
188 }
189 }
190}
191
192QT_INIT_METAOBJECT const QMetaObject UMLClassifier::staticMetaObject = { {
193 QMetaObject::SuperData::link<UMLPackage::staticMetaObject>(),
196 qt_static_metacall,
197 nullptr,
198 nullptr
199} };
200
201
202const QMetaObject *UMLClassifier::metaObject() const
203{
204 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
205}
206
207void *UMLClassifier::qt_metacast(const char *_clname)
208{
209 if (!_clname) return nullptr;
210 if (!strcmp(_clname, qt_meta_stringdata_UMLClassifier.stringdata0))
211 return static_cast<void*>(this);
212 return UMLPackage::qt_metacast(_clname);
213}
214
215int UMLClassifier::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
216{
217 _id = UMLPackage::qt_metacall(_c, _id, _a);
218 if (_id < 0)
219 return _id;
220 if (_c == QMetaObject::InvokeMetaMethod) {
221 if (_id < 6)
222 qt_static_metacall(this, _c, _id, _a);
223 _id -= 6;
224 } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
225 if (_id < 6)
226 qt_static_metacall(this, _c, _id, _a);
227 _id -= 6;
228 }
229 return _id;
230}
231
232// SIGNAL 0
234{
235 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
236 QMetaObject::activate(this, &staticMetaObject, 0, _a);
237}
238
239// SIGNAL 1
241{
242 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
243 QMetaObject::activate(this, &staticMetaObject, 1, _a);
244}
245
246// SIGNAL 2
248{
249 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
250 QMetaObject::activate(this, &staticMetaObject, 2, _a);
251}
252
253// SIGNAL 3
255{
256 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
257 QMetaObject::activate(this, &staticMetaObject, 3, _a);
258}
259
260// SIGNAL 4
262{
263 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
264 QMetaObject::activate(this, &staticMetaObject, 4, _a);
265}
266
267// SIGNAL 5
269{
270 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
271 QMetaObject::activate(this, &staticMetaObject, 5, _a);
272}
273QT_WARNING_POP
274QT_END_MOC_NAMESPACE
A base class for classifier list items (e.g. attributes)
Definition classifierlistitem.h:25
Information for a non-graphical Concept/Class.
Definition classifier.h:35
void operationRemoved(UMLClassifierListItem *)
Definition moc_classifier.cpp:240
void operationAdded(UMLClassifierListItem *)
Definition moc_classifier.cpp:233
void attributeAdded(UMLClassifierListItem *)
Definition moc_classifier.cpp:261
void templateAdded(UMLClassifierListItem *)
Definition moc_classifier.cpp:247
void templateRemoved(UMLClassifierListItem *)
Definition moc_classifier.cpp:254
void attributeRemoved(UMLClassifierListItem *)
Definition moc_classifier.cpp:268
static const qt_meta_stringdata_UMLClassifier_t qt_meta_stringdata_UMLClassifier
Definition moc_classifier.cpp:33
static const uint qt_meta_data_UMLClassifier[]
Definition moc_classifier.cpp:53
#define QT_MOC_LITERAL(idx, ofs, len)
Definition moc_classifier.cpp:28
Definition moc_classifier.cpp:24
QByteArrayData data[9]
Definition moc_classifier.cpp:25
char stringdata0[132]
Definition moc_classifier.cpp:26