kernel/qmetatype.cpp

Q_GLOBAL_STATIC(QVector<QCustomTypeInfo>, customTypes)

executed: }

Execution Count:4165

4165

419 QByteArray typeName; -

420 int alias; -

421 }; -

422 -

423 namespace -

424 { -

425 union CheckThatItIsPod -

426 { // This should break if QMetaTypeInterface is not a POD type -

427 QMetaTypeInterface iface; -

428 }; -

429 } -

430 -

431 Q_DECLARE_TYPEINFO(QCustomTypeInfo, Q_MOVABLE_TYPE); -

432

never executed: delete x;

executed: return thisGlobalStatic.pointer.load();

Execution Count:569435

partially evaluated: !thisGlobalStatic.pointer.testAndSetOrdered(0, x)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:65

evaluated: !thisGlobalStatic.pointer.load()

TRUE	FALSE
yes Evaluation Count:66	yes Evaluation Count:569388

evaluated: !thisGlobalStatic.destroyed

TRUE	FALSE
yes Evaluation Count:65	yes Evaluation Count:1

0-569435

433

Q_GLOBAL_STATIC(QReadWriteLock, customTypesLock)

never executed: delete x;

executed: return thisGlobalStatic.pointer.load();

Execution Count:551942

partially evaluated: !thisGlobalStatic.pointer.testAndSetOrdered(0, x)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:65

evaluated: !thisGlobalStatic.pointer.load()

TRUE	FALSE
yes Evaluation Count:66	yes Evaluation Count:551860

evaluated: !thisGlobalStatic.destroyed

TRUE	FALSE
yes Evaluation Count:65	yes Evaluation Count:1

0-551942

434 -

435 #ifndef QT_NO_DATASTREAM -

436 /*! -

437 \internal -

438 */ -

439 void QMetaType::registerStreamOperators(const char *typeName, SaveOperator saveOp, -

440 LoadOperator loadOp) -

441 { -

442

registerStreamOperators(type(typeName), saveOp, loadOp);

executed (the execution status of this line is deduced): registerStreamOperators(type(typeName), saveOp, loadOp);

443

return; //builtin types should not be registered;

executed: }

Execution Count:5

444 -

445 /*! -

446 \internal -

447 */ -

448 void QMetaType::registerStreamOperators(int idx, SaveOperator saveOp, -

449 LoadOperator loadOp) -

450 { -

451

if (idx < User)

evaluated: idx < User

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:6

2-6

452

executed: return;

Execution Count:2

453

QVector<QCustomTypeInfo> *ct = customTypes();

executed (the execution status of this line is deduced): QVector<QCustomTypeInfo> *ct = customTypes();

454

partially evaluated: !ct

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:6

0-6

455

QWriteLocker locker(customTypesLock());

never executed: return;

456

executed (the execution status of this line is deduced): QWriteLocker locker(customTypesLock());

457

QCustomTypeInfo &inf = (*ct)[idx - User];

executed (the execution status of this line is deduced): QCustomTypeInfo &inf = (*ct)[idx - User];

458

inf.saveOp = saveOp;

executed (the execution status of this line is deduced): inf.saveOp = saveOp;

459

inf.loadOp = loadOp;

executed (the execution status of this line is deduced): inf.loadOp = loadOp;

460

const uint type = typeId;

executed: }

Execution Count:6

461 #endif // QT_NO_DATASTREAM -

462 -

463 /*! -

464 Returns the type name associated with the given \a typeId, or 0 if no -

465 matching type was found. The returned pointer must not be deleted. -

466 -

467 \sa type(), isRegistered(), Type -

468 */ -

469 const char *QMetaType::typeName(int typeId) -

470 { -

471

executed (the execution status of this line is deduced): const uint type = typeId;

472 // In theory it can be filled during compilation time, but for some reason template code -

473 // that is able to do it causes GCC 4.6 to generate additional 3K of executable code. Probably -

474 // it is not worth of it. -

475 static const char *namesCache[QMetaType::HighestInternalId + 1]; -

476 -

477

const char *result;

executed (the execution status of this line is deduced): const char *result;

478

if (type <= QMetaType::HighestInternalId && ((result = namesCache[type])))

evaluated: type <= QMetaType::HighestInternalId

TRUE	FALSE
yes Evaluation Count:22860	yes Evaluation Count:4692

evaluated: ((result = namesCache[type]))

TRUE	FALSE
yes Evaluation Count:22216	yes Evaluation Count:644

644-22860

479

return result;

executed: return result;

Execution Count:22216

22216

480 -

481 #define QT_METATYPE_TYPEID_TYPENAME_CONVERTER(MetaTypeName, TypeId, RealName) \ -

482 case QMetaType::MetaTypeName: result = #RealName; break; -

483 -

484 switch (QMetaType::Type(type)) { -

485

QT_FOR_EACH_STATIC_TYPE(QT_METATYPE_TYPEID_TYPENAME_CONVERTER)

executed: break;

Execution Count:6

executed: break;

Execution Count:30

executed: break;

Execution Count:48

executed: break;

Execution Count:29

executed: break;

Execution Count:31

executed: break;

Execution Count:29

executed: break;

Execution Count:32

executed: break;

Execution Count:4

executed: break;

Execution Count:28

executed: break;

Execution Count:3

executed: break;

Execution Count:3

executed: break;

Execution Count:28

executed: break;

Execution Count:5

executed: break;

Execution Count:3

executed: break;

Execution Count:2

executed: break;

Execution Count:9

executed: break;

Execution Count:3

executed: break;

Execution Count:35

executed: break;

Execution Count:16

executed: break;

Execution Count:14

executed: break;

Execution Count:2

executed: break;

Execution Count:4

executed: break;

Execution Count:3

executed: break;

Execution Count:6

executed: break;

Execution Count:6

executed: break;

Execution Count:2

executed: break;

Execution Count:9

executed: break;

Execution Count:3

executed: break;

Execution Count:2

executed: break;

Execution Count:3

executed: break;

Execution Count:2

executed: break;

Execution Count:2

executed: break;

Execution Count:8

executed: break;

Execution Count:3

executed: break;

Execution Count:3

executed: break;

Execution Count:3

executed: break;

Execution Count:2

executed: break;

Execution Count:8

executed: break;

Execution Count:18

executed: break;

Execution Count:2

executed: break;

Execution Count:2

executed: break;

Execution Count:2

executed: break;

Execution Count:2

executed: break;

Execution Count:2

executed: break;

Execution Count:12

executed: break;

Execution Count:4

executed: break;

Execution Count:5

executed: break;

Execution Count:2

executed: break;

Execution Count:5

executed: break;

Execution Count:4

executed: break;

Execution Count:4

executed: break;

Execution Count:4

executed: break;

Execution Count:4

executed: break;

Execution Count:3

executed: break;

Execution Count:5

executed: break;

Execution Count:4

executed: break;

Execution Count:4

executed: break;

Execution Count:4

executed: break;

Execution Count:4

executed: break;

Execution Count:4

executed: break;

Execution Count:4

executed: break;

Execution Count:4

executed: break;

Execution Count:4

executed: break;

Execution Count:4

executed: break;

Execution Count:4

executed: break;

Execution Count:5

executed: break;

Execution Count:5

executed: break;

Execution Count:5

executed: break;

Execution Count:5

executed: break;

Execution Count:5

executed: break;

Execution Count:3

executed: break;

Execution Count:3

2-48

486 -

487 default: { -

488

if (Q_UNLIKELY(type < QMetaType::User)) {

evaluated: __builtin_expect(!!(type < QMetaType::User), false)

TRUE	FALSE
yes Evaluation Count:966	yes Evaluation Count:3790

966-3790

489

return 0; // It can happen when someone cast int to QVariant::Type, we should not crash...

executed: return 0;

Execution Count:966

966

490 } else { -

491

const QVector<QCustomTypeInfo> * const ct = customTypes();

executed (the execution status of this line is deduced): const QVector<QCustomTypeInfo> * const ct = customTypes();

492

return ct && uint(ct->count()) > type - QMetaType::User && !ct->at(type - QMetaType::User).typeName.isEmpty()

executed (the execution status of this line is deduced): QReadLocker locker(customTypesLock());

493

executed:

return ct && uint(ct->count()) > type - QMetaType::User && !ct->at(type - QMetaType::User).typeName.isEmpty() ? ct->at(type - QMetaType::User).typeName.constData() : 0;

Execution Count:3790

3790

494

? ct->at(type - QMetaType::User).typeName.constData()

executed:

return ct && uint(ct->count()) > type - QMetaType::User && !ct->at(type - QMetaType::User).typeName.isEmpty() ? ct->at(type - QMetaType::User).typeName.constData() : 0;

Execution Count:3790

3790

495

: 0;

executed:

return ct && uint(ct->count()) > type - QMetaType::User && !ct->at(type - QMetaType::User).typeName.isEmpty() ? ct->at(type - QMetaType::User).typeName.constData() : 0;

Execution Count:3790

3790

496 } -

497 } -

498 } -

499 #undef QT_METATYPE_TYPEID_TYPENAME_CONVERTER -

500 -

501

Q_ASSERT(type <= QMetaType::HighestInternalId);

executed (the execution status of this line is deduced): qt_noop();

502

namesCache[type] = result;

executed (the execution status of this line is deduced): namesCache[type] = result;

503

return result;

executed: return result;

Execution Count:580

580

504 } -

505 -

506 /*! -

507 \internal -

508 Similar to QMetaType::type(), but only looks in the static set of types. -

509 */ -

510 static inline int qMetaTypeStaticType(const char *typeName, int length) -

511 { -

512

int i = 0;

executed (the execution status of this line is deduced): int i = 0;

513

while (types[i].typeName && ((length != types[i].typeNameLength)

evaluated: types[i].typeName

TRUE	FALSE
yes Evaluation Count:48341949	yes Evaluation Count:328547

evaluated: (length != types[i].typeNameLength)

TRUE	FALSE
yes Evaluation Count:45734700	yes Evaluation Count:2610175

328547-48341949

514

|| strcmp(typeName, types[i].typeName))) {

evaluated: strcmp(typeName, types[i].typeName)

TRUE	FALSE
yes Evaluation Count:1549675	yes Evaluation Count:1060542

1060542-1549675

515

++i;

executed (the execution status of this line is deduced): ++i;

516

const QVector<QCustomTypeInfo> * const ct = customTypes();

executed: }

Execution Count:47279290

47279290

517

return types[i].type;

executed: return types[i].type;

Execution Count:1389069

1389069

518 } -

519 -

520 /*! -

521 \internal -

522 Similar to QMetaType::type(), but only looks in the custom set of -

523 types, and doesn't lock the mutex. -

524 */ -

525 static int qMetaTypeCustomType_unlocked(const char *typeName, int length) -

526 { -

527

executed (the execution status of this line is deduced): const QVector<QCustomTypeInfo> * const ct = customTypes();

528

return QMetaType::UnknownType;

partially evaluated: !ct

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:328811

0-328811

529

never executed: return QMetaType::UnknownType;

530 -

531

for (int v = 0; v < ct->count(); ++v) {

evaluated: v < ct->count()

TRUE	FALSE
yes Evaluation Count:12332377	yes Evaluation Count:116358

116358-12332377

532

const QCustomTypeInfo &customInfo = ct->at(v);

executed (the execution status of this line is deduced): const QCustomTypeInfo &customInfo = ct->at(v);

533

if ((length == customInfo.typeName.size())

evaluated: (length == customInfo.typeName.size())

TRUE	FALSE
yes Evaluation Count:7005978	yes Evaluation Count:5435231

5435231-7005978

534

&& !strcmp(typeName, customInfo.typeName.constData())) {

evaluated: !strcmp(typeName, customInfo.typeName.constData())

TRUE	FALSE
yes Evaluation Count:212433	yes Evaluation Count:6795590

212433-6795590

535

if (customInfo.alias >= 0)

evaluated: customInfo.alias >= 0

TRUE	FALSE
yes Evaluation Count:57	yes Evaluation Count:212378

57-212378

536

return customInfo.alias;

executed: return customInfo.alias;

Execution Count:57

537

return v + QMetaType::User;

executed: return v + QMetaType::User;

Execution Count:212378

212378

538 } -

539

return QMetaType::UnknownType;

executed: }

Execution Count:12120432

12120432

540

executed: return QMetaType::UnknownType;

Execution Count:116358

116358

541 } -

542 -

543 /*! -

544 \internal -

545 -

546 This function is needed until existing code outside of qtbase -

547 has been changed to call the new version of registerType(). -

548 */ -

549 int QMetaType::registerType(const char *typeName, Deleter deleter, -

550 Creator creator) -

551 { -

552

return registerType(typeName, deleter, creator,

never executed:

return registerType(typeName, deleter, creator, QtMetaTypePrivate::QMetaTypeFunctionHelper<void>::Destruct, QtMetaTypePrivate::QMetaTypeFunctionHelper<void>::Construct, 0, TypeFlags(), 0);

553

QtMetaTypePrivate::QMetaTypeFunctionHelper<void>::Destruct,

never executed:

return registerType(typeName, deleter, creator, QtMetaTypePrivate::QMetaTypeFunctionHelper<void>::Destruct, QtMetaTypePrivate::QMetaTypeFunctionHelper<void>::Construct, 0, TypeFlags(), 0);

554

QtMetaTypePrivate::QMetaTypeFunctionHelper<void>::Construct, 0, TypeFlags(), 0);

never executed:

return registerType(typeName, deleter, creator, QtMetaTypePrivate::QMetaTypeFunctionHelper<void>::Destruct, QtMetaTypePrivate::QMetaTypeFunctionHelper<void>::Construct, 0, TypeFlags(), 0);

555 } -

556 -

557 /*! -

558 \internal -

559 \since 5.0 -

560 -

561 Registers a user type for marshalling, with \a typeName, a \a -

562 deleter, a \a creator, a \a destructor, a \a constructor, and -

563 a \a size. Returns the type's handle, or -1 if the type could -

564 not be registered. -

565 */ -

566 int QMetaType::registerType(const char *typeName, Deleter deleter, -

567 Creator creator, -

568 Destructor destructor, -

569 Constructor constructor, -

570 int size, TypeFlags flags, const QMetaObject *metaObject) -

571 { -

572 #ifdef QT_NO_QOBJECT -

573 NS(QByteArray) normalizedTypeName = typeName; -

574 #else -

575

NS(QByteArray) normalizedTypeName = QMetaObject::normalizedType(typeName);

executed (the execution status of this line is deduced): ::QByteArray normalizedTypeName = QMetaObject::normalizedType(typeName);

576 #endif -

577 -

578

return registerNormalizedType(normalizedTypeName, deleter, creator, destructor, constructor, size, flags, metaObject);

executed: return registerNormalizedType(normalizedTypeName, deleter, creator, destructor, constructor, size, flags, metaObject);

Execution Count:4

579 } -

580 -

581 -

582 /*! -

583 \internal -

584 \since 5.0 -

585 -

586 Registers a user type for marshalling, with \a normalizedTypeName, a \a -

587 deleter, a \a creator, a \a destructor, a \a constructor, and -

588 a \a size. Returns the type's handle, or -1 if the type could -

589 not be registered. Note that normalizedTypeName is not checked for -

590 conformance with Qt's normalized format, so it must already -

591 conform. -

592 */ -

