From 53fde3c573737592a02c5e15ad4fe253ac3304a4 Mon Sep 17 00:00:00 2001
From: Ulf Hermann <ulf.hermann@qt.io>
Date: Tue, 25 Aug 2020 17:41:42 +0200
Subject: Reimplement QSequentialIterable using QMetaSequence

Change-Id: Ie721a5f0caa697c4bf15a81f3762cf79d3c54f5a
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
---
 .../corelib/kernel/qmetatype/tst_qmetatype.cpp     |  5 ++
 .../auto/corelib/kernel/qvariant/tst_qvariant.cpp  | 78 +++++++++++++---------
 2 files changed, 50 insertions(+), 33 deletions(-)

(limited to 'tests/auto/corelib')

diff --git a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp
index ba8c42f22f..05fffd928a 100644
--- a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp
+++ b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp
@@ -1000,6 +1000,11 @@ void tst_QMetaType::alignOf()
 }
 
 struct CustomMovable { CustomMovable() {} };
+
+// needed for QSet<CustomMovable>. We actually check that it makes sense.
+bool operator==(const CustomMovable &, const CustomMovable &) { return true; }
+qsizetype qHash(const CustomMovable &, qsizetype seed = 0) { return seed; }
+
 #if !defined(Q_CC_CLANG) && defined(Q_CC_GNU) && Q_CC_GNU < 501
 QT_BEGIN_NAMESPACE
 Q_DECLARE_TYPEINFO(CustomMovable, Q_MOVABLE_TYPE);
