1berry/qtbase
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

QMetaType: use modern comparisons

Browse Source 
Internal QPropertyBindingPrivatePtr, QArgumentType classes
also have been updated;

Replace class operators operator==(), operator!=() of
QRegularExpression to friend method comparesEqual() and
Q_DECLARE_EQUALITY_COMPARABLE macro.

Task-number: QTBUG-120304
Change-Id: I010617cbcb8bd6afb7c21ee4345398648821f72c
Reviewed-by: Ivan Solovev <ivan.solovev@qt.io>
This commit is contained in:
Tatiana Borisova 2024-04-30 15:27:02 +02:00
parent ced943e936
commit 5a0faa9198
7 changed files with 54 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
src/corelib/kernel/qmetaobject_p.h
View File

@ -111,22 +111,18 @@ public:
const_cast<QArgumentType *>(this)->_name = QMetaType(_type).name();
return _name;
}
bool operator==(const QArgumentType &other) const
{
if (_type && other._type)
return _type == other._type;
else
return name() == other.name();
}
bool operator!=(const QArgumentType &other) const
{
if (_type && other._type)
return _type != other._type;
else
return name() != other.name();
}
private:
friend bool comparesEqual(const QArgumentType &lhs,
const QArgumentType &rhs) noexcept
{
if (lhs._type && rhs._type)
return lhs._type == rhs._type;
else
return lhs.name() == rhs.name();
}
Q_DECLARE_EQUALITY_COMPARABLE(QArgumentType)
int _type;
QByteArray _name;
};

13
src/corelib/kernel/qmetatype.cpp
View File

@ -474,6 +474,7 @@ const char *QtMetaTypePrivate::typedefNameForType(const QtPrivate::QMetaTypeInte
\ingroup objectmodel
\threadsafe
\compares equality
The class is used as a helper to marshall types in QVariant and
in queued signals and slots connections. It associates a type
@ -925,20 +926,20 @@ void QMetaType::unregisterMetaType(QMetaType type)
Returns the QMetaType corresponding to the type in the template parameter.
*/
/*! \fn bool QMetaType::operator==(QMetaType a, QMetaType b)
/*! \fn bool QMetaType::operator==(const QMetaType &lhs, const QMetaType &rhs)
\since 5.15
\overload
Returns \c true if the QMetaType \a a represents the same type
as the QMetaType \a b, otherwise returns \c false.
Returns \c true if the QMetaType \a lhs represents the same type
as the QMetaType \a rhs, otherwise returns \c false.
*/
/*! \fn bool QMetaType::operator!=(QMetaType a, QMetaType b)
/*! \fn bool QMetaType::operator!=(const QMetaType &lhs, const QMetaType &rhs)
\since 5.15
\overload
Returns \c true if the QMetaType \a a represents a different type
than the QMetaType \a b, otherwise returns \c false.
Returns \c true if the QMetaType \a lhs represents a different type
than the QMetaType \a rhs, otherwise returns \c false.
*/
/*! \internal */

16
src/corelib/kernel/qmetatype.h
View File

@ -518,20 +518,20 @@ public:
template<typename T>
constexpr static QMetaType fromType();
static QMetaType fromName(QByteArrayView name);
friend bool operator==(QMetaType a, QMetaType b)
private:
friend bool comparesEqual(const QMetaType &lhs,
const QMetaType &rhs) noexcept
{
if (a.d_ptr == b.d_ptr)
if (lhs.d_ptr == rhs.d_ptr)
return true;
if (!a.d_ptr || !b.d_ptr)
if (!lhs.d_ptr || !rhs.d_ptr)
return false; // one type is undefined, the other is defined
// avoid id call if we already have the id
const int aId = a.id();
const int bId = b.id();
const int aId = lhs.id();
const int bId = rhs.id();
return aId == bId;
}
friend bool operator!=(QMetaType a, QMetaType b) { return !(a == b); }
Q_DECLARE_EQUALITY_COMPARABLE(QMetaType)
#ifndef QT_NO_DEBUG_STREAM
private:
friend Q_CORE_EXPORT QDebug operator<<(QDebug d, QMetaType m);

34
src/corelib/kernel/qpropertyprivate.h
View File

@ -95,28 +95,20 @@ public:
void swap(QPropertyBindingPrivatePtr &other) noexcept
{ qt_ptr_swap(d, other.d); }
friend bool operator==(const QPropertyBindingPrivatePtr &p1, const QPropertyBindingPrivatePtr &p2) noexcept
{ return p1.d == p2.d; }
friend bool operator!=(const QPropertyBindingPrivatePtr &p1, const QPropertyBindingPrivatePtr &p2) noexcept
{ return p1.d != p2.d; }
friend bool operator==(const QPropertyBindingPrivatePtr &p1, const T *ptr) noexcept
{ return p1.d == ptr; }
friend bool operator!=(const QPropertyBindingPrivatePtr &p1, const T *ptr) noexcept
{ return p1.d != ptr; }
friend bool operator==(const T *ptr, const QPropertyBindingPrivatePtr &p2) noexcept
{ return ptr == p2.d; }
friend bool operator!=(const T *ptr, const QPropertyBindingPrivatePtr &p2) noexcept
{ return ptr != p2.d; }
friend bool operator==(const QPropertyBindingPrivatePtr &p1, std::nullptr_t) noexcept
{ return !p1; }
friend bool operator!=(const QPropertyBindingPrivatePtr &p1, std::nullptr_t) noexcept
{ return p1; }
friend bool operator==(std::nullptr_t, const QPropertyBindingPrivatePtr &p2) noexcept
{ return !p2; }
friend bool operator!=(std::nullptr_t, const QPropertyBindingPrivatePtr &p2) noexcept
{ return p2; }
private:
friend bool comparesEqual(const QPropertyBindingPrivatePtr &lhs,
const QPropertyBindingPrivatePtr &rhs) noexcept
{ return lhs.d == rhs.d; }
Q_DECLARE_EQUALITY_COMPARABLE(QPropertyBindingPrivatePtr)
friend bool comparesEqual(const QPropertyBindingPrivatePtr &lhs,
const T *rhs) noexcept
{ return lhs.d == rhs; }
Q_DECLARE_EQUALITY_COMPARABLE(QPropertyBindingPrivatePtr, T*)
friend bool comparesEqual(const QPropertyBindingPrivatePtr &lhs,
std::nullptr_t) noexcept
{ return !lhs; }
Q_DECLARE_EQUALITY_COMPARABLE(QPropertyBindingPrivatePtr, std::nullptr_t)
QtPrivate::RefCounted *d;
};