593 int QMetaType::registerNormalizedType(const NS(QByteArray) &normalizedTypeName, Deleter deleter, -

594 Creator creator, -

595 Destructor destructor, -

596 Constructor constructor, -

597 int size, TypeFlags flags, const QMetaObject *metaObject) -

598 { -

599

QVector<QCustomTypeInfo> *ct = customTypes();

executed (the execution status of this line is deduced): QVector<QCustomTypeInfo> *ct = customTypes();

600

if (!ct || normalizedTypeName.isEmpty() || !deleter || !creator || !destructor || !constructor)

partially evaluated: !ct

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:16253

partially evaluated: normalizedTypeName.isEmpty()

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:16259

partially evaluated: !deleter

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:16258

partially evaluated: !creator

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:16259

partially evaluated: !destructor

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:16260

partially evaluated: !constructor

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:16263

0-16263

601

return -1;

never executed: return -1;

602 -

603

int idx = qMetaTypeStaticType(normalizedTypeName.constData(),

executed (the execution status of this line is deduced): int idx = qMetaTypeStaticType(normalizedTypeName.constData(),

604

executed (the execution status of this line is deduced): normalizedTypeName.size());

605 -

606

int previousSize = 0;

executed (the execution status of this line is deduced): int previousSize = 0;

607

int previousFlags = 0;

executed (the execution status of this line is deduced): int previousFlags = 0;

608

QWriteLocker locker(customTypesLock());

partially evaluated: idx == UnknownType

TRUE	FALSE
yes Evaluation Count:16077	no Evaluation Count:0

0-16077

609

executed (the execution status of this line is deduced): QWriteLocker locker(customTypesLock());

610

idx = qMetaTypeCustomType_unlocked(normalizedTypeName.constData(),

executed (the execution status of this line is deduced): idx = qMetaTypeCustomType_unlocked(normalizedTypeName.constData(),

611

executed (the execution status of this line is deduced): normalizedTypeName.size());

612

inf.typeName = normalizedTypeName;

evaluated: idx == UnknownType

TRUE	FALSE
yes Evaluation Count:4153	yes Evaluation Count:12127

4153-12127

613

QCustomTypeInfo inf;

executed (the execution status of this line is deduced): QCustomTypeInfo inf;

614

executed (the execution status of this line is deduced): inf.typeName = normalizedTypeName;

615

inf.creator = creator;

executed (the execution status of this line is deduced): inf.creator = creator;

616

inf.deleter = deleter;

executed (the execution status of this line is deduced): inf.deleter = deleter;

617 #ifndef QT_NO_DATASTREAM -

618

inf.loadOp = 0;

executed (the execution status of this line is deduced): inf.loadOp = 0;

619

inf.saveOp = 0;

executed (the execution status of this line is deduced): inf.saveOp = 0;

620 #endif -

621

inf.alias = -1;

executed (the execution status of this line is deduced): inf.alias = -1;

622

inf.constructor = constructor;

executed (the execution status of this line is deduced): inf.constructor = constructor;

623

inf.destructor = destructor;

executed (the execution status of this line is deduced): inf.destructor = destructor;

624

inf.size = size;

executed (the execution status of this line is deduced): inf.size = size;

625

inf.flags = flags;

executed (the execution status of this line is deduced): inf.flags = flags;

626

inf.metaObject = metaObject;

executed (the execution status of this line is deduced): inf.metaObject = metaObject;

627

idx = ct->size() + User;

executed (the execution status of this line is deduced): idx = ct->size() + User;

628

ct->append(inf);

executed (the execution status of this line is deduced): ct->append(inf);

629

return idx;

executed: return idx;

Execution Count:4153

4153

630 } -

631 -

632

if (idx >= User) {

partially evaluated: idx >= User

TRUE	FALSE
yes Evaluation Count:12127	no Evaluation Count:0

0-12127

633

previousSize = ct->at(idx - User).size;

executed (the execution status of this line is deduced): previousSize = ct->at(idx - User).size;

634

previousFlags = ct->at(idx - User).flags;

executed (the execution status of this line is deduced): previousFlags = ct->at(idx - User).flags;

635

executed: }

Execution Count:12127

12127

636

previousSize = QMetaType::sizeOf(idx);

executed: }

Execution Count:12127

12127

637 -

638

if (idx < User) {

partially evaluated: idx < User

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:12127

0-12127

639

never executed (the execution status of this line is deduced): previousSize = QMetaType::sizeOf(idx);

640

previousFlags = QMetaType::typeFlags(idx);

never executed (the execution status of this line is deduced): previousFlags = QMetaType::typeFlags(idx);

641

if (previousSize != size) {

never executed: }

642 -

643

partially evaluated: previousSize != size

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:12127

0-12127

644

qFatal("QMetaType::registerType: Binary compatibility break "

never executed (the execution status of this line is deduced):

 QMessageLogger("kernel/qmetatype.cpp", 644, __PRETTY_FUNCTION__).fatal("QMetaType::registerType: Binary compatibility break "

645

"-- Size mismatch for type '%s' [%i]. Previously registered "

never executed (the execution status of this line is deduced): "-- Size mismatch for type '%s' [%i]. Previously registered "

646

"size %i, now registering size %i.",

never executed (the execution status of this line is deduced): "size %i, now registering size %i.",

647

normalizedTypeName.constData(), idx, previousSize, size);

never executed (the execution status of this line is deduced): normalizedTypeName.constData(), idx, previousSize, size);

648

previousFlags |= WasDeclaredAsMetaType;

never executed: }

649 -

650 // Ignore WasDeclaredAsMetaType inconsitency, to many users were hitting the problem -

651

executed (the execution status of this line is deduced): previousFlags |= WasDeclaredAsMetaType;

652

flags |= WasDeclaredAsMetaType;

executed (the execution status of this line is deduced): flags |= WasDeclaredAsMetaType;

653 -

654

if (previousFlags != flags) {

partially evaluated: previousFlags != flags

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:12127

0-12127

655

const int maskForTypeInfo = NeedsConstruction | NeedsDestruction | MovableType;

never executed (the execution status of this line is deduced): const int maskForTypeInfo = NeedsConstruction | NeedsDestruction | MovableType;

656

const char *msg = "QMetaType::registerType: Binary compatibility break. "

never executed (the execution status of this line is deduced): const char *msg = "QMetaType::registerType: Binary compatibility break. "

657

"\nType flags for type '%s' [%i] don't match. Previously "

never executed (the execution status of this line is deduced): "\nType flags for type '%s' [%i] don't match. Previously "

658

"registered TypeFlags(0x%x), now registering TypeFlags(0x%x). "

never executed (the execution status of this line is deduced): "registered TypeFlags(0x%x), now registering TypeFlags(0x%x). "

659

"This is an ODR break, which means that your application depends on a C++ undefined behavior."

never executed (the execution status of this line is deduced): "This is an ODR break, which means that your application depends on a C++ undefined behavior."

660

"\nHint: %s";

never executed (the execution status of this line is deduced): "\nHint: %s";

661

QT_PREPEND_NAMESPACE(QByteArray) hint;

never executed (the execution status of this line is deduced): ::QByteArray hint;

662

if ((previousFlags & maskForTypeInfo) != (flags & maskForTypeInfo)) {

never evaluated: (previousFlags & maskForTypeInfo) != (flags & maskForTypeInfo)

663

hint += "\nIt seems that the type was registered at least twice in a different translation units, "

never executed (the execution status of this line is deduced): hint += "\nIt seems that the type was registered at least twice in a different translation units, "

664

"but Q_DECLARE_TYPEINFO is not visible from all the translations unit or different flags were used."

never executed (the execution status of this line is deduced): "but Q_DECLARE_TYPEINFO is not visible from all the translations unit or different flags were used."

665

"Remember that Q_DECLARE_TYPEINFO should be declared before QMetaType registration, "

never executed (the execution status of this line is deduced): "Remember that Q_DECLARE_TYPEINFO should be declared before QMetaType registration, "

666

"preferably it should be placed just after the type declaration and before Q_DECLARE_METATYPE";

never executed (the execution status of this line is deduced): "preferably it should be placed just after the type declaration and before Q_DECLARE_METATYPE";

667

qFatal(msg, normalizedTypeName.constData(), idx, previousFlags, int(flags), hint.constData());

never executed: }

668

never executed (the execution status of this line is deduced):

 QMessageLogger("kernel/qmetatype.cpp", 668, __PRETTY_FUNCTION__).fatal(msg, normalizedTypeName.constData(), idx, previousFlags, int(flags), hint.constData());

669

NS(QByteArray) normalizedTypeName = QMetaObject::normalizedType(typeName);

never executed: }

670 -

671

return idx;

executed: return idx;

Execution Count:12127

12127

672 } -

673 -

674 /*! -

675 \internal -

676 \since 4.7 -

677 -

678 Registers a user type for marshalling, as an alias of another type (typedef) -

679 */ -

680 int QMetaType::registerTypedef(const char* typeName, int aliasId) -

681 { -

682 #ifdef QT_NO_QOBJECT -

683 NS(QByteArray) normalizedTypeName = typeName; -

684 #else -

685

never executed (the execution status of this line is deduced): ::QByteArray normalizedTypeName = QMetaObject::normalizedType(typeName);

686 #endif -

687 -

688

return registerNormalizedTypedef(normalizedTypeName, aliasId);

never executed: return registerNormalizedTypedef(normalizedTypeName, aliasId);

689 } -

690 -

691 /*! -

692 \internal -

693 \since 5.0 -

694 -

695 Registers a user type for marshalling, as an alias of another type (typedef). -

696 Note that normalizedTypeName is not checked for conformance with Qt's normalized format, -

697 so it must already conform. -

698 */ -

699 int QMetaType::registerNormalizedTypedef(const NS(QByteArray) &normalizedTypeName, int aliasId) -

700 { -

701

QVector<QCustomTypeInfo> *ct = customTypes();

executed (the execution status of this line is deduced): QVector<QCustomTypeInfo> *ct = customTypes();

702

if (!ct || normalizedTypeName.isEmpty())

partially evaluated: !ct

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:688

partially evaluated: normalizedTypeName.isEmpty()

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:688

0-688

703

return -1;

never executed: return -1;

704 -

705

int idx = qMetaTypeStaticType(normalizedTypeName.constData(),

executed (the execution status of this line is deduced): int idx = qMetaTypeStaticType(normalizedTypeName.constData(),

706

executed (the execution status of this line is deduced): normalizedTypeName.size());

707 -

708

QWriteLocker locker(customTypesLock());

evaluated: idx == UnknownType

TRUE	FALSE
yes Evaluation Count:681	yes Evaluation Count:7

7-681

709

executed (the execution status of this line is deduced): QWriteLocker locker(customTypesLock());

710

idx = qMetaTypeCustomType_unlocked(normalizedTypeName.constData(),

executed (the execution status of this line is deduced): idx = qMetaTypeCustomType_unlocked(normalizedTypeName.constData(),

711

executed (the execution status of this line is deduced): normalizedTypeName.size());

712 -

713

inf.typeName = normalizedTypeName;

evaluated: idx == UnknownType

TRUE	FALSE
yes Evaluation Count:12	yes Evaluation Count:669

12-669

714

QCustomTypeInfo inf;

executed (the execution status of this line is deduced): QCustomTypeInfo inf;

715

executed (the execution status of this line is deduced): inf.typeName = normalizedTypeName;

716

inf.alias = aliasId;

executed (the execution status of this line is deduced): inf.alias = aliasId;

717

inf.creator = 0;

executed (the execution status of this line is deduced): inf.creator = 0;

718

inf.deleter = 0;

executed (the execution status of this line is deduced): inf.deleter = 0;

719

ct->append(inf);

executed (the execution status of this line is deduced): ct->append(inf);

720

return aliasId;

executed: return aliasId;

Execution Count:12

721 } -

722

qFatal("QMetaType::registerTypedef: Binary compatibility break "

executed: }

Execution Count:669

669

723 -

724

if (idx != aliasId) {

partially evaluated: idx != aliasId

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:676

0-676

725

never executed (the execution status of this line is deduced):

 QMessageLogger("kernel/qmetatype.cpp", 725, __PRETTY_FUNCTION__).fatal("QMetaType::registerTypedef: Binary compatibility break "

726

"-- Type name '%s' previously registered as typedef of '%s' [%i], "

never executed (the execution status of this line is deduced): "-- Type name '%s' previously registered as typedef of '%s' [%i], "

727

"now registering as typedef of '%s' [%i].",

never executed (the execution status of this line is deduced): "now registering as typedef of '%s' [%i].",

728

normalizedTypeName.constData(), QMetaType::typeName(idx), idx,

never executed (the execution status of this line is deduced): normalizedTypeName.constData(), QMetaType::typeName(idx), idx,

729

QMetaType::typeName(aliasId), aliasId);

never executed (the execution status of this line is deduced): QMetaType::typeName(aliasId), aliasId);

never executed: }

executed: return idx;

Execution Count:676

676

732 } -

733 -

734 /*! -

735 Returns true if the datatype with ID \a type is registered; -

736 otherwise returns false. -

737 -

738 \sa type(), typeName(), Type -

739 */ -

740 bool QMetaType::isRegistered(int type) -

741 { -

742 // predefined type -

743

if ((type >= FirstCoreType && type <= LastCoreType)

evaluated: type >= FirstCoreType

TRUE	FALSE
yes Evaluation Count:39891	yes Evaluation Count:3

evaluated: type <= LastCoreType

TRUE	FALSE
yes Evaluation Count:24794	yes Evaluation Count:15097

3-39891

744

|| (type >= FirstGuiType && type <= LastGuiType)

evaluated: type >= FirstGuiType

TRUE	FALSE
yes Evaluation Count:15095	yes Evaluation Count:5

evaluated: type <= LastGuiType

TRUE	FALSE
yes Evaluation Count:67	yes Evaluation Count:15028

5-15095

745

|| (type >= FirstWidgetsType && type <= LastWidgetsType)) {

evaluated: type >= FirstWidgetsType

TRUE	FALSE
yes Evaluation Count:15026	yes Evaluation Count:7

evaluated: type <= LastWidgetsType

TRUE	FALSE
yes Evaluation Count:3	yes Evaluation Count:15023

3-15026

746

return true;

executed: return true;

Execution Count:24864

24864

747 } -

748 -

749

const QVector<QCustomTypeInfo> * const ct = customTypes();

executed (the execution status of this line is deduced): QReadLocker locker(customTypesLock());

750

executed (the execution status of this line is deduced): const QVector<QCustomTypeInfo> * const ct = customTypes();

751

return ((type >= User) && (ct && ct->count() > type - User) && !ct->at(type - User).typeName.isEmpty());

executed: return ((type >= User) && (ct && ct->count() > type - User) && !ct->at(type - User).typeName.isEmpty());

Execution Count:15030

15030

752 } -

753 -

754 /*! -

755 \fn int qMetaTypeTypeImpl(const char *typeName) -

756 \internal -

757 -

758 Implementation of QMetaType::type(). -

759 */ -

760 template <bool tryNormalizedType> -

