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