Enable QArrayData to reference external array data

By default, QTypedArrayData::fromRawData provides the same semantics as
already exist in QByteArray and QString (immutable, sharable data), but
more combinations are possible. In particular, immutable-unsharable
leaves the data owner in control of its lifetime by forcing deep copies.

As part of this, a new isMutable property is introduced in QArrayData.
This could be taken to be implicit in statics that are initialized with
a proper size but with alloc set to 0. QStringLiteral and QByteLiteral
already did this, forcing re-allocations on resize even before the
(static, thus shared) ref-count is considered.

The isMutable property detaches data mutability and shared status, which
are orthogonal concepts (at least in the unshared state). For the time
being, there is no API to explicitly (re)set mutability, but statics and
RawData mark data immutable.

Change-Id: I33a995a35e1c3d7a12391b1d7c36095aa28e221a
Reviewed-by: Robin Burchell <robin+qt@viroteck.net>
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>

2 files changed, 57 insertions, 0 deletions

diff --git a/tests/auto/corelib/tools/qarraydata/simplevector.h b/tests/auto/corelib/tools/qarraydata/simplevector.h
index a1eb2dac48..3fa7905a39 100644
--- a/tests/auto/corelib/tools/qarraydata/simplevector.h
+++ b/tests/auto/corelib/tools/qarraydata/simplevector.h
@@ -274,6 +274,12 @@ public:
         d.detach();
     }
 
+    static SimpleVector fromRawData(const T *data, size_t size,
+            QArrayData::AllocateOptions options = Data::Default)
+    {
+        return SimpleVector(Data::fromRawData(data, size, options));
+    }
+
 private:
     QArrayDataPointer<T> d;
 };
diff --git a/tests/auto/corelib/tools/qarraydata/tst_qarraydata.cpp b/tests/auto/corelib/tools/qarraydata/tst_qarraydata.cpp
index 90c865c9e7..4dba02cc70 100644
--- a/tests/auto/corelib/tools/qarraydata/tst_qarraydata.cpp
+++ b/tests/auto/corelib/tools/qarraydata/tst_qarraydata.cpp
@@ -81,6 +81,7 @@ private slots:
     void arrayOps();
     void setSharable_data();
     void setSharable();
+    void fromRawData();
 };
 
 template <class T> const T &const_(const T &t) { return t; }
@@ -1131,5 +1132,55 @@ void tst_QArrayData::setSharable()
     QVERIFY(array->ref.isSharable());
 }
 
+void tst_QArrayData::fromRawData()
+{
+    static const int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
+
+    {
+        // Default: Immutable, sharable
+        SimpleVector<int> raw = SimpleVector<int>::fromRawData(array,
+                sizeof(array)/sizeof(array[0]), QArrayData::Default);
+
+        QCOMPARE(raw.size(), size_t(11));
+        QCOMPARE(raw.constBegin(), array);
+        QCOMPARE(raw.constEnd(), array + sizeof(array)/sizeof(array[0]));
+
+        QVERIFY(!raw.isShared());
+        QVERIFY(SimpleVector<int>(raw).isSharedWith(raw));
+        QVERIFY(!raw.isShared());
+
+        // Detach
+        QCOMPARE(raw.back(), 11);
+        QVERIFY(raw.constBegin() != array);
+    }
+
+    {
+        // Immutable, unsharable
+        SimpleVector<int> raw = SimpleVector<int>::fromRawData(array,
+                sizeof(array)/sizeof(array[0]), QArrayData::Unsharable);
+
+        QCOMPARE(raw.size(), size_t(11));
+        QCOMPARE(raw.constBegin(), array);
+        QCOMPARE(raw.constEnd(), array + sizeof(array)/sizeof(array[0]));
+
+        SimpleVector<int> copy(raw);
+        QVERIFY(!copy.isSharedWith(raw));
+        QVERIFY(!raw.isShared());
+
+        QCOMPARE(copy.size(), size_t(11));
+
+        for (size_t i = 0; i < 11; ++i)
+            QCOMPARE(const_(copy)[i], const_(raw)[i]);
+
+        QCOMPARE(raw.size(), size_t(11));
+        QCOMPARE(raw.constBegin(), array);
+        QCOMPARE(raw.constEnd(), array + sizeof(array)/sizeof(array[0]));
+
+        // Detach
+        QCOMPARE(raw.back(), 11);
+        QVERIFY(raw.constBegin() != array);
+    }
+}
+
 QTEST_APPLESS_MAIN(tst_QArrayData)
 #include "tst_qarraydata.moc"