761 static inline int qMetaTypeTypeImpl(const char *typeName) -

762 { -

763

int length = qstrlen(typeName);

executed (the execution status of this line is deduced): int length = qstrlen(typeName);

764

if (!length)

evaluated: !length

TRUE	FALSE
yes Evaluation Count:102	yes Evaluation Count:1372267

102-1372267

765

return QMetaType::UnknownType;

executed: return QMetaType::UnknownType;

Execution Count:102

102

766

int type = qMetaTypeStaticType(typeName, length);

executed (the execution status of this line is deduced): int type = qMetaTypeStaticType(typeName, length);

767

if (type == QMetaType::UnknownType) {

evaluated: type == QMetaType::UnknownType

TRUE	FALSE
yes Evaluation Count:311729	yes Evaluation Count:1060532

311729-1060532

768

type = qMetaTypeCustomType_unlocked(typeName, length);

executed (the execution status of this line is deduced): QReadLocker locker(customTypesLock());

769

executed (the execution status of this line is deduced): type = qMetaTypeCustomType_unlocked(typeName, length);

770 #ifndef QT_NO_QOBJECT -

771

if ((type == QMetaType::UnknownType) && tryNormalizedType) {

evaluated: (type == QMetaType::UnknownType)

TRUE	FALSE
yes Evaluation Count:112093	yes Evaluation Count:199636

evaluated: tryNormalizedType

TRUE	FALSE
yes Evaluation Count:106	yes Evaluation Count:111987

106-199636

772

const NS(QByteArray) normalizedTypeName = QMetaObject::normalizedType(typeName);

executed (the execution status of this line is deduced): const ::QByteArray normalizedTypeName = QMetaObject::normalizedType(typeName);

773

type = qMetaTypeStaticType(normalizedTypeName.constData(),

executed (the execution status of this line is deduced): type = qMetaTypeStaticType(normalizedTypeName.constData(),

774

if (type == QMetaType::UnknownType) {

executed (the execution status of this line is deduced): normalizedTypeName.size());

775

evaluated: type == QMetaType::UnknownType

TRUE	FALSE
yes Evaluation Count:104	yes Evaluation Count:2

2-104

776

type = qMetaTypeCustomType_unlocked(normalizedTypeName.constData(),

executed (the execution status of this line is deduced): type = qMetaTypeCustomType_unlocked(normalizedTypeName.constData(),

777

executed (the execution status of this line is deduced): normalizedTypeName.size());

778

executed: }

Execution Count:104

104

779

executed: }

Execution Count:106

106

780 #endif -

781

return qMetaTypeTypeImpl</*tryNormalizedType=*/true>(typeName);

executed: }

Execution Count:311724

311724

782

return type;

executed: return type;

Execution Count:1372273

1372273

783 } -

784 -

785 /*! -

786 Returns a handle to the type called \a typeName, or QMetaType::UnknownType if there is -

787 no such type. -

788 -

789 \sa isRegistered(), typeName(), Type -

790 */ -

791 int QMetaType::type(const char *typeName) -

792 { -

793

executed: return qMetaTypeTypeImpl< true>(typeName);

Execution Count:126573

126573

794 } -

795 -

796 /*! -

797 \a internal -

798 -

799 Similar to QMetaType::type(); the only difference is that this function -

800 doesn't attempt to normalize the type name (i.e., the lookup will fail -

801 for type names in non-normalized form). -

802 */ -

803 int qMetaTypeTypeInternal(const char *typeName) -

804 { -

805

return qMetaTypeTypeImpl</*tryNormalizedType=*/false>(typeName);

executed: return qMetaTypeTypeImpl< false>(typeName);

Execution Count:1245806

1245806

806 } -

807 -

808 #ifndef QT_NO_DATASTREAM -

809 /*! -

810 Writes the object pointed to by \a data with the ID \a type to -

811 the given \a stream. Returns true if the object is saved -

812 successfully; otherwise returns false. -

813 -

814 The type must have been registered with qRegisterMetaType() and -

815 qRegisterMetaTypeStreamOperators() beforehand. -

816 -

817 Normally, you should not need to call this function directly. -

818 Instead, use QVariant's \c operator<<(), which relies on save() -

819 to stream custom types. -

820 -

821 \sa load(), qRegisterMetaTypeStreamOperators() -

822 */ -

823 bool QMetaType::save(QDataStream &stream, int type, const void *data) -

824 { -

825

if (!data || !isRegistered(type))

evaluated: !data

TRUE	FALSE
yes Evaluation Count:25	yes Evaluation Count:12359

partially evaluated: !isRegistered(type)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:12359

0-12359

826

executed: return false;

Execution Count:25

827 -

828 switch(type) { -

829 case QMetaType::UnknownType: -

830 case QMetaType::Void: -

831 case QMetaType::VoidStar: -

832 case QMetaType::QObjectStar: -

833 case QMetaType::QModelIndex: -

834 case QMetaType::QJsonValue: -

835 case QMetaType::QJsonObject: -

836 case QMetaType::QJsonArray: -

837 case QMetaType::QJsonDocument: -

838

stream << qlonglong(*static_cast<const long *>(data));

executed: return false;

Execution Count:7

839 case QMetaType::Long: -

840

executed (the execution status of this line is deduced): stream << qlonglong(*static_cast<const long *>(data));

841

stream << *static_cast<const int *>(data);

executed: break;

Execution Count:5

842 case QMetaType::Int: -

843

executed (the execution status of this line is deduced): stream << *static_cast<const int *>(data);

844

stream << *static_cast<const short *>(data);

executed: break;

Execution Count:175

175

845 case QMetaType::Short: -

846

executed (the execution status of this line is deduced): stream << *static_cast<const short *>(data);

847

stream << *static_cast<const signed char *>(data);

executed: break;

Execution Count:5

848 case QMetaType::Char: -

849 // force a char to be signed -

850

executed (the execution status of this line is deduced): stream << *static_cast<const signed char *>(data);

851

stream << qulonglong(*static_cast<const ulong *>(data));

executed: break;

Execution Count:5

852 case QMetaType::ULong: -

853

executed (the execution status of this line is deduced): stream << qulonglong(*static_cast<const ulong *>(data));

854

stream << *static_cast<const uint *>(data);

executed: break;

Execution Count:5

855 case QMetaType::UInt: -

856

executed (the execution status of this line is deduced): stream << *static_cast<const uint *>(data);

857

stream << *static_cast<const qlonglong *>(data);

executed: break;

Execution Count:4

858 case QMetaType::LongLong: -

859

executed (the execution status of this line is deduced): stream << *static_cast<const qlonglong *>(data);

860

stream << *static_cast<const qulonglong *>(data);

executed: break;

Execution Count:3

861 case QMetaType::ULongLong: -

862

executed (the execution status of this line is deduced): stream << *static_cast<const qulonglong *>(data);

863

stream << *static_cast<const ushort *>(data);

executed: break;

Execution Count:3

864 case QMetaType::UShort: -

865

executed (the execution status of this line is deduced): stream << *static_cast<const ushort *>(data);

866

stream << *static_cast<const signed char *>(data);

executed: break;

Execution Count:5

867 case QMetaType::SChar: -

868

executed (the execution status of this line is deduced): stream << *static_cast<const signed char *>(data);

869

stream << *static_cast<const uchar *>(data);

executed: break;

Execution Count:1

870 case QMetaType::UChar: -

871

executed (the execution status of this line is deduced): stream << *static_cast<const uchar *>(data);

872

stream << qint8(*static_cast<const bool *>(data));

executed: break;

Execution Count:5

873 case QMetaType::Bool: -

874

executed (the execution status of this line is deduced): stream << qint8(*static_cast<const bool *>(data));

875

stream << *static_cast<const float *>(data);

executed: break;

Execution Count:3

876 case QMetaType::Float: -

877

executed (the execution status of this line is deduced): stream << *static_cast<const float *>(data);

878

stream << *static_cast<const double *>(data);

executed: break;

Execution Count:7

879 case QMetaType::Double: -

880

executed (the execution status of this line is deduced): stream << *static_cast<const double *>(data);

881

stream << *static_cast<const NS(QChar) *>(data);

executed: break;

Execution Count:6

882 case QMetaType::QChar: -

883

executed (the execution status of this line is deduced): stream << *static_cast<const ::QChar *>(data);

884

stream << *static_cast<const NS(QVariantMap)*>(data);

executed: break;

Execution Count:5

885 #ifndef QT_BOOTSTRAPPED -

886 case QMetaType::QVariantMap: -

887

executed (the execution status of this line is deduced): stream << *static_cast<const ::QVariantMap*>(data);

888

stream << *static_cast<const NS(QVariantHash)*>(data);

executed: break;

Execution Count:5

889 case QMetaType::QVariantHash: -

890

executed (the execution status of this line is deduced): stream << *static_cast<const ::QVariantHash*>(data);

891

stream << *static_cast<const NS(QVariantList)*>(data);

executed: break;

Execution Count:3

892 case QMetaType::QVariantList: -

893

executed (the execution status of this line is deduced): stream << *static_cast<const ::QVariantList*>(data);

894

stream << *static_cast<const NS(QVariant)*>(data);

executed: break;

Execution Count:19

895 case QMetaType::QVariant: -

896

executed (the execution status of this line is deduced): stream << *static_cast<const ::QVariant*>(data);

897

stream << *static_cast<const NS(QByteArray)*>(data);

executed: break;

Execution Count:3

898 #endif -

899 case QMetaType::QByteArray: -

900

executed (the execution status of this line is deduced): stream << *static_cast<const ::QByteArray*>(data);

901

stream << *static_cast<const NS(QString)*>(data);

executed: break;

Execution Count:6

902 case QMetaType::QString: -

903

executed (the execution status of this line is deduced): stream << *static_cast<const ::QString*>(data);

904

stream << *static_cast<const NS(QStringList)*>(data);

executed: break;

Execution Count:11934

11934

905 case QMetaType::QStringList: -

906

executed (the execution status of this line is deduced): stream << *static_cast<const ::QStringList*>(data);

907

stream << *static_cast<const NS(QBitArray)*>(data);

executed: break;

Execution Count:8

908 #ifndef QT_BOOTSTRAPPED -

909 case QMetaType::QBitArray: -

910

executed (the execution status of this line is deduced): stream << *static_cast<const ::QBitArray*>(data);

911

stream << *static_cast<const NS(QDate)*>(data);

executed: break;

Execution Count:5

912 #endif -

913 case QMetaType::QDate: -

914

executed (the execution status of this line is deduced): stream << *static_cast<const ::QDate*>(data);

915

stream << *static_cast<const NS(QTime)*>(data);

executed: break;

Execution Count:5

916 case QMetaType::QTime: -

917

executed (the execution status of this line is deduced): stream << *static_cast<const ::QTime*>(data);

918

stream << *static_cast<const NS(QDateTime)*>(data);

executed: break;

Execution Count:5

919 case QMetaType::QDateTime: -

920

executed (the execution status of this line is deduced): stream << *static_cast<const ::QDateTime*>(data);

921

stream << *static_cast<const NS(QUrl)*>(data);

executed: break;

Execution Count:5

922 #ifndef QT_BOOTSTRAPPED -

923 case QMetaType::QUrl: -

924

executed (the execution status of this line is deduced): stream << *static_cast<const ::QUrl*>(data);

925

stream << *static_cast<const NS(QLocale)*>(data);

executed: break;

Execution Count:3

926 #endif -

927 case QMetaType::QLocale: -

928

executed (the execution status of this line is deduced): stream << *static_cast<const ::QLocale*>(data);

929

stream << *static_cast<const NS(QRect)*>(data);

executed: break;

Execution Count:3

930 #ifndef QT_NO_GEOM_VARIANT -

931 case QMetaType::QRect: -

932

executed (the execution status of this line is deduced): stream << *static_cast<const ::QRect*>(data);

933

stream << *static_cast<const NS(QRectF)*>(data);

executed: break;

Execution Count:5

934 case QMetaType::QRectF: -

935

executed (the execution status of this line is deduced): stream << *static_cast<const ::QRectF*>(data);

936

stream << *static_cast<const NS(QSize)*>(data);

executed: break;

Execution Count:3

937 case QMetaType::QSize: -

938

executed (the execution status of this line is deduced): stream << *static_cast<const ::QSize*>(data);

939

stream << *static_cast<const NS(QSizeF)*>(data);

executed: break;

Execution Count:6

940 case QMetaType::QSizeF: -

941

executed (the execution status of this line is deduced): stream << *static_cast<const ::QSizeF*>(data);

942

stream << *static_cast<const NS(QLine)*>(data);

executed: break;

Execution Count:3

943 case QMetaType::QLine: -

944

executed (the execution status of this line is deduced): stream << *static_cast<const ::QLine*>(data);

945

stream << *static_cast<const NS(QLineF)*>(data);

executed: break;

Execution Count:3

946 case QMetaType::QLineF: -

947

executed (the execution status of this line is deduced): stream << *static_cast<const ::QLineF*>(data);

948

stream << *static_cast<const NS(QPoint)*>(data);

executed: break;

Execution Count:3

949 case QMetaType::QPoint: -

950

executed (the execution status of this line is deduced): stream << *static_cast<const ::QPoint*>(data);

951

stream << *static_cast<const NS(QPointF)*>(data);

executed: break;

Execution Count:5

952 case QMetaType::QPointF: -

953

executed (the execution status of this line is deduced): stream << *static_cast<const ::QPointF*>(data);

954

stream << *static_cast<const NS(QRegExp)*>(data);

executed: break;

Execution Count:3

955 #endif -

956 #ifndef QT_NO_REGEXP -

957 case QMetaType::QRegExp: -

958

executed (the execution status of this line is deduced): stream << *static_cast<const ::QRegExp*>(data);

959

stream << *static_cast<const NS(QRegularExpression)*>(data);

executed: break;

Execution Count:47

960 #endif -

961 #ifndef QT_BOOTSTRAPPED -

962 #ifndef QT_NO_REGEXP -

963 case QMetaType::QRegularExpression: -

964

executed (the execution status of this line is deduced): stream << *static_cast<const ::QRegularExpression*>(data);

965

stream << *static_cast<const NS(QEasingCurve)*>(data);

executed: break;

Execution Count:4

966 #endif // QT_NO_REGEXP -

967 case QMetaType::QEasingCurve: -

968

executed (the execution status of this line is deduced): stream << *static_cast<const ::QEasingCurve*>(data);

969

executed: break;

Execution Count:1

970 #endif // QT_BOOTSTRAPPED -

971 case QMetaType::QFont: -

972 case QMetaType::QPixmap: -

973 case QMetaType::QBrush: -

974 case QMetaType::QColor: -

975 case QMetaType::QPalette: -

976 case QMetaType::QImage: -

977 case QMetaType::QPolygon: -

978 case QMetaType::QPolygonF: -

979 case QMetaType::QRegion: -

980 case QMetaType::QBitmap: -

981 case QMetaType::QCursor: -

982 case QMetaType::QKeySequence: -

983 case QMetaType::QPen: -

984 case QMetaType::QTextLength: -

985 case QMetaType::QTextFormat: -

986 case QMetaType::QMatrix: -

987 case QMetaType::QTransform: -

988 case QMetaType::QMatrix4x4: -

989 case QMetaType::QVector2D: -

990 case QMetaType::QVector3D: -

991 case QMetaType::QVector4D: -

992 case QMetaType::QQuaternion: -

993 case QMetaType::QIcon: -

994

if (!qMetaTypeGuiHelper)

partially evaluated: !qMetaTypeGuiHelper

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:20

0-20

995

qMetaTypeGuiHelper[type - FirstGuiType].saveOp(stream, data);

never executed: return false;

996

executed (the execution status of this line is deduced): qMetaTypeGuiHelper[type - FirstGuiType].saveOp(stream, data);

997

if (!qMetaTypeWidgetsHelper)

executed: break;

Execution Count:20

998 case QMetaType::QSizePolicy: -

999

partially evaluated: !qMetaTypeWidgetsHelper

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

0-1

1000

qMetaTypeWidgetsHelper[type - FirstWidgetsType].saveOp(stream, data);

never executed: return false;

1001

executed (the execution status of this line is deduced): qMetaTypeWidgetsHelper[type - FirstWidgetsType].saveOp(stream, data);

1002

stream << *static_cast<const NS(QUuid)*>(data);

executed: break;

Execution Count:1

1003 case QMetaType::QUuid: -

1004

executed (the execution status of this line is deduced): stream << *static_cast<const ::QUuid*>(data);

1005

const QVector<QCustomTypeInfo> * const ct = customTypes();

executed: break;

Execution Count:2

1006 default: { -

1007

executed (the execution status of this line is deduced): const QVector<QCustomTypeInfo> * const ct = customTypes();

1008

partially evaluated: !ct

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:5

0-5

1009

never executed: return false;

1010 -

1011

SaveOperator saveOp = 0;

executed (the execution status of this line is deduced): SaveOperator saveOp = 0;

1012 { -

1013

saveOp = ct->at(type - User).saveOp;

executed (the execution status of this line is deduced): QReadLocker locker(customTypesLock());

1014

executed (the execution status of this line is deduced): saveOp = ct->at(type - User).saveOp;

1015 } -

1016 -

1017

if (!saveOp)

evaluated: !saveOp

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:4

1-4

1018

executed: return false;

Execution Count:1

1019

saveOp(stream, data);

executed (the execution status of this line is deduced): saveOp(stream, data);

1020

if (!data || !isRegistered(type))

executed: break;

Execution Count:4

1021 } -

1022 -

1023

return true;

executed: return true;

Execution Count:12351

12351

1024 } -

1025 -

1026 /*! -

1027 Reads the object of the specified \a type from the given \a -

1028 stream into \a data. Returns true if the object is loaded -

1029 successfully; otherwise returns false. -

1030 -

1031 The type must have been registered with qRegisterMetaType() and -

1032 qRegisterMetaTypeStreamOperators() beforehand. -

1033 -

1034 Normally, you should not need to call this function directly. -

1035 Instead, use QVariant's \c operator>>(), which relies on load() -

1036 to stream custom types. -

1037 -

1038 \sa save(), qRegisterMetaTypeStreamOperators() -

1039 */ -

1040 bool QMetaType::load(QDataStream &stream, int type, void *data) -

1041 { -

1042

evaluated: !data

TRUE	FALSE
yes Evaluation Count:25	yes Evaluation Count:12438

partially evaluated: !isRegistered(type)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:12438

0-12438

1043

executed: return false;

Execution Count:25

1044 -

1045 switch(type) { -

1046 case QMetaType::UnknownType: -

1047 case QMetaType::Void: -

1048 case QMetaType::VoidStar: -

1049 case QMetaType::QObjectStar: -

1050 case QMetaType::QModelIndex: -

1051 case QMetaType::QJsonValue: -

1052 case QMetaType::QJsonObject: -

1053 case QMetaType::QJsonArray: -

1054 case QMetaType::QJsonDocument: -

1055

*static_cast<long *>(data) = long(l);

executed: return false;

Execution Count:7

1056 case QMetaType::Long: { -

1057

qlonglong l;

executed (the execution status of this line is deduced): qlonglong l;

1058

stream >> l;

executed (the execution status of this line is deduced): stream >> l;

1059

executed (the execution status of this line is deduced): *static_cast<long *>(data) = long(l);

1060

stream >> *static_cast<int *>(data);

executed: break;

Execution Count:9

1061 case QMetaType::Int: -

1062

executed (the execution status of this line is deduced): stream >> *static_cast<int *>(data);

1063

stream >> *static_cast<short *>(data);

executed: break;

Execution Count:146

146

1064 case QMetaType::Short: -

1065

executed (the execution status of this line is deduced): stream >> *static_cast<short *>(data);

1066

stream >> *static_cast<signed char *>(data);

executed: break;

Execution Count:9

1067 case QMetaType::Char: -

1068 // force a char to be signed -

1069

executed (the execution status of this line is deduced): stream >> *static_cast<signed char *>(data);

1070

*static_cast<ulong *>(data) = ulong(ul);

executed: break;

Execution Count:9

1071 case QMetaType::ULong: { -

1072

qulonglong ul;

executed (the execution status of this line is deduced): qulonglong ul;

1073

stream >> ul;

executed (the execution status of this line is deduced): stream >> ul;

1074

executed (the execution status of this line is deduced): *static_cast<ulong *>(data) = ulong(ul);

1075

stream >> *static_cast<uint *>(data);

executed: break;

Execution Count:9

1076 case QMetaType::UInt: -

1077

executed (the execution status of this line is deduced): stream >> *static_cast<uint *>(data);

1078

stream >> *static_cast<qlonglong *>(data);

executed: break;

Execution Count:8

1079 case QMetaType::LongLong: -

1080

executed (the execution status of this line is deduced): stream >> *static_cast<qlonglong *>(data);

1081

stream >> *static_cast<qulonglong *>(data);

executed: break;

Execution Count:7

1082 case QMetaType::ULongLong: -

1083

executed (the execution status of this line is deduced): stream >> *static_cast<qulonglong *>(data);

1084

stream >> *static_cast<ushort *>(data);

executed: break;

Execution Count:7

1085 case QMetaType::UShort: -

1086

executed (the execution status of this line is deduced): stream >> *static_cast<ushort *>(data);

1087

stream >> *static_cast<signed char *>(data);

executed: break;

Execution Count:9

1088 case QMetaType::SChar: -

1089

executed (the execution status of this line is deduced): stream >> *static_cast<signed char *>(data);

1090

stream >> *static_cast<uchar *>(data);

executed: break;

Execution Count:3

1091 case QMetaType::UChar: -

1092

executed (the execution status of this line is deduced): stream >> *static_cast<uchar *>(data);

1093

*static_cast<bool *>(data) = b;

executed: break;

Execution Count:9

1094 case QMetaType::Bool: { -

1095

qint8 b;

executed (the execution status of this line is deduced): qint8 b;

1096

stream >> b;

executed (the execution status of this line is deduced): stream >> b;

1097

executed (the execution status of this line is deduced): *static_cast<bool *>(data) = b;

1098

stream >> *static_cast<float *>(data);

executed: break;

Execution Count:7

1099 case QMetaType::Float: -

1100

executed (the execution status of this line is deduced): stream >> *static_cast<float *>(data);

1101

stream >> *static_cast<double *>(data);

executed: break;

Execution Count:11

1102 case QMetaType::Double: -

1103

executed (the execution status of this line is deduced): stream >> *static_cast<double *>(data);

1104

stream >> *static_cast< NS(QChar)*>(data);

executed: break;

Execution Count:10

1105 case QMetaType::QChar: -

1106

executed (the execution status of this line is deduced): stream >> *static_cast< ::QChar*>(data);

1107

stream >> *static_cast< NS(QVariantMap)*>(data);

executed: break;

Execution Count:9

1108 #ifndef QT_BOOTSTRAPPED -

1109 case QMetaType::QVariantMap: -

1110

executed (the execution status of this line is deduced): stream >> *static_cast< ::QVariantMap*>(data);

1111

stream >> *static_cast< NS(QVariantHash)*>(data);

executed: break;

Execution Count:8

1112 case QMetaType::QVariantHash: -

1113

executed (the execution status of this line is deduced): stream >> *static_cast< ::QVariantHash*>(data);

1114

stream >> *static_cast< NS(QVariantList)*>(data);

executed: break;

Execution Count:7

1115 case QMetaType::QVariantList: -

1116

executed (the execution status of this line is deduced): stream >> *static_cast< ::QVariantList*>(data);

1117

stream >> *static_cast< NS(QVariant)*>(data);

executed: break;

Execution Count:12

1118 case QMetaType::QVariant: -

1119

executed (the execution status of this line is deduced): stream >> *static_cast< ::QVariant*>(data);

1120

stream >> *static_cast< NS(QByteArray)*>(data);

executed: break;

Execution Count:7

1121 #endif -

1122 case QMetaType::QByteArray: -

1123

executed (the execution status of this line is deduced): stream >> *static_cast< ::QByteArray*>(data);

1124

stream >> *static_cast< NS(QString)*>(data);

executed: break;

Execution Count:9

1125 case QMetaType::QString: -

1126

executed (the execution status of this line is deduced): stream >> *static_cast< ::QString*>(data);

1127

stream >> *static_cast< NS(QStringList)*>(data);

executed: break;

Execution Count:11907

11907

1128 case QMetaType::QStringList: -

1129

executed (the execution status of this line is deduced): stream >> *static_cast< ::QStringList*>(data);

1130

stream >> *static_cast< NS(QBitArray)*>(data);

executed: break;

Execution Count:12

1131 #ifndef QT_BOOTSTRAPPED -

1132 case QMetaType::QBitArray: -

1133

executed (the execution status of this line is deduced): stream >> *static_cast< ::QBitArray*>(data);

1134

stream >> *static_cast< NS(QDate)*>(data);

executed: break;

Execution Count:9

1135 #endif -

1136 case QMetaType::QDate: -

1137

executed (the execution status of this line is deduced): stream >> *static_cast< ::QDate*>(data);

1138

stream >> *static_cast< NS(QTime)*>(data);

executed: break;

Execution Count:9

1139 case QMetaType::QTime: -

1140

executed (the execution status of this line is deduced): stream >> *static_cast< ::QTime*>(data);

1141

stream >> *static_cast< NS(QDateTime)*>(data);

executed: break;

Execution Count:9

1142 case QMetaType::QDateTime: -

1143

executed (the execution status of this line is deduced): stream >> *static_cast< ::QDateTime*>(data);

1144

stream >> *static_cast< NS(QUrl)*>(data);

executed: break;

Execution Count:9

1145 #ifndef QT_BOOTSTRAPPED -

1146 case QMetaType::QUrl: -

1147

executed (the execution status of this line is deduced): stream >> *static_cast< ::QUrl*>(data);

1148

stream >> *static_cast< NS(QLocale)*>(data);

executed: break;

Execution Count:7

1149 #endif -

1150 case QMetaType::QLocale: -

1151

executed (the execution status of this line is deduced): stream >> *static_cast< ::QLocale*>(data);

1152

stream >> *static_cast< NS(QRect)*>(data);

executed: break;

Execution Count:7

1153 #ifndef QT_NO_GEOM_VARIANT -

1154 case QMetaType::QRect: -

1155

executed (the execution status of this line is deduced): stream >> *static_cast< ::QRect*>(data);

1156

stream >> *static_cast< NS(QRectF)*>(data);

executed: break;

Execution Count:9

1157 case QMetaType::QRectF: -

1158

executed (the execution status of this line is deduced): stream >> *static_cast< ::QRectF*>(data);

1159

stream >> *static_cast< NS(QSize)*>(data);

executed: break;

Execution Count:7

1160 case QMetaType::QSize: -

1161

executed (the execution status of this line is deduced): stream >> *static_cast< ::QSize*>(data);

1162

stream >> *static_cast< NS(QSizeF)*>(data);

executed: break;

Execution Count:10

1163 case QMetaType::QSizeF: -

1164

executed (the execution status of this line is deduced): stream >> *static_cast< ::QSizeF*>(data);

1165

stream >> *static_cast< NS(QLine)*>(data);

executed: break;

Execution Count:7

1166 case QMetaType::QLine: -

1167

executed (the execution status of this line is deduced): stream >> *static_cast< ::QLine*>(data);

1168

stream >> *static_cast< NS(QLineF)*>(data);

executed: break;

Execution Count:7

1169 case QMetaType::QLineF: -

1170

executed (the execution status of this line is deduced): stream >> *static_cast< ::QLineF*>(data);

1171

stream >> *static_cast< NS(QPoint)*>(data);

executed: break;

Execution Count:7

1172 case QMetaType::QPoint: -

1173

executed (the execution status of this line is deduced): stream >> *static_cast< ::QPoint*>(data);

1174

stream >> *static_cast< NS(QPointF)*>(data);

executed: break;

Execution Count:9

1175 case QMetaType::QPointF: -

1176

executed (the execution status of this line is deduced): stream >> *static_cast< ::QPointF*>(data);

1177

stream >> *static_cast< NS(QRegExp)*>(data);

executed: break;

Execution Count:7

1178 #endif -

1179 #ifndef QT_NO_REGEXP -

1180 case QMetaType::QRegExp: -

1181

executed (the execution status of this line is deduced): stream >> *static_cast< ::QRegExp*>(data);

1182

stream >> *static_cast< NS(QRegularExpression)*>(data);

executed: break;

Execution Count:51

1183 #endif -

1184 #ifndef QT_BOOTSTRAPPED -

1185 #ifndef QT_NO_REGEXP -

1186 case QMetaType::QRegularExpression: -

1187

executed (the execution status of this line is deduced): stream >> *static_cast< ::QRegularExpression*>(data);

1188

stream >> *static_cast< NS(QEasingCurve)*>(data);

executed: break;

Execution Count:7

1189 #endif // QT_NO_REGEXP -

1190 case QMetaType::QEasingCurve: -

1191

executed (the execution status of this line is deduced): stream >> *static_cast< ::QEasingCurve*>(data);

1192

executed: break;

Execution Count:3

1193 #endif // QT_BOOTSTRAPPED -

1194 case QMetaType::QFont: -

1195 case QMetaType::QPixmap: -

1196 case QMetaType::QBrush: -

1197 case QMetaType::QColor: -

1198 case QMetaType::QPalette: -

1199 case QMetaType::QImage: -

1200 case QMetaType::QPolygon: -

1201 case QMetaType::QPolygonF: -

1202 case QMetaType::QRegion: -

1203 case QMetaType::QBitmap: -

1204 case QMetaType::QCursor: -

1205 case QMetaType::QKeySequence: -

1206 case QMetaType::QPen: -

1207 case QMetaType::QTextLength: -

1208 case QMetaType::QTextFormat: -

1209 case QMetaType::QMatrix: -

1210 case QMetaType::QTransform: -

1211 case QMetaType::QMatrix4x4: -

1212 case QMetaType::QVector2D: -

1213 case QMetaType::QVector3D: -

1214 case QMetaType::QVector4D: -

1215 case QMetaType::QQuaternion: -

1216 case QMetaType::QIcon: -

1217

if (!qMetaTypeGuiHelper)

partially evaluated: !qMetaTypeGuiHelper

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:19

0-19

1218

qMetaTypeGuiHelper[type - FirstGuiType].loadOp(stream, data);

never executed: return false;

1219

executed (the execution status of this line is deduced): qMetaTypeGuiHelper[type - FirstGuiType].loadOp(stream, data);

1220

if (!qMetaTypeWidgetsHelper)

executed: break;

Execution Count:19

1221 case QMetaType::QSizePolicy: -

1222

partially evaluated: !qMetaTypeWidgetsHelper

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

0-1

1223

qMetaTypeWidgetsHelper[type - FirstWidgetsType].loadOp(stream, data);

never executed: return false;

1224

executed (the execution status of this line is deduced): qMetaTypeWidgetsHelper[type - FirstWidgetsType].loadOp(stream, data);

1225

stream >> *static_cast< NS(QUuid)*>(data);

executed: break;

Execution Count:1

1226 case QMetaType::QUuid: -

1227

executed (the execution status of this line is deduced): stream >> *static_cast< ::QUuid*>(data);

1228

const QVector<QCustomTypeInfo> * const ct = customTypes();

executed: break;

Execution Count:5

1229 default: { -

1230

executed (the execution status of this line is deduced): const QVector<QCustomTypeInfo> * const ct = customTypes();

1231

partially evaluated: !ct

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:8

0-8

1232

never executed: return false;

1233 -

1234

LoadOperator loadOp = 0;

executed (the execution status of this line is deduced): LoadOperator loadOp = 0;

1235 { -

1236

loadOp = ct->at(type - User).loadOp;

executed (the execution status of this line is deduced): QReadLocker locker(customTypesLock());

1237

executed (the execution status of this line is deduced): loadOp = ct->at(type - User).loadOp;

1238 } -

1239 -

1240

if (!loadOp)

evaluated: !loadOp

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:6

2-6

1241

executed: return false;

Execution Count:2

1242

loadOp(stream, data);

executed (the execution status of this line is deduced): loadOp(stream, data);

1243

return copy ? new T(*static_cast<const T*>(copy)) : new T();

executed: break;

Execution Count:6

1244 } -

1245

return true;

executed: return true;

Execution Count:12429

12429

1246 } -

1247 #endif // QT_NO_DATASTREAM -

1248 namespace { -

1249 class TypeCreator { -

1250 template<typename T, bool IsAcceptedType = DefinedTypesFilter::Acceptor<T>::IsAccepted> -

1251 struct CreatorImpl { -

1252 static void *Create(const int /* type */, const void *copy) -

1253 { -

1254 // Using QMetaTypeFunctionHelper<T>::Create adds function call cost, even if it is a template (gcc). -

1255 // This "copy" check is moved out from the switcher by compiler (at least by gcc) -

1256

executed: return copy ? new T(*static_cast<const T*>(copy)) : new T();

Execution Count:197530

197530

1257 } -

1258 }; -

1259 template<typename T> -

1260 struct CreatorImpl<T, /* IsAcceptedType = */ false> { -

1261 static void *Create(const int type, const void *copy) -

1262 { -

1263

evaluated: QModulesPrivate::QTypeModuleInfo<T>::IsGui

TRUE	FALSE
yes Evaluation Count:3330	yes Evaluation Count:3

3-3330

1264

return qMetaTypeGuiHelper[type - QMetaType::FirstGuiType].creator(copy);

evaluated: __builtin_expect(!!(qMetaTypeGuiHelper), true)

TRUE	FALSE
yes Evaluation Count:3307	yes Evaluation Count:23

23-3307

1265

executed: return qMetaTypeGuiHelper[type - QMetaType::FirstGuiType].creator(copy);

Execution Count:3307

3307

1266

if (QModulesPrivate::QTypeModuleInfo<T>::IsWidget) {

executed: }

Execution Count:23

1267

evaluated: QModulesPrivate::QTypeModuleInfo<T>::IsWidget

TRUE	FALSE
yes Evaluation Count:3	yes Evaluation Count:23

3-23

1268

return qMetaTypeWidgetsHelper[type - QMetaType::FirstWidgetsType].creator(copy);

evaluated: __builtin_expect(!!(qMetaTypeWidgetsHelper), true)

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:1

1-2

1269

executed: return qMetaTypeWidgetsHelper[type - QMetaType::FirstWidgetsType].creator(copy);

Execution Count:2

1270

executed: }

Execution Count:1

1271 // This point can be reached only for known types that definition is not available, for example -

1272 // in bootstrap mode. We have no other choice then ignore it. -

1273

executed: return 0;

Execution Count:24

1274 } -

1275 }; -

1276 public: -

1277 TypeCreator(const int type) -

1278 : m_type(type) -

1279

void *delegate(const T *copy) { return CreatorImpl<T>::Create(m_type, copy); }

executed: }

Execution Count:252696

252696

1280 -

1281 template<typename T> -

1282

executed: return CreatorImpl<T>::Create(m_type, copy);

Execution Count:200863

200863

1283

void *delegate(const void*) { return 0; }

executed: return 0;

Execution Count:3

1284

void *delegate(const QMetaTypeSwitcher::UnknownType *) { return 0; }

executed: return 0;

Execution Count:86

1285 void *delegate(const QMetaTypeSwitcher::NotBuiltinType *copy) -

1286 { -

1287

QMetaType::Creator creator;

executed (the execution status of this line is deduced): QMetaType::Creator creator;

1288

const QVector<QCustomTypeInfo> * const ct = customTypes();

executed (the execution status of this line is deduced): const QVector<QCustomTypeInfo> * const ct = customTypes();

1289 { -

1290

if (Q_UNLIKELY(m_type < QMetaType::User || !ct || ct->count() <= m_type - QMetaType::User))

executed (the execution status of this line is deduced): QReadLocker locker(customTypesLock());

1291

partially evaluated: __builtin_expect(!!(m_type < QMetaType::User || !ct || ct->count() <= m_type - QMetaType::User), false)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:51744

0-51744

1292

creator = ct->at(m_type - QMetaType::User).creator;

never executed: return 0;

1293

executed (the execution status of this line is deduced): creator = ct->at(m_type - QMetaType::User).creator;

1294 } -

1295

Q_ASSERT_X(creator, "void *QMetaType::create(int type, const void *copy)", "The type was not properly registered");

executed (the execution status of this line is deduced): qt_noop();

1296

return creator(copy);

executed: return creator(copy);

Execution Count:51745

51745

1297 } -

1298 private: -

1299 const int m_type; -

1300 }; -

1301 } // namespace -

1302 -

1303 /*! -

1304 Returns a copy of \a copy, assuming it is of type \a type. If \a -

1305 copy is zero, creates a default constructed instance. -

1306 -

1307 \sa destroy(), isRegistered(), Type -

1308 */ -

1309 void *QMetaType::create(int type, const void *copy) -

1310 { -

1311

TypeCreator typeCreator(type);

executed (the execution status of this line is deduced): TypeCreator typeCreator(type);

1312

return QMetaTypeSwitcher::switcher<void*>(typeCreator, type, copy);

executed: return QMetaTypeSwitcher::switcher<void*>(typeCreator, type, copy);

Execution Count:252699

252699

1313 } -

1314 -

1315 namespace { -

1316 class TypeDestroyer { -

1317 template<typename T, bool IsAcceptedType = DefinedTypesFilter::Acceptor<T>::IsAccepted> -

1318 struct DestroyerImpl { -

1319

static void Destroy(const int /* type */, void *where) { QtMetaTypePrivate::QMetaTypeFunctionHelper<T>::Delete(where); }

executed: }

Execution Count:197524

197524

1320 }; -

1321 template<typename T> -

1322 struct DestroyerImpl<T, /* IsAcceptedType = */ false> { -

1323 static void Destroy(const int type, void *where) -

1324 { -

1325

evaluated: QModulesPrivate::QTypeModuleInfo<T>::IsGui

TRUE	FALSE
yes Evaluation Count:3330	yes Evaluation Count:3

3-3330

1326

qMetaTypeGuiHelper[type - QMetaType::FirstGuiType].deleter(where);

evaluated: __builtin_expect(!!(qMetaTypeGuiHelper), true)

TRUE	FALSE
yes Evaluation Count:3307	yes Evaluation Count:23

23-3307

1327

executed: qMetaTypeGuiHelper[type - QMetaType::FirstGuiType].deleter(where);

Execution Count:3307

3307

1328

if (QModulesPrivate::QTypeModuleInfo<T>::IsWidget) {

executed: return;

Execution Count:3330

3330

1329 } -

1330

partially evaluated: QModulesPrivate::QTypeModuleInfo<T>::IsWidget

TRUE	FALSE
yes Evaluation Count:3	no Evaluation Count:0

0-3

1331

qMetaTypeWidgetsHelper[type - QMetaType::FirstWidgetsType].deleter(where);

evaluated: __builtin_expect(!!(qMetaTypeWidgetsHelper), true)

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:1

1-2

1332

executed: qMetaTypeWidgetsHelper[type - QMetaType::FirstWidgetsType].deleter(where);

Execution Count:2

1333

executed: return;

Execution Count:3

1334 } -

1335 // This point can be reached only for known types that definition is not available, for example -

1336 // in bootstrap mode. We have no other choice then ignore it. -

1337

never executed: }

1338 }; -

1339 public: -

1340 TypeDestroyer(const int type) -

1341 : m_type(type) -

1342

void delegate(const T *where) { DestroyerImpl<T>::Destroy(m_type, const_cast<T*>(where)); }

executed: }

Execution Count:250056

250056

1343 -

1344 template<typename T> -

1345

executed: }

Execution Count:200857

200857

1346 void delegate(const void *) {} -

1347 void delegate(const QMetaTypeSwitcher::UnknownType*) {} -

1348

void delegate(const QMetaTypeSwitcher::NotBuiltinType *where) { customTypeDestroyer(m_type, (void*)where); }

executed: }

Execution Count:49209

49209

1349 -

1350 private: -

1351 static void customTypeDestroyer(const int type, void *where) -

1352 { -

1353

QMetaType::Destructor deleter;

executed (the execution status of this line is deduced): QMetaType::Destructor deleter;

1354

const QVector<QCustomTypeInfo> * const ct = customTypes();

executed (the execution status of this line is deduced): const QVector<QCustomTypeInfo> * const ct = customTypes();

1355 { -

1356

if (Q_UNLIKELY(type < QMetaType::User || !ct || ct->count() <= type - QMetaType::User))

executed (the execution status of this line is deduced): QReadLocker locker(customTypesLock());

1357

evaluated: __builtin_expect(!!(type < QMetaType::User || !ct || ct->count() <= type - QMetaType::User), false)

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:49213

1-49213

1358

deleter = ct->at(type - QMetaType::User).deleter;

executed: return;

Execution Count:1

1359

executed (the execution status of this line is deduced): deleter = ct->at(type - QMetaType::User).deleter;

1360 } -

1361

Q_ASSERT_X(deleter, "void QMetaType::destroy(int type, void *data)", "The type was not properly registered");

executed (the execution status of this line is deduced): qt_noop();

1362

deleter(where);

executed (the execution status of this line is deduced): deleter(where);

1363

TypeDestroyer deleter(type);

executed: }

Execution Count:49209

49209

1364 -

1365 const int m_type; -

1366 }; -

1367 } // namespace -

