Warning, /sdk/clazy/tests/fully-qualified-moc-types/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_NonNamespacedGadget_t {
0024 QByteArrayData data[1];
0025 char stringdata0[20];
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_NonNamespacedGadget_t, stringdata0) + ofs \
0030 - idx * sizeof(QByteArrayData)) \
0031 )
0032 static const qt_meta_stringdata_NonNamespacedGadget_t qt_meta_stringdata_NonNamespacedGadget = {
0033 {
0034 QT_MOC_LITERAL(0, 0, 19) // "NonNamespacedGadget"
0035
0036 },
0037 "NonNamespacedGadget"
0038 };
0039 #undef QT_MOC_LITERAL
0040
0041 static const uint qt_meta_data_NonNamespacedGadget[] = {
0042
0043 // content:
0044 8, // revision
0045 0, // classname
0046 0, 0, // classinfo
0047 0, 0, // methods
0048 0, 0, // properties
0049 0, 0, // enums/sets
0050 0, 0, // constructors
0051 4, // flags
0052 0, // signalCount
0053
0054 0 // eod
0055 };
0056
0057 QT_INIT_METAOBJECT const QMetaObject NonNamespacedGadget::staticMetaObject = { {
0058 nullptr,
0059 qt_meta_stringdata_NonNamespacedGadget.data,
0060 qt_meta_data_NonNamespacedGadget,
0061 nullptr,
0062 nullptr,
0063 nullptr
0064 } };
0065
0066 struct qt_meta_stringdata_NS__NamespacedGadget_t {
0067 QByteArrayData data[1];
0068 char stringdata0[21];
0069 };
0070 #define QT_MOC_LITERAL(idx, ofs, len) \
0071 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
0072 qptrdiff(offsetof(qt_meta_stringdata_NS__NamespacedGadget_t, stringdata0) + ofs \
0073 - idx * sizeof(QByteArrayData)) \
0074 )
0075 static const qt_meta_stringdata_NS__NamespacedGadget_t qt_meta_stringdata_NS__NamespacedGadget = {
0076 {
0077 QT_MOC_LITERAL(0, 0, 20) // "NS::NamespacedGadget"
0078
0079 },
0080 "NS::NamespacedGadget"
0081 };
0082 #undef QT_MOC_LITERAL
0083
0084 static const uint qt_meta_data_NS__NamespacedGadget[] = {
0085
0086 // content:
0087 8, // revision
0088 0, // classname
0089 0, 0, // classinfo
0090 0, 0, // methods
0091 0, 0, // properties
0092 0, 0, // enums/sets
0093 0, 0, // constructors
0094 4, // flags
0095 0, // signalCount
0096
0097 0 // eod
0098 };
0099
0100 QT_INIT_METAOBJECT const QMetaObject NS::NamespacedGadget::staticMetaObject = { {
0101 nullptr,
0102 qt_meta_stringdata_NS__NamespacedGadget.data,
0103 qt_meta_data_NS__NamespacedGadget,
0104 nullptr,
0105 nullptr,
0106 nullptr
0107 } };
0108
0109 struct qt_meta_stringdata_NS__MyObject_t {
0110 QByteArrayData data[44];
0111 char stringdata0[436];
0112 };
0113 #define QT_MOC_LITERAL(idx, ofs, len) \
0114 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
0115 qptrdiff(offsetof(qt_meta_stringdata_NS__MyObject_t, stringdata0) + ofs \
0116 - idx * sizeof(QByteArrayData)) \
0117 )
0118 static const qt_meta_stringdata_NS__MyObject_t qt_meta_stringdata_NS__MyObject = {
0119 {
0120 QT_MOC_LITERAL(0, 0, 12), // "NS::MyObject"
0121 QT_MOC_LITERAL(1, 13, 5), // "mysig"
0122 QT_MOC_LITERAL(2, 19, 0), // ""
0123 QT_MOC_LITERAL(3, 20, 10), // "NS::MyType"
0124 QT_MOC_LITERAL(4, 31, 6), // "mysig2"
0125 QT_MOC_LITERAL(5, 38, 7), // "MyType&"
0126 QT_MOC_LITERAL(6, 46, 6), // "mysig3"
0127 QT_MOC_LITERAL(7, 53, 6), // "mysig4"
0128 QT_MOC_LITERAL(8, 60, 6), // "mysig5"
0129 QT_MOC_LITERAL(9, 67, 1), // "A"
0130 QT_MOC_LITERAL(10, 69, 6), // "mysig6"
0131 QT_MOC_LITERAL(11, 76, 6), // "mysig7"
0132 QT_MOC_LITERAL(12, 83, 8), // "const A*"
0133 QT_MOC_LITERAL(13, 92, 6), // "mysig8"
0134 QT_MOC_LITERAL(14, 99, 2), // "A*"
0135 QT_MOC_LITERAL(15, 102, 7), // "myslot1"
0136 QT_MOC_LITERAL(16, 110, 7), // "myslot2"
0137 QT_MOC_LITERAL(17, 118, 6), // "MyType"
0138 QT_MOC_LITERAL(18, 125, 7), // "myslot3"
0139 QT_MOC_LITERAL(19, 133, 7), // "myslot4"
0140 QT_MOC_LITERAL(20, 141, 7), // "myslot5"
0141 QT_MOC_LITERAL(21, 149, 7), // "myslot6"
0142 QT_MOC_LITERAL(22, 157, 7), // "myslot7"
0143 QT_MOC_LITERAL(23, 165, 7), // "myslot8"
0144 QT_MOC_LITERAL(24, 173, 12), // "myinvokable1"
0145 QT_MOC_LITERAL(25, 186, 12), // "myinvokable2"
0146 QT_MOC_LITERAL(26, 199, 12), // "myinvokable3"
0147 QT_MOC_LITERAL(27, 212, 12), // "myinvokable4"
0148 QT_MOC_LITERAL(28, 225, 12), // "myinvokable5"
0149 QT_MOC_LITERAL(29, 238, 12), // "myinvokable6"
0150 QT_MOC_LITERAL(30, 251, 12), // "myinvokable7"
0151 QT_MOC_LITERAL(31, 264, 12), // "myinvokable8"
0152 QT_MOC_LITERAL(32, 277, 12), // "myinvokable9"
0153 QT_MOC_LITERAL(33, 290, 7), // "MyType*"
0154 QT_MOC_LITERAL(34, 298, 3), // "foo"
0155 QT_MOC_LITERAL(35, 302, 4), // "foo1"
0156 QT_MOC_LITERAL(36, 307, 7), // "enumFoo"
0157 QT_MOC_LITERAL(37, 315, 7), // "EnumFoo"
0158 QT_MOC_LITERAL(38, 323, 16), // "namespacedGadget"
0159 QT_MOC_LITERAL(39, 340, 16), // "NamespacedGadget"
0160 QT_MOC_LITERAL(40, 357, 17), // "namespacedGadget2"
0161 QT_MOC_LITERAL(41, 375, 20), // "NS::NamespacedGadget"
0162 QT_MOC_LITERAL(42, 396, 19), // "nonNamespacedGadget"
0163 QT_MOC_LITERAL(43, 416, 19) // "NonNamespacedGadget"
0164
0165 },
0166 "NS::MyObject\0mysig\0\0NS::MyType\0mysig2\0"
0167 "MyType&\0mysig3\0mysig4\0mysig5\0A\0mysig6\0"
0168 "mysig7\0const A*\0mysig8\0A*\0myslot1\0"
0169 "myslot2\0MyType\0myslot3\0myslot4\0myslot5\0"
0170 "myslot6\0myslot7\0myslot8\0myinvokable1\0"
0171 "myinvokable2\0myinvokable3\0myinvokable4\0"
0172 "myinvokable5\0myinvokable6\0myinvokable7\0"
0173 "myinvokable8\0myinvokable9\0MyType*\0foo\0"
0174 "foo1\0enumFoo\0EnumFoo\0namespacedGadget\0"
0175 "NamespacedGadget\0namespacedGadget2\0"
0176 "NS::NamespacedGadget\0nonNamespacedGadget\0"
0177 "NonNamespacedGadget"
0178 };
0179 #undef QT_MOC_LITERAL
0180
0181 static const uint qt_meta_data_NS__MyObject[] = {
0182
0183 // content:
0184 8, // revision
0185 0, // classname
0186 0, 0, // classinfo
0187 25, 14, // methods
0188 6, 214, // properties
0189 0, 0, // enums/sets
0190 0, 0, // constructors
0191 0, // flags
0192 8, // signalCount
0193
0194 // signals: name, argc, parameters, tag, flags
0195 1, 1, 139, 2, 0x06 /* Public */,
0196 4, 1, 142, 2, 0x06 /* Public */,
0197 6, 1, 145, 2, 0x06 /* Public */,
0198 7, 1, 148, 2, 0x06 /* Public */,
0199 8, 1, 151, 2, 0x06 /* Public */,
0200 10, 1, 154, 2, 0x06 /* Public */,
0201 11, 1, 157, 2, 0x06 /* Public */,
0202 13, 1, 160, 2, 0x06 /* Public */,
0203
0204 // slots: name, argc, parameters, tag, flags
0205 15, 1, 163, 2, 0x0a /* Public */,
0206 16, 1, 166, 2, 0x0a /* Public */,
0207 18, 1, 169, 2, 0x0a /* Public */,
0208 19, 1, 172, 2, 0x0a /* Public */,
0209 20, 1, 175, 2, 0x0a /* Public */,
0210 21, 1, 178, 2, 0x0a /* Public */,
0211 22, 1, 181, 2, 0x0a /* Public */,
0212 23, 1, 184, 2, 0x0a /* Public */,
0213
0214 // methods: name, argc, parameters, tag, flags
0215 24, 1, 187, 2, 0x02 /* Public */,
0216 25, 1, 190, 2, 0x02 /* Public */,
0217 26, 1, 193, 2, 0x02 /* Public */,
0218 27, 1, 196, 2, 0x02 /* Public */,
0219 28, 1, 199, 2, 0x02 /* Public */,
0220 29, 1, 202, 2, 0x02 /* Public */,
0221 30, 1, 205, 2, 0x02 /* Public */,
0222 31, 1, 208, 2, 0x02 /* Public */,
0223 32, 1, 211, 2, 0x02 /* Public */,
0224
0225 // signals: parameters
0226 QMetaType::Void, 0x80000000 | 3, 2,
0227 QMetaType::Void, 0x80000000 | 5, 2,
0228 QMetaType::Void, 0x80000000 | 3, 2,
0229 QMetaType::Void, 0x80000000 | 3, 2,
0230 QMetaType::Void, 0x80000000 | 9, 2,
0231 QMetaType::Void, 0x80000000 | 9, 2,
0232 QMetaType::Void, 0x80000000 | 12, 2,
0233 QMetaType::Void, 0x80000000 | 14, 2,
0234
0235 // slots: parameters
0236 QMetaType::Void, 0x80000000 | 3, 2,
0237 QMetaType::Void, 0x80000000 | 17, 2,
0238 QMetaType::Void, 0x80000000 | 3, 2,
0239 QMetaType::Void, 0x80000000 | 3, 2,
0240 QMetaType::Void, 0x80000000 | 9, 2,
0241 QMetaType::Void, 0x80000000 | 9, 2,
0242 QMetaType::Void, 0x80000000 | 12, 2,
0243 QMetaType::Void, 0x80000000 | 14, 2,
0244
0245 // methods: parameters
0246 QMetaType::Void, 0x80000000 | 3, 2,
0247 QMetaType::Void, 0x80000000 | 17, 2,
0248 QMetaType::Void, 0x80000000 | 3, 2,
0249 QMetaType::Void, 0x80000000 | 3, 2,
0250 QMetaType::Void, 0x80000000 | 9, 2,
0251 QMetaType::Void, 0x80000000 | 9, 2,
0252 QMetaType::Void, 0x80000000 | 12, 2,
0253 QMetaType::Void, 0x80000000 | 14, 2,
0254 0x80000000 | 33, 0x80000000 | 3, 2,
0255
0256 // properties: name, type, flags
0257 34, 0x80000000 | 3, 0x00095009,
0258 35, 0x80000000 | 17, 0x00095009,
0259 36, 0x80000000 | 37, 0x00095409,
0260 38, 0x80000000 | 39, 0x00095409,
0261 40, 0x80000000 | 41, 0x00095409,
0262 42, 0x80000000 | 43, 0x00095409,
0263
0264 0 // eod
0265 };
0266
0267 void NS::MyObject::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
0268 {
0269 if (_c == QMetaObject::InvokeMetaMethod) {
0270 auto *_t = static_cast<MyObject *>(_o);
0271 (void)_t;
0272 switch (_id) {
0273 case 0: _t->mysig((*reinterpret_cast< NS::MyType(*)>(_a[1]))); break;
0274 case 1: _t->mysig2((*reinterpret_cast< MyType(*)>(_a[1]))); break;
0275 case 2: _t->mysig3((*reinterpret_cast< NS::MyType(*)>(_a[1]))); break;
0276 case 3: _t->mysig4((*reinterpret_cast< const NS::MyType(*)>(_a[1]))); break;
0277 case 4: _t->mysig5((*reinterpret_cast< A(*)>(_a[1]))); break;
0278 case 5: _t->mysig6((*reinterpret_cast< const A(*)>(_a[1]))); break;
0279 case 6: _t->mysig7((*reinterpret_cast< const A*(*)>(_a[1]))); break;
0280 case 7: _t->mysig8((*reinterpret_cast< A*(*)>(_a[1]))); break;
0281 case 8: _t->myslot1((*reinterpret_cast< NS::MyType(*)>(_a[1]))); break;
0282 case 9: _t->myslot2((*reinterpret_cast< MyType(*)>(_a[1]))); break;
0283 case 10: _t->myslot3((*reinterpret_cast< NS::MyType(*)>(_a[1]))); break;
0284 case 11: _t->myslot4((*reinterpret_cast< const NS::MyType(*)>(_a[1]))); break;
0285 case 12: _t->myslot5((*reinterpret_cast< A(*)>(_a[1]))); break;
0286 case 13: _t->myslot6((*reinterpret_cast< const A(*)>(_a[1]))); break;
0287 case 14: _t->myslot7((*reinterpret_cast< const A*(*)>(_a[1]))); break;
0288 case 15: _t->myslot8((*reinterpret_cast< A*(*)>(_a[1]))); break;
0289 case 16: _t->myinvokable1((*reinterpret_cast< NS::MyType(*)>(_a[1]))); break;
0290 case 17: _t->myinvokable2((*reinterpret_cast< MyType(*)>(_a[1]))); break;
0291 case 18: _t->myinvokable3((*reinterpret_cast< NS::MyType(*)>(_a[1]))); break;
0292 case 19: _t->myinvokable4((*reinterpret_cast< const NS::MyType(*)>(_a[1]))); break;
0293 case 20: _t->myinvokable5((*reinterpret_cast< A(*)>(_a[1]))); break;
0294 case 21: _t->myinvokable6((*reinterpret_cast< const A(*)>(_a[1]))); break;
0295 case 22: _t->myinvokable7((*reinterpret_cast< const A*(*)>(_a[1]))); break;
0296 case 23: _t->myinvokable8((*reinterpret_cast< A*(*)>(_a[1]))); break;
0297 case 24: { MyType* _r = _t->myinvokable9((*reinterpret_cast< NS::MyType(*)>(_a[1])));
0298 if (_a[0]) *reinterpret_cast< MyType**>(_a[0]) = std::move(_r); } break;
0299 default: ;
0300 }
0301 } else if (_c == QMetaObject::IndexOfMethod) {
0302 int *result = reinterpret_cast<int *>(_a[0]);
0303 {
0304 using _t = void (MyObject::*)(NS::MyType );
0305 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&MyObject::mysig)) {
0306 *result = 0;
0307 return;
0308 }
0309 }
0310 {
0311 using _t = void (MyObject::*)(MyType & );
0312 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&MyObject::mysig2)) {
0313 *result = 1;
0314 return;
0315 }
0316 }
0317 {
0318 using _t = void (MyObject::*)(NS::MyType );
0319 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&MyObject::mysig3)) {
0320 *result = 2;
0321 return;
0322 }
0323 }
0324 {
0325 using _t = void (MyObject::*)(const NS::MyType & );
0326 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&MyObject::mysig4)) {
0327 *result = 3;
0328 return;
0329 }
0330 }
0331 {
0332 using _t = void (MyObject::*)(A );
0333 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&MyObject::mysig5)) {
0334 *result = 4;
0335 return;
0336 }
0337 }
0338 {
0339 using _t = void (MyObject::*)(const A );
0340 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&MyObject::mysig6)) {
0341 *result = 5;
0342 return;
0343 }
0344 }
0345 {
0346 using _t = void (MyObject::*)(const A * );
0347 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&MyObject::mysig7)) {
0348 *result = 6;
0349 return;
0350 }
0351 }
0352 {
0353 using _t = void (MyObject::*)(A * );
0354 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&MyObject::mysig8)) {
0355 *result = 7;
0356 return;
0357 }
0358 }
0359 }
0360 #ifndef QT_NO_PROPERTIES
0361 else if (_c == QMetaObject::ReadProperty) {
0362 auto *_t = static_cast<MyObject *>(_o);
0363 (void)_t;
0364 void *_v = _a[0];
0365 switch (_id) {
0366 case 0: *reinterpret_cast< NS::MyType*>(_v) = _t->foo(); break;
0367 case 1: *reinterpret_cast< MyType*>(_v) = _t->foo(); break;
0368 case 2: *reinterpret_cast< EnumFoo*>(_v) = _t->enumFoo(); break;
0369 case 3: *reinterpret_cast< NamespacedGadget*>(_v) = _t->namespacedGadget(); break;
0370 case 4: *reinterpret_cast< NS::NamespacedGadget*>(_v) = _t->namespacedGadget2(); break;
0371 case 5: *reinterpret_cast< NonNamespacedGadget*>(_v) = _t->nonNamespacedGadget(); break;
0372 default: break;
0373 }
0374 } else if (_c == QMetaObject::WriteProperty) {
0375 } else if (_c == QMetaObject::ResetProperty) {
0376 }
0377 #endif // QT_NO_PROPERTIES
0378 }
0379
0380 QT_INIT_METAOBJECT const QMetaObject NS::MyObject::staticMetaObject = { {
0381 QMetaObject::SuperData::link<QObject::staticMetaObject>(),
0382 qt_meta_stringdata_NS__MyObject.data,
0383 qt_meta_data_NS__MyObject,
0384 qt_static_metacall,
0385 nullptr,
0386 nullptr
0387 } };
0388
0389
0390 const QMetaObject *NS::MyObject::metaObject() const
0391 {
0392 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
0393 }
0394
0395 void *NS::MyObject::qt_metacast(const char *_clname)
0396 {
0397 if (!_clname) return nullptr;
0398 if (!strcmp(_clname, qt_meta_stringdata_NS__MyObject.stringdata0))
0399 return static_cast<void*>(this);
0400 return QObject::qt_metacast(_clname);
0401 }
0402
0403 int NS::MyObject::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
0404 {
0405 _id = QObject::qt_metacall(_c, _id, _a);
0406 if (_id < 0)
0407 return _id;
0408 if (_c == QMetaObject::InvokeMetaMethod) {
0409 if (_id < 25)
0410 qt_static_metacall(this, _c, _id, _a);
0411 _id -= 25;
0412 } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
0413 if (_id < 25)
0414 *reinterpret_cast<int*>(_a[0]) = -1;
0415 _id -= 25;
0416 }
0417 #ifndef QT_NO_PROPERTIES
0418 else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
0419 || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
0420 qt_static_metacall(this, _c, _id, _a);
0421 _id -= 6;
0422 } else if (_c == QMetaObject::QueryPropertyDesignable) {
0423 _id -= 6;
0424 } else if (_c == QMetaObject::QueryPropertyScriptable) {
0425 _id -= 6;
0426 } else if (_c == QMetaObject::QueryPropertyStored) {
0427 _id -= 6;
0428 } else if (_c == QMetaObject::QueryPropertyEditable) {
0429 _id -= 6;
0430 } else if (_c == QMetaObject::QueryPropertyUser) {
0431 _id -= 6;
0432 }
0433 #endif // QT_NO_PROPERTIES
0434 return _id;
0435 }
0436
0437 // SIGNAL 0
0438 void NS::MyObject::mysig(NS::MyType _t1)
0439 {
0440 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
0441 QMetaObject::activate(this, &staticMetaObject, 0, _a);
0442 }
0443
0444 // SIGNAL 1
0445 void NS::MyObject::mysig2(MyType & _t1)
0446 {
0447 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
0448 QMetaObject::activate(this, &staticMetaObject, 1, _a);
0449 }
0450
0451 // SIGNAL 2
0452 void NS::MyObject::mysig3(NS::MyType _t1)
0453 {
0454 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
0455 QMetaObject::activate(this, &staticMetaObject, 2, _a);
0456 }
0457
0458 // SIGNAL 3
0459 void NS::MyObject::mysig4(const NS::MyType & _t1)
0460 {
0461 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
0462 QMetaObject::activate(this, &staticMetaObject, 3, _a);
0463 }
0464
0465 // SIGNAL 4
0466 void NS::MyObject::mysig5(A _t1)
0467 {
0468 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
0469 QMetaObject::activate(this, &staticMetaObject, 4, _a);
0470 }
0471
0472 // SIGNAL 5
0473 void NS::MyObject::mysig6(const A _t1)
0474 {
0475 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
0476 QMetaObject::activate(this, &staticMetaObject, 5, _a);
0477 }
0478
0479 // SIGNAL 6
0480 void NS::MyObject::mysig7(const A * _t1)
0481 {
0482 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
0483 QMetaObject::activate(this, &staticMetaObject, 6, _a);
0484 }
0485
0486 // SIGNAL 7
0487 void NS::MyObject::mysig8(A * _t1)
0488 {
0489 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
0490 QMetaObject::activate(this, &staticMetaObject, 7, _a);
0491 }
0492 struct qt_meta_stringdata_MyObj2_t {
0493 QByteArrayData data[31];
0494 char stringdata0[582];
0495 };
0496 #define QT_MOC_LITERAL(idx, ofs, len) \
0497 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
0498 qptrdiff(offsetof(qt_meta_stringdata_MyObj2_t, stringdata0) + ofs \
0499 - idx * sizeof(QByteArrayData)) \
0500 )
0501 static const qt_meta_stringdata_MyObj2_t qt_meta_stringdata_MyObj2 = {
0502 {
0503 QT_MOC_LITERAL(0, 0, 6), // "MyObj2"
0504 QT_MOC_LITERAL(1, 7, 5), // "mySig"
0505 QT_MOC_LITERAL(2, 13, 0), // ""
0506 QT_MOC_LITERAL(3, 14, 8), // "AnnonFoo"
0507 QT_MOC_LITERAL(4, 23, 15), // "unqualPairParam"
0508 QT_MOC_LITERAL(5, 39, 22), // "std::pair<bool,QualMe>"
0509 QT_MOC_LITERAL(6, 62, 15), // "unqualPairClass"
0510 QT_MOC_LITERAL(7, 78, 17), // "pair<bool,QualMe>"
0511 QT_MOC_LITERAL(8, 96, 13), // "fullyQUalPair"
0512 QT_MOC_LITERAL(9, 110, 30), // "std::pair<bool,MyObj2::QualMe>"
0513 QT_MOC_LITERAL(10, 141, 9), // "typeAlias"
0514 QT_MOC_LITERAL(11, 151, 6), // "MyList"
0515 QT_MOC_LITERAL(12, 158, 23), // "genericWithoutFullyQual"
0516 QT_MOC_LITERAL(13, 182, 13), // "QList<QualMe>"
0517 QT_MOC_LITERAL(14, 196, 16), // "genericFullyQual"
0518 QT_MOC_LITERAL(15, 213, 21), // "QList<MyObj2::QualMe>"
0519 QT_MOC_LITERAL(16, 235, 20), // "qstringListTypealias"
0520 QT_MOC_LITERAL(17, 256, 13), // "fullTypeAlias"
0521 QT_MOC_LITERAL(18, 270, 14), // "MyObj2::MyList"
0522 QT_MOC_LITERAL(19, 285, 22), // "unqualGenericDbusReply"
0523 QT_MOC_LITERAL(20, 308, 25), // "QDBusPendingReply<QualMe>"
0524 QT_MOC_LITERAL(21, 334, 13), // "boolDbusReply"
0525 QT_MOC_LITERAL(22, 348, 23), // "QDBusPendingReply<bool>"
0526 QT_MOC_LITERAL(23, 372, 13), // "voidDbusReply"
0527 QT_MOC_LITERAL(24, 386, 19), // "QDBusPendingReply<>"
0528 QT_MOC_LITERAL(25, 406, 16), // "typedefInGeneric"
0529 QT_MOC_LITERAL(26, 423, 25), // "QDBusPendingReply<MyList>"
0530 QT_MOC_LITERAL(27, 449, 13), // "nestedGeneric"
0531 QT_MOC_LITERAL(28, 463, 43), // "QDBusPendingReply<std::shared..."
0532 QT_MOC_LITERAL(29, 507, 30), // "nestedNotFullyQualifiedGeneric"
0533 QT_MOC_LITERAL(30, 538, 43) // "QDBusPendingReply<std::shared..."
0534
0535 },
0536 "MyObj2\0mySig\0\0AnnonFoo\0unqualPairParam\0"
0537 "std::pair<bool,QualMe>\0unqualPairClass\0"
0538 "pair<bool,QualMe>\0fullyQUalPair\0"
0539 "std::pair<bool,MyObj2::QualMe>\0typeAlias\0"
0540 "MyList\0genericWithoutFullyQual\0"
0541 "QList<QualMe>\0genericFullyQual\0"
0542 "QList<MyObj2::QualMe>\0qstringListTypealias\0"
0543 "fullTypeAlias\0MyObj2::MyList\0"
0544 "unqualGenericDbusReply\0QDBusPendingReply<QualMe>\0"
0545 "boolDbusReply\0QDBusPendingReply<bool>\0"
0546 "voidDbusReply\0QDBusPendingReply<>\0"
0547 "typedefInGeneric\0QDBusPendingReply<MyList>\0"
0548 "nestedGeneric\0QDBusPendingReply<std::shared_ptr<MyObj2> >\0"
0549 "nestedNotFullyQualifiedGeneric\0"
0550 "QDBusPendingReply<std::shared_ptr<MyList> >"
0551 };
0552 #undef QT_MOC_LITERAL
0553
0554 static const uint qt_meta_data_MyObj2[] = {
0555
0556 // content:
0557 8, // revision
0558 0, // classname
0559 0, 0, // classinfo
0560 15, 14, // methods
0561 0, 0, // properties
0562 0, 0, // enums/sets
0563 0, 0, // constructors
0564 0, // flags
0565 1, // signalCount
0566
0567 // signals: name, argc, parameters, tag, flags
0568 1, 1, 89, 2, 0x06 /* Public */,
0569
0570 // slots: name, argc, parameters, tag, flags
0571 4, 0, 92, 2, 0x0a /* Public */,
0572 6, 0, 93, 2, 0x0a /* Public */,
0573 8, 0, 94, 2, 0x0a /* Public */,
0574 10, 0, 95, 2, 0x0a /* Public */,
0575 12, 0, 96, 2, 0x0a /* Public */,
0576 14, 0, 97, 2, 0x0a /* Public */,
0577 16, 0, 98, 2, 0x0a /* Public */,
0578 17, 0, 99, 2, 0x0a /* Public */,
0579 19, 0, 100, 2, 0x0a /* Public */,
0580 21, 0, 101, 2, 0x0a /* Public */,
0581 23, 0, 102, 2, 0x0a /* Public */,
0582 25, 0, 103, 2, 0x0a /* Public */,
0583 27, 1, 104, 2, 0x0a /* Public */,
0584 29, 1, 107, 2, 0x0a /* Public */,
0585
0586 // signals: parameters
0587 QMetaType::Void, 0x80000000 | 3, 2,
0588
0589 // slots: parameters
0590 0x80000000 | 5,
0591 0x80000000 | 7,
0592 0x80000000 | 9,
0593 0x80000000 | 11,
0594 0x80000000 | 13,
0595 0x80000000 | 15,
0596 QMetaType::QStringList,
0597 0x80000000 | 18,
0598 0x80000000 | 20,
0599 0x80000000 | 22,
0600 0x80000000 | 24,
0601 0x80000000 | 26,
0602 QMetaType::Void, 0x80000000 | 28, 2,
0603 QMetaType::Void, 0x80000000 | 30, 2,
0604
0605 0 // eod
0606 };
0607
0608 void MyObj2::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
0609 {
0610 if (_c == QMetaObject::InvokeMetaMethod) {
0611 auto *_t = static_cast<MyObj2 *>(_o);
0612 (void)_t;
0613 switch (_id) {
0614 case 0: _t->mySig((*reinterpret_cast< AnnonFoo(*)>(_a[1]))); break;
0615 case 1: { std::pair<bool,QualMe> _r = _t->unqualPairParam();
0616 if (_a[0]) *reinterpret_cast< std::pair<bool,QualMe>*>(_a[0]) = std::move(_r); } break;
0617 case 2: { pair<bool,QualMe> _r = _t->unqualPairClass();
0618 if (_a[0]) *reinterpret_cast< pair<bool,QualMe>*>(_a[0]) = std::move(_r); } break;
0619 case 3: { std::pair<bool,MyObj2::QualMe> _r = _t->fullyQUalPair();
0620 if (_a[0]) *reinterpret_cast< std::pair<bool,MyObj2::QualMe>*>(_a[0]) = std::move(_r); } break;
0621 case 4: { MyList _r = _t->typeAlias();
0622 if (_a[0]) *reinterpret_cast< MyList*>(_a[0]) = std::move(_r); } break;
0623 case 5: { QList<QualMe> _r = _t->genericWithoutFullyQual();
0624 if (_a[0]) *reinterpret_cast< QList<QualMe>*>(_a[0]) = std::move(_r); } break;
0625 case 6: { QList<MyObj2::QualMe> _r = _t->genericFullyQual();
0626 if (_a[0]) *reinterpret_cast< QList<MyObj2::QualMe>*>(_a[0]) = std::move(_r); } break;
0627 case 7: { QStringList _r = _t->qstringListTypealias();
0628 if (_a[0]) *reinterpret_cast< QStringList*>(_a[0]) = std::move(_r); } break;
0629 case 8: { MyObj2::MyList _r = _t->fullTypeAlias();
0630 if (_a[0]) *reinterpret_cast< MyObj2::MyList*>(_a[0]) = std::move(_r); } break;
0631 case 9: { QDBusPendingReply<QualMe> _r = _t->unqualGenericDbusReply();
0632 if (_a[0]) *reinterpret_cast< QDBusPendingReply<QualMe>*>(_a[0]) = std::move(_r); } break;
0633 case 10: { QDBusPendingReply<bool> _r = _t->boolDbusReply();
0634 if (_a[0]) *reinterpret_cast< QDBusPendingReply<bool>*>(_a[0]) = std::move(_r); } break;
0635 case 11: { QDBusPendingReply<> _r = _t->voidDbusReply();
0636 if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); } break;
0637 case 12: { QDBusPendingReply<MyList> _r = _t->typedefInGeneric();
0638 if (_a[0]) *reinterpret_cast< QDBusPendingReply<MyList>*>(_a[0]) = std::move(_r); } break;
0639 case 13: _t->nestedGeneric((*reinterpret_cast< QDBusPendingReply<std::shared_ptr<MyObj2> >(*)>(_a[1]))); break;
0640 case 14: _t->nestedNotFullyQualifiedGeneric((*reinterpret_cast< QDBusPendingReply<std::shared_ptr<MyList> >(*)>(_a[1]))); break;
0641 default: ;
0642 }
0643 } else if (_c == QMetaObject::IndexOfMethod) {
0644 int *result = reinterpret_cast<int *>(_a[0]);
0645 {
0646 using _t = void (MyObj2::*)(AnnonFoo );
0647 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&MyObj2::mySig)) {
0648 *result = 0;
0649 return;
0650 }
0651 }
0652 }
0653 }
0654
0655 QT_INIT_METAOBJECT const QMetaObject MyObj2::staticMetaObject = { {
0656 QMetaObject::SuperData::link<QObject::staticMetaObject>(),
0657 qt_meta_stringdata_MyObj2.data,
0658 qt_meta_data_MyObj2,
0659 qt_static_metacall,
0660 nullptr,
0661 nullptr
0662 } };
0663
0664
0665 const QMetaObject *MyObj2::metaObject() const
0666 {
0667 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
0668 }
0669
0670 void *MyObj2::qt_metacast(const char *_clname)
0671 {
0672 if (!_clname) return nullptr;
0673 if (!strcmp(_clname, qt_meta_stringdata_MyObj2.stringdata0))
0674 return static_cast<void*>(this);
0675 return QObject::qt_metacast(_clname);
0676 }
0677
0678 int MyObj2::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
0679 {
0680 _id = QObject::qt_metacall(_c, _id, _a);
0681 if (_id < 0)
0682 return _id;
0683 if (_c == QMetaObject::InvokeMetaMethod) {
0684 if (_id < 15)
0685 qt_static_metacall(this, _c, _id, _a);
0686 _id -= 15;
0687 } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
0688 if (_id < 15)
0689 *reinterpret_cast<int*>(_a[0]) = -1;
0690 _id -= 15;
0691 }
0692 return _id;
0693 }
0694
0695 // SIGNAL 0
0696 void MyObj2::mySig(AnnonFoo _t1)
0697 {
0698 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
0699 QMetaObject::activate(this, &staticMetaObject, 0, _a);
0700 }
0701 QT_WARNING_POP
0702 QT_END_MOC_NAMESPACE