1/****************************************************************************
2** Meta object code from reading C++ file 'qvalidator.h'
3**
4** Created by: The Qt Meta Object Compiler version 68 (Qt 6.0.0)
5**
6** WARNING! All changes made in this file will be lost!
7*****************************************************************************/
8
9#include <memory>
10#include "util/qvalidator.h"
11#include <QtCore/qbytearray.h>
12#include <QtCore/qmetatype.h>
13#if !defined(Q_MOC_OUTPUT_REVISION)
14#error "The header file 'qvalidator.h' doesn't include <QObject>."
15#elif Q_MOC_OUTPUT_REVISION != 68
16#error "This file was generated using the moc from 6.0.0. It"
17#error "cannot be used with the include files from this version of Qt."
18#error "(The moc has changed too much.)"
19#endif
20
21QT_BEGIN_MOC_NAMESPACE
22QT_WARNING_PUSH
23QT_WARNING_DISABLE_DEPRECATED
24struct qt_meta_stringdata_QValidator_t {
25 const uint offsetsAndSize[14];
26 char stringdata0[58];
27};
28#define QT_MOC_LITERAL(ofs, len) \
29 uint(offsetof(qt_meta_stringdata_QValidator_t, stringdata0) + ofs), len
30static const qt_meta_stringdata_QValidator_t qt_meta_stringdata_QValidator = {
31 {
32QT_MOC_LITERAL(0, 10), // "QValidator"
33QT_MOC_LITERAL(11, 7), // "changed"
34QT_MOC_LITERAL(19, 0), // ""
35QT_MOC_LITERAL(20, 5), // "State"
36QT_MOC_LITERAL(26, 7), // "Invalid"
37QT_MOC_LITERAL(34, 12), // "Intermediate"
38QT_MOC_LITERAL(47, 10) // "Acceptable"
39
40 },
41 "QValidator\0changed\0\0State\0Invalid\0"
42 "Intermediate\0Acceptable"
43};
44#undef QT_MOC_LITERAL
45
46static const uint qt_meta_data_QValidator[] = {
47
48 // content:
49 9, // revision
50 0, // classname
51 0, 0, // classinfo
52 1, 14, // methods
53 0, 0, // properties
54 1, 21, // enums/sets
55 0, 0, // constructors
56 0, // flags
57 1, // signalCount
58
59 // signals: name, argc, parameters, tag, flags, initial metatype offsets
60 1, 0, 20, 2, 0x06, 0 /* Public */,
61
62 // signals: parameters
63 QMetaType::Void,
64
65 // enums: name, alias, flags, count, data
66 3, 3, 0x0, 3, 26,
67
68 // enum data: key, value
69 4, uint(QValidator::Invalid),
70 5, uint(QValidator::Intermediate),
71 6, uint(QValidator::Acceptable),
72
73 0 // eod
74};
75
76void QValidator::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
77{
78 if (_c == QMetaObject::InvokeMetaMethod) {
79 Q_ASSERT(staticMetaObject.cast(_o));
80 auto *_t = static_cast<QValidator *>(_o);
81 Q_UNUSED(_t)
82 switch (_id) {
83 case 0: _t->changed(); break;
84 default: ;
85 }
86 } else if (_c == QMetaObject::IndexOfMethod) {
87 int *result = reinterpret_cast<int *>(_a[0]);
88 {
89 using _t = void (QValidator::*)();
90 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QValidator::changed)) {
91 *result = 0;
92 return;
93 }
94 }
95 }
96 Q_UNUSED(_a);
97}
98
99const QMetaObject QValidator::staticMetaObject = { {
100 QMetaObject::SuperData::link<QObject::staticMetaObject>(),
101 qt_meta_stringdata_QValidator.offsetsAndSize,
102 qt_meta_data_QValidator,
103 qt_static_metacall,
104 nullptr,
105qt_incomplete_metaTypeArray<qt_meta_stringdata_QValidator_t
106, QtPrivate::TypeAndForceComplete<void, std::false_type>
107
108
109
110>,
111 nullptr
112} };
113
114
115const QMetaObject *QValidator::metaObject() const
116{
117 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
118}
119
120void *QValidator::qt_metacast(const char *_clname)
121{
122 if (!_clname) return nullptr;
123 if (!strcmp(_clname, qt_meta_stringdata_QValidator.stringdata0))
124 return static_cast<void*>(this);
125 return QObject::qt_metacast(_clname);
126}
127
128int QValidator::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
129{
130 _id = QObject::qt_metacall(_c, _id, _a);
131 if (_id < 0)
132 return _id;
133 if (_c == QMetaObject::InvokeMetaMethod) {
134 if (_id < 1)
135 qt_static_metacall(this, _c, _id, _a);
136 _id -= 1;
137 } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
138 if (_id < 1)
139 *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
140 _id -= 1;
141 }
142 return _id;
143}
144
145// SIGNAL 0
146void QValidator::changed()
147{
148 QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
149}
150struct qt_meta_stringdata_QIntValidator_t {
151 const uint offsetsAndSize[12];
152 char stringdata0[51];
153};
154#define QT_MOC_LITERAL(ofs, len) \
155 uint(offsetof(qt_meta_stringdata_QIntValidator_t, stringdata0) + ofs), len
156static const qt_meta_stringdata_QIntValidator_t qt_meta_stringdata_QIntValidator = {
157 {
158QT_MOC_LITERAL(0, 13), // "QIntValidator"
159QT_MOC_LITERAL(14, 13), // "bottomChanged"
160QT_MOC_LITERAL(28, 0), // ""
161QT_MOC_LITERAL(29, 6), // "bottom"
162QT_MOC_LITERAL(36, 10), // "topChanged"
163QT_MOC_LITERAL(47, 3) // "top"
164
165 },
166 "QIntValidator\0bottomChanged\0\0bottom\0"
167 "topChanged\0top"
168};
169#undef QT_MOC_LITERAL
170
171static const uint qt_meta_data_QIntValidator[] = {
172
173 // content:
174 9, // revision
175 0, // classname
176 0, 0, // classinfo
177 2, 14, // methods
178 2, 32, // properties
179 0, 0, // enums/sets
180 0, 0, // constructors
181 0, // flags
182 2, // signalCount
183
184 // signals: name, argc, parameters, tag, flags, initial metatype offsets
185 1, 1, 26, 2, 0x06, 2 /* Public */,
186 4, 1, 29, 2, 0x06, 4 /* Public */,
187
188 // signals: parameters
189 QMetaType::Void, QMetaType::Int, 3,
190 QMetaType::Void, QMetaType::Int, 5,
191
192 // properties: name, type, flags
193 3, QMetaType::Int, 0x00015103, uint(0), 0,
194 5, QMetaType::Int, 0x00015103, uint(1), 0,
195
196 0 // eod
197};
198
199void QIntValidator::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
200{
201 if (_c == QMetaObject::InvokeMetaMethod) {
202 Q_ASSERT(staticMetaObject.cast(_o));
203 auto *_t = static_cast<QIntValidator *>(_o);
204 Q_UNUSED(_t)
205 switch (_id) {
206 case 0: _t->bottomChanged((*reinterpret_cast< int(*)>(_a[1]))); break;
207 case 1: _t->topChanged((*reinterpret_cast< int(*)>(_a[1]))); break;
208 default: ;
209 }
210 } else if (_c == QMetaObject::IndexOfMethod) {
211 int *result = reinterpret_cast<int *>(_a[0]);
212 {
213 using _t = void (QIntValidator::*)(int );
214 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QIntValidator::bottomChanged)) {
215 *result = 0;
216 return;
217 }
218 }
219 {
220 using _t = void (QIntValidator::*)(int );
221 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QIntValidator::topChanged)) {
222 *result = 1;
223 return;
224 }
225 }
226 }
227#ifndef QT_NO_PROPERTIES
228 else if (_c == QMetaObject::ReadProperty) {
229 Q_ASSERT(staticMetaObject.cast(_o));
230 auto *_t = static_cast<QIntValidator *>(_o);
231 Q_UNUSED(_t)
232 void *_v = _a[0];
233 switch (_id) {
234 case 0: *reinterpret_cast< int*>(_v) = _t->bottom(); break;
235 case 1: *reinterpret_cast< int*>(_v) = _t->top(); break;
236 default: break;
237 }
238 } else if (_c == QMetaObject::WriteProperty) {
239 Q_ASSERT(staticMetaObject.cast(_o));
240 auto *_t = static_cast<QIntValidator *>(_o);
241 Q_UNUSED(_t)
242 void *_v = _a[0];
243 switch (_id) {
244 case 0: _t->setBottom(*reinterpret_cast< int*>(_v)); break;
245 case 1: _t->setTop(*reinterpret_cast< int*>(_v)); break;
246 default: break;
247 }
248 } else if (_c == QMetaObject::ResetProperty) {
249 } else if (_c == QMetaObject::BindableProperty) {
250 }
251#endif // QT_NO_PROPERTIES
252}
253
254const QMetaObject QIntValidator::staticMetaObject = { {
255 QMetaObject::SuperData::link<QValidator::staticMetaObject>(),
256 qt_meta_stringdata_QIntValidator.offsetsAndSize,
257 qt_meta_data_QIntValidator,
258 qt_static_metacall,
259 nullptr,
260qt_incomplete_metaTypeArray<qt_meta_stringdata_QIntValidator_t
261, QtPrivate::TypeAndForceComplete<int, std::true_type>, QtPrivate::TypeAndForceComplete<int, std::true_type>, QtPrivate::TypeAndForceComplete<void, std::false_type>, QtPrivate::TypeAndForceComplete<int, std::false_type>, QtPrivate::TypeAndForceComplete<void, std::false_type>, QtPrivate::TypeAndForceComplete<int, std::false_type>
262
263
264
265>,
266 nullptr
267} };
268
269
270const QMetaObject *QIntValidator::metaObject() const
271{
272 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
273}
274
275void *QIntValidator::qt_metacast(const char *_clname)
276{
277 if (!_clname) return nullptr;
278 if (!strcmp(_clname, qt_meta_stringdata_QIntValidator.stringdata0))
279 return static_cast<void*>(this);
280 return QValidator::qt_metacast(_clname);
281}
282
283int QIntValidator::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
284{
285 _id = QValidator::qt_metacall(_c, _id, _a);
286 if (_id < 0)
287 return _id;
288 if (_c == QMetaObject::InvokeMetaMethod) {
289 if (_id < 2)
290 qt_static_metacall(this, _c, _id, _a);
291 _id -= 2;
292 } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
293 if (_id < 2)
294 *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
295 _id -= 2;
296 }
297#ifndef QT_NO_PROPERTIES
298 else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
299 || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
300 || _c == QMetaObject::RegisterPropertyMetaType) {
301 qt_static_metacall(this, _c, _id, _a);
302 _id -= 2;
303 }
304#endif // QT_NO_PROPERTIES
305 return _id;
306}
307
308// SIGNAL 0
309void QIntValidator::bottomChanged(int _t1)
310{
311 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
312 QMetaObject::activate(this, &staticMetaObject, 0, _a);
313}
314
315// SIGNAL 1
316void QIntValidator::topChanged(int _t1)
317{
318 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
319 QMetaObject::activate(this, &staticMetaObject, 1, _a);
320}
321struct qt_meta_stringdata_QDoubleValidator_t {
322 const uint offsetsAndSize[28];
323 char stringdata0[176];
324};
325#define QT_MOC_LITERAL(ofs, len) \
326 uint(offsetof(qt_meta_stringdata_QDoubleValidator_t, stringdata0) + ofs), len
327static const qt_meta_stringdata_QDoubleValidator_t qt_meta_stringdata_QDoubleValidator = {
328 {
329QT_MOC_LITERAL(0, 16), // "QDoubleValidator"
330QT_MOC_LITERAL(17, 13), // "bottomChanged"
331QT_MOC_LITERAL(31, 0), // ""
332QT_MOC_LITERAL(32, 6), // "bottom"
333QT_MOC_LITERAL(39, 10), // "topChanged"
334QT_MOC_LITERAL(50, 3), // "top"
335QT_MOC_LITERAL(54, 15), // "decimalsChanged"
336QT_MOC_LITERAL(70, 8), // "decimals"
337QT_MOC_LITERAL(79, 15), // "notationChanged"
338QT_MOC_LITERAL(95, 26), // "QDoubleValidator::Notation"
339QT_MOC_LITERAL(122, 8), // "notation"
340QT_MOC_LITERAL(131, 8), // "Notation"
341QT_MOC_LITERAL(140, 16), // "StandardNotation"
342QT_MOC_LITERAL(157, 18) // "ScientificNotation"
343
344 },
345 "QDoubleValidator\0bottomChanged\0\0bottom\0"
346 "topChanged\0top\0decimalsChanged\0decimals\0"
347 "notationChanged\0QDoubleValidator::Notation\0"
348 "notation\0Notation\0StandardNotation\0"
349 "ScientificNotation"
350};
351#undef QT_MOC_LITERAL
352
353static const uint qt_meta_data_QDoubleValidator[] = {
354
355 // content:
356 9, // revision
357 0, // classname
358 0, 0, // classinfo
359 4, 14, // methods
360 4, 50, // properties
361 1, 70, // enums/sets
362 0, 0, // constructors
363 0, // flags
364 4, // signalCount
365
366 // signals: name, argc, parameters, tag, flags, initial metatype offsets
367 1, 1, 38, 2, 0x06, 4 /* Public */,
368 4, 1, 41, 2, 0x06, 6 /* Public */,
369 6, 1, 44, 2, 0x06, 8 /* Public */,
370 8, 1, 47, 2, 0x06, 10 /* Public */,
371
372 // signals: parameters
373 QMetaType::Void, QMetaType::Double, 3,
374 QMetaType::Void, QMetaType::Double, 5,
375 QMetaType::Void, QMetaType::Int, 7,
376 QMetaType::Void, 0x80000000 | 9, 10,
377
378 // properties: name, type, flags
379 3, QMetaType::Double, 0x00015103, uint(0), 0,
380 5, QMetaType::Double, 0x00015103, uint(1), 0,
381 7, QMetaType::Int, 0x00015103, uint(2), 0,
382 10, 0x80000000 | 11, 0x0001510b, uint(3), 0,
383
384 // enums: name, alias, flags, count, data
385 11, 11, 0x0, 2, 75,
386
387 // enum data: key, value
388 12, uint(QDoubleValidator::StandardNotation),
389 13, uint(QDoubleValidator::ScientificNotation),
390
391 0 // eod
392};
393
394void QDoubleValidator::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
395{
396 if (_c == QMetaObject::InvokeMetaMethod) {
397 Q_ASSERT(staticMetaObject.cast(_o));
398 auto *_t = static_cast<QDoubleValidator *>(_o);
399 Q_UNUSED(_t)
400 switch (_id) {
401 case 0: _t->bottomChanged((*reinterpret_cast< double(*)>(_a[1]))); break;
402 case 1: _t->topChanged((*reinterpret_cast< double(*)>(_a[1]))); break;
403 case 2: _t->decimalsChanged((*reinterpret_cast< int(*)>(_a[1]))); break;
404 case 3: _t->notationChanged((*reinterpret_cast< QDoubleValidator::Notation(*)>(_a[1]))); break;
405 default: ;
406 }
407 } else if (_c == QMetaObject::IndexOfMethod) {
408 int *result = reinterpret_cast<int *>(_a[0]);
409 {
410 using _t = void (QDoubleValidator::*)(double );
411 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QDoubleValidator::bottomChanged)) {
412 *result = 0;
413 return;
414 }
415 }
416 {
417 using _t = void (QDoubleValidator::*)(double );
418 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QDoubleValidator::topChanged)) {
419 *result = 1;
420 return;
421 }
422 }
423 {
424 using _t = void (QDoubleValidator::*)(int );
425 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QDoubleValidator::decimalsChanged)) {
426 *result = 2;
427 return;
428 }
429 }
430 {
431 using _t = void (QDoubleValidator::*)(QDoubleValidator::Notation );
432 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QDoubleValidator::notationChanged)) {
433 *result = 3;
434 return;
435 }
436 }
437 }
438#ifndef QT_NO_PROPERTIES
439 else if (_c == QMetaObject::ReadProperty) {
440 Q_ASSERT(staticMetaObject.cast(_o));
441 auto *_t = static_cast<QDoubleValidator *>(_o);
442 Q_UNUSED(_t)
443 void *_v = _a[0];
444 switch (_id) {
445 case 0: *reinterpret_cast< double*>(_v) = _t->bottom(); break;
446 case 1: *reinterpret_cast< double*>(_v) = _t->top(); break;
447 case 2: *reinterpret_cast< int*>(_v) = _t->decimals(); break;
448 case 3: *reinterpret_cast< Notation*>(_v) = _t->notation(); break;
449 default: break;
450 }
451 } else if (_c == QMetaObject::WriteProperty) {
452 Q_ASSERT(staticMetaObject.cast(_o));
453 auto *_t = static_cast<QDoubleValidator *>(_o);
454 Q_UNUSED(_t)
455 void *_v = _a[0];
456 switch (_id) {
457 case 0: _t->setBottom(*reinterpret_cast< double*>(_v)); break;
458 case 1: _t->setTop(*reinterpret_cast< double*>(_v)); break;
459 case 2: _t->setDecimals(*reinterpret_cast< int*>(_v)); break;
460 case 3: _t->setNotation(*reinterpret_cast< Notation*>(_v)); break;
461 default: break;
462 }
463 } else if (_c == QMetaObject::ResetProperty) {
464 } else if (_c == QMetaObject::BindableProperty) {
465 }
466#endif // QT_NO_PROPERTIES
467}
468
469const QMetaObject QDoubleValidator::staticMetaObject = { {
470 QMetaObject::SuperData::link<QValidator::staticMetaObject>(),
471 qt_meta_stringdata_QDoubleValidator.offsetsAndSize,
472 qt_meta_data_QDoubleValidator,
473 qt_static_metacall,
474 nullptr,
475qt_incomplete_metaTypeArray<qt_meta_stringdata_QDoubleValidator_t
476, QtPrivate::TypeAndForceComplete<double, std::true_type>, QtPrivate::TypeAndForceComplete<double, std::true_type>, QtPrivate::TypeAndForceComplete<int, std::true_type>, QtPrivate::TypeAndForceComplete<Notation, std::true_type>, QtPrivate::TypeAndForceComplete<void, std::false_type>, QtPrivate::TypeAndForceComplete<double, std::false_type>, QtPrivate::TypeAndForceComplete<void, std::false_type>, QtPrivate::TypeAndForceComplete<double, std::false_type>, QtPrivate::TypeAndForceComplete<void, std::false_type>, QtPrivate::TypeAndForceComplete<int, std::false_type>, QtPrivate::TypeAndForceComplete<void, std::false_type>, QtPrivate::TypeAndForceComplete<QDoubleValidator::Notation, std::false_type>
477
478
479
480>,
481 nullptr
482} };
483
484
485const QMetaObject *QDoubleValidator::metaObject() const
486{
487 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
488}
489
490void *QDoubleValidator::qt_metacast(const char *_clname)
491{
492 if (!_clname) return nullptr;
493 if (!strcmp(_clname, qt_meta_stringdata_QDoubleValidator.stringdata0))
494 return static_cast<void*>(this);
495 return QValidator::qt_metacast(_clname);
496}
497
498int QDoubleValidator::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
499{
500 _id = QValidator::qt_metacall(_c, _id, _a);
501 if (_id < 0)
502 return _id;
503 if (_c == QMetaObject::InvokeMetaMethod) {
504 if (_id < 4)
505 qt_static_metacall(this, _c, _id, _a);
506 _id -= 4;
507 } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
508 if (_id < 4)
509 *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
510 _id -= 4;
511 }
512#ifndef QT_NO_PROPERTIES
513 else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
514 || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
515 || _c == QMetaObject::RegisterPropertyMetaType) {
516 qt_static_metacall(this, _c, _id, _a);
517 _id -= 4;
518 }
519#endif // QT_NO_PROPERTIES
520 return _id;
521}
522
523// SIGNAL 0
524void QDoubleValidator::bottomChanged(double _t1)
525{
526 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
527 QMetaObject::activate(this, &staticMetaObject, 0, _a);
528}
529
530// SIGNAL 1
531void QDoubleValidator::topChanged(double _t1)
532{
533 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
534 QMetaObject::activate(this, &staticMetaObject, 1, _a);
535}
536
537// SIGNAL 2
538void QDoubleValidator::decimalsChanged(int _t1)
539{
540 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
541 QMetaObject::activate(this, &staticMetaObject, 2, _a);
542}
543
544// SIGNAL 3
545void QDoubleValidator::notationChanged(QDoubleValidator::Notation _t1)
546{
547 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
548 QMetaObject::activate(this, &staticMetaObject, 3, _a);
549}
550struct qt_meta_stringdata_QRegularExpressionValidator_t {
551 const uint offsetsAndSize[12];
552 char stringdata0[96];
553};
554#define QT_MOC_LITERAL(ofs, len) \
555 uint(offsetof(qt_meta_stringdata_QRegularExpressionValidator_t, stringdata0) + ofs), len
556static const qt_meta_stringdata_QRegularExpressionValidator_t qt_meta_stringdata_QRegularExpressionValidator = {
557 {
558QT_MOC_LITERAL(0, 27), // "QRegularExpressionValidator"
559QT_MOC_LITERAL(28, 24), // "regularExpressionChanged"
560QT_MOC_LITERAL(53, 0), // ""
561QT_MOC_LITERAL(54, 2), // "re"
562QT_MOC_LITERAL(57, 20), // "setRegularExpression"
563QT_MOC_LITERAL(78, 17) // "regularExpression"
564
565 },
566 "QRegularExpressionValidator\0"
567 "regularExpressionChanged\0\0re\0"
568 "setRegularExpression\0regularExpression"
569};
570#undef QT_MOC_LITERAL
571
572static const uint qt_meta_data_QRegularExpressionValidator[] = {
573
574 // content:
575 9, // revision
576 0, // classname
577 0, 0, // classinfo
578 2, 14, // methods
579 1, 32, // properties
580 0, 0, // enums/sets
581 0, 0, // constructors
582 0, // flags
583 1, // signalCount
584
585 // signals: name, argc, parameters, tag, flags, initial metatype offsets
586 1, 1, 26, 2, 0x06, 1 /* Public */,
587
588 // slots: name, argc, parameters, tag, flags, initial metatype offsets
589 4, 1, 29, 2, 0x0a, 3 /* Public */,
590
591 // signals: parameters
592 QMetaType::Void, QMetaType::QRegularExpression, 3,
593
594 // slots: parameters
595 QMetaType::Void, QMetaType::QRegularExpression, 3,
596
597 // properties: name, type, flags
598 5, QMetaType::QRegularExpression, 0x00015103, uint(0), 0,
599
600 0 // eod
601};
602
603void QRegularExpressionValidator::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
604{
605 if (_c == QMetaObject::InvokeMetaMethod) {
606 Q_ASSERT(staticMetaObject.cast(_o));
607 auto *_t = static_cast<QRegularExpressionValidator *>(_o);
608 Q_UNUSED(_t)
609 switch (_id) {
610 case 0: _t->regularExpressionChanged((*reinterpret_cast< const QRegularExpression(*)>(_a[1]))); break;
611 case 1: _t->setRegularExpression((*reinterpret_cast< const QRegularExpression(*)>(_a[1]))); break;
612 default: ;
613 }
614 } else if (_c == QMetaObject::IndexOfMethod) {
615 int *result = reinterpret_cast<int *>(_a[0]);
616 {
617 using _t = void (QRegularExpressionValidator::*)(const QRegularExpression & );
618 if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QRegularExpressionValidator::regularExpressionChanged)) {
619 *result = 0;
620 return;
621 }
622 }
623 }
624#ifndef QT_NO_PROPERTIES
625 else if (_c == QMetaObject::ReadProperty) {
626 Q_ASSERT(staticMetaObject.cast(_o));
627 auto *_t = static_cast<QRegularExpressionValidator *>(_o);
628 Q_UNUSED(_t)
629 void *_v = _a[0];
630 switch (_id) {
631 case 0: *reinterpret_cast< QRegularExpression*>(_v) = _t->regularExpression(); break;
632 default: break;
633 }
634 } else if (_c == QMetaObject::WriteProperty) {
635 Q_ASSERT(staticMetaObject.cast(_o));
636 auto *_t = static_cast<QRegularExpressionValidator *>(_o);
637 Q_UNUSED(_t)
638 void *_v = _a[0];
639 switch (_id) {
640 case 0: _t->setRegularExpression(*reinterpret_cast< QRegularExpression*>(_v)); break;
641 default: break;
642 }
643 } else if (_c == QMetaObject::ResetProperty) {
644 } else if (_c == QMetaObject::BindableProperty) {
645 }
646#endif // QT_NO_PROPERTIES
647}
648
649const QMetaObject QRegularExpressionValidator::staticMetaObject = { {
650 QMetaObject::SuperData::link<QValidator::staticMetaObject>(),
651 qt_meta_stringdata_QRegularExpressionValidator.offsetsAndSize,
652 qt_meta_data_QRegularExpressionValidator,
653 qt_static_metacall,
654 nullptr,
655qt_incomplete_metaTypeArray<qt_meta_stringdata_QRegularExpressionValidator_t
656, QtPrivate::TypeAndForceComplete<QRegularExpression, std::true_type>, QtPrivate::TypeAndForceComplete<void, std::false_type>, QtPrivate::TypeAndForceComplete<const QRegularExpression &, std::false_type>
657, QtPrivate::TypeAndForceComplete<void, std::false_type>, QtPrivate::TypeAndForceComplete<const QRegularExpression &, std::false_type>
658
659
660>,
661 nullptr
662} };
663
664
665const QMetaObject *QRegularExpressionValidator::metaObject() const
666{
667 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
668}
669
670void *QRegularExpressionValidator::qt_metacast(const char *_clname)
671{
672 if (!_clname) return nullptr;
673 if (!strcmp(_clname, qt_meta_stringdata_QRegularExpressionValidator.stringdata0))
674 return static_cast<void*>(this);
675 return QValidator::qt_metacast(_clname);
676}
677
678int QRegularExpressionValidator::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
679{
680 _id = QValidator::qt_metacall(_c, _id, _a);
681 if (_id < 0)
682 return _id;
683 if (_c == QMetaObject::InvokeMetaMethod) {
684 if (_id < 2)
685 qt_static_metacall(this, _c, _id, _a);
686 _id -= 2;
687 } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
688 if (_id < 2)
689 *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
690 _id -= 2;
691 }
692#ifndef QT_NO_PROPERTIES
693 else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
694 || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
695 || _c == QMetaObject::RegisterPropertyMetaType) {
696 qt_static_metacall(this, _c, _id, _a);
697 _id -= 1;
698 }
699#endif // QT_NO_PROPERTIES
700 return _id;
701}
702
703// SIGNAL 0
704void QRegularExpressionValidator::regularExpressionChanged(const QRegularExpression & _t1)
705{
706 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
707 QMetaObject::activate(this, &staticMetaObject, 0, _a);
708}
709QT_WARNING_POP
710QT_END_MOC_NAMESPACE
711