1368 -

1369 -

1370 /*! -

1371 Destroys the \a data, assuming it is of the \a type given. -

1372 -

1373 \sa create(), isRegistered(), Type -

1374 */ -

1375 void QMetaType::destroy(int type, void *data) -

1376 { -

1377

executed (the execution status of this line is deduced): TypeDestroyer deleter(type);

1378

QMetaTypeSwitcher::switcher<void>(deleter, type, data);

executed (the execution status of this line is deduced): QMetaTypeSwitcher::switcher<void>(deleter, type, data);

1379

static void *Construct(const int /*type*/, void *where, const void *copy) { return QtMetaTypePrivate::QMetaTypeFunctionHelper<T>::Construct(where, copy); }

executed: }

Execution Count:250070

250070

1380 -

1381 namespace { -

1382 class TypeConstructor { -

1383 template<typename T, bool IsAcceptedType = DefinedTypesFilter::Acceptor<T>::IsAccepted> -

1384 struct ConstructorImpl { -

1385

executed: return QtMetaTypePrivate::QMetaTypeFunctionHelper<T>::Construct(where, copy);

Execution Count:86

1386 }; -

1387 template<typename T> -

1388 struct ConstructorImpl<T, /* IsAcceptedType = */ false> { -

1389 static void *Construct(const int type, void *where, const void *copy) -

1390 { -

1391

if (QModulesPrivate::QTypeModuleInfo<T>::IsGui)

partially evaluated: QModulesPrivate::QTypeModuleInfo<T>::IsGui

TRUE	FALSE
yes Evaluation Count:42	no Evaluation Count:0

0-42

1392

return Q_LIKELY(qMetaTypeGuiHelper) ? qMetaTypeGuiHelper[type - QMetaType::FirstGuiType].constructor(where, copy) : 0;

executed:

return __builtin_expect(!!(qMetaTypeGuiHelper), true) ? qMetaTypeGuiHelper[type - QMetaType::FirstGuiType].constructor(where, copy) : 0;

Execution Count:42

1393 -

1394

if (QModulesPrivate::QTypeModuleInfo<T>::IsWidget)

never evaluated: QModulesPrivate::QTypeModuleInfo<T>::IsWidget

1395

return Q_LIKELY(qMetaTypeWidgetsHelper) ? qMetaTypeWidgetsHelper[type - QMetaType::FirstWidgetsType].constructor(where, copy) : 0;

never executed:

return __builtin_expect(!!(qMetaTypeWidgetsHelper), true) ? qMetaTypeWidgetsHelper[type - QMetaType::FirstWidgetsType].constructor(where, copy) : 0;

1396 -

1397 // This point can be reached only for known types that definition is not available, for example -

1398 // in bootstrap mode. We have no other choice then ignore it. -

1399

never executed: return 0;

1400 } -

1401 }; -

1402 public: -

1403 TypeConstructor(const int type, void *where) -

1404 : m_type(type) -

1405 , m_where(where) -

1406

void *delegate(const T *copy) { return ConstructorImpl<T>::Construct(m_type, m_where, copy); }

executed: }

Execution Count:6127

6127

1407 -

1408 template<typename T> -

1409

executed: return ConstructorImpl<T>::Construct(m_type, m_where, copy);

Execution Count:128

128

1410

void *delegate(const void *) { return m_where; }

never executed: return m_where;

1411

void *delegate(const QMetaTypeSwitcher::UnknownType*) { return m_where; }

never executed: return m_where;

1412

void *delegate(const QMetaTypeSwitcher::NotBuiltinType *copy) { return customTypeConstructor(m_type, m_where, copy); }

executed: return customTypeConstructor(m_type, m_where, copy);

Execution Count:6000

6000

1413 -

1414 private: -

1415 static void *customTypeConstructor(const int type, void *where, const void *copy) -

1416 { -

1417

QMetaType::Constructor ctor;

executed (the execution status of this line is deduced): QMetaType::Constructor ctor;

1418

const QVector<QCustomTypeInfo> * const ct = customTypes();

executed (the execution status of this line is deduced): const QVector<QCustomTypeInfo> * const ct = customTypes();

1419 { -

1420

if (Q_UNLIKELY(type < QMetaType::User || !ct || ct->count() <= type - QMetaType::User))

executed (the execution status of this line is deduced): QReadLocker locker(customTypesLock());

1421

partially evaluated: __builtin_expect(!!(type < QMetaType::User || !ct || ct->count() <= type - QMetaType::User), false)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:6000

0-6000

1422

ctor = ct->at(type - QMetaType::User).constructor;

never executed: return 0;

1423

executed (the execution status of this line is deduced): ctor = ct->at(type - QMetaType::User).constructor;

1424 } -

1425

Q_ASSERT_X(ctor, "void *QMetaType::construct(int type, void *where, const void *copy)", "The type was not properly registered");

executed (the execution status of this line is deduced): qt_noop();

1426

return ctor(where, copy);

executed: return ctor(where, copy);

Execution Count:5998

5998

1427 } -

1428 -

1429 const int m_type; -

1430 void *m_where; -

1431 }; -