1
tests/auto/corelib/kernel/qmetatype/CMakeLists.txt
View File

@ -51,6 +51,7 @@ qt_internal_add_test(tst_qmetatype
../../../other/qvariant_common
LIBRARIES
Qt::CorePrivate
Qt::TestPrivate
Qt::Gui
qmetatype_lib1
qmetatype_lib2

1
tests/auto/corelib/kernel/qmetatype/tst_qmetatype.h
View File

@ -111,6 +111,7 @@ private slots:
void customDebugStream();
void unknownType();
void fromType();
void compareCompiles();
void operatorEq_data();
void operatorEq();
void operatorEq2_data();

25
tests/auto/corelib/kernel/qmetatype/tst_qmetatype2.cpp
View File

@ -5,6 +5,7 @@
#include "tst_qmetatype_libs.h"
#include <QtCore/private/qmetaobjectbuilder_p.h>
#include <QtTest/private/qcomparisontesthelper_p.h>
void tst_QMetaType::constRefs()
{
@ -418,6 +419,11 @@ struct CharTemplate
} y;
};
void tst_QMetaType::compareCompiles()
{
QTestPrivate::testEqualityOperatorsCompile<QMetaType>();
}
void tst_QMetaType::operatorEq_data()
{
QTest::addColumn<QMetaType>("typeA");
@ -447,10 +453,7 @@ void tst_QMetaType::operatorEq()
QFETCH(QMetaType, typeB);
QFETCH(bool, eq);
QCOMPARE(typeA == typeB, eq);
QCOMPARE(typeB == typeA, eq);
QCOMPARE(typeA != typeB, !eq);
QCOMPARE(typeB != typeA, !eq);
QT_TEST_EQUALITY_OPS(typeA, typeB, eq);
#if !defined(Q_OS_WIN) && !defined(Q_OS_INTEGRITY)
// for built-in types or locally-defined types, this must also hold true
@ -487,10 +490,10 @@ FOR_EACH_CORE_METATYPE(GET_METATYPE_FROM_TYPE)
QCOMPARE(fromId2.id(), type);
// confirm that they're all equal
QCOMPARE(fromId1, fromId2);
QCOMPARE(fromType1, fromType2);
QCOMPARE(fromType1, fromId1);
QCOMPARE(fromType2, fromId2);
QT_TEST_EQUALITY_OPS(fromId1, fromId2, true);
QT_TEST_EQUALITY_OPS(fromType1, fromType2, true);
QT_TEST_EQUALITY_OPS(fromType1, fromId1, true);
QT_TEST_EQUALITY_OPS(fromType2, fromId2, true);
#if !defined(Q_OS_WIN) && !defined(Q_OS_INTEGRITY)
// for built-in types (other than void), this must be true
@ -541,7 +544,7 @@ void tst_QMetaType::operatorEqAcrossLibs()
// DO THIS FIRST:
// if this isn't a built-in type, then the QMetaTypeInterface::typeId is
// initially set to 0
QCOMPARE(lib1Type, lib2Type);
QT_TEST_EQUALITY_OPS(lib1Type, lib2Type, true);
int actualTypeId = localType.id();
bool builtinTypeExpected = builtinTypeId != QMetaType::UnknownType;
@ -559,8 +562,8 @@ void tst_QMetaType::operatorEqAcrossLibs()
QCOMPARE(lib2Type.id(), actualTypeId);
QCOMPARE(QByteArray(lib1Type.name()), QByteArray(localType.name()));
QCOMPARE(QByteArray(lib2Type.name()), QByteArray(localType.name()));
QCOMPARE(lib1Type, localType);
QCOMPARE(lib2Type, localType);
QT_TEST_EQUALITY_OPS(lib1Type, localType, true);
QT_TEST_EQUALITY_OPS(lib2Type, localType, true);
#if !defined(Q_OS_WIN) && !defined(Q_OS_INTEGRITY)
if (actualTypeId < QMetaType::FirstGuiType && actualTypeId != QMetaType::Void) {