Warning, /sdk/clazy/tests/fully-qualified-moc-types/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
0016 #include <QtCore/qxptype_traits.h>
0017 #if !defined(Q_MOC_OUTPUT_REVISION)
0018 #error "The header file 'main.cpp' doesn't include <QObject>."
0019 #elif Q_MOC_OUTPUT_REVISION != 68
0020 #error "This file was generated using the moc from 6.7.0. It"
0021 #error "cannot be used with the include files from this version of Qt."
0022 #error "(The moc has changed too much.)"
0023 #endif
0024
0025 #ifndef Q_CONSTINIT
0026 #define Q_CONSTINIT
0027 #endif
0028
0029 QT_WARNING_PUSH
0030 QT_WARNING_DISABLE_DEPRECATED
0031 QT_WARNING_DISABLE_GCC("-Wuseless-cast")
0032 namespace {
0033
0034 #ifdef QT_MOC_HAS_STRINGDATA
0035 struct qt_meta_stringdata_CLASSNonNamespacedGadgetENDCLASS_t {};
0036 constexpr auto qt_meta_stringdata_CLASSNonNamespacedGadgetENDCLASS = QtMocHelpers::stringData(
0037 "NonNamespacedGadget"
0038 );
0039 #else // !QT_MOC_HAS_STRINGDATA
0040 #error "qtmochelpers.h not found or too old."
0041 #endif // !QT_MOC_HAS_STRINGDATA
0042 } // unnamed namespace
0043
0044 Q_CONSTINIT static const uint qt_meta_data_CLASSNonNamespacedGadgetENDCLASS[] = {
0045
0046 // content:
0047 12, // revision
0048 0, // classname
0049 0, 0, // classinfo
0050 0, 0, // methods
0051 0, 0, // properties
0052 0, 0, // enums/sets
0053 0, 0, // constructors
0054 4, // flags
0055 0, // signalCount
0056
0057 0 // eod
0058 };
0059
0060 Q_CONSTINIT const QMetaObject NonNamespacedGadget::staticMetaObject = { {
0061 nullptr,
0062 qt_meta_stringdata_CLASSNonNamespacedGadgetENDCLASS.offsetsAndSizes,
0063 qt_meta_data_CLASSNonNamespacedGadgetENDCLASS,
0064 nullptr,
0065 nullptr,
0066 qt_incomplete_metaTypeArray<qt_meta_stringdata_CLASSNonNamespacedGadgetENDCLASS_t,
0067 // Q_OBJECT / Q_GADGET
0068 QtPrivate::TypeAndForceComplete<NonNamespacedGadget, std::true_type>
0069 >,
0070 nullptr
0071 } };
0072
0073 namespace {
0074
0075 #ifdef QT_MOC_HAS_STRINGDATA
0076 struct qt_meta_stringdata_CLASSNSSCOPENamespacedGadgetENDCLASS_t {};
0077 constexpr auto qt_meta_stringdata_CLASSNSSCOPENamespacedGadgetENDCLASS = QtMocHelpers::stringData(
0078 "NS::NamespacedGadget"
0079 );
0080 #else // !QT_MOC_HAS_STRINGDATA
0081 #error "qtmochelpers.h not found or too old."
0082 #endif // !QT_MOC_HAS_STRINGDATA
0083 } // unnamed namespace
0084
0085 Q_CONSTINIT static const uint qt_meta_data_CLASSNSSCOPENamespacedGadgetENDCLASS[] = {
0086
0087 // content:
0088 12, // revision
0089 0, // classname
0090 0, 0, // classinfo
0091 0, 0, // methods
0092 0, 0, // properties
0093 0, 0, // enums/sets
0094 0, 0, // constructors
0095 4, // flags
0096 0, // signalCount
0097
0098 0 // eod
0099 };
0100
0101 Q_CONSTINIT const QMetaObject NS::NamespacedGadget::staticMetaObject = { {
0102 nullptr,
0103 qt_meta_stringdata_CLASSNSSCOPENamespacedGadgetENDCLASS.offsetsAndSizes,
0104 qt_meta_data_CLASSNSSCOPENamespacedGadgetENDCLASS,
0105 nullptr,
0106 nullptr,
0107 qt_incomplete_metaTypeArray<qt_meta_stringdata_CLASSNSSCOPENamespacedGadgetENDCLASS_t,
0108 // Q_OBJECT / Q_GADGET
0109 QtPrivate::TypeAndForceComplete<NamespacedGadget, std::true_type>
0110 >,
0111 nullptr
0112 } };
0113
0114 namespace {
0115
0116 #ifdef QT_MOC_HAS_STRINGDATA
0117 struct qt_meta_stringdata_CLASSNSSCOPEMyObjectENDCLASS_t {};
0118 constexpr auto qt_meta_stringdata_CLASSNSSCOPEMyObjectENDCLASS = QtMocHelpers::stringData(
0119 "NS::MyObject",
0120 "mysig",
0121 "",
0122 "NS::MyType",
0123 "mysig2",
0124 "MyType&",
0125 "mysig3",
0126 "mysig4",
0127 "mysig5",
0128 "A",
0129 "mysig6",
0130 "mysig7",
0131 "const A*",
0132 "mysig8",
0133 "A*",
0134 "myslot1",
0135 "myslot2",
0136 "MyType",
0137 "myslot3",
0138 "myslot4",
0139 "myslot5",
0140 "myslot6",
0141 "myslot7",
0142 "myslot8",
0143 "myinvokable1",
0144 "myinvokable2",
0145 "myinvokable3",
0146 "myinvokable4",
0147 "myinvokable5",
0148 "myinvokable6",
0149 "myinvokable7",
0150 "myinvokable8",
0151 "myinvokable9",
0152 "MyType*",
0153 "foo",
0154 "foo1",
0155 "enumFoo",
0156 "EnumFoo",
0157 "namespacedGadget",
0158 "NamespacedGadget",
0159 "namespacedGadget2",
0160 "NS::NamespacedGadget",
0161 "nonNamespacedGadget",
0162 "NonNamespacedGadget"
0163 );
0164 #else // !QT_MOC_HAS_STRINGDATA
0165 #error "qtmochelpers.h not found or too old."
0166 #endif // !QT_MOC_HAS_STRINGDATA
0167 } // unnamed namespace
0168
0169 Q_CONSTINIT static const uint qt_meta_data_CLASSNSSCOPEMyObjectENDCLASS[] = {
0170
0171 // content:
0172 12, // revision
0173 0, // classname
0174 0, 0, // classinfo
0175 25, 14, // methods
0176 6, 239, // properties
0177 0, 0, // enums/sets
0178 0, 0, // constructors
0179 0, // flags
0180 8, // signalCount
0181
0182 // signals: name, argc, parameters, tag, flags, initial metatype offsets
0183 1, 1, 164, 2, 0x06, 7 /* Public */,
0184 4, 1, 167, 2, 0x06, 9 /* Public */,
0185 6, 1, 170, 2, 0x06, 11 /* Public */,
0186 7, 1, 173, 2, 0x06, 13 /* Public */,
0187 8, 1, 176, 2, 0x06, 15 /* Public */,
0188 10, 1, 179, 2, 0x06, 17 /* Public */,
0189 11, 1, 182, 2, 0x06, 19 /* Public */,
0190 13, 1, 185, 2, 0x06, 21 /* Public */,
0191
0192 // slots: name, argc, parameters, tag, flags, initial metatype offsets
0193 15, 1, 188, 2, 0x0a, 23 /* Public */,
0194 16, 1, 191, 2, 0x0a, 25 /* Public */,
0195 18, 1, 194, 2, 0x0a, 27 /* Public */,
0196 19, 1, 197, 2, 0x0a, 29 /* Public */,
0197 20, 1, 200, 2, 0x0a, 31 /* Public */,
0198 21, 1, 203, 2, 0x0a, 33 /* Public */,
0199 22, 1, 206, 2, 0x0a, 35 /* Public */,
0200 23, 1, 209, 2, 0x0a, 37 /* Public */,
0201
0202 // methods: name, argc, parameters, tag, flags, initial metatype offsets
0203 24, 1, 212, 2, 0x02, 39 /* Public */,
0204 25, 1, 215, 2, 0x02, 41 /* Public */,
0205 26, 1, 218, 2, 0x02, 43 /* Public */,
0206 27, 1, 221, 2, 0x02, 45 /* Public */,
0207 28, 1, 224, 2, 0x02, 47 /* Public */,
0208 29, 1, 227, 2, 0x02, 49 /* Public */,
0209 30, 1, 230, 2, 0x02, 51 /* Public */,
0210 31, 1, 233, 2, 0x02, 53 /* Public */,
0211 32, 1, 236, 2, 0x02, 55 /* Public */,
0212
0213 // signals: parameters
0214 QMetaType::Void, 0x80000000 | 3, 2,
0215 QMetaType::Void, 0x80000000 | 5, 2,
0216 QMetaType::Void, 0x80000000 | 3, 2,
0217 QMetaType::Void, 0x80000000 | 3, 2,
0218 QMetaType::Void, 0x80000000 | 9, 2,
0219 QMetaType::Void, 0x80000000 | 9, 2,
0220 QMetaType::Void, 0x80000000 | 12, 2,
0221 QMetaType::Void, 0x80000000 | 14, 2,
0222
0223 // slots: parameters
0224 QMetaType::Void, 0x80000000 | 3, 2,
0225 QMetaType::Void, 0x80000000 | 17, 2,
0226 QMetaType::Void, 0x80000000 | 3, 2,
0227 QMetaType::Void, 0x80000000 | 3, 2,
0228 QMetaType::Void, 0x80000000 | 9, 2,
0229 QMetaType::Void, 0x80000000 | 9, 2,
0230 QMetaType::Void, 0x80000000 | 12, 2,
0231 QMetaType::Void, 0x80000000 | 14, 2,
0232
0233 // methods: parameters
0234 QMetaType::Void, 0x80000000 | 3, 2,
0235 QMetaType::Void, 0x80000000 | 17, 2,
0236 QMetaType::Void, 0x80000000 | 3, 2,
0237 QMetaType::Void, 0x80000000 | 3, 2,
0238 QMetaType::Void, 0x80000000 | 9, 2,
0239 QMetaType::Void, 0x80000000 | 9, 2,
0240 QMetaType::Void, 0x80000000 | 12, 2,
0241 QMetaType::Void, 0x80000000 | 14, 2,
0242 0x80000000 | 33, 0x80000000 | 3, 2,
0243
0244 // properties: name, type, flags
0245 34, 0x80000000 | 3, 0x00015009, uint(-1), 0,
0246 35, 0x80000000 | 17, 0x00015009, uint(-1), 0,
0247 36, 0x80000000 | 37, 0x00015409, uint(-1), 0,
0248 38, 0x80000000 | 39, 0x00015409, uint(-1), 0,
0249 40, 0x80000000 | 41, 0x00015409, uint(-1), 0,
0250 42, 0x80000000 | 43, 0x00015409, uint(-1), 0,
0251
0252 0 // eod
0253 };
0254
0255 Q_CONSTINIT const QMetaObject NS::MyObject::staticMetaObject = { {
0256 QMetaObject::SuperData::link<QObject::staticMetaObject>(),
0257 qt_meta_stringdata_CLASSNSSCOPEMyObjectENDCLASS.offsetsAndSizes,
0258 qt_meta_data_CLASSNSSCOPEMyObjectENDCLASS,
0259 qt_static_metacall,
0260 nullptr,
0261 qt_incomplete_metaTypeArray<qt_meta_stringdata_CLASSNSSCOPEMyObjectENDCLASS_t,
0262 // property 'foo'
0263 QtPrivate::TypeAndForceComplete<NS::MyType, std::true_type>,
0264 // property 'foo1'
0265 QtPrivate::TypeAndForceComplete<MyType, std::true_type>,
0266 // property 'enumFoo'
0267 QtPrivate::TypeAndForceComplete<EnumFoo, std::true_type>,
0268 // property 'namespacedGadget'
0269 QtPrivate::TypeAndForceComplete<NamespacedGadget, std::true_type>,
0270 // property 'namespacedGadget2'
0271 QtPrivate::TypeAndForceComplete<NS::NamespacedGadget, std::true_type>,
0272 // property 'nonNamespacedGadget'
0273 QtPrivate::TypeAndForceComplete<NonNamespacedGadget, std::true_type>,
0274 // Q_OBJECT / Q_GADGET
0275 QtPrivate::TypeAndForceComplete<MyObject, std::true_type>,
0276 // method 'mysig'
0277 QtPrivate::TypeAndForceComplete<void, std::false_type>,
0278 QtPrivate::TypeAndForceComplete<NS::MyType, std::false_type>,
0279 // method 'mysig2'
0280 QtPrivate::TypeAndForceComplete<void, std::false_type>,
0281 QtPrivate::TypeAndForceComplete<MyType &, std::false_type>,
0282 // method 'mysig3'
0283 QtPrivate::TypeAndForceComplete<void, std::false_type>,
0284 QtPrivate::TypeAndForceComplete<NS::MyType, std::false_type>,
0285 // method 'mysig4'
0286 QtPrivate::TypeAndForceComplete<void, std::false_type>,
0287 QtPrivate::TypeAndForceComplete<const NS::MyType &, std::false_type>,
0288 // method 'mysig5'
0289 QtPrivate::TypeAndForceComplete<void, std::false_type>,
0290 QtPrivate::TypeAndForceComplete<A, std::false_type>,
0291 // method 'mysig6'
0292 QtPrivate::TypeAndForceComplete<void, std::false_type>,
0293 QtPrivate::TypeAndForceComplete<const A, std::false_type>,
0294 // method 'mysig7'
0295 QtPrivate::TypeAndForceComplete<void, std::false_type>,
0296 QtPrivate::TypeAndForceComplete<const A *, std::false_type>,
0297 // method 'mysig8'
0298 QtPrivate::TypeAndForceComplete<void, std::false_type>,
0299 QtPrivate::TypeAndForceComplete<A *, std::false_type>,
0300 // method 'myslot1'
0301 QtPrivate::TypeAndForceComplete<void, std::false_type>,
0302 QtPrivate::TypeAndForceComplete<NS::MyType, std::false_type>,
0303 // method 'myslot2'
0304 QtPrivate::TypeAndForceComplete<void, std::false_type>,
0305 QtPrivate::TypeAndForceComplete<MyType, std::false_type>,
0306 // method 'myslot3'
0307 QtPrivate::TypeAndForceComplete<void, std::false_type>,
0308 QtPrivate::TypeAndForceComplete<NS::MyType, std::false_type>,
0309 // method 'myslot4'
0310 QtPrivate::TypeAndForceComplete<void, std::false_type>,
0311 QtPrivate::TypeAndForceComplete<const NS::MyType &, std::false_type>,
0312 // method 'myslot5'
0313 QtPrivate::TypeAndForceComplete<void, std::false_type>,
0314 QtPrivate::TypeAndForceComplete<A, std::false_type>,
0315 // method 'myslot6'
0316 QtPrivate::TypeAndForceComplete<void, std::false_type>,
0317 QtPrivate::TypeAndForceComplete<const A, std::false_type>,
0318 // method 'myslot7'
0319 QtPrivate::TypeAndForceComplete<void, std::false_type>,
0320 QtPrivate::TypeAndForceComplete<const A *, std::false_type>,
0321 // method 'myslot8'
0322 QtPrivate::TypeAndForceComplete<void, std::false_type>,
0323 QtPrivate::TypeAndForceComplete<A *, std::false_type>,
0324 // method 'myinvokable1'
0325 QtPrivate::TypeAndForceComplete<void, std::false_type>,
0326 QtPrivate::TypeAndForceComplete<NS::MyType, std::false_type>,
0327 // method 'myinvokable2'
0328 QtPrivate::TypeAndForceComplete<void, std::false_type>,
0329 QtPrivate::TypeAndForceComplete<MyType, std::false_type>,
0330 // method 'myinvokable3'
0331 QtPrivate::TypeAndForceComplete<void, std::false_type>,
0332 QtPrivate::TypeAndForceComplete<NS::MyType, std::false_type>,
0333 // method 'myinvokable4'
0334 QtPrivate::TypeAndForceComplete<void, std::false_type>,
0335 QtPrivate::TypeAndForceComplete<const NS::MyType &, std::false_type>,
0336 // method 'myinvokable5'
0337 QtPrivate::TypeAndForceComplete<void, std::false_type>,
0338 QtPrivate::TypeAndForceComplete<A, std::false_type>,
0339 // method 'myinvokable6'
0340 QtPrivate::TypeAndForceComplete<void, std::false_type>,
0341 QtPrivate::TypeAndForceComplete<const A, std::false_type>,
0342 // method 'myinvokable7'
0343 QtPrivate::TypeAndForceComplete<void, std::false_type>,
0344 QtPrivate::TypeAndForceComplete<const A *, std::false_type>,
0345 // method 'myinvokable8'
0346 QtPrivate::TypeAndForceComplete<void, std::false_type>,
0347 QtPrivate::TypeAndForceComplete<A *, std::false_type>,
0348 // method 'myinvokable9'
0349 QtPrivate::TypeAndForceComplete<MyType *, std::false_type>,
0350 QtPrivate::TypeAndForceComplete<NS::MyType, std::false_type>
0351 >,
0352 nullptr
0353 } };
0354
0355 void NS::MyObject::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
0356 {
0357 if (_c == QMetaObject::InvokeMetaMethod) {
0358 auto *_t = static_cast<MyObject *>(_o);
0359 (void)_t;
0360 switch (_id) {
0361 case 0: _t->mysig((*reinterpret_cast< std::add_pointer_t<NS::MyType>>(_a[1]))); break;
0362 case 1: _t->mysig2((*reinterpret_cast< std::add_pointer_t<MyType&>>(_a[1]))); break;
0363 case 2: _t->mysig3((*reinterpret_cast< std::add_pointer_t<NS::MyType>>(_a[1]))); break;
0364 case 3: _t->mysig4((*reinterpret_cast< std::add_pointer_t<NS::MyType>>(_a[1]))); break;
0365 case 4: _t->mysig5((*reinterpret_cast< std::add_pointer_t<A>>(_a[1]))); break;
0366 case 5: _t->mysig6((*reinterpret_cast< std::add_pointer_t<A>>(_a[1]))); break;
0367 case 6: _t->mysig7((*reinterpret_cast< std::add_pointer_t<const A*>>(_a[1]))); break;
0368 case 7: _t->mysig8((*reinterpret_cast< std::add_pointer_t<A*>>(_a[1]))); break;
0369 case 8: _t->myslot1((*reinterpret_cast< std::add_pointer_t<NS::MyType>>(_a[1]))); break;
0370 case 9: _t->myslot2((*reinterpret_cast< std::add_pointer_t<MyType>>(_a[1]))); break;
0371 case 10: _t->myslot3((*reinterpret_cast< std::add_pointer_t<NS::MyType>>(_a[1]))); break;
0372 case 11: _t->myslot4((*reinterpret_cast< std::add_pointer_t<NS::MyType>>(_a[1]))); break;
0373 case 12: _t->myslot5((*reinterpret_cast< std::add_pointer_t<A>>(_a[1]))); break;
0374 case 13: _t->myslot6((*reinterpret_cast< std::add_pointer_t<A>>(_a[1]))); break;
0375 case 14: _t->myslot7((*reinterpret_cast< std::add_pointer_t<const A*>>(_a[1]))); break;
0376 case 15: _t->myslot8((*reinterpret_cast< std::add_pointer_t<A*>>(_a[1]))); break;
0377 case 16: _t->myinvokable1((*reinterpret_cast< std::add_pointer_t<NS::MyType>>(_a[1]))); break;
0378 case 17: _t->myinvokable2((*reinterpret_cast< std::add_pointer_t<MyType>>(_a[1]))); break;
0379 case 18: _t->myinvokable3((*reinterpret_cast< std::add_pointer_t<NS::MyType>>(_a[1]))); break;
0380 case 19: _t->myinvokable4((*reinterpret_cast< std::add_pointer_t<NS::MyType>>(_a[1]))); break;
0381 case 20: _t->myinvokable5((*reinterpret_cast< std::add_pointer_t<A>>(_a[1]))); break;
0382 case 21: _t->myinvokable6((*reinterpret_cast< std::add_pointer_t<A>>(_a[1]))); break;
0383 case 22: _t->myinvokable7((*reinterpret_cast< std::add_pointer_t<const A*>>(_a[1]))); break;
0384 case 23: _t->myinvokable8((*reinterpret_cast< std::add_pointer_t<A*>>(_a[1]))); break;
0385 case 24: { MyType* _r = _t->myinvokable9((*reinterpret_cast< std::add_pointer_t<NS::MyType>>(_a[1])));
0386 if (_a[0]) *reinterpret_cast< MyType**>(_a[0]) = std::move(_r); } break;
0387 default: ;
0388 }
0389 } else if (_c == QMetaObject::IndexOfMethod) {
0390 int *result = reinterpret_cast<int *>(_a[0]);
0391 {
0392 using _t = void (MyObject::*)(NS::MyType );
0393 if (_t _q_method = &MyObject::mysig; *reinterpret_cast<_t *>(_a[1]) == _q_method) {
0394 *result = 0;
0395 return;
0396 }
0397 }
0398 {
0399 using _t = void (MyObject::*)(MyType & );
0400 if (_t _q_method = &MyObject::mysig2; *reinterpret_cast<_t *>(_a[1]) == _q_method) {
0401 *result = 1;
0402 return;
0403 }
0404 }
0405 {
0406 using _t = void (MyObject::*)(NS::MyType );
0407 if (_t _q_method = &MyObject::mysig3; *reinterpret_cast<_t *>(_a[1]) == _q_method) {
0408 *result = 2;
0409 return;
0410 }
0411 }
0412 {
0413 using _t = void (MyObject::*)(const NS::MyType & );
0414 if (_t _q_method = &MyObject::mysig4; *reinterpret_cast<_t *>(_a[1]) == _q_method) {
0415 *result = 3;
0416 return;
0417 }
0418 }
0419 {
0420 using _t = void (MyObject::*)(A );
0421 if (_t _q_method = &MyObject::mysig5; *reinterpret_cast<_t *>(_a[1]) == _q_method) {
0422 *result = 4;
0423 return;
0424 }
0425 }
0426 {
0427 using _t = void (MyObject::*)(const A );
0428 if (_t _q_method = &MyObject::mysig6; *reinterpret_cast<_t *>(_a[1]) == _q_method) {
0429 *result = 5;
0430 return;
0431 }
0432 }
0433 {
0434 using _t = void (MyObject::*)(const A * );
0435 if (_t _q_method = &MyObject::mysig7; *reinterpret_cast<_t *>(_a[1]) == _q_method) {
0436 *result = 6;
0437 return;
0438 }
0439 }
0440 {
0441 using _t = void (MyObject::*)(A * );
0442 if (_t _q_method = &MyObject::mysig8; *reinterpret_cast<_t *>(_a[1]) == _q_method) {
0443 *result = 7;
0444 return;
0445 }
0446 }
0447 } else if (_c == QMetaObject::ReadProperty) {
0448 auto *_t = static_cast<MyObject *>(_o);
0449 (void)_t;
0450 void *_v = _a[0];
0451 switch (_id) {
0452 case 0: *reinterpret_cast< NS::MyType*>(_v) = _t->foo(); break;
0453 case 1: *reinterpret_cast< MyType*>(_v) = _t->foo(); break;
0454 case 2: *reinterpret_cast< EnumFoo*>(_v) = _t->enumFoo(); break;
0455 case 3: *reinterpret_cast< NamespacedGadget*>(_v) = _t->namespacedGadget(); break;
0456 case 4: *reinterpret_cast< NS::NamespacedGadget*>(_v) = _t->namespacedGadget2(); break;
0457 case 5: *reinterpret_cast< NonNamespacedGadget*>(_v) = _t->nonNamespacedGadget(); break;
0458 default: break;
0459 }
0460 } else if (_c == QMetaObject::WriteProperty) {
0461 } else if (_c == QMetaObject::ResetProperty) {
0462 } else if (_c == QMetaObject::BindableProperty) {
0463 }
0464 }
0465
0466 const QMetaObject *NS::MyObject::metaObject() const
0467 {
0468 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
0469 }
0470
0471 void *NS::MyObject::qt_metacast(const char *_clname)
0472 {
0473 if (!_clname) return nullptr;
0474 if (!strcmp(_clname, qt_meta_stringdata_CLASSNSSCOPEMyObjectENDCLASS.stringdata0))
0475 return static_cast<void*>(this);
0476 return QObject::qt_metacast(_clname);
0477 }
0478
0479 int NS::MyObject::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
0480 {
0481 _id = QObject::qt_metacall(_c, _id, _a);
0482 if (_id < 0)
0483 return _id;
0484 if (_c == QMetaObject::InvokeMetaMethod) {
0485 if (_id < 25)
0486 qt_static_metacall(this, _c, _id, _a);
0487 _id -= 25;
0488 } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
0489 if (_id < 25)
0490 *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
0491 _id -= 25;
0492 }else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
0493 || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
0494 || _c == QMetaObject::RegisterPropertyMetaType) {
0495 qt_static_metacall(this, _c, _id, _a);
0496 _id -= 6;
0497 }
0498 return _id;
0499 }
0500
0501 // SIGNAL 0
0502 void NS::MyObject::mysig(NS::MyType _t1)
0503 {
0504 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
0505 QMetaObject::activate(this, &staticMetaObject, 0, _a);
0506 }
0507
0508 // SIGNAL 1
0509 void NS::MyObject::mysig2(MyType & _t1)
0510 {
0511 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
0512 QMetaObject::activate(this, &staticMetaObject, 1, _a);
0513 }
0514
0515 // SIGNAL 2
0516 void NS::MyObject::mysig3(NS::MyType _t1)
0517 {
0518 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
0519 QMetaObject::activate(this, &staticMetaObject, 2, _a);
0520 }
0521
0522 // SIGNAL 3
0523 void NS::MyObject::mysig4(const NS::MyType & _t1)
0524 {
0525 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
0526 QMetaObject::activate(this, &staticMetaObject, 3, _a);
0527 }
0528
0529 // SIGNAL 4
0530 void NS::MyObject::mysig5(A _t1)
0531 {
0532 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
0533 QMetaObject::activate(this, &staticMetaObject, 4, _a);
0534 }
0535
0536 // SIGNAL 5
0537 void NS::MyObject::mysig6(const A _t1)
0538 {
0539 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
0540 QMetaObject::activate(this, &staticMetaObject, 5, _a);
0541 }
0542
0543 // SIGNAL 6
0544 void NS::MyObject::mysig7(const A * _t1)
0545 {
0546 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
0547 QMetaObject::activate(this, &staticMetaObject, 6, _a);
0548 }
0549
0550 // SIGNAL 7
0551 void NS::MyObject::mysig8(A * _t1)
0552 {
0553 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
0554 QMetaObject::activate(this, &staticMetaObject, 7, _a);
0555 }
0556 namespace {
0557
0558 #ifdef QT_MOC_HAS_STRINGDATA
0559 struct qt_meta_stringdata_CLASSMyObj2ENDCLASS_t {};
0560 constexpr auto qt_meta_stringdata_CLASSMyObj2ENDCLASS = QtMocHelpers::stringData(
0561 "MyObj2",
0562 "mySig",
0563 "",
0564 "AnnonFoo",
0565 "unqualPairParam",
0566 "std::pair<bool,QualMe>",
0567 "unqualPairClass",
0568 "pair<bool,QualMe>",
0569 "fullyQUalPair",
0570 "std::pair<bool,MyObj2::QualMe>",
0571 "typeAlias",
0572 "MyList",
0573 "genericWithoutFullyQual",
0574 "QList<QualMe>",
0575 "genericFullyQual",
0576 "QList<MyObj2::QualMe>",
0577 "qstringListTypealias",
0578 "fullTypeAlias",
0579 "MyObj2::MyList",
0580 "unqualGenericDbusReply",
0581 "QDBusPendingReply<QualMe>",
0582 "boolDbusReply",
0583 "QDBusPendingReply<bool>",
0584 "voidDbusReply",
0585 "QDBusPendingReply<>",
0586 "typedefInGeneric",
0587 "QDBusPendingReply<MyList>",
0588 "nestedGeneric",
0589 "QDBusPendingReply<std::shared_ptr<MyObj2>>",
0590 "nestedNotFullyQualifiedGeneric",
0591 "QDBusPendingReply<std::shared_ptr<MyList>>"
0592 );
0593 #else // !QT_MOC_HAS_STRINGDATA
0594 #error "qtmochelpers.h not found or too old."
0595 #endif // !QT_MOC_HAS_STRINGDATA
0596 } // unnamed namespace
0597
0598 Q_CONSTINIT static const uint qt_meta_data_CLASSMyObj2ENDCLASS[] = {
0599
0600 // content:
0601 12, // revision
0602 0, // classname
0603 0, 0, // classinfo
0604 15, 14, // methods
0605 0, 0, // properties
0606 0, 0, // enums/sets
0607 0, 0, // constructors
0608 0, // flags
0609 1, // signalCount
0610
0611 // signals: name, argc, parameters, tag, flags, initial metatype offsets
0612 1, 1, 104, 2, 0x06, 1 /* Public */,
0613
0614 // slots: name, argc, parameters, tag, flags, initial metatype offsets
0615 4, 0, 107, 2, 0x0a, 3 /* Public */,
0616 6, 0, 108, 2, 0x0a, 4 /* Public */,
0617 8, 0, 109, 2, 0x0a, 5 /* Public */,
0618 10, 0, 110, 2, 0x0a, 6 /* Public */,
0619 12, 0, 111, 2, 0x0a, 7 /* Public */,
0620 14, 0, 112, 2, 0x0a, 8 /* Public */,
0621 16, 0, 113, 2, 0x0a, 9 /* Public */,
0622 17, 0, 114, 2, 0x0a, 10 /* Public */,
0623 19, 0, 115, 2, 0x0a, 11 /* Public */,
0624 21, 0, 116, 2, 0x0a, 12 /* Public */,
0625 23, 0, 117, 2, 0x0a, 13 /* Public */,
0626 25, 0, 118, 2, 0x0a, 14 /* Public */,
0627 27, 1, 119, 2, 0x0a, 15 /* Public */,
0628 29, 1, 122, 2, 0x0a, 17 /* Public */,
0629
0630 // signals: parameters
0631 QMetaType::Void, 0x80000000 | 3, 2,
0632
0633 // slots: parameters
0634 0x80000000 | 5,
0635 0x80000000 | 7,
0636 0x80000000 | 9,
0637 0x80000000 | 11,
0638 0x80000000 | 13,
0639 0x80000000 | 15,
0640 QMetaType::QStringList,
0641 0x80000000 | 18,
0642 0x80000000 | 20,
0643 0x80000000 | 22,
0644 0x80000000 | 24,
0645 0x80000000 | 26,
0646 QMetaType::Void, 0x80000000 | 28, 2,
0647 QMetaType::Void, 0x80000000 | 30, 2,
0648
0649 0 // eod
0650 };
0651
0652 Q_CONSTINIT const QMetaObject MyObj2::staticMetaObject = { {
0653 QMetaObject::SuperData::link<QObject::staticMetaObject>(),
0654 qt_meta_stringdata_CLASSMyObj2ENDCLASS.offsetsAndSizes,
0655 qt_meta_data_CLASSMyObj2ENDCLASS,
0656 qt_static_metacall,
0657 nullptr,
0658 qt_incomplete_metaTypeArray<qt_meta_stringdata_CLASSMyObj2ENDCLASS_t,
0659 // Q_OBJECT / Q_GADGET
0660 QtPrivate::TypeAndForceComplete<MyObj2, std::true_type>,
0661 // method 'mySig'
0662 QtPrivate::TypeAndForceComplete<void, std::false_type>,
0663 QtPrivate::TypeAndForceComplete<AnnonFoo, std::false_type>,
0664 // method 'unqualPairParam'
0665 QtPrivate::TypeAndForceComplete<std::pair<bool,QualMe>, std::false_type>,
0666 // method 'unqualPairClass'
0667 QtPrivate::TypeAndForceComplete<pair<bool,QualMe>, std::false_type>,
0668 // method 'fullyQUalPair'
0669 QtPrivate::TypeAndForceComplete<std::pair<bool,MyObj2::QualMe>, std::false_type>,
0670 // method 'typeAlias'
0671 QtPrivate::TypeAndForceComplete<MyList, std::false_type>,
0672 // method 'genericWithoutFullyQual'
0673 QtPrivate::TypeAndForceComplete<QList<QualMe>, std::false_type>,
0674 // method 'genericFullyQual'
0675 QtPrivate::TypeAndForceComplete<QList<MyObj2::QualMe>, std::false_type>,
0676 // method 'qstringListTypealias'
0677 QtPrivate::TypeAndForceComplete<QStringList, std::false_type>,
0678 // method 'fullTypeAlias'
0679 QtPrivate::TypeAndForceComplete<MyObj2::MyList, std::false_type>,
0680 // method 'unqualGenericDbusReply'
0681 QtPrivate::TypeAndForceComplete<QDBusPendingReply<QualMe>, std::false_type>,
0682 // method 'boolDbusReply'
0683 QtPrivate::TypeAndForceComplete<QDBusPendingReply<bool>, std::false_type>,
0684 // method 'voidDbusReply'
0685 QtPrivate::TypeAndForceComplete<QDBusPendingReply<>, std::false_type>,
0686 // method 'typedefInGeneric'
0687 QtPrivate::TypeAndForceComplete<QDBusPendingReply<MyList>, std::false_type>,
0688 // method 'nestedGeneric'
0689 QtPrivate::TypeAndForceComplete<void, std::false_type>,
0690 QtPrivate::TypeAndForceComplete<QDBusPendingReply<std::shared_ptr<MyObj2>>, std::false_type>,
0691 // method 'nestedNotFullyQualifiedGeneric'
0692 QtPrivate::TypeAndForceComplete<void, std::false_type>,
0693 QtPrivate::TypeAndForceComplete<QDBusPendingReply<std::shared_ptr<MyList>>, std::false_type>
0694 >,
0695 nullptr
0696 } };
0697
0698 void MyObj2::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
0699 {
0700 if (_c == QMetaObject::InvokeMetaMethod) {
0701 auto *_t = static_cast<MyObj2 *>(_o);
0702 (void)_t;
0703 switch (_id) {
0704 case 0: _t->mySig((*reinterpret_cast< std::add_pointer_t<AnnonFoo>>(_a[1]))); break;
0705 case 1: { std::pair<bool,QualMe> _r = _t->unqualPairParam();
0706 if (_a[0]) *reinterpret_cast< std::pair<bool,QualMe>*>(_a[0]) = std::move(_r); } break;
0707 case 2: { pair<bool,QualMe> _r = _t->unqualPairClass();
0708 if (_a[0]) *reinterpret_cast< pair<bool,QualMe>*>(_a[0]) = std::move(_r); } break;
0709 case 3: { std::pair<bool,MyObj2::QualMe> _r = _t->fullyQUalPair();
0710 if (_a[0]) *reinterpret_cast< std::pair<bool,MyObj2::QualMe>*>(_a[0]) = std::move(_r); } break;
0711 case 4: { MyList _r = _t->typeAlias();
0712 if (_a[0]) *reinterpret_cast< MyList*>(_a[0]) = std::move(_r); } break;
0713 case 5: { QList<QualMe> _r = _t->genericWithoutFullyQual();
0714 if (_a[0]) *reinterpret_cast< QList<QualMe>*>(_a[0]) = std::move(_r); } break;
0715 case 6: { QList<MyObj2::QualMe> _r = _t->genericFullyQual();
0716 if (_a[0]) *reinterpret_cast< QList<MyObj2::QualMe>*>(_a[0]) = std::move(_r); } break;
0717 case 7: { QStringList _r = _t->qstringListTypealias();
0718 if (_a[0]) *reinterpret_cast< QStringList*>(_a[0]) = std::move(_r); } break;
0719 case 8: { MyObj2::MyList _r = _t->fullTypeAlias();
0720 if (_a[0]) *reinterpret_cast< MyObj2::MyList*>(_a[0]) = std::move(_r); } break;
0721 case 9: { QDBusPendingReply<QualMe> _r = _t->unqualGenericDbusReply();
0722 if (_a[0]) *reinterpret_cast< QDBusPendingReply<QualMe>*>(_a[0]) = std::move(_r); } break;
0723 case 10: { QDBusPendingReply<bool> _r = _t->boolDbusReply();
0724 if (_a[0]) *reinterpret_cast< QDBusPendingReply<bool>*>(_a[0]) = std::move(_r); } break;
0725 case 11: { QDBusPendingReply<> _r = _t->voidDbusReply();
0726 if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); } break;
0727 case 12: { QDBusPendingReply<MyList> _r = _t->typedefInGeneric();
0728 if (_a[0]) *reinterpret_cast< QDBusPendingReply<MyList>*>(_a[0]) = std::move(_r); } break;
0729 case 13: _t->nestedGeneric((*reinterpret_cast< std::add_pointer_t<QDBusPendingReply<std::shared_ptr<MyObj2>>>>(_a[1]))); break;
0730 case 14: _t->nestedNotFullyQualifiedGeneric((*reinterpret_cast< std::add_pointer_t<QDBusPendingReply<std::shared_ptr<MyList>>>>(_a[1]))); break;
0731 default: ;
0732 }
0733 } else if (_c == QMetaObject::IndexOfMethod) {
0734 int *result = reinterpret_cast<int *>(_a[0]);
0735 {
0736 using _t = void (MyObj2::*)(AnnonFoo );
0737 if (_t _q_method = &MyObj2::mySig; *reinterpret_cast<_t *>(_a[1]) == _q_method) {
0738 *result = 0;
0739 return;
0740 }
0741 }
0742 }
0743 }
0744
0745 const QMetaObject *MyObj2::metaObject() const
0746 {
0747 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
0748 }
0749
0750 void *MyObj2::qt_metacast(const char *_clname)
0751 {
0752 if (!_clname) return nullptr;
0753 if (!strcmp(_clname, qt_meta_stringdata_CLASSMyObj2ENDCLASS.stringdata0))
0754 return static_cast<void*>(this);
0755 return QObject::qt_metacast(_clname);
0756 }
0757
0758 int MyObj2::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
0759 {
0760 _id = QObject::qt_metacall(_c, _id, _a);
0761 if (_id < 0)
0762 return _id;
0763 if (_c == QMetaObject::InvokeMetaMethod) {
0764 if (_id < 15)
0765 qt_static_metacall(this, _c, _id, _a);
0766 _id -= 15;
0767 } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
0768 if (_id < 15)
0769 *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
0770 _id -= 15;
0771 }
0772 return _id;
0773 }
0774
0775 // SIGNAL 0
0776 void MyObj2::mySig(AnnonFoo _t1)
0777 {
0778 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
0779 QMetaObject::activate(this, &staticMetaObject, 0, _a);
0780 }
0781 QT_WARNING_POP