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