diff --git a/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp b/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp
index 8796589df3..75a72f0c92 100644
--- a/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp
+++ b/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp
@@ -4528,28 +4528,37 @@ void tst_QVariant::shouldDeleteVariantDataWorksForSequential()
 {
     QCOMPARE(instanceCount, 0);
     {
-        QtMetaTypePrivate::QSequentialIterableImpl iterator {};
-        iterator._iteratorCapabilities = QtMetaTypePrivate::RandomAccessCapability |
-                                         QtMetaTypePrivate::BiDirectionalCapability |
-                                         QtMetaTypePrivate::ForwardCapability;
-
-        iterator._size = [](const void *) {return 1;};
-        iterator._metaType = QMetaType::fromType<MyType>();
-        iterator._moveTo = [](const void *, void **, QtMetaTypePrivate::QSequentialIterableImpl::Position) {};
-        iterator._append = [](const void *, const void *) {};
-        iterator._advance = [](void **, int) {};
-        iterator._destroyIter = [](void **){};
-        iterator._equalIter = [](void * const *, void * const *){return true; /*all iterators are nullptr*/};
-        iterator._destroyIter = [](void **){};
-        iterator._at = [](const void *, int, void *dataPtr) -> void {
+        QtMetaContainerPrivate::QMetaSequenceInterface metaSequence {};
+        metaSequence.iteratorCapabilities = QtMetaContainerPrivate::RandomAccessCapability
+                | QtMetaContainerPrivate::BiDirectionalCapability
+                | QtMetaContainerPrivate::ForwardCapability;
+
+        metaSequence.sizeFn = [](const void *) { return qsizetype(1); };
+        metaSequence.createConstIteratorFn =
+                [](const void *, QtMetaContainerPrivate::QMetaSequenceInterface::Position) -> void* {
+            return nullptr;
+        };
+        metaSequence.addElementFn = [](void *, const void *) {};
+        metaSequence.advanceConstIteratorFn = [](void *, qsizetype) {};
+        metaSequence.destroyConstIteratorFn = [](const void *){};
+        metaSequence.compareConstIteratorFn = [](const void *, const void *) {
+            return true; // all iterators are nullptr
+        };
+        metaSequence.copyConstIteratorFn = [](void *, const void *){};
+        metaSequence.diffConstIteratorFn = [](const void *, const void *) -> qsizetype  {
+            return 0;
+        };
+        metaSequence.elementAtIndexFn = [](const void *, qsizetype, void *dataPtr) -> void {
             MyType mytype {1, "eins"};
             *static_cast<MyType *>(dataPtr) = mytype;
         };
-        iterator._get = [](void * const *, void *dataPtr) -> void {
+        metaSequence.elementAtConstIteratorFn = [](const void *, void *dataPtr) -> void {
             MyType mytype {2, "zwei"};
             *static_cast<MyType *>(dataPtr) = mytype;
         };
-        QSequentialIterable iterable {iterator};
+        metaSequence.valueMetaType = QMetaType::fromType<MyType>();
+
+        QSequentialIterable iterable(QMetaSequence(&metaSequence), nullptr);
         QVariant value1 = iterable.at(0);
         QVERIFY(value1.canConvert<MyType>());
         QCOMPARE(value1.value<MyType>().number, 1);
@@ -4669,12 +4678,13 @@ void tst_QVariant::qt4UuidDataStream()
 
 void tst_QVariant::sequentialIterableEndianessSanityCheck()
 {
-    namespace QMTP = QtMetaTypePrivate;
-    uint oldIteratorCaps = QMTP::ForwardCapability | QMTP::BiDirectionalCapability | QMTP::RandomAccessCapability;
-    QMTP::QSequentialIterableImpl seqImpl {};
-    QCOMPARE(seqImpl.revision(), 0u);
-    memcpy(&seqImpl._iteratorCapabilities, &oldIteratorCaps, sizeof(oldIteratorCaps));
-    QCOMPARE(seqImpl.revision(), 0u);
+    namespace QMTP = QtMetaContainerPrivate;
+    QMTP::IteratorCapabilities oldIteratorCaps
+            = QMTP::ForwardCapability | QMTP::BiDirectionalCapability | QMTP::RandomAccessCapability;
+    QMTP::QMetaSequenceInterface seqImpl {};
+    QCOMPARE(seqImpl.revision, 0u);
+    memcpy(&seqImpl.iteratorCapabilities, &oldIteratorCaps, sizeof(oldIteratorCaps));
+    QCOMPARE(seqImpl.revision, 0u);
 }
 
 void tst_QVariant::sequentialIterableAppend()
@@ -4682,22 +4692,24 @@ void tst_QVariant::sequentialIterableAppend()
     {
         QList<int> container { 1, 2 };
         auto variant = QVariant::fromValue(container);
-        QVERIFY(variant.canConvert<QtMetaTypePrivate::QSequentialIterableImpl>());
-        auto asIterable = variant.value<QtMetaTypePrivate::QSequentialIterableImpl>();
+        QVERIFY(variant.canConvert<QSequentialIterable>());
+        auto asIterable = variant.value<QSequentialIterable>();
         const int i = 3, j = 4;
-        asIterable.append(&i);
-        asIterable.append(&j);
+        void *mutableIterable = const_cast<void *>(asIterable.constIterable());
+        asIterable.metaSequence().addElement(mutableIterable, &i);
+        asIterable.metaSequence().addElement(mutableIterable, &j);
         QCOMPARE(variant.value<QList<int>>(), QList<int> ({ 1, 2, 3, 4 }));
     }
     {
         QSet<QByteArray> container { QByteArray{"hello"}, QByteArray{"world"} };
         auto variant = QVariant::fromValue(std::move(container));
-        QVERIFY(variant.canConvert<QtMetaTypePrivate::QSequentialIterableImpl>());
-        auto asIterable = variant.value<QtMetaTypePrivate::QSequentialIterableImpl>();
+        QVERIFY(variant.canConvert<QSequentialIterable>());
+        auto asIterable = variant.value<QSequentialIterable>();
         QByteArray qba1 {"goodbye"};
         QByteArray qba2 { "moon" };
-        asIterable.append( &qba1 );
-        asIterable.append( &qba2);
+        void *mutableIterable = const_cast<void *>(asIterable.constIterable());
+        asIterable.metaSequence().addElement(mutableIterable, &qba1);
+        asIterable.metaSequence().addElement(mutableIterable, &qba2);
         QSet<QByteArray> reference { "hello", "world", "goodbye", "moon" };
         QCOMPARE(variant.value<QSet<QByteArray>>(), reference);
     }
@@ -4707,8 +4719,8 @@ void tst_QVariant::preferDirectConversionOverInterfaces()
 {
     using namespace QtMetaTypePrivate;
     bool calledCorrectConverter = false;
-    QMetaType::registerConverter<MyType, QSequentialIterableImpl>([](const MyType &) {
-        return QSequentialIterableImpl {};
+    QMetaType::registerConverter<MyType, QSequentialIterable>([](const MyType &) {
+        return QSequentialIterable {};
     });
     QMetaType::registerConverter<MyType, QVariantList>([&calledCorrectConverter](const MyType &) {
         calledCorrectConverter = true;
@@ -4727,7 +4739,7 @@ void tst_QVariant::preferDirectConversionOverInterfaces()
     });
     auto holder = QVariant::fromValue(MyType {});
 
-    QVERIFY(holder.canConvert<QSequentialIterableImpl>());
+    QVERIFY(holder.canConvert<QSequentialIterable>());
     QVERIFY(holder.canConvert<QVariantList>());
     QVERIFY(holder.canConvert<QAssociativeIterableImpl>());
     QVERIFY(holder.canConvert<QVariantHash>());
-- 
cgit v1.2.3