1432 } // namespace -

1433 -

1434 /*! -

1435 \since 5.0 -

1436 -

1437 Constructs a value of the given \a type in the existing memory -

1438 addressed by \a where, that is a copy of \a copy, and returns -

1439 \a where. If \a copy is zero, the value is default constructed. -

1440 -

1441 This is a low-level function for explicitly managing the memory -

1442 used to store the type. Consider calling create() if you don't -

1443 need this level of control (that is, use "new" rather than -

1444 "placement new"). -

1445 -

1446 You must ensure that \a where points to a location that can store -

1447 a value of type \a type, and that \a where is suitably aligned. -

1448 The type's size can be queried by calling sizeOf(). -

1449 -

1450 The rule of thumb for alignment is that a type is aligned to its -

1451 natural boundary, which is the smallest power of 2 that is bigger -

1452 than the type, unless that alignment is larger than the maximum -

1453 useful alignment for the platform. For practical purposes, -

1454 alignment larger than 2 * sizeof(void*) is only necessary for -

1455 special hardware instructions (e.g., aligned SSE loads and stores -

1456 on x86). -

1457 -

1458 \sa destruct(), sizeOf() -

1459 */ -

1460 void *QMetaType::construct(int type, void *where, const void *copy) -

1461 { -

1462

if (!where)

evaluated: !where

TRUE	FALSE
yes Evaluation Count:90	yes Evaluation Count:6127

90-6127

1463

TypeConstructor constructor(type, where);

executed: return 0;

Execution Count:90

1464

executed (the execution status of this line is deduced): TypeConstructor constructor(type, where);

1465

return QMetaTypeSwitcher::switcher<void*>(constructor, type, copy);

executed: return QMetaTypeSwitcher::switcher<void*>(constructor, type, copy);

Execution Count:6127

6127

1466 } -

