Warning, /sdk/clazy/tests/old-style-connect/main.qt5.moc_ is written in an unsupported language. File is not indexed.
0001 /****************************************************************************
0002 ** Meta object code from reading C++ file 'main.cpp'
0003 **
0004 ** Created by: The Qt Meta Object Compiler version 67 (Qt 5.15.12)
0005 **
0006 ** WARNING! All changes made in this file will be lost!
0007 *****************************************************************************/
0008
0009 #include <memory>
0010 #include <QtCore/qbytearray.h>
0011 #include <QtCore/qmetatype.h>
0012 #if !defined(Q_MOC_OUTPUT_REVISION)
0013 #error "The header file 'main.cpp' doesn't include <QObject>."
0014 #elif Q_MOC_OUTPUT_REVISION != 67
0015 #error "This file was generated using the moc from 5.15.12. It"
0016 #error "cannot be used with the include files from this version of Qt."
0017 #error "(The moc has changed too much.)"
0018 #endif
0019
0020 QT_BEGIN_MOC_NAMESPACE
0021 QT_WARNING_PUSH
0022 QT_WARNING_DISABLE_DEPRECATED
0023 struct qt_meta_stringdata_MyObj_t {
0024 QByteArrayData data[7];
0025 char stringdata0[41];
0026 };
0027 #define QT_MOC_LITERAL(idx, ofs, len) \
0028 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
0029 qptrdiff(offsetof(qt_meta_stringdata_MyObj_t, stringdata0) + ofs \
0030 - idx * sizeof(QByteArrayData)) \
0031 )
0032 static const qt_meta_stringdata_MyObj_t qt_meta_stringdata_MyObj = {
0033 {
0034 QT_MOC_LITERAL(0, 0, 5), // "MyObj"
0035 QT_MOC_LITERAL(1, 6, 7), // "signal1"
0036 QT_MOC_LITERAL(2, 14, 0), // ""
0037 QT_MOC_LITERAL(3, 15, 5), // "slot1"
0038 QT_MOC_LITERAL(4, 21, 5), // "slot2"
0039 QT_MOC_LITERAL(5, 27, 11), // "slotWithArg"
0040 QT_MOC_LITERAL(6, 39, 1) // "i"
0041
0042 },
0043 "MyObj\0signal1\0\0slot1\0slot2\0slotWithArg\0"
0044 "i"
0045 };
0046 #undef QT_MOC_LITERAL
0047
0048 static const uint qt_meta_data_MyObj[] = {
0049
0050 // content:
0051 8, // revision
0052 0, // classname
0053 0, 0, // classinfo
0054 5, 14, // methods
0055 0, 0, // properties
0056 0, 0, // enums/sets
0057 0, 0, // constructors
0058 0, // flags
0059 1, // signalCount
0060
0061 // signals: name, argc, parameters, tag, flags
0062 1, 0, 39, 2, 0x06 /* Public */,
0063
0064 // slots: name, argc, parameters, tag, flags
0065 3, 0, 40, 2, 0x0a /* Public */,
0066 4, 0, 41, 2, 0x0a /* Public */,
0067 5, 1, 42, 2, 0x0a /* Public */,
0068 5, 0, 45, 2, 0x2a /* Public | MethodCloned */,
0069
0070 // signals: parameters
0071 QMetaType::Void,
0072
0073 // slots: parameters
0074 QMetaType::Void,
0075 QMetaType::Void,
0076 QMetaType::Void, QMetaType::Int, 6,
0077 QMetaType::Void,
0078
0079 0 // eod
0080 };
0081
0082 void MyObj::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
0083 {
0084 if (_c == QMetaObject::InvokeMetaMethod) {
0085 auto *_t = static_cast<MyObj *>(_o);
0086 (void)_t;
0087 switch (_id) {
0088 case 0: _t->signal1(); break;
0089 case 1: _t->slot1(); break;
0090 case 2: _t->slot2(); break;
0091 case 3: _t->slotWithArg((*reinterpret_cast< int(*)>(_a[1]))); break;
0092 case 4: _t->slotWithArg(); break;
0093 default: ;
0094 }
0095 } else if (_c == QMetaObject::IndexOfMethod) {
0096 int *result = reinterpret_cast<int *>(_a[0]);
0097 {
0098 using _t = void (MyObj::*)();
0099 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&MyObj::signal1)) {
0100 *result = 0;
0101 return;
0102 }
0103 }
0104 }
0105 }
0106
0107 QT_INIT_METAOBJECT const QMetaObject MyObj::staticMetaObject = { {
0108 QMetaObject::SuperData::link<QObject::staticMetaObject>(),
0109 qt_meta_stringdata_MyObj.data,
0110 qt_meta_data_MyObj,
0111 qt_static_metacall,
0112 nullptr,
0113 nullptr
0114 } };
0115
0116
0117 const QMetaObject *MyObj::metaObject() const
0118 {
0119 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
0120 }
0121
0122 void *MyObj::qt_metacast(const char *_clname)
0123 {
0124 if (!_clname) return nullptr;
0125 if (!strcmp(_clname, qt_meta_stringdata_MyObj.stringdata0))
0126 return static_cast<void*>(this);
0127 return QObject::qt_metacast(_clname);
0128 }
0129
0130 int MyObj::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
0131 {
0132 _id = QObject::qt_metacall(_c, _id, _a);
0133 if (_id < 0)
0134 return _id;
0135 if (_c == QMetaObject::InvokeMetaMethod) {
0136 if (_id < 5)
0137 qt_static_metacall(this, _c, _id, _a);
0138 _id -= 5;
0139 } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
0140 if (_id < 5)
0141 *reinterpret_cast<int*>(_a[0]) = -1;
0142 _id -= 5;
0143 }
0144 return _id;
0145 }
0146
0147 // SIGNAL 0
0148 void MyObj::signal1()
0149 {
0150 QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
0151 }
0152 struct qt_meta_stringdata_MyObjDerived_t {
0153 QByteArrayData data[1];
0154 char stringdata0[13];
0155 };
0156 #define QT_MOC_LITERAL(idx, ofs, len) \
0157 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
0158 qptrdiff(offsetof(qt_meta_stringdata_MyObjDerived_t, stringdata0) + ofs \
0159 - idx * sizeof(QByteArrayData)) \
0160 )
0161 static const qt_meta_stringdata_MyObjDerived_t qt_meta_stringdata_MyObjDerived = {
0162 {
0163 QT_MOC_LITERAL(0, 0, 12) // "MyObjDerived"
0164
0165 },
0166 "MyObjDerived"
0167 };
0168 #undef QT_MOC_LITERAL
0169
0170 static const uint qt_meta_data_MyObjDerived[] = {
0171
0172 // content:
0173 8, // revision
0174 0, // classname
0175 0, 0, // classinfo
0176 0, 0, // methods
0177 0, 0, // properties
0178 0, 0, // enums/sets
0179 0, 0, // constructors
0180 0, // flags
0181 0, // signalCount
0182
0183 0 // eod
0184 };
0185
0186 void MyObjDerived::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
0187 {
0188 (void)_o;
0189 (void)_id;
0190 (void)_c;
0191 (void)_a;
0192 }
0193
0194 QT_INIT_METAOBJECT const QMetaObject MyObjDerived::staticMetaObject = { {
0195 QMetaObject::SuperData::link<MyObj::staticMetaObject>(),
0196 qt_meta_stringdata_MyObjDerived.data,
0197 qt_meta_data_MyObjDerived,
0198 qt_static_metacall,
0199 nullptr,
0200 nullptr
0201 } };
0202
0203
0204 const QMetaObject *MyObjDerived::metaObject() const
0205 {
0206 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
0207 }
0208
0209 void *MyObjDerived::qt_metacast(const char *_clname)
0210 {
0211 if (!_clname) return nullptr;
0212 if (!strcmp(_clname, qt_meta_stringdata_MyObjDerived.stringdata0))
0213 return static_cast<void*>(this);
0214 return MyObj::qt_metacast(_clname);
0215 }
0216
0217 int MyObjDerived::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
0218 {
0219 _id = MyObj::qt_metacall(_c, _id, _a);
0220 return _id;
0221 }
0222 struct qt_meta_stringdata_OtherObj_t {
0223 QByteArrayData data[3];
0224 char stringdata0[20];
0225 };
0226 #define QT_MOC_LITERAL(idx, ofs, len) \
0227 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
0228 qptrdiff(offsetof(qt_meta_stringdata_OtherObj_t, stringdata0) + ofs \
0229 - idx * sizeof(QByteArrayData)) \
0230 )
0231 static const qt_meta_stringdata_OtherObj_t qt_meta_stringdata_OtherObj = {
0232 {
0233 QT_MOC_LITERAL(0, 0, 8), // "OtherObj"
0234 QT_MOC_LITERAL(1, 9, 9), // "otherSlot"
0235 QT_MOC_LITERAL(2, 19, 0) // ""
0236
0237 },
0238 "OtherObj\0otherSlot\0"
0239 };
0240 #undef QT_MOC_LITERAL
0241
0242 static const uint qt_meta_data_OtherObj[] = {
0243
0244 // content:
0245 8, // revision
0246 0, // classname
0247 0, 0, // classinfo
0248 1, 14, // methods
0249 0, 0, // properties
0250 0, 0, // enums/sets
0251 0, 0, // constructors
0252 0, // flags
0253 0, // signalCount
0254
0255 // slots: name, argc, parameters, tag, flags
0256 1, 0, 19, 2, 0x0a /* Public */,
0257
0258 // slots: parameters
0259 QMetaType::Void,
0260
0261 0 // eod
0262 };
0263
0264 void OtherObj::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
0265 {
0266 if (_c == QMetaObject::InvokeMetaMethod) {
0267 auto *_t = static_cast<OtherObj *>(_o);
0268 (void)_t;
0269 switch (_id) {
0270 case 0: _t->otherSlot(); break;
0271 default: ;
0272 }
0273 }
0274 (void)_a;
0275 }
0276
0277 QT_INIT_METAOBJECT const QMetaObject OtherObj::staticMetaObject = { {
0278 QMetaObject::SuperData::link<QObject::staticMetaObject>(),
0279 qt_meta_stringdata_OtherObj.data,
0280 qt_meta_data_OtherObj,
0281 qt_static_metacall,
0282 nullptr,
0283 nullptr
0284 } };
0285
0286
0287 const QMetaObject *OtherObj::metaObject() const
0288 {
0289 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
0290 }
0291
0292 void *OtherObj::qt_metacast(const char *_clname)
0293 {
0294 if (!_clname) return nullptr;
0295 if (!strcmp(_clname, qt_meta_stringdata_OtherObj.stringdata0))
0296 return static_cast<void*>(this);
0297 return QObject::qt_metacast(_clname);
0298 }
0299
0300 int OtherObj::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
0301 {
0302 _id = QObject::qt_metacall(_c, _id, _a);
0303 if (_id < 0)
0304 return _id;
0305 if (_c == QMetaObject::InvokeMetaMethod) {
0306 if (_id < 1)
0307 qt_static_metacall(this, _c, _id, _a);
0308 _id -= 1;
0309 } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
0310 if (_id < 1)
0311 *reinterpret_cast<int*>(_a[0]) = -1;
0312 _id -= 1;
0313 }
0314 return _id;
0315 }
0316 struct qt_meta_stringdata_WithNesting_t {
0317 QByteArrayData data[5];
0318 char stringdata0[36];
0319 };
0320 #define QT_MOC_LITERAL(idx, ofs, len) \
0321 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
0322 qptrdiff(offsetof(qt_meta_stringdata_WithNesting_t, stringdata0) + ofs \
0323 - idx * sizeof(QByteArrayData)) \
0324 )
0325 static const qt_meta_stringdata_WithNesting_t qt_meta_stringdata_WithNesting = {
0326 {
0327 QT_MOC_LITERAL(0, 0, 11), // "WithNesting"
0328 QT_MOC_LITERAL(1, 12, 7), // "signal1"
0329 QT_MOC_LITERAL(2, 20, 0), // ""
0330 QT_MOC_LITERAL(3, 21, 5), // "slot1"
0331 QT_MOC_LITERAL(4, 27, 8) // "privSlot"
0332
0333 },
0334 "WithNesting\0signal1\0\0slot1\0privSlot"
0335 };
0336 #undef QT_MOC_LITERAL
0337
0338 static const uint qt_meta_data_WithNesting[] = {
0339
0340 // content:
0341 8, // revision
0342 0, // classname
0343 0, 0, // classinfo
0344 3, 14, // methods
0345 0, 0, // properties
0346 0, 0, // enums/sets
0347 0, 0, // constructors
0348 0, // flags
0349 1, // signalCount
0350
0351 // signals: name, argc, parameters, tag, flags
0352 1, 0, 29, 2, 0x06 /* Public */,
0353
0354 // slots: name, argc, parameters, tag, flags
0355 3, 0, 30, 2, 0x0a /* Public */,
0356 4, 0, 31, 2, 0x08 /* Private */,
0357
0358 // signals: parameters
0359 QMetaType::Void,
0360
0361 // slots: parameters
0362 QMetaType::Void,
0363 QMetaType::Void,
0364
0365 0 // eod
0366 };
0367
0368 void WithNesting::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
0369 {
0370 if (_c == QMetaObject::InvokeMetaMethod) {
0371 auto *_t = static_cast<WithNesting *>(_o);
0372 (void)_t;
0373 switch (_id) {
0374 case 0: _t->signal1(); break;
0375 case 1: _t->slot1(); break;
0376 case 2: _t->privSlot(); break;
0377 default: ;
0378 }
0379 } else if (_c == QMetaObject::IndexOfMethod) {
0380 int *result = reinterpret_cast<int *>(_a[0]);
0381 {
0382 using _t = void (WithNesting::*)();
0383 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&WithNesting::signal1)) {
0384 *result = 0;
0385 return;
0386 }
0387 }
0388 }
0389 (void)_a;
0390 }
0391
0392 QT_INIT_METAOBJECT const QMetaObject WithNesting::staticMetaObject = { {
0393 QMetaObject::SuperData::link<QObject::staticMetaObject>(),
0394 qt_meta_stringdata_WithNesting.data,
0395 qt_meta_data_WithNesting,
0396 qt_static_metacall,
0397 nullptr,
0398 nullptr
0399 } };
0400
0401
0402 const QMetaObject *WithNesting::metaObject() const
0403 {
0404 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
0405 }
0406
0407 void *WithNesting::qt_metacast(const char *_clname)
0408 {
0409 if (!_clname) return nullptr;
0410 if (!strcmp(_clname, qt_meta_stringdata_WithNesting.stringdata0))
0411 return static_cast<void*>(this);
0412 return QObject::qt_metacast(_clname);
0413 }
0414
0415 int WithNesting::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
0416 {
0417 _id = QObject::qt_metacall(_c, _id, _a);
0418 if (_id < 0)
0419 return _id;
0420 if (_c == QMetaObject::InvokeMetaMethod) {
0421 if (_id < 3)
0422 qt_static_metacall(this, _c, _id, _a);
0423 _id -= 3;
0424 } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
0425 if (_id < 3)
0426 *reinterpret_cast<int*>(_a[0]) = -1;
0427 _id -= 3;
0428 }
0429 return _id;
0430 }
0431
0432 // SIGNAL 0
0433 void WithNesting::signal1()
0434 {
0435 QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
0436 }
0437 struct qt_meta_stringdata_WithNesting__Private_t {
0438 QByteArrayData data[4];
0439 char stringdata0[37];
0440 };
0441 #define QT_MOC_LITERAL(idx, ofs, len) \
0442 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
0443 qptrdiff(offsetof(qt_meta_stringdata_WithNesting__Private_t, stringdata0) + ofs \
0444 - idx * sizeof(QByteArrayData)) \
0445 )
0446 static const qt_meta_stringdata_WithNesting__Private_t qt_meta_stringdata_WithNesting__Private = {
0447 {
0448 QT_MOC_LITERAL(0, 0, 20), // "WithNesting::Private"
0449 QT_MOC_LITERAL(1, 21, 7), // "signal1"
0450 QT_MOC_LITERAL(2, 29, 0), // ""
0451 QT_MOC_LITERAL(3, 30, 6) // "pSlot1"
0452
0453 },
0454 "WithNesting::Private\0signal1\0\0pSlot1"
0455 };
0456 #undef QT_MOC_LITERAL
0457
0458 static const uint qt_meta_data_WithNesting__Private[] = {
0459
0460 // content:
0461 8, // revision
0462 0, // classname
0463 0, 0, // classinfo
0464 2, 14, // methods
0465 0, 0, // properties
0466 0, 0, // enums/sets
0467 0, 0, // constructors
0468 0, // flags
0469 1, // signalCount
0470
0471 // signals: name, argc, parameters, tag, flags
0472 1, 0, 24, 2, 0x06 /* Public */,
0473
0474 // slots: name, argc, parameters, tag, flags
0475 3, 0, 25, 2, 0x0a /* Public */,
0476
0477 // signals: parameters
0478 QMetaType::Void,
0479
0480 // slots: parameters
0481 QMetaType::Void,
0482
0483 0 // eod
0484 };
0485
0486 void WithNesting::Private::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
0487 {
0488 if (_c == QMetaObject::InvokeMetaMethod) {
0489 auto *_t = static_cast<Private *>(_o);
0490 (void)_t;
0491 switch (_id) {
0492 case 0: _t->signal1(); break;
0493 case 1: _t->pSlot1(); break;
0494 default: ;
0495 }
0496 } else if (_c == QMetaObject::IndexOfMethod) {
0497 int *result = reinterpret_cast<int *>(_a[0]);
0498 {
0499 using _t = void (Private::*)();
0500 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&Private::signal1)) {
0501 *result = 0;
0502 return;
0503 }
0504 }
0505 }
0506 (void)_a;
0507 }
0508
0509 QT_INIT_METAOBJECT const QMetaObject WithNesting::Private::staticMetaObject = { {
0510 QMetaObject::SuperData::link<QObject::staticMetaObject>(),
0511 qt_meta_stringdata_WithNesting__Private.data,
0512 qt_meta_data_WithNesting__Private,
0513 qt_static_metacall,
0514 nullptr,
0515 nullptr
0516 } };
0517
0518
0519 const QMetaObject *WithNesting::Private::metaObject() const
0520 {
0521 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
0522 }
0523
0524 void *WithNesting::Private::qt_metacast(const char *_clname)
0525 {
0526 if (!_clname) return nullptr;
0527 if (!strcmp(_clname, qt_meta_stringdata_WithNesting__Private.stringdata0))
0528 return static_cast<void*>(this);
0529 return QObject::qt_metacast(_clname);
0530 }
0531
0532 int WithNesting::Private::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
0533 {
0534 _id = QObject::qt_metacall(_c, _id, _a);
0535 if (_id < 0)
0536 return _id;
0537 if (_c == QMetaObject::InvokeMetaMethod) {
0538 if (_id < 2)
0539 qt_static_metacall(this, _c, _id, _a);
0540 _id -= 2;
0541 } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
0542 if (_id < 2)
0543 *reinterpret_cast<int*>(_a[0]) = -1;
0544 _id -= 2;
0545 }
0546 return _id;
0547 }
0548
0549 // SIGNAL 0
0550 void WithNesting::Private::signal1()
0551 {
0552 QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
0553 }
0554 struct qt_meta_stringdata_TestingArgumentCounts_t {
0555 QByteArrayData data[9];
0556 char stringdata0[51];
0557 };
0558 #define QT_MOC_LITERAL(idx, ofs, len) \
0559 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
0560 qptrdiff(offsetof(qt_meta_stringdata_TestingArgumentCounts_t, stringdata0) + ofs \
0561 - idx * sizeof(QByteArrayData)) \
0562 )
0563 static const qt_meta_stringdata_TestingArgumentCounts_t qt_meta_stringdata_TestingArgumentCounts = {
0564 {
0565 QT_MOC_LITERAL(0, 0, 21), // "TestingArgumentCounts"
0566 QT_MOC_LITERAL(1, 22, 3), // "si0"
0567 QT_MOC_LITERAL(2, 26, 0), // ""
0568 QT_MOC_LITERAL(3, 27, 3), // "si1"
0569 QT_MOC_LITERAL(4, 31, 3), // "si2"
0570 QT_MOC_LITERAL(5, 35, 3), // "si3"
0571 QT_MOC_LITERAL(6, 39, 3), // "sl0"
0572 QT_MOC_LITERAL(7, 43, 3), // "sl1"
0573 QT_MOC_LITERAL(8, 47, 3) // "sl2"
0574
0575 },
0576 "TestingArgumentCounts\0si0\0\0si1\0si2\0"
0577 "si3\0sl0\0sl1\0sl2"
0578 };
0579 #undef QT_MOC_LITERAL
0580
0581 static const uint qt_meta_data_TestingArgumentCounts[] = {
0582
0583 // content:
0584 8, // revision
0585 0, // classname
0586 0, 0, // classinfo
0587 8, 14, // methods
0588 0, 0, // properties
0589 0, 0, // enums/sets
0590 0, 0, // constructors
0591 0, // flags
0592 4, // signalCount
0593
0594 // signals: name, argc, parameters, tag, flags
0595 1, 0, 54, 2, 0x06 /* Public */,
0596 3, 1, 55, 2, 0x06 /* Public */,
0597 4, 2, 58, 2, 0x06 /* Public */,
0598 5, 3, 63, 2, 0x06 /* Public */,
0599
0600 // slots: name, argc, parameters, tag, flags
0601 6, 0, 70, 2, 0x0a /* Public */,
0602 7, 1, 71, 2, 0x0a /* Public */,
0603 8, 3, 74, 2, 0x0a /* Public */,
0604 8, 2, 81, 2, 0x2a /* Public | MethodCloned */,
0605
0606 // signals: parameters
0607 QMetaType::Void,
0608 QMetaType::Void, QMetaType::QString, 2,
0609 QMetaType::Void, QMetaType::QString, QMetaType::QString, 2, 2,
0610 QMetaType::Void, QMetaType::QString, QMetaType::QString, QMetaType::QString, 2, 2, 2,
0611
0612 // slots: parameters
0613 QMetaType::Void,
0614 QMetaType::Void, QMetaType::QString, 2,
0615 QMetaType::Void, QMetaType::QString, QMetaType::QString, QMetaType::QString, 2, 2, 2,
0616 QMetaType::Void, QMetaType::QString, QMetaType::QString, 2, 2,
0617
0618 0 // eod
0619 };
0620
0621 void TestingArgumentCounts::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
0622 {
0623 if (_c == QMetaObject::InvokeMetaMethod) {
0624 auto *_t = static_cast<TestingArgumentCounts *>(_o);
0625 (void)_t;
0626 switch (_id) {
0627 case 0: _t->si0(); break;
0628 case 1: _t->si1((*reinterpret_cast< QString(*)>(_a[1]))); break;
0629 case 2: _t->si2((*reinterpret_cast< QString(*)>(_a[1])),(*reinterpret_cast< QString(*)>(_a[2]))); break;
0630 case 3: _t->si3((*reinterpret_cast< QString(*)>(_a[1])),(*reinterpret_cast< QString(*)>(_a[2])),(*reinterpret_cast< QString(*)>(_a[3]))); break;
0631 case 4: _t->sl0(); break;
0632 case 5: _t->sl1((*reinterpret_cast< QString(*)>(_a[1]))); break;
0633 case 6: _t->sl2((*reinterpret_cast< QString(*)>(_a[1])),(*reinterpret_cast< QString(*)>(_a[2])),(*reinterpret_cast< QString(*)>(_a[3]))); break;
0634 case 7: _t->sl2((*reinterpret_cast< QString(*)>(_a[1])),(*reinterpret_cast< QString(*)>(_a[2]))); break;
0635 default: ;
0636 }
0637 } else if (_c == QMetaObject::IndexOfMethod) {
0638 int *result = reinterpret_cast<int *>(_a[0]);
0639 {
0640 using _t = void (TestingArgumentCounts::*)();
0641 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestingArgumentCounts::si0)) {
0642 *result = 0;
0643 return;
0644 }
0645 }
0646 {
0647 using _t = void (TestingArgumentCounts::*)(QString );
0648 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestingArgumentCounts::si1)) {
0649 *result = 1;
0650 return;
0651 }
0652 }
0653 {
0654 using _t = void (TestingArgumentCounts::*)(QString , QString );
0655 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestingArgumentCounts::si2)) {
0656 *result = 2;
0657 return;
0658 }
0659 }
0660 {
0661 using _t = void (TestingArgumentCounts::*)(QString , QString , QString );
0662 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestingArgumentCounts::si3)) {
0663 *result = 3;
0664 return;
0665 }
0666 }
0667 }
0668 }
0669
0670 QT_INIT_METAOBJECT const QMetaObject TestingArgumentCounts::staticMetaObject = { {
0671 QMetaObject::SuperData::link<QObject::staticMetaObject>(),
0672 qt_meta_stringdata_TestingArgumentCounts.data,
0673 qt_meta_data_TestingArgumentCounts,
0674 qt_static_metacall,
0675 nullptr,
0676 nullptr
0677 } };
0678
0679
0680 const QMetaObject *TestingArgumentCounts::metaObject() const
0681 {
0682 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
0683 }
0684
0685 void *TestingArgumentCounts::qt_metacast(const char *_clname)
0686 {
0687 if (!_clname) return nullptr;
0688 if (!strcmp(_clname, qt_meta_stringdata_TestingArgumentCounts.stringdata0))
0689 return static_cast<void*>(this);
0690 return QObject::qt_metacast(_clname);
0691 }
0692
0693 int TestingArgumentCounts::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
0694 {
0695 _id = QObject::qt_metacall(_c, _id, _a);
0696 if (_id < 0)
0697 return _id;
0698 if (_c == QMetaObject::InvokeMetaMethod) {
0699 if (_id < 8)
0700 qt_static_metacall(this, _c, _id, _a);
0701 _id -= 8;
0702 } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
0703 if (_id < 8)
0704 *reinterpret_cast<int*>(_a[0]) = -1;
0705 _id -= 8;
0706 }
0707 return _id;
0708 }
0709
0710 // SIGNAL 0
0711 void TestingArgumentCounts::si0()
0712 {
0713 QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
0714 }
0715
0716 // SIGNAL 1
0717 void TestingArgumentCounts::si1(QString _t1)
0718 {
0719 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
0720 QMetaObject::activate(this, &staticMetaObject, 1, _a);
0721 }
0722
0723 // SIGNAL 2
0724 void TestingArgumentCounts::si2(QString _t1, QString _t2)
0725 {
0726 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
0727 QMetaObject::activate(this, &staticMetaObject, 2, _a);
0728 }
0729
0730 // SIGNAL 3
0731 void TestingArgumentCounts::si3(QString _t1, QString _t2, QString _t3)
0732 {
0733 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t3))) };
0734 QMetaObject::activate(this, &staticMetaObject, 3, _a);
0735 }
0736 struct qt_meta_stringdata_TestingProtected_t {
0737 QByteArrayData data[1];
0738 char stringdata0[17];
0739 };
0740 #define QT_MOC_LITERAL(idx, ofs, len) \
0741 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
0742 qptrdiff(offsetof(qt_meta_stringdata_TestingProtected_t, stringdata0) + ofs \
0743 - idx * sizeof(QByteArrayData)) \
0744 )
0745 static const qt_meta_stringdata_TestingProtected_t qt_meta_stringdata_TestingProtected = {
0746 {
0747 QT_MOC_LITERAL(0, 0, 16) // "TestingProtected"
0748
0749 },
0750 "TestingProtected"
0751 };
0752 #undef QT_MOC_LITERAL
0753
0754 static const uint qt_meta_data_TestingProtected[] = {
0755
0756 // content:
0757 8, // revision
0758 0, // classname
0759 0, 0, // classinfo
0760 0, 0, // methods
0761 0, 0, // properties
0762 0, 0, // enums/sets
0763 0, 0, // constructors
0764 0, // flags
0765 0, // signalCount
0766
0767 0 // eod
0768 };
0769
0770 void TestingProtected::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
0771 {
0772 (void)_o;
0773 (void)_id;
0774 (void)_c;
0775 (void)_a;
0776 }
0777
0778 QT_INIT_METAOBJECT const QMetaObject TestingProtected::staticMetaObject = { {
0779 QMetaObject::SuperData::link<QObject::staticMetaObject>(),
0780 qt_meta_stringdata_TestingProtected.data,
0781 qt_meta_data_TestingProtected,
0782 qt_static_metacall,
0783 nullptr,
0784 nullptr
0785 } };
0786
0787
0788 const QMetaObject *TestingProtected::metaObject() const
0789 {
0790 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
0791 }
0792
0793 void *TestingProtected::qt_metacast(const char *_clname)
0794 {
0795 if (!_clname) return nullptr;
0796 if (!strcmp(_clname, qt_meta_stringdata_TestingProtected.stringdata0))
0797 return static_cast<void*>(this);
0798 return QObject::qt_metacast(_clname);
0799 }
0800
0801 int TestingProtected::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
0802 {
0803 _id = QObject::qt_metacall(_c, _id, _a);
0804 return _id;
0805 }
0806 struct qt_meta_stringdata_TestTypes_t {
0807 QByteArrayData data[58];
0808 char stringdata0[282];
0809 };
0810 #define QT_MOC_LITERAL(idx, ofs, len) \
0811 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
0812 qptrdiff(offsetof(qt_meta_stringdata_TestTypes_t, stringdata0) + ofs \
0813 - idx * sizeof(QByteArrayData)) \
0814 )
0815 static const qt_meta_stringdata_TestTypes_t qt_meta_stringdata_TestTypes = {
0816 {
0817 QT_MOC_LITERAL(0, 0, 9), // "TestTypes"
0818 QT_MOC_LITERAL(1, 10, 2), // "s1"
0819 QT_MOC_LITERAL(2, 13, 0), // ""
0820 QT_MOC_LITERAL(3, 14, 2), // "s2"
0821 QT_MOC_LITERAL(4, 17, 2), // "s3"
0822 QT_MOC_LITERAL(5, 20, 4), // "int*"
0823 QT_MOC_LITERAL(6, 25, 2), // "s4"
0824 QT_MOC_LITERAL(7, 28, 5), // "bool*"
0825 QT_MOC_LITERAL(8, 34, 2), // "s5"
0826 QT_MOC_LITERAL(9, 37, 6), // "float*"
0827 QT_MOC_LITERAL(10, 44, 2), // "s6"
0828 QT_MOC_LITERAL(11, 47, 2), // "s7"
0829 QT_MOC_LITERAL(12, 50, 2), // "s8"
0830 QT_MOC_LITERAL(13, 53, 5), // "char*"
0831 QT_MOC_LITERAL(14, 59, 2), // "s9"
0832 QT_MOC_LITERAL(15, 62, 3), // "s10"
0833 QT_MOC_LITERAL(16, 66, 3), // "s11"
0834 QT_MOC_LITERAL(17, 70, 2), // "S1"
0835 QT_MOC_LITERAL(18, 73, 3), // "s12"
0836 QT_MOC_LITERAL(19, 77, 2), // "S2"
0837 QT_MOC_LITERAL(20, 80, 3), // "s13"
0838 QT_MOC_LITERAL(21, 84, 2), // "S3"
0839 QT_MOC_LITERAL(22, 87, 3), // "s14"
0840 QT_MOC_LITERAL(23, 91, 3), // "S1a"
0841 QT_MOC_LITERAL(24, 95, 3), // "s15"
0842 QT_MOC_LITERAL(25, 99, 3), // "S1*"
0843 QT_MOC_LITERAL(26, 103, 3), // "s16"
0844 QT_MOC_LITERAL(27, 107, 3), // "S2*"
0845 QT_MOC_LITERAL(28, 111, 3), // "s17"
0846 QT_MOC_LITERAL(29, 115, 3), // "S3*"
0847 QT_MOC_LITERAL(30, 119, 3), // "s18"
0848 QT_MOC_LITERAL(31, 123, 4), // "S1a*"
0849 QT_MOC_LITERAL(32, 128, 3), // "s19"
0850 QT_MOC_LITERAL(33, 132, 3), // "S1&"
0851 QT_MOC_LITERAL(34, 136, 3), // "s20"
0852 QT_MOC_LITERAL(35, 140, 3), // "S2&"
0853 QT_MOC_LITERAL(36, 144, 3), // "s21"
0854 QT_MOC_LITERAL(37, 148, 3), // "S3&"
0855 QT_MOC_LITERAL(38, 152, 3), // "s22"
0856 QT_MOC_LITERAL(39, 156, 4), // "S1a&"
0857 QT_MOC_LITERAL(40, 161, 3), // "s23"
0858 QT_MOC_LITERAL(41, 165, 3), // "s24"
0859 QT_MOC_LITERAL(42, 169, 3), // "s25"
0860 QT_MOC_LITERAL(43, 173, 3), // "s26"
0861 QT_MOC_LITERAL(44, 177, 3), // "s27"
0862 QT_MOC_LITERAL(45, 181, 9), // "const S1*"
0863 QT_MOC_LITERAL(46, 191, 3), // "s28"
0864 QT_MOC_LITERAL(47, 195, 9), // "const S2*"
0865 QT_MOC_LITERAL(48, 205, 3), // "s29"
0866 QT_MOC_LITERAL(49, 209, 9), // "const S3*"
0867 QT_MOC_LITERAL(50, 219, 3), // "s30"
0868 QT_MOC_LITERAL(51, 223, 10), // "const S1a*"
0869 QT_MOC_LITERAL(52, 234, 3), // "s31"
0870 QT_MOC_LITERAL(53, 238, 3), // "s32"
0871 QT_MOC_LITERAL(54, 242, 13), // "doubleClicked"
0872 QT_MOC_LITERAL(55, 256, 11), // "QModelIndex"
0873 QT_MOC_LITERAL(56, 268, 9), // "triggered"
0874 QT_MOC_LITERAL(57, 278, 3) // "yes"
0875
0876 },
0877 "TestTypes\0s1\0\0s2\0s3\0int*\0s4\0bool*\0s5\0"
0878 "float*\0s6\0s7\0s8\0char*\0s9\0s10\0s11\0S1\0"
0879 "s12\0S2\0s13\0S3\0s14\0S1a\0s15\0S1*\0s16\0S2*\0"
0880 "s17\0S3*\0s18\0S1a*\0s19\0S1&\0s20\0S2&\0s21\0"
0881 "S3&\0s22\0S1a&\0s23\0s24\0s25\0s26\0s27\0"
0882 "const S1*\0s28\0const S2*\0s29\0const S3*\0"
0883 "s30\0const S1a*\0s31\0s32\0doubleClicked\0"
0884 "QModelIndex\0triggered\0yes"
0885 };
0886 #undef QT_MOC_LITERAL
0887
0888 static const uint qt_meta_data_TestTypes[] = {
0889
0890 // content:
0891 8, // revision
0892 0, // classname
0893 0, 0, // classinfo
0894 35, 14, // methods
0895 0, 0, // properties
0896 0, 0, // enums/sets
0897 0, 0, // constructors
0898 0, // flags
0899 35, // signalCount
0900
0901 // signals: name, argc, parameters, tag, flags
0902 1, 1, 189, 2, 0x06 /* Public */,
0903 3, 1, 192, 2, 0x06 /* Public */,
0904 4, 1, 195, 2, 0x06 /* Public */,
0905 6, 1, 198, 2, 0x06 /* Public */,
0906 8, 1, 201, 2, 0x06 /* Public */,
0907 10, 1, 204, 2, 0x06 /* Public */,
0908 11, 1, 207, 2, 0x06 /* Public */,
0909 12, 1, 210, 2, 0x06 /* Public */,
0910 14, 1, 213, 2, 0x06 /* Public */,
0911 15, 1, 216, 2, 0x06 /* Public */,
0912 16, 1, 219, 2, 0x06 /* Public */,
0913 18, 1, 222, 2, 0x06 /* Public */,
0914 20, 1, 225, 2, 0x06 /* Public */,
0915 22, 1, 228, 2, 0x06 /* Public */,
0916 24, 1, 231, 2, 0x06 /* Public */,
0917 26, 1, 234, 2, 0x06 /* Public */,
0918 28, 1, 237, 2, 0x06 /* Public */,
0919 30, 1, 240, 2, 0x06 /* Public */,
0920 32, 1, 243, 2, 0x06 /* Public */,
0921 34, 1, 246, 2, 0x06 /* Public */,
0922 36, 1, 249, 2, 0x06 /* Public */,
0923 38, 1, 252, 2, 0x06 /* Public */,
0924 40, 1, 255, 2, 0x06 /* Public */,
0925 41, 1, 258, 2, 0x06 /* Public */,
0926 42, 1, 261, 2, 0x06 /* Public */,
0927 43, 1, 264, 2, 0x06 /* Public */,
0928 44, 1, 267, 2, 0x06 /* Public */,
0929 46, 1, 270, 2, 0x06 /* Public */,
0930 48, 1, 273, 2, 0x06 /* Public */,
0931 50, 1, 276, 2, 0x06 /* Public */,
0932 52, 1, 279, 2, 0x06 /* Public */,
0933 53, 1, 282, 2, 0x06 /* Public */,
0934 54, 1, 285, 2, 0x06 /* Public */,
0935 56, 1, 288, 2, 0x06 /* Public */,
0936 56, 0, 291, 2, 0x26 /* Public | MethodCloned */,
0937
0938 // signals: parameters
0939 QMetaType::Void, QMetaType::Bool, 2,
0940 QMetaType::Void, QMetaType::Int, 2,
0941 QMetaType::Void, 0x80000000 | 5, 2,
0942 QMetaType::Void, 0x80000000 | 7, 2,
0943 QMetaType::Void, 0x80000000 | 9, 2,
0944 QMetaType::Void, 0x80000000 | 9, 2,
0945 QMetaType::Void, QMetaType::Char, 2,
0946 QMetaType::Void, 0x80000000 | 13, 2,
0947 QMetaType::Void, QMetaType::Float, 2,
0948 QMetaType::Void, QMetaType::Double, 2,
0949 QMetaType::Void, 0x80000000 | 17, 2,
0950 QMetaType::Void, 0x80000000 | 19, 2,
0951 QMetaType::Void, 0x80000000 | 21, 2,
0952 QMetaType::Void, 0x80000000 | 23, 2,
0953 QMetaType::Void, 0x80000000 | 25, 2,
0954 QMetaType::Void, 0x80000000 | 27, 2,
0955 QMetaType::Void, 0x80000000 | 29, 2,
0956 QMetaType::Void, 0x80000000 | 31, 2,
0957 QMetaType::Void, 0x80000000 | 33, 2,
0958 QMetaType::Void, 0x80000000 | 35, 2,
0959 QMetaType::Void, 0x80000000 | 37, 2,
0960 QMetaType::Void, 0x80000000 | 39, 2,
0961 QMetaType::Void, 0x80000000 | 17, 2,
0962 QMetaType::Void, 0x80000000 | 19, 2,
0963 QMetaType::Void, 0x80000000 | 21, 2,
0964 QMetaType::Void, 0x80000000 | 23, 2,
0965 QMetaType::Void, 0x80000000 | 45, 2,
0966 QMetaType::Void, 0x80000000 | 47, 2,
0967 QMetaType::Void, 0x80000000 | 49, 2,
0968 QMetaType::Void, 0x80000000 | 51, 2,
0969 QMetaType::Void, 0x80000000 | 17, 2,
0970 QMetaType::Void, 0x80000000 | 33, 2,
0971 QMetaType::Void, 0x80000000 | 55, 2,
0972 QMetaType::Void, QMetaType::Bool, 57,
0973 QMetaType::Void,
0974
0975 0 // eod
0976 };
0977
0978 void TestTypes::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
0979 {
0980 if (_c == QMetaObject::InvokeMetaMethod) {
0981 auto *_t = static_cast<TestTypes *>(_o);
0982 (void)_t;
0983 switch (_id) {
0984 case 0: _t->s1((*reinterpret_cast< bool(*)>(_a[1]))); break;
0985 case 1: _t->s2((*reinterpret_cast< int(*)>(_a[1]))); break;
0986 case 2: _t->s3((*reinterpret_cast< int*(*)>(_a[1]))); break;
0987 case 3: _t->s4((*reinterpret_cast< bool*(*)>(_a[1]))); break;
0988 case 4: _t->s5((*reinterpret_cast< float*(*)>(_a[1]))); break;
0989 case 5: _t->s6((*reinterpret_cast< float*(*)>(_a[1]))); break;
0990 case 6: _t->s7((*reinterpret_cast< char(*)>(_a[1]))); break;
0991 case 7: _t->s8((*reinterpret_cast< char*(*)>(_a[1]))); break;
0992 case 8: _t->s9((*reinterpret_cast< float(*)>(_a[1]))); break;
0993 case 9: _t->s10((*reinterpret_cast< double(*)>(_a[1]))); break;
0994 case 10: _t->s11((*reinterpret_cast< S1(*)>(_a[1]))); break;
0995 case 11: _t->s12((*reinterpret_cast< S2(*)>(_a[1]))); break;
0996 case 12: _t->s13((*reinterpret_cast< S3(*)>(_a[1]))); break;
0997 case 13: _t->s14((*reinterpret_cast< S1a(*)>(_a[1]))); break;
0998 case 14: _t->s15((*reinterpret_cast< S1*(*)>(_a[1]))); break;
0999 case 15: _t->s16((*reinterpret_cast< S2*(*)>(_a[1]))); break;
1000 case 16: _t->s17((*reinterpret_cast< S3*(*)>(_a[1]))); break;
1001 case 17: _t->s18((*reinterpret_cast< S1a*(*)>(_a[1]))); break;
1002 case 18: _t->s19((*reinterpret_cast< S1(*)>(_a[1]))); break;
1003 case 19: _t->s20((*reinterpret_cast< S2(*)>(_a[1]))); break;
1004 case 20: _t->s21((*reinterpret_cast< S3(*)>(_a[1]))); break;
1005 case 21: _t->s22((*reinterpret_cast< S1a(*)>(_a[1]))); break;
1006 case 22: _t->s23((*reinterpret_cast< const S1(*)>(_a[1]))); break;
1007 case 23: _t->s24((*reinterpret_cast< const S2(*)>(_a[1]))); break;
1008 case 24: _t->s25((*reinterpret_cast< const S3(*)>(_a[1]))); break;
1009 case 25: _t->s26((*reinterpret_cast< const S1a(*)>(_a[1]))); break;
1010 case 26: _t->s27((*reinterpret_cast< const S1*(*)>(_a[1]))); break;
1011 case 27: _t->s28((*reinterpret_cast< const S2*(*)>(_a[1]))); break;
1012 case 28: _t->s29((*reinterpret_cast< const S3*(*)>(_a[1]))); break;
1013 case 29: _t->s30((*reinterpret_cast< const S1a*(*)>(_a[1]))); break;
1014 case 30: _t->s31((*reinterpret_cast< const S1(*)>(_a[1]))); break;
1015 case 31: _t->s32((*reinterpret_cast< S1(*)>(_a[1]))); break;
1016 case 32: _t->doubleClicked((*reinterpret_cast< const QModelIndex(*)>(_a[1]))); break;
1017 case 33: _t->triggered((*reinterpret_cast< bool(*)>(_a[1]))); break;
1018 case 34: _t->triggered(); break;
1019 default: ;
1020 }
1021 } else if (_c == QMetaObject::IndexOfMethod) {
1022 int *result = reinterpret_cast<int *>(_a[0]);
1023 {
1024 using _t = void (TestTypes::*)(bool );
1025 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestTypes::s1)) {
1026 *result = 0;
1027 return;
1028 }
1029 }
1030 {
1031 using _t = void (TestTypes::*)(int );
1032 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestTypes::s2)) {
1033 *result = 1;
1034 return;
1035 }
1036 }
1037 {
1038 using _t = void (TestTypes::*)(int * );
1039 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestTypes::s3)) {
1040 *result = 2;
1041 return;
1042 }
1043 }
1044 {
1045 using _t = void (TestTypes::*)(bool * );
1046 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestTypes::s4)) {
1047 *result = 3;
1048 return;
1049 }
1050 }
1051 {
1052 using _t = void (TestTypes::*)(float * );
1053 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestTypes::s5)) {
1054 *result = 4;
1055 return;
1056 }
1057 }
1058 {
1059 using _t = void (TestTypes::*)(float * );
1060 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestTypes::s6)) {
1061 *result = 5;
1062 return;
1063 }
1064 }
1065 {
1066 using _t = void (TestTypes::*)(char );
1067 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestTypes::s7)) {
1068 *result = 6;
1069 return;
1070 }
1071 }
1072 {
1073 using _t = void (TestTypes::*)(char * );
1074 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestTypes::s8)) {
1075 *result = 7;
1076 return;
1077 }
1078 }
1079 {
1080 using _t = void (TestTypes::*)(float );
1081 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestTypes::s9)) {
1082 *result = 8;
1083 return;
1084 }
1085 }
1086 {
1087 using _t = void (TestTypes::*)(double );
1088 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestTypes::s10)) {
1089 *result = 9;
1090 return;
1091 }
1092 }
1093 {
1094 using _t = void (TestTypes::*)(S1 );
1095 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestTypes::s11)) {
1096 *result = 10;
1097 return;
1098 }
1099 }
1100 {
1101 using _t = void (TestTypes::*)(S2 );
1102 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestTypes::s12)) {
1103 *result = 11;
1104 return;
1105 }
1106 }
1107 {
1108 using _t = void (TestTypes::*)(S3 );
1109 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestTypes::s13)) {
1110 *result = 12;
1111 return;
1112 }
1113 }
1114 {
1115 using _t = void (TestTypes::*)(S1a );
1116 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestTypes::s14)) {
1117 *result = 13;
1118 return;
1119 }
1120 }
1121 {
1122 using _t = void (TestTypes::*)(S1 * );
1123 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestTypes::s15)) {
1124 *result = 14;
1125 return;
1126 }
1127 }
1128 {
1129 using _t = void (TestTypes::*)(S2 * );
1130 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestTypes::s16)) {
1131 *result = 15;
1132 return;
1133 }
1134 }
1135 {
1136 using _t = void (TestTypes::*)(S3 * );
1137 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestTypes::s17)) {
1138 *result = 16;
1139 return;
1140 }
1141 }
1142 {
1143 using _t = void (TestTypes::*)(S1a * );
1144 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestTypes::s18)) {
1145 *result = 17;
1146 return;
1147 }
1148 }
1149 {
1150 using _t = void (TestTypes::*)(S1 & );
1151 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestTypes::s19)) {
1152 *result = 18;
1153 return;
1154 }
1155 }
1156 {
1157 using _t = void (TestTypes::*)(S2 & );
1158 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestTypes::s20)) {
1159 *result = 19;
1160 return;
1161 }
1162 }
1163 {
1164 using _t = void (TestTypes::*)(S3 & );
1165 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestTypes::s21)) {
1166 *result = 20;
1167 return;
1168 }
1169 }
1170 {
1171 using _t = void (TestTypes::*)(S1a & );
1172 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestTypes::s22)) {
1173 *result = 21;
1174 return;
1175 }
1176 }
1177 {
1178 using _t = void (TestTypes::*)(const S1 );
1179 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestTypes::s23)) {
1180 *result = 22;
1181 return;
1182 }
1183 }
1184 {
1185 using _t = void (TestTypes::*)(const S2 );
1186 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestTypes::s24)) {
1187 *result = 23;
1188 return;
1189 }
1190 }
1191 {
1192 using _t = void (TestTypes::*)(const S3 );
1193 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestTypes::s25)) {
1194 *result = 24;
1195 return;
1196 }
1197 }
1198 {
1199 using _t = void (TestTypes::*)(const S1a );
1200 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestTypes::s26)) {
1201 *result = 25;
1202 return;
1203 }
1204 }
1205 {
1206 using _t = void (TestTypes::*)(const S1 * );
1207 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestTypes::s27)) {
1208 *result = 26;
1209 return;
1210 }
1211 }
1212 {
1213 using _t = void (TestTypes::*)(const S2 * );
1214 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestTypes::s28)) {
1215 *result = 27;
1216 return;
1217 }
1218 }
1219 {
1220 using _t = void (TestTypes::*)(const S3 * );
1221 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestTypes::s29)) {
1222 *result = 28;
1223 return;
1224 }
1225 }
1226 {
1227 using _t = void (TestTypes::*)(const S1a * );
1228 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestTypes::s30)) {
1229 *result = 29;
1230 return;
1231 }
1232 }
1233 {
1234 using _t = void (TestTypes::*)(const S1 & );
1235 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestTypes::s31)) {
1236 *result = 30;
1237 return;
1238 }
1239 }
1240 {
1241 using _t = void (TestTypes::*)(S1 & );
1242 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestTypes::s32)) {
1243 *result = 31;
1244 return;
1245 }
1246 }
1247 {
1248 using _t = void (TestTypes::*)(const QModelIndex & );
1249 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestTypes::doubleClicked)) {
1250 *result = 32;
1251 return;
1252 }
1253 }
1254 {
1255 using _t = void (TestTypes::*)(bool );
1256 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TestTypes::triggered)) {
1257 *result = 33;
1258 return;
1259 }
1260 }
1261 }
1262 }
1263
1264 QT_INIT_METAOBJECT const QMetaObject TestTypes::staticMetaObject = { {
1265 QMetaObject::SuperData::link<QObject::staticMetaObject>(),
1266 qt_meta_stringdata_TestTypes.data,
1267 qt_meta_data_TestTypes,
1268 qt_static_metacall,
1269 nullptr,
1270 nullptr
1271 } };
1272
1273
1274 const QMetaObject *TestTypes::metaObject() const
1275 {
1276 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
1277 }
1278
1279 void *TestTypes::qt_metacast(const char *_clname)
1280 {
1281 if (!_clname) return nullptr;
1282 if (!strcmp(_clname, qt_meta_stringdata_TestTypes.stringdata0))
1283 return static_cast<void*>(this);
1284 return QObject::qt_metacast(_clname);
1285 }
1286
1287 int TestTypes::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
1288 {
1289 _id = QObject::qt_metacall(_c, _id, _a);
1290 if (_id < 0)
1291 return _id;
1292 if (_c == QMetaObject::InvokeMetaMethod) {
1293 if (_id < 35)
1294 qt_static_metacall(this, _c, _id, _a);
1295 _id -= 35;
1296 } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
1297 if (_id < 35)
1298 *reinterpret_cast<int*>(_a[0]) = -1;
1299 _id -= 35;
1300 }
1301 return _id;
1302 }
1303
1304 // SIGNAL 0
1305 void TestTypes::s1(bool _t1)
1306 {
1307 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1308 QMetaObject::activate(this, &staticMetaObject, 0, _a);
1309 }
1310
1311 // SIGNAL 1
1312 void TestTypes::s2(int _t1)
1313 {
1314 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1315 QMetaObject::activate(this, &staticMetaObject, 1, _a);
1316 }
1317
1318 // SIGNAL 2
1319 void TestTypes::s3(int * _t1)
1320 {
1321 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1322 QMetaObject::activate(this, &staticMetaObject, 2, _a);
1323 }
1324
1325 // SIGNAL 3
1326 void TestTypes::s4(bool * _t1)
1327 {
1328 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1329 QMetaObject::activate(this, &staticMetaObject, 3, _a);
1330 }
1331
1332 // SIGNAL 4
1333 void TestTypes::s5(float * _t1)
1334 {
1335 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1336 QMetaObject::activate(this, &staticMetaObject, 4, _a);
1337 }
1338
1339 // SIGNAL 5
1340 void TestTypes::s6(float * _t1)
1341 {
1342 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1343 QMetaObject::activate(this, &staticMetaObject, 5, _a);
1344 }
1345
1346 // SIGNAL 6
1347 void TestTypes::s7(char _t1)
1348 {
1349 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1350 QMetaObject::activate(this, &staticMetaObject, 6, _a);
1351 }
1352
1353 // SIGNAL 7
1354 void TestTypes::s8(char * _t1)
1355 {
1356 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1357 QMetaObject::activate(this, &staticMetaObject, 7, _a);
1358 }
1359
1360 // SIGNAL 8
1361 void TestTypes::s9(float _t1)
1362 {
1363 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1364 QMetaObject::activate(this, &staticMetaObject, 8, _a);
1365 }
1366
1367 // SIGNAL 9
1368 void TestTypes::s10(double _t1)
1369 {
1370 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1371 QMetaObject::activate(this, &staticMetaObject, 9, _a);
1372 }
1373
1374 // SIGNAL 10
1375 void TestTypes::s11(S1 _t1)
1376 {
1377 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1378 QMetaObject::activate(this, &staticMetaObject, 10, _a);
1379 }
1380
1381 // SIGNAL 11
1382 void TestTypes::s12(S2 _t1)
1383 {
1384 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1385 QMetaObject::activate(this, &staticMetaObject, 11, _a);
1386 }
1387
1388 // SIGNAL 12
1389 void TestTypes::s13(S3 _t1)
1390 {
1391 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1392 QMetaObject::activate(this, &staticMetaObject, 12, _a);
1393 }
1394
1395 // SIGNAL 13
1396 void TestTypes::s14(S1a _t1)
1397 {
1398 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1399 QMetaObject::activate(this, &staticMetaObject, 13, _a);
1400 }
1401
1402 // SIGNAL 14
1403 void TestTypes::s15(S1 * _t1)
1404 {
1405 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1406 QMetaObject::activate(this, &staticMetaObject, 14, _a);
1407 }
1408
1409 // SIGNAL 15
1410 void TestTypes::s16(S2 * _t1)
1411 {
1412 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1413 QMetaObject::activate(this, &staticMetaObject, 15, _a);
1414 }
1415
1416 // SIGNAL 16
1417 void TestTypes::s17(S3 * _t1)
1418 {
1419 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1420 QMetaObject::activate(this, &staticMetaObject, 16, _a);
1421 }
1422
1423 // SIGNAL 17
1424 void TestTypes::s18(S1a * _t1)
1425 {
1426 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1427 QMetaObject::activate(this, &staticMetaObject, 17, _a);
1428 }
1429
1430 // SIGNAL 18
1431 void TestTypes::s19(S1 & _t1)
1432 {
1433 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1434 QMetaObject::activate(this, &staticMetaObject, 18, _a);
1435 }
1436
1437 // SIGNAL 19
1438 void TestTypes::s20(S2 & _t1)
1439 {
1440 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1441 QMetaObject::activate(this, &staticMetaObject, 19, _a);
1442 }
1443
1444 // SIGNAL 20
1445 void TestTypes::s21(S3 & _t1)
1446 {
1447 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1448 QMetaObject::activate(this, &staticMetaObject, 20, _a);
1449 }
1450
1451 // SIGNAL 21
1452 void TestTypes::s22(S1a & _t1)
1453 {
1454 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1455 QMetaObject::activate(this, &staticMetaObject, 21, _a);
1456 }
1457
1458 // SIGNAL 22
1459 void TestTypes::s23(const S1 _t1)
1460 {
1461 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1462 QMetaObject::activate(this, &staticMetaObject, 22, _a);
1463 }
1464
1465 // SIGNAL 23
1466 void TestTypes::s24(const S2 _t1)
1467 {
1468 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1469 QMetaObject::activate(this, &staticMetaObject, 23, _a);
1470 }
1471
1472 // SIGNAL 24
1473 void TestTypes::s25(const S3 _t1)
1474 {
1475 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1476 QMetaObject::activate(this, &staticMetaObject, 24, _a);
1477 }
1478
1479 // SIGNAL 25
1480 void TestTypes::s26(const S1a _t1)
1481 {
1482 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1483 QMetaObject::activate(this, &staticMetaObject, 25, _a);
1484 }
1485
1486 // SIGNAL 26
1487 void TestTypes::s27(const S1 * _t1)
1488 {
1489 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1490 QMetaObject::activate(this, &staticMetaObject, 26, _a);
1491 }
1492
1493 // SIGNAL 27
1494 void TestTypes::s28(const S2 * _t1)
1495 {
1496 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1497 QMetaObject::activate(this, &staticMetaObject, 27, _a);
1498 }
1499
1500 // SIGNAL 28
1501 void TestTypes::s29(const S3 * _t1)
1502 {
1503 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1504 QMetaObject::activate(this, &staticMetaObject, 28, _a);
1505 }
1506
1507 // SIGNAL 29
1508 void TestTypes::s30(const S1a * _t1)
1509 {
1510 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1511 QMetaObject::activate(this, &staticMetaObject, 29, _a);
1512 }
1513
1514 // SIGNAL 30
1515 void TestTypes::s31(const S1 & _t1)
1516 {
1517 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1518 QMetaObject::activate(this, &staticMetaObject, 30, _a);
1519 }
1520
1521 // SIGNAL 31
1522 void TestTypes::s32(S1 & _t1)
1523 {
1524 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1525 QMetaObject::activate(this, &staticMetaObject, 31, _a);
1526 }
1527
1528 // SIGNAL 32
1529 void TestTypes::doubleClicked(const QModelIndex & _t1)
1530 {
1531 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1532 QMetaObject::activate(this, &staticMetaObject, 32, _a);
1533 }
1534
1535 // SIGNAL 33
1536 void TestTypes::triggered(bool _t1)
1537 {
1538 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1539 QMetaObject::activate(this, &staticMetaObject, 33, _a);
1540 }
1541 struct qt_meta_stringdata_Kleo__ProgressDialog_t {
1542 QByteArrayData data[1];
1543 char stringdata0[21];
1544 };
1545 #define QT_MOC_LITERAL(idx, ofs, len) \
1546 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
1547 qptrdiff(offsetof(qt_meta_stringdata_Kleo__ProgressDialog_t, stringdata0) + ofs \
1548 - idx * sizeof(QByteArrayData)) \
1549 )
1550 static const qt_meta_stringdata_Kleo__ProgressDialog_t qt_meta_stringdata_Kleo__ProgressDialog = {
1551 {
1552 QT_MOC_LITERAL(0, 0, 20) // "Kleo::ProgressDialog"
1553
1554 },
1555 "Kleo::ProgressDialog"
1556 };
1557 #undef QT_MOC_LITERAL
1558
1559 static const uint qt_meta_data_Kleo__ProgressDialog[] = {
1560
1561 // content:
1562 8, // revision
1563 0, // classname
1564 0, 0, // classinfo
1565 0, 0, // methods
1566 0, 0, // properties
1567 0, 0, // enums/sets
1568 0, 0, // constructors
1569 0, // flags
1570 0, // signalCount
1571
1572 0 // eod
1573 };
1574
1575 void Kleo::ProgressDialog::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
1576 {
1577 (void)_o;
1578 (void)_id;
1579 (void)_c;
1580 (void)_a;
1581 }
1582
1583 QT_INIT_METAOBJECT const QMetaObject Kleo::ProgressDialog::staticMetaObject = { {
1584 QMetaObject::SuperData::link<QProgressDialog::staticMetaObject>(),
1585 qt_meta_stringdata_Kleo__ProgressDialog.data,
1586 qt_meta_data_Kleo__ProgressDialog,
1587 qt_static_metacall,
1588 nullptr,
1589 nullptr
1590 } };
1591
1592
1593 const QMetaObject *Kleo::ProgressDialog::metaObject() const
1594 {
1595 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
1596 }
1597
1598 void *Kleo::ProgressDialog::qt_metacast(const char *_clname)
1599 {
1600 if (!_clname) return nullptr;
1601 if (!strcmp(_clname, qt_meta_stringdata_Kleo__ProgressDialog.stringdata0))
1602 return static_cast<void*>(this);
1603 return QProgressDialog::qt_metacast(_clname);
1604 }
1605
1606 int Kleo::ProgressDialog::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
1607 {
1608 _id = QProgressDialog::qt_metacall(_c, _id, _a);
1609 return _id;
1610 }
1611 struct qt_meta_stringdata_TestQPointerMember_t {
1612 QByteArrayData data[3];
1613 char stringdata0[26];
1614 };
1615 #define QT_MOC_LITERAL(idx, ofs, len) \
1616 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
1617 qptrdiff(offsetof(qt_meta_stringdata_TestQPointerMember_t, stringdata0) + ofs \
1618 - idx * sizeof(QByteArrayData)) \
1619 )
1620 static const qt_meta_stringdata_TestQPointerMember_t qt_meta_stringdata_TestQPointerMember = {
1621 {
1622 QT_MOC_LITERAL(0, 0, 18), // "TestQPointerMember"
1623 QT_MOC_LITERAL(1, 19, 5), // "slot1"
1624 QT_MOC_LITERAL(2, 25, 0) // ""
1625
1626 },
1627 "TestQPointerMember\0slot1\0"
1628 };
1629 #undef QT_MOC_LITERAL
1630
1631 static const uint qt_meta_data_TestQPointerMember[] = {
1632
1633 // content:
1634 8, // revision
1635 0, // classname
1636 0, 0, // classinfo
1637 1, 14, // methods
1638 0, 0, // properties
1639 0, 0, // enums/sets
1640 0, 0, // constructors
1641 0, // flags
1642 0, // signalCount
1643
1644 // slots: name, argc, parameters, tag, flags
1645 1, 0, 19, 2, 0x0a /* Public */,
1646
1647 // slots: parameters
1648 QMetaType::Void,
1649
1650 0 // eod
1651 };
1652
1653 void TestQPointerMember::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
1654 {
1655 if (_c == QMetaObject::InvokeMetaMethod) {
1656 auto *_t = static_cast<TestQPointerMember *>(_o);
1657 (void)_t;
1658 switch (_id) {
1659 case 0: _t->slot1(); break;
1660 default: ;
1661 }
1662 }
1663 (void)_a;
1664 }
1665
1666 QT_INIT_METAOBJECT const QMetaObject TestQPointerMember::staticMetaObject = { {
1667 QMetaObject::SuperData::link<QObject::staticMetaObject>(),
1668 qt_meta_stringdata_TestQPointerMember.data,
1669 qt_meta_data_TestQPointerMember,
1670 qt_static_metacall,
1671 nullptr,
1672 nullptr
1673 } };
1674
1675
1676 const QMetaObject *TestQPointerMember::metaObject() const
1677 {
1678 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
1679 }
1680
1681 void *TestQPointerMember::qt_metacast(const char *_clname)
1682 {
1683 if (!_clname) return nullptr;
1684 if (!strcmp(_clname, qt_meta_stringdata_TestQPointerMember.stringdata0))
1685 return static_cast<void*>(this);
1686 return QObject::qt_metacast(_clname);
1687 }
1688
1689 int TestQPointerMember::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
1690 {
1691 _id = QObject::qt_metacall(_c, _id, _a);
1692 if (_id < 0)
1693 return _id;
1694 if (_c == QMetaObject::InvokeMetaMethod) {
1695 if (_id < 1)
1696 qt_static_metacall(this, _c, _id, _a);
1697 _id -= 1;
1698 } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
1699 if (_id < 1)
1700 *reinterpret_cast<int*>(_a[0]) = -1;
1701 _id -= 1;
1702 }
1703 return _id;
1704 }
1705 struct qt_meta_stringdata_TestStatic_t {
1706 QByteArrayData data[3];
1707 char stringdata0[17];
1708 };
1709 #define QT_MOC_LITERAL(idx, ofs, len) \
1710 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
1711 qptrdiff(offsetof(qt_meta_stringdata_TestStatic_t, stringdata0) + ofs \
1712 - idx * sizeof(QByteArrayData)) \
1713 )
1714 static const qt_meta_stringdata_TestStatic_t qt_meta_stringdata_TestStatic = {
1715 {
1716 QT_MOC_LITERAL(0, 0, 10), // "TestStatic"
1717 QT_MOC_LITERAL(1, 11, 4), // "test"
1718 QT_MOC_LITERAL(2, 16, 0) // ""
1719
1720 },
1721 "TestStatic\0test\0"
1722 };
1723 #undef QT_MOC_LITERAL
1724
1725 static const uint qt_meta_data_TestStatic[] = {
1726
1727 // content:
1728 8, // revision
1729 0, // classname
1730 0, 0, // classinfo
1731 1, 14, // methods
1732 0, 0, // properties
1733 0, 0, // enums/sets
1734 0, 0, // constructors
1735 0, // flags
1736 0, // signalCount
1737
1738 // slots: name, argc, parameters, tag, flags
1739 1, 1, 19, 2, 0x0a /* Public */,
1740
1741 // slots: parameters
1742 QMetaType::Void, QMetaType::QObjectStar, 2,
1743
1744 0 // eod
1745 };
1746
1747 void TestStatic::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
1748 {
1749 if (_c == QMetaObject::InvokeMetaMethod) {
1750 auto *_t = static_cast<TestStatic *>(_o);
1751 (void)_t;
1752 switch (_id) {
1753 case 0: _t->test((*reinterpret_cast< QObject*(*)>(_a[1]))); break;
1754 default: ;
1755 }
1756 }
1757 }
1758
1759 QT_INIT_METAOBJECT const QMetaObject TestStatic::staticMetaObject = { {
1760 QMetaObject::SuperData::link<QObject::staticMetaObject>(),
1761 qt_meta_stringdata_TestStatic.data,
1762 qt_meta_data_TestStatic,
1763 qt_static_metacall,
1764 nullptr,
1765 nullptr
1766 } };
1767
1768
1769 const QMetaObject *TestStatic::metaObject() const
1770 {
1771 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
1772 }
1773
1774 void *TestStatic::qt_metacast(const char *_clname)
1775 {
1776 if (!_clname) return nullptr;
1777 if (!strcmp(_clname, qt_meta_stringdata_TestStatic.stringdata0))
1778 return static_cast<void*>(this);
1779 return QObject::qt_metacast(_clname);
1780 }
1781
1782 int TestStatic::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
1783 {
1784 _id = QObject::qt_metacall(_c, _id, _a);
1785 if (_id < 0)
1786 return _id;
1787 if (_c == QMetaObject::InvokeMetaMethod) {
1788 if (_id < 1)
1789 qt_static_metacall(this, _c, _id, _a);
1790 _id -= 1;
1791 } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
1792 if (_id < 1)
1793 *reinterpret_cast<int*>(_a[0]) = -1;
1794 _id -= 1;
1795 }
1796 return _id;
1797 }
1798 QT_WARNING_POP
1799 QT_END_MOC_NAMESPACE