1467 -

1468 -

1469 namespace { -

1470 class TypeDestructor { -

1471 template<typename T, bool IsAcceptedType = DefinedTypesFilter::Acceptor<T>::IsAccepted> -

1472 struct DestructorImpl { -

1473

static void Destruct(const int /* type */, void *where) { QtMetaTypePrivate::QMetaTypeFunctionHelper<T>::Destruct(where); }

executed: }

Execution Count:86

1474 }; -

1475 template<typename T> -

1476 struct DestructorImpl<T, /* IsAcceptedType = */ false> { -

1477 static void Destruct(const int type, void *where) -

1478 { -

1479

partially evaluated: QModulesPrivate::QTypeModuleInfo<T>::IsGui

TRUE	FALSE
yes Evaluation Count:42	no Evaluation Count:0

0-42

1480

qMetaTypeGuiHelper[type - QMetaType::FirstGuiType].destructor(where);

partially evaluated: __builtin_expect(!!(qMetaTypeGuiHelper), true)

TRUE	FALSE
yes Evaluation Count:42	no Evaluation Count:0

0-42

1481

executed: qMetaTypeGuiHelper[type - QMetaType::FirstGuiType].destructor(where);

Execution Count:42

1482

if (QModulesPrivate::QTypeModuleInfo<T>::IsWidget) {

executed: return;

Execution Count:42

1483 } -

1484

never evaluated: QModulesPrivate::QTypeModuleInfo<T>::IsWidget

1485

qMetaTypeWidgetsHelper[type - QMetaType::FirstWidgetsType].destructor(where);

never evaluated: __builtin_expect(!!(qMetaTypeWidgetsHelper), true)

1486

never executed: qMetaTypeWidgetsHelper[type - QMetaType::FirstWidgetsType].destructor(where);

1487

never executed: return;

1488 } -

1489 // This point can be reached only for known types that definition is not available, for example -

1490 // in bootstrap mode. We have no other choice then ignore it. -

1491

never executed: }

1492 }; -

1493 public: -

1494 TypeDestructor(const int type) -

1495 : m_type(type) -

1496

void delegate(const T *where) { DestructorImpl<T>::Destruct(m_type, const_cast<T*>(where)); }

executed: }

Execution Count:48583

48583

1497 -

1498 template<typename T> -

1499

executed: }

Execution Count:128

128

1500 void delegate(const void *) {} -

1501 void delegate(const QMetaTypeSwitcher::UnknownType*) {} -

1502

void delegate(const QMetaTypeSwitcher::NotBuiltinType *where) { customTypeDestructor(m_type, (void*)where); }

executed: }

Execution Count:48457

48457

1503 -

1504 private: -

1505 static void customTypeDestructor(const int type, void *where) -

1506 { -

1507

QMetaType::Destructor dtor;

executed (the execution status of this line is deduced): QMetaType::Destructor dtor;

1508

const QVector<QCustomTypeInfo> * const ct = customTypes();

executed (the execution status of this line is deduced): const QVector<QCustomTypeInfo> * const ct = customTypes();

1509 { -

1510

if (Q_UNLIKELY(type < QMetaType::User || !ct || ct->count() <= type - QMetaType::User))

executed (the execution status of this line is deduced): QReadLocker locker(customTypesLock());

1511

partially evaluated: __builtin_expect(!!(type < QMetaType::User || !ct || ct->count() <= type - QMetaType::User), false)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:48456

0-48456

1512

dtor = ct->at(type - QMetaType::User).destructor;

never executed: return;

1513

executed (the execution status of this line is deduced): dtor = ct->at(type - QMetaType::User).destructor;

1514 } -

1515

Q_ASSERT_X(dtor, "void QMetaType::destruct(int type, void *where)", "The type was not properly registered");

executed (the execution status of this line is deduced): qt_noop();

1516

dtor(where);

executed (the execution status of this line is deduced): dtor(where);

1517

executed: }

Execution Count:48457

48457

1518 -

1519 const int m_type; -

1520 }; -

1521 } // namespace -

1522 -

1523 /*! -

1524 \since 5.0 -

1525 -

1526 Destructs the value of the given \a type, located at \a where. -

1527 -

1528 Unlike destroy(), this function only invokes the type's -

1529 destructor, it doesn't invoke the delete operator. -

1530 -

1531 \sa construct() -

1532 */ -

1533 void QMetaType::destruct(int type, void *where) -

1534 { -

1535

if (!where)

evaluated: !where

TRUE	FALSE
yes Evaluation Count:46	yes Evaluation Count:48583

46-48583

1536

TypeDestructor destructor(type);

executed: return;

Execution Count:46

1537

executed (the execution status of this line is deduced): TypeDestructor destructor(type);

1538

QMetaTypeSwitcher::switcher<void>(destructor, type, where);

executed (the execution status of this line is deduced): QMetaTypeSwitcher::switcher<void>(destructor, type, where);

1539

static int Size(const int) { return QTypeInfo<T>::sizeOf; }

executed: }

Execution Count:48585

48585

1540 -

1541 -

1542 namespace { -

1543 class SizeOf { -

1544 template<typename T, bool IsAcceptedType = DefinedTypesFilter::Acceptor<T>::IsAccepted> -

1545 struct SizeOfImpl { -

1546

executed: return QTypeInfo<T>::sizeOf;

Execution Count:89

1547 }; -

1548 template<typename T> -

1549 struct SizeOfImpl<T, /* IsAcceptedType = */ false> { -

1550 static int Size(const int type) -

1551 { -

1552

if (QModulesPrivate::QTypeModuleInfo<T>::IsGui)

partially evaluated: QModulesPrivate::QTypeModuleInfo<T>::IsGui

TRUE	FALSE
yes Evaluation Count:63	no Evaluation Count:0

0-63

1553

return Q_LIKELY(qMetaTypeGuiHelper) ? qMetaTypeGuiHelper[type - QMetaType::FirstGuiType].size : 0;

executed: return __builtin_expect(!!(qMetaTypeGuiHelper), true) ? qMetaTypeGuiHelper[type - QMetaType::FirstGuiType].size : 0;

Execution Count:63

1554 -

1555

if (QModulesPrivate::QTypeModuleInfo<T>::IsWidget)

never evaluated: QModulesPrivate::QTypeModuleInfo<T>::IsWidget

1556

return Q_LIKELY(qMetaTypeWidgetsHelper) ? qMetaTypeWidgetsHelper[type - QMetaType::FirstWidgetsType].size : 0;

never executed:

return __builtin_expect(!!(qMetaTypeWidgetsHelper), true) ? qMetaTypeWidgetsHelper[type - QMetaType::FirstWidgetsType].size : 0;

1557 -

1558 // This point can be reached only for known types that definition is not available, for example -

1559 // in bootstrap mode. We have no other choice then ignore it. -

1560

never executed: return 0;

1561 } -

1562 }; -

1563 -

1564 public: -

1565 SizeOf(int type) -

1566 : m_type(type) -

1567

int delegate(const T*) { return SizeOfImpl<T>::Size(m_type); }

executed: }

Execution Count:221

221

1568 -

1569 template<typename T> -

1570

executed: return SizeOfImpl<T>::Size(m_type);

Execution Count:152

152

1571

int delegate(const QMetaTypeSwitcher::UnknownType*) { return 0; }

executed: return 0;

Execution Count:3

1572

int delegate(const QMetaTypeSwitcher::NotBuiltinType*) { return customTypeSizeOf(m_type); }

executed: return customTypeSizeOf(m_type);

Execution Count:66

1573 private: -

1574 static int customTypeSizeOf(const int type) -

1575 { -

1576

const QVector<QCustomTypeInfo> * const ct = customTypes();

executed (the execution status of this line is deduced): const QVector<QCustomTypeInfo> * const ct = customTypes();

1577

if (Q_UNLIKELY(type < QMetaType::User || !ct || ct->count() <= type - QMetaType::User))

executed (the execution status of this line is deduced): QReadLocker locker(customTypesLock());

1578

evaluated: __builtin_expect(!!(type < QMetaType::User || !ct || ct->count() <= type - QMetaType::User), false)

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:65

1-65

1579

return ct->at(type - QMetaType::User).size;

executed: return 0;

Execution Count:1

1580

executed: return ct->at(type - QMetaType::User).size;

Execution Count:65

1581 } -

1582 -

1583 const int m_type; -

1584 }; -

1585 } // namespace -

1586 -

1587 /*! -

1588 \since 5.0 -

1589 -

1590 Returns the size of the given \a type in bytes (i.e. sizeof(T), -

1591 where T is the actual type identified by the \a type argument). -

1592 -

1593 This function is typically used together with construct() -

1594 to perform low-level management of the memory used by a type. -

1595 -

1596 \sa construct() -

1597 */ -

1598 int QMetaType::sizeOf(int type) -

1599 { -

1600

SizeOf sizeOf(type);

executed (the execution status of this line is deduced): SizeOf sizeOf(type);

1601

return QMetaTypeSwitcher::switcher<int>(sizeOf, type, 0);

executed: return QMetaTypeSwitcher::switcher<int>(sizeOf, type, 0);

Execution Count:221

221

1602 } -

1603 -

1604 namespace { -

1605 class Flags -

1606 { -

1607 template<typename T, bool IsAcceptedType = DefinedTypesFilter::Acceptor<T>::IsAccepted> -

1608 struct FlagsImpl -

1609 { -

1610 static quint32 Flags(const int /* type */) -

1611 { -

1612

return QtPrivate::QMetaTypeTypeFlags<T>::Flags;

executed: return QtPrivate::QMetaTypeTypeFlags<T>::Flags;

Execution Count:492

492

1613 } -

1614 }; -

1615 template<typename T> -

1616 struct FlagsImpl<T, /* IsAcceptedType = */ false> -

1617 { -

1618 static quint32 Flags(const int type) -

1619 { -

1620

if (QModulesPrivate::QTypeModuleInfo<T>::IsGui)

evaluated: QModulesPrivate::QTypeModuleInfo<T>::IsGui

TRUE	FALSE
yes Evaluation Count:164	yes Evaluation Count:2

2-164

1621

return Q_LIKELY(qMetaTypeGuiHelper) ? qMetaTypeGuiHelper[type - QMetaType::FirstGuiType].flags : 0;

executed: return __builtin_expect(!!(qMetaTypeGuiHelper), true) ? qMetaTypeGuiHelper[type - QMetaType::FirstGuiType].flags : 0;

Execution Count:164

164

1622 -

1623

if (QModulesPrivate::QTypeModuleInfo<T>::IsWidget)

partially evaluated: QModulesPrivate::QTypeModuleInfo<T>::IsWidget

TRUE	FALSE
yes Evaluation Count:2	no Evaluation Count:0

0-2

1624

return Q_LIKELY(qMetaTypeWidgetsHelper) ? qMetaTypeWidgetsHelper[type - QMetaType::FirstWidgetsType].flags : 0;

executed:

return __builtin_expect(!!(qMetaTypeWidgetsHelper), true) ? qMetaTypeWidgetsHelper[type - QMetaType::FirstWidgetsType].flags : 0;

Execution Count:2

1625 -

1626 // This point can be reached only for known types that definition is not available, for example -

1627 // in bootstrap mode. We have no other choice then ignore it. -

1628

never executed: return 0;

1629 } -

1630 }; -

1631 public: -

1632 Flags(const int type) -

1633 : m_type(type) -

1634

quint32 delegate(const T*) { return FlagsImpl<T>::Flags(m_type); }

executed: }

Execution Count:5615

5615

1635 template<typename T> -

1636

executed: return FlagsImpl<T>::Flags(m_type);

Execution Count:658

658

1637

quint32 delegate(const void*) { return 0; }

executed: return 0;

Execution Count:1

1638

quint32 delegate(const QMetaTypeSwitcher::UnknownType*) { return 0; }

executed: return 0;

Execution Count:14

1639

quint32 delegate(const QMetaTypeSwitcher::NotBuiltinType*) { return customTypeFlags(m_type); }

executed: return customTypeFlags(m_type);

Execution Count:4942

4942

1640 private: -

1641 const int m_type; -

1642 static quint32 customTypeFlags(const int type) -

1643 { -

1644

const QVector<QCustomTypeInfo> * const ct = customTypes();

executed (the execution status of this line is deduced): const QVector<QCustomTypeInfo> * const ct = customTypes();

1645

if (Q_UNLIKELY(!ct || type < QMetaType::User))

partially evaluated: __builtin_expect(!!(!ct || type < QMetaType::User), false)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:4942

0-4942

1646

never executed: return 0;

1647

if (Q_UNLIKELY(ct->count() <= type - QMetaType::User))

executed (the execution status of this line is deduced): QReadLocker locker(customTypesLock());

1648

evaluated: __builtin_expect(!!(ct->count() <= type - QMetaType::User), false)

TRUE	FALSE
yes Evaluation Count:5	yes Evaluation Count:4937

5-4937

1649

return ct->at(type - QMetaType::User).flags;

executed: return 0;

Execution Count:5

1650

executed: return ct->at(type - QMetaType::User).flags;

Execution Count:4937

4937

1651 } -

1652 }; -

1653 } // namespace -

1654 -

1655 /*! -

1656 \since 5.0 -

1657 -

1658 Returns flags of the given \a type. -

1659 -

1660 \sa QMetaType::TypeFlags -

1661 */ -

1662 QMetaType::TypeFlags QMetaType::typeFlags(int type) -

1663 { -

1664

Flags flags(type);

executed (the execution status of this line is deduced): Flags flags(type);

1665

return static_cast<QMetaType::TypeFlags>(QMetaTypeSwitcher::switcher<quint32>(flags, type, 0));

executed: return static_cast<QMetaType::TypeFlags>(QMetaTypeSwitcher::switcher<quint32>(flags, type, 0));

Execution Count:5615

5615

1666 } -

1667 -

1668 #ifndef QT_BOOTSTRAPPED -

1669 namespace { -

1670 class MetaObject -

1671 { -

1672 public: -

1673 MetaObject(const int type) -

1674 : m_type(type) -

1675

const QMetaObject *delegate(const T*) { return QtPrivate::MetaObjectForType<T>::value(); }

executed: }

Execution Count:7

1676 template<typename T> -

1677

executed: return QtPrivate::MetaObjectForType<T>::value();

Execution Count:2

1678

const QMetaObject *delegate(const void*) { return 0; }

never executed: return 0;

1679

const QMetaObject *delegate(const QMetaTypeSwitcher::UnknownType*) { return 0; }

never executed: return 0;

1680

const QMetaObject *delegate(const QMetaTypeSwitcher::NotBuiltinType*) { return customMetaObject(m_type); }

executed: return customMetaObject(m_type);

Execution Count:5

1681 private: -

1682 const int m_type; -

1683 static const QMetaObject *customMetaObject(const int type) -

1684 { -

1685

const QVector<QCustomTypeInfo> * const ct = customTypes();

executed (the execution status of this line is deduced): const QVector<QCustomTypeInfo> * const ct = customTypes();

1686

if (Q_UNLIKELY(!ct || type < QMetaType::User))

partially evaluated: __builtin_expect(!!(!ct || type < QMetaType::User), false)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:5

0-5

1687

never executed: return 0;

1688

if (Q_UNLIKELY(ct->count() <= type - QMetaType::User))

executed (the execution status of this line is deduced): QReadLocker locker(customTypesLock());

1689

partially evaluated: __builtin_expect(!!(ct->count() <= type - QMetaType::User), false)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:5

0-5

1690

return ct->at(type - QMetaType::User).metaObject;

never executed: return 0;

1691

executed: return ct->at(type - QMetaType::User).metaObject;

Execution Count:5

1692 } -

1693 }; -

1694 } // namespace -

1695 #endif -

1696 -

1697 /*! -

1698 \since 5.0 -

1699 -

1700 Returns QMetaObject of a given \a type, if the \a type is a pointer to type derived from QObject. -

1701 */ -

1702 const QMetaObject *QMetaType::metaObjectForType(int type) -

1703 { -

1704 #ifndef QT_BOOTSTRAPPED -

1705

MetaObject mo(type);

executed (the execution status of this line is deduced): MetaObject mo(type);

1706

return QMetaTypeSwitcher::switcher<const QMetaObject*>(mo, type, 0);

executed: return QMetaTypeSwitcher::switcher<const QMetaObject*>(mo, type, 0);

Execution Count:7

1707 #else -

1708 Q_UNUSED(type); -

1709 return 0; -

1710 #endif -

1711 } -

1712 -

1713 /*! -

1714 \fn int qRegisterMetaType(const char *typeName) -

1715 \relates QMetaType -

1716 \threadsafe -

1717 -

1718 Registers the type name \a typeName for the type \c{T}. Returns -

1719 the internal ID used by QMetaType. Any class or struct that has a -

1720 public default constructor, a public copy constructor and a public -

1721 destructor can be registered. -

1722 -

1723 This function requires that \c{T} is a fully defined type at the point -

1724 where the function is called. For pointer types, it also requires that the -

1725 pointed to type is fully defined. Use Q_DECLARE_OPAQUE_POINTER() to be able -

1726 to register pointers to forward declared types. -

1727 -

1728 After a type has been registered, you can create and destroy -

1729 objects of that type dynamically at run-time. -

1730 -

1731 This example registers the class \c{MyClass}: -

1732 -

1733 \snippet code/src_corelib_kernel_qmetatype.cpp 4 -

1734 -

1735 This function is useful to register typedefs so they can be used -

1736 by QMetaProperty, or in QueuedConnections -

1737 -

1738 \snippet code/src_corelib_kernel_qmetatype.cpp 9 -

1739 -

1740 \warning This function is useful only for registering an alias (typedef) -

1741 for every other use case Q_DECLARE_METATYPE and qMetaTypeId() should be used instead. -

1742 -

1743 \sa qRegisterMetaTypeStreamOperators(), QMetaType::isRegistered(), -

1744 Q_DECLARE_METATYPE() -

1745 */ -

1746 -

1747 /*! -

1748 \fn void qRegisterMetaTypeStreamOperators(const char *typeName) -

1749 \relates QMetaType -

1750 \threadsafe -

1751 -

1752 Registers the stream operators for the type \c{T} called \a -

1753 typeName. -

1754 -

1755 Afterward, the type can be streamed using QMetaType::load() and -

1756 QMetaType::save(). These functions are used when streaming a -

1757 QVariant. -

1758 -

1759 \snippet code/src_corelib_kernel_qmetatype.cpp 5 -

1760 -

1761 The stream operators should have the following signatures: -

1762 -

1763 \snippet code/src_corelib_kernel_qmetatype.cpp 6 -

1764 -

1765 \sa qRegisterMetaType(), QMetaType::isRegistered(), Q_DECLARE_METATYPE() -

1766 */ -

1767 -

1768 /*! \typedef QMetaType::Deleter -

1769 \internal -

1770 */ -

1771 /*! \typedef QMetaType::Creator -

1772 \internal -

1773 */ -

1774 /*! \typedef QMetaType::SaveOperator -

1775 \internal -

1776 */ -

1777 /*! \typedef QMetaType::LoadOperator -

1778 \internal -

1779 */ -

1780 /*! \typedef QMetaType::Destructor -

1781 \internal -

1782 */ -

1783 /*! \typedef QMetaType::Constructor -

1784 \internal -

1785 */ -

1786 -

1787 /*! -

1788 \fn int qRegisterMetaType() -

1789 \relates QMetaType -

1790 \threadsafe -

1791 \since 4.2 -

1792 -

1793 Call this function to register the type \c T. \c T must be declared with -

1794 Q_DECLARE_METATYPE(). Returns the meta type Id. -

1795 -

1796 Example: -

1797 -

1798 \snippet code/src_corelib_kernel_qmetatype.cpp 7 -

1799 -

1800 This function requires that \c{T} is a fully defined type at the point -

1801 where the function is called. For pointer types, it also requires that the -

1802 pointed to type is fully defined. Use Q_DECLARE_OPAQUE_POINTER() to be able -

1803 to register pointers to forward declared types. -

1804 -

1805 After a type has been registered, you can create and destroy -

1806 objects of that type dynamically at run-time. -

1807 -

1808 To use the type \c T in QVariant, using Q_DECLARE_METATYPE() is -

1809 sufficient. To use the type \c T in queued signal and slot connections, -

1810 \c{qRegisterMetaType<T>()} must be called before the first connection -

1811 is established. -

1812 -

1813 Also, to use type \c T with the QObject::property() API, -

1814 \c{qRegisterMetaType<T>()} must be called before it is used, typically -

1815 in the constructor of the class that uses \c T, or in the \c{main()} -

1816 function. -

1817 -

1818 \sa Q_DECLARE_METATYPE() -

1819 */ -

1820 -

1821 /*! -

1822 \fn int qMetaTypeId() -

1823 \relates QMetaType -

1824 \threadsafe -

1825 \since 4.1 -

1826 -

1827 Returns the meta type id of type \c T at compile time. If the -

1828 type was not declared with Q_DECLARE_METATYPE(), compilation will -

1829 fail. -

1830 -

1831 Typical usage: -

1832 -

1833 \snippet code/src_corelib_kernel_qmetatype.cpp 8 -

1834 -

1835 QMetaType::type() returns the same ID as qMetaTypeId(), but does -

1836 a lookup at runtime based on the name of the type. -

1837 QMetaType::type() is a bit slower, but compilation succeeds if a -

1838 type is not registered. -

1839 -

1840 \sa Q_DECLARE_METATYPE(), QMetaType::type() -

1841 */ -

1842 -

1843 namespace { -

1844 class TypeInfo { -

1845 template<typename T, bool IsAcceptedType = DefinedTypesFilter::Acceptor<T>::IsAccepted> -

1846 struct TypeInfoImpl -

1847 { -

1848 TypeInfoImpl(const uint /* type */, QMetaTypeInterface &info) -

1849 { -

1850

QMetaTypeInterface tmp = QT_METATYPE_INTERFACE_INIT_NO_DATASTREAM(T);

executed (the execution status of this line is deduced):

 QMetaTypeInterface tmp = { (QtMetaTypePrivate::QMetaTypeFunctionHelper<T, QtMetaTypePrivate::TypeDefinition<T>::IsAvailable>::Create), (QtMetaTypePrivate::QMetaTypeFunctionHelper<T, QtMetaTypePrivate::TypeDefinition<T>::IsAvailable>::Delete), 0, 0, (QtMetaTypePrivate::QMetaTypeFunctionHelper<T, QtMetaTypePrivate::TypeDefinition<T>::IsAvailable>::Construct), (QtMetaTypePrivate::QMetaTypeFunctionHelper<T, QtMetaTypePrivate::TypeDefinition<T>::IsAvailable>::Destruct), (QTypeInfo<T>::sizeOf), QtPrivate::QMetaTypeTypeFlags<T>::Flags, (QtPrivate::MetaObjectForType<T>::value()) };

1851

info = tmp;

executed (the execution status of this line is deduced): info = tmp;

1852

executed: }

Execution Count:290

290

1853 }; -

1854 -

1855 template<typename T> -

1856 struct TypeInfoImpl<T, /* IsAcceptedType = */ false> -

1857 { -

1858 TypeInfoImpl(const uint type, QMetaTypeInterface &info) -

1859 { -

1860

never evaluated: QModulesPrivate::QTypeModuleInfo<T>::IsGui

1861

info = qMetaTypeGuiHelper[type - QMetaType::FirstGuiType];

never evaluated: __builtin_expect(!!(qMetaTypeGuiHelper), true)

1862

never executed: info = qMetaTypeGuiHelper[type - QMetaType::FirstGuiType];

1863

if (QModulesPrivate::QTypeModuleInfo<T>::IsWidget) {

never executed: return;

1864 } -

1865

never evaluated: QModulesPrivate::QTypeModuleInfo<T>::IsWidget

1866

info = qMetaTypeWidgetsHelper[type - QMetaType::FirstWidgetsType];

never evaluated: __builtin_expect(!!(qMetaTypeWidgetsHelper), true)

1867

never executed: info = qMetaTypeWidgetsHelper[type - QMetaType::FirstWidgetsType];

1868

never executed: return;

1869 } -

1870

QMetaTypeInterface tmp = QT_METATYPE_INTERFACE_INIT_EMPTY();

never executed: }

1871 }; -

1872 public: -

1873 QMetaTypeInterface info; -

1874 TypeInfo(const uint type) -

1875 : m_type(type) -

1876 { -

1877

executed (the execution status of this line is deduced): QMetaTypeInterface tmp = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };

1878

info = tmp;

executed (the execution status of this line is deduced): info = tmp;

1879

void delegate(const T*) { TypeInfoImpl<T>(m_type, info); }

executed: }

Execution Count:45057

45057

1880 template<typename T> -

1881

executed: }

Execution Count:290

290

1882 void delegate(const QMetaTypeSwitcher::UnknownType*) {} -

1883

void delegate(const QMetaTypeSwitcher::NotBuiltinType*) { customTypeInfo(m_type); }

executed: }

Execution Count:44749

44749

1884 private: -

1885 void customTypeInfo(const uint type) -

1886 { -

1887

const QVector<QCustomTypeInfo> * const ct = customTypes();

executed (the execution status of this line is deduced): const QVector<QCustomTypeInfo> * const ct = customTypes();

1888

if (Q_UNLIKELY(!ct))

partially evaluated: __builtin_expect(!!(!ct), false)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:44749

0-44749

1889

never executed: return;

1890

if (Q_LIKELY(uint(ct->count()) > type - QMetaType::User))

executed (the execution status of this line is deduced): QReadLocker locker(customTypesLock());

1891

evaluated: __builtin_expect(!!(uint(ct->count()) > type - QMetaType::User), true)

TRUE	FALSE
yes Evaluation Count:44718	yes Evaluation Count:31

31-44718

1892

info = ct->at(type - QMetaType::User);

executed: info = ct->at(type - QMetaType::User);

Execution Count:44718

44718

1893

QMetaTypeSwitcher::switcher<void>(typeInfo, type, 0);

executed: }

Execution Count:44749

44749

1894 -

1895 const uint m_type; -

1896 }; -

1897 } // namespace -

1898 -

1899 /*! -

1900 \fn QMetaType QMetaType::typeInfo(const int type) -

1901 \internal -

1902 */ -

1903 QMetaType QMetaType::typeInfo(const int type) -

1904 { -

1905

TypeInfo typeInfo(type);

executed (the execution status of this line is deduced): TypeInfo typeInfo(type);

1906

executed (the execution status of this line is deduced): QMetaTypeSwitcher::switcher<void>(typeInfo, type, 0);

1907

return typeInfo.info.creator ? QMetaType(QMetaType::NoExtensionFlags

executed:

return typeInfo.info.creator ? QMetaType(QMetaType::NoExtensionFlags , static_cast<const QMetaTypeInterface *>(0) , typeInfo.info.creator , typeInfo.info.deleter , typeInfo.info.saveOp , typeInfo.info.loadOp , typeInfo.info.constructor , typeInfo.info.destructor , typeInfo.info.size , typeInfo.info.flags , type , typeInfo.info.metaObject) : QMetaType(UnknownType);

Execution Count:45057

45057

1908

, static_cast<const QMetaTypeInterface *>(0) // typeInfo::info is a temporary variable, we can't return address of it.

executed:

return typeInfo.info.creator ? QMetaType(QMetaType::NoExtensionFlags , static_cast<const QMetaTypeInterface *>(0) , typeInfo.info.creator , typeInfo.info.deleter , typeInfo.info.saveOp , typeInfo.info.loadOp , typeInfo.info.constructor , typeInfo.info.destructor , typeInfo.info.size , typeInfo.info.flags , type , typeInfo.info.metaObject) : QMetaType(UnknownType);

Execution Count:45057

45057

1909

, typeInfo.info.creator

executed:

return typeInfo.info.creator ? QMetaType(QMetaType::NoExtensionFlags , static_cast<const QMetaTypeInterface *>(0) , typeInfo.info.creator , typeInfo.info.deleter , typeInfo.info.saveOp , typeInfo.info.loadOp , typeInfo.info.constructor , typeInfo.info.destructor , typeInfo.info.size , typeInfo.info.flags , type , typeInfo.info.metaObject) : QMetaType(UnknownType);

Execution Count:45057

45057

1910

, typeInfo.info.deleter

executed:

return typeInfo.info.creator ? QMetaType(QMetaType::NoExtensionFlags , static_cast<const QMetaTypeInterface *>(0) , typeInfo.info.creator , typeInfo.info.deleter , typeInfo.info.saveOp , typeInfo.info.loadOp , typeInfo.info.constructor , typeInfo.info.destructor , typeInfo.info.size , typeInfo.info.flags , type , typeInfo.info.metaObject) : QMetaType(UnknownType);

Execution Count:45057

45057

1911

, typeInfo.info.saveOp

executed:

return typeInfo.info.creator ? QMetaType(QMetaType::NoExtensionFlags , static_cast<const QMetaTypeInterface *>(0) , typeInfo.info.creator , typeInfo.info.deleter , typeInfo.info.saveOp , typeInfo.info.loadOp , typeInfo.info.constructor , typeInfo.info.destructor , typeInfo.info.size , typeInfo.info.flags , type , typeInfo.info.metaObject) : QMetaType(UnknownType);

Execution Count:45057

45057

1912

, typeInfo.info.loadOp

executed:

return typeInfo.info.creator ? QMetaType(QMetaType::NoExtensionFlags , static_cast<const QMetaTypeInterface *>(0) , typeInfo.info.creator , typeInfo.info.deleter , typeInfo.info.saveOp , typeInfo.info.loadOp , typeInfo.info.constructor , typeInfo.info.destructor , typeInfo.info.size , typeInfo.info.flags , type , typeInfo.info.metaObject) : QMetaType(UnknownType);

Execution Count:45057

45057

1913

, typeInfo.info.constructor

executed:

return typeInfo.info.creator ? QMetaType(QMetaType::NoExtensionFlags , static_cast<const QMetaTypeInterface *>(0) , typeInfo.info.creator , typeInfo.info.deleter , typeInfo.info.saveOp , typeInfo.info.loadOp , typeInfo.info.constructor , typeInfo.info.destructor , typeInfo.info.size , typeInfo.info.flags , type , typeInfo.info.metaObject) : QMetaType(UnknownType);

Execution Count:45057

45057

1914

, typeInfo.info.destructor

executed:

return typeInfo.info.creator ? QMetaType(QMetaType::NoExtensionFlags , static_cast<const QMetaTypeInterface *>(0) , typeInfo.info.creator , typeInfo.info.deleter , typeInfo.info.saveOp , typeInfo.info.loadOp , typeInfo.info.constructor , typeInfo.info.destructor , typeInfo.info.size , typeInfo.info.flags , type , typeInfo.info.metaObject) : QMetaType(UnknownType);

Execution Count:45057

45057

1915

, typeInfo.info.size

executed:

return typeInfo.info.creator ? QMetaType(QMetaType::NoExtensionFlags , static_cast<const QMetaTypeInterface *>(0) , typeInfo.info.creator , typeInfo.info.deleter , typeInfo.info.saveOp , typeInfo.info.loadOp , typeInfo.info.constructor , typeInfo.info.destructor , typeInfo.info.size , typeInfo.info.flags , type , typeInfo.info.metaObject) : QMetaType(UnknownType);

Execution Count:45057

45057

1916

, typeInfo.info.flags

executed:

return typeInfo.info.creator ? QMetaType(QMetaType::NoExtensionFlags , static_cast<const QMetaTypeInterface *>(0) , typeInfo.info.creator , typeInfo.info.deleter , typeInfo.info.saveOp , typeInfo.info.loadOp , typeInfo.info.constructor , typeInfo.info.destructor , typeInfo.info.size , typeInfo.info.flags , type , typeInfo.info.metaObject) : QMetaType(UnknownType);

Execution Count:45057

45057

1917

, type

executed:

return typeInfo.info.creator ? QMetaType(QMetaType::NoExtensionFlags , static_cast<const QMetaTypeInterface *>(0) , typeInfo.info.creator , typeInfo.info.deleter , typeInfo.info.saveOp , typeInfo.info.loadOp , typeInfo.info.constructor , typeInfo.info.destructor , typeInfo.info.size , typeInfo.info.flags , type , typeInfo.info.metaObject) : QMetaType(UnknownType);

Execution Count:45057

45057

1918

, typeInfo.info.metaObject)

executed:

return typeInfo.info.creator ? QMetaType(QMetaType::NoExtensionFlags , static_cast<const QMetaTypeInterface *>(0) , typeInfo.info.creator , typeInfo.info.deleter , typeInfo.info.saveOp , typeInfo.info.loadOp , typeInfo.info.constructor , typeInfo.info.destructor , typeInfo.info.size , typeInfo.info.flags , type , typeInfo.info.metaObject) : QMetaType(UnknownType);

Execution Count:45057

45057

1919

: QMetaType(UnknownType);

executed:

return typeInfo.info.creator ? QMetaType(QMetaType::NoExtensionFlags , static_cast<const QMetaTypeInterface *>(0) , typeInfo.info.creator , typeInfo.info.deleter , typeInfo.info.saveOp , typeInfo.info.loadOp , typeInfo.info.constructor , typeInfo.info.destructor , typeInfo.info.size , typeInfo.info.flags , type , typeInfo.info.metaObject) : QMetaType(UnknownType);

Execution Count:45057

45057

1920 } -

1921 -

1922 /*! -

1923 \fn QMetaType::QMetaType(const int typeId) -

1924 \since 5.0 -

1925 -

1926 Constructs a QMetaType object that contains all information about type \a typeId. -

1927 */ -

1928 QMetaType::QMetaType(const int typeId) -

1929 : m_typeId(typeId) -

1930 { -

1931

if (Q_UNLIKELY(typeId == UnknownType)) {

evaluated: __builtin_expect(!!(typeId == UnknownType), false)

TRUE	FALSE
yes Evaluation Count:51	yes Evaluation Count:45057

51-45057

1932 // Constructs invalid QMetaType instance. -

1933

m_extensionFlags = 0xffffffff;

executed (the execution status of this line is deduced): m_extensionFlags = 0xffffffff;

1934

Q_ASSERT(!isValid());

executed (the execution status of this line is deduced): qt_noop();

1935

} else {

executed: }

Execution Count:51

1936 // TODO it can be better. -

1937

*this = QMetaType::typeInfo(typeId);

executed (the execution status of this line is deduced): *this = QMetaType::typeInfo(typeId);

1938

if (m_typeId == UnknownType)

evaluated: m_typeId == UnknownType

TRUE	FALSE
yes Evaluation Count:49	yes Evaluation Count:45008

49-45008

1939

m_extensionFlags = 0xffffffff;

executed: m_extensionFlags = 0xffffffff;

Execution Count:49

1940

else if (m_typeId == QMetaType::Void)

evaluated: m_typeId == QMetaType::Void

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:45006

2-45006

1941

m_extensionFlags = CreateEx | DestroyEx | ConstructEx | DestructEx;

executed: m_extensionFlags = CreateEx | DestroyEx | ConstructEx | DestructEx;

Execution Count:2

1942 } -

1943 } -

1944 -

1945 /*! -

1946 \fn QMetaType::QMetaType(const QMetaType &other) -

1947 \since 5.0 -

1948 -

1949 Copy constructs a QMetaType object. -

1950 */ -

1951 QMetaType::QMetaType(const QMetaType &other) -

1952 : m_creator(other.m_creator) -

1953 , m_deleter(other.m_deleter) -

1954 , m_saveOp(other.m_saveOp) -

1955 , m_loadOp(other.m_loadOp) -

1956 , m_constructor(other.m_constructor) -

1957 , m_destructor(other.m_destructor) -

1958 , m_extension(other.m_extension) // space reserved for future use -

1959 , m_size(other.m_size) -

1960 , m_typeFlags(other.m_typeFlags) -

1961 , m_extensionFlags(other.m_extensionFlags) -

1962 , m_typeId(other.m_typeId) -

1963 , m_metaObject(other.m_metaObject) -

1964

m_creator = other.m_creator;

never executed: }

1965 -

1966 QMetaType &QMetaType::operator =(const QMetaType &other) -

1967 { -

1968

executed (the execution status of this line is deduced): m_creator = other.m_creator;

1969

m_deleter = other.m_deleter;

executed (the execution status of this line is deduced): m_deleter = other.m_deleter;

1970

m_saveOp = other.m_saveOp;

executed (the execution status of this line is deduced): m_saveOp = other.m_saveOp;

1971

m_loadOp = other.m_loadOp;

executed (the execution status of this line is deduced): m_loadOp = other.m_loadOp;

1972

m_constructor = other.m_constructor;

executed (the execution status of this line is deduced): m_constructor = other.m_constructor;

1973

m_destructor = other.m_destructor;

executed (the execution status of this line is deduced): m_destructor = other.m_destructor;

1974

m_size = other.m_size;

executed (the execution status of this line is deduced): m_size = other.m_size;

1975

m_typeFlags = other.m_typeFlags;

executed (the execution status of this line is deduced): m_typeFlags = other.m_typeFlags;

1976

m_extensionFlags = other.m_extensionFlags;

executed (the execution status of this line is deduced): m_extensionFlags = other.m_extensionFlags;

1977

m_extension = other.m_extension; // space reserved for future use

executed (the execution status of this line is deduced): m_extension = other.m_extension;

1978

m_typeId = other.m_typeId;

executed (the execution status of this line is deduced): m_typeId = other.m_typeId;

1979

m_metaObject = other.m_metaObject;

executed (the execution status of this line is deduced): m_metaObject = other.m_metaObject;

1980

return *this;

executed: return *this;

Execution Count:45057

45057

1981 } -

1982 -

1983 /*! -

1984 \fn void QMetaType::ctor(const QMetaTypeInterface *info) -

1985 \internal -

1986 -

1987 Method used for future binary compatible extensions. The function may be -

1988 called from within QMetaType's constructor to force a library call from -

1989 inlined code. -

1990 */ -

1991 void QMetaType::ctor(const QMetaTypeInterface *info) -

1992 { -

1993 // Special case for Void type, the type is valid but not constructible. -

1994 // In future we may consider to remove this assert and extend this function to initialize -

1995 // differently m_extensionFlags for different types. Currently it is not needed. -

1996

Q_ASSERT(m_typeId == QMetaType::Void);

executed (the execution status of this line is deduced): qt_noop();

1997

Q_UNUSED(info);

executed (the execution status of this line is deduced): (void)info;;

1998

m_extensionFlags = CreateEx | DestroyEx | ConstructEx | DestructEx;

executed (the execution status of this line is deduced): m_extensionFlags = CreateEx | DestroyEx | ConstructEx | DestructEx;

1999

executed: }

Execution Count:2

2000 -

2001 /*! -

2002 \fn void QMetaType::dtor() -

2003 \internal -

2004 -

2005 Method used for future binary compatible extensions. The function may be -

2006 called from within QMetaType's destructor to force a library call from -

2007 inlined code. -

2008 */ -

2009 void QMetaType::dtor() -

2010 {} -

2011 -

2012 /*! -

2013 \fn void *QMetaType::createExtended(const void *copy) const -

2014 \internal -

2015 -

2016 Method used for future binary compatible extensions. The function may be called -

2017 during QMetaType::create to force library call from inlined code. -

2018 */ -

2019 void *QMetaType::createExtended(const void *copy) const -

2020 { -

2021

Q_UNUSED(copy);

never executed (the execution status of this line is deduced): (void)copy;;

2022

never executed: return 0;

2023 } -

2024 -

2025 /*! -

2026 \fn void QMetaType::destroyExtended(void *data) const -

2027 \internal -

2028 -

2029 Method used for future binary compatible extensions. The function may be called -

2030 during QMetaType::destroy to force library call from inlined code. -

2031 */ -

2032 void QMetaType::destroyExtended(void *data) const -

2033 { -

2034

Q_UNUSED(data);

never executed (the execution status of this line is deduced): (void)data;;

2035

never executed: }

2036 -

2037 /*! -

2038 \fn void *QMetaType::constructExtended(void *where, const void *copy) const -

2039 \internal -

2040 -

2041 Method used for future binary compatible extensions. The function may be called -

2042 during QMetaType::construct to force library call from inlined code. -

2043 */ -

2044 void *QMetaType::constructExtended(void *where, const void *copy) const -

2045 { -

2046

Q_UNUSED(where);

never executed (the execution status of this line is deduced): (void)where;;

2047

Q_UNUSED(copy);

never executed (the execution status of this line is deduced): (void)copy;;

2048

never executed: return 0;

2049 } -

2050 -

2051 /*! -

2052 \fn void QMetaType::destructExtended(void *data) const -

2053 \internal -

2054 -

2055 Method used for future binary compatible extensions. The function may be called -

2056 during QMetaType::destruct to force library call from inlined code. -

2057 */ -

2058 void QMetaType::destructExtended(void *data) const -

2059 { -

2060

Q_UNUSED(data);

never executed (the execution status of this line is deduced): (void)data;;

2061

never executed: }

2062 -

2063 /*! -

2064 \fn uint QMetaType::sizeExtended() const -

2065 \internal -

2066 -

2067 Method used for future binary compatible extensions. The function may be -

2068 called from within QMetaType::size to force a library call from -

2069 inlined code. -

2070 */ -

2071 uint QMetaType::sizeExtended() const -

2072 { -

2073

executed: return 0;

Execution Count:22

2074 } -

2075 -

2076 /*! -

2077 \fn QMetaType::TypeFlags QMetaType::flagsExtended() const -

2078 \internal -

2079 -

2080 Method used for future binary compatible extensions. The function may be -

2081 called from within QMetaType::flags to force a library call from -

2082 inlined code. -

2083 */ -

2084 QMetaType::TypeFlags QMetaType::flagsExtended() const -

2085 { -

2086

executed: return 0;

Execution Count:3

2087 } -

2088 -

2089 /*! -

2090 \brief QMetaType::metaObjectExtended -

2091 \internal -

2092 -

2093 Method used for future binary compatible extensions. The function may be -

2094 called from within QMetaType::metaObject to force a library call from -

2095 inlined code. -

2096 */ -

2097 const QMetaObject *QMetaType::metaObjectExtended() const -

2098 { -

2099

if (!qMetaTypeWidgetsHelper)

never executed: return 0;

2100 } -

2101 -

2102 -

2103 namespace QtPrivate -

2104 { -

2105 const QMetaObject *metaObjectForQWidget() -

2106 { -

2107

never evaluated: !qMetaTypeWidgetsHelper

2108