Various cleanups in qarraydataops and qarraydatapointer

Various cleanups. Add copyAppend overload for forward iterators and a
insert overload for inserting n elements.

Change-Id: Ic41cd20818b8307e957948d04ef6379368defa55
Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>

1 files changed, 53 insertions, 56 deletions

diff --git a/src/corelib/tools/qarraydatapointer.h b/src/corelib/tools/qarraydatapointer.h
index c52b84f4ce..9103064bd9 100644
--- a/src/corelib/tools/qarraydatapointer.h
+++ b/src/corelib/tools/qarraydatapointer.h
@@ -41,6 +41,7 @@
 #define QARRAYDATAPOINTER_H
 
 #include <QtCore/qarraydataops.h>
+#include <QtCore/qcontainertools_impl.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -56,38 +57,33 @@ public:
     typedef typename Data::const_iterator const_iterator;
 
     QArrayDataPointer() noexcept
-        : d(Data::sharedNull()), b(Data::sharedNullData()), size(0)
+        : d(Data::sharedNull()), ptr(Data::sharedNullData()), size(0)
     {
     }
 
-    QArrayDataPointer(const QArrayDataPointer &other)
-        : d(other.d), b(other.b), size(other.size)
+    QArrayDataPointer(const QArrayDataPointer &other) noexcept
+        : d(other.d), ptr(other.ptr), size(other.size)
     {
-        if (!other.d->ref()) {
-            // must clone
-            QPair<Data *, T *> pair = other.clone(other.d->cloneFlags());
-            d = pair.first;
-            b = pair.second;
-        }
+        other.d->ref();
     }
 
-    QArrayDataPointer(Data *header, T *data, size_t n = 0)
-        : d(header), b(data), size(n)
+    QArrayDataPointer(Data *header, T *adata, size_t n = 0) noexcept
+        : d(header), ptr(adata), size(n)
     {
     }
 
-    explicit QArrayDataPointer(QPair<QTypedArrayData<T> *, T *> data, size_t n = 0)
-        : d(data.first), b(data.second), size(n)
+    explicit QArrayDataPointer(QPair<QTypedArrayData<T> *, T *> adata, size_t n = 0)
+        : d(adata.first), ptr(adata.second), size(n)
     {
         Q_CHECK_PTR(d);
     }
 
-    QArrayDataPointer(QArrayDataPointerRef<T> ref)
-        : d(ref.ptr), b(ref.data), size(ref.size)
+    QArrayDataPointer(QArrayDataPointerRef<T> dd) noexcept
+        : d(dd.ptr), ptr(dd.data), size(dd.size)
     {
     }
 
-    QArrayDataPointer &operator=(const QArrayDataPointer &other)
+    QArrayDataPointer &operator=(const QArrayDataPointer &other) noexcept
     {
         QArrayDataPointer tmp(other);
         this->swap(tmp);
@@ -95,9 +91,11 @@ public:
     }
 
     QArrayDataPointer(QArrayDataPointer &&other) noexcept
-        : d(other.d), b(other.b), size(other.size)
+        : d(other.d), ptr(other.ptr), size(other.size)
     {
         other.d = Data::sharedNull();
+        other.ptr = Data::sharedNullData();
+        other.size = 0;
     }
 
     QArrayDataPointer &operator=(QArrayDataPointer &&other) noexcept
@@ -107,25 +105,25 @@ public:
         return *this;
     }
 
-    DataOps &operator*()
+    DataOps &operator*() noexcept
     {
         Q_ASSERT(d);
         return *static_cast<DataOps *>(this);
     }
 
-    DataOps *operator->()
+    DataOps *operator->() noexcept
     {
         Q_ASSERT(d);
         return static_cast<DataOps *>(this);
     }
 
-    const DataOps &operator*() const
+    const DataOps &operator*() const noexcept
     {
         Q_ASSERT(d);
         return *static_cast<const DataOps *>(this);
     }
 
-    const DataOps *operator->() const
+    const DataOps *operator->() const noexcept
     {
         Q_ASSERT(d);
         return static_cast<const DataOps *>(this);
@@ -140,43 +138,41 @@ public:
         }
     }
 
-    bool isNull() const
+    bool isNull() const noexcept
     {
         return d == Data::sharedNull();
     }
 
-    T *data() { return b; }
-    const T *data() const { return b; }
+    T *data() noexcept { return ptr; }
+    const T *data() const noexcept { return ptr; }
 
-    iterator begin() { return data(); }
-    iterator end() { return data() + size; }
-    const_iterator begin() const { return data(); }
-    const_iterator end() const { return data() + size; }
-    const_iterator constBegin() const { return data(); }
-    const_iterator constEnd() const { return data() + size; }
+    iterator begin(iterator = iterator()) noexcept { return data(); }
+    iterator end(iterator = iterator()) noexcept { return data() + size; }
+    const_iterator begin(const_iterator = const_iterator()) const noexcept { return data(); }
+    const_iterator end(const_iterator = const_iterator()) const noexcept { return data() + size; }
+    const_iterator constBegin(const_iterator = const_iterator()) const noexcept { return data(); }
+    const_iterator constEnd(const_iterator = const_iterator()) const noexcept { return data() + size; }
 
     void swap(QArrayDataPointer &other) noexcept
     {
         qSwap(d, other.d);
-        qSwap(b, other.b);
+        qSwap(ptr, other.ptr);
         qSwap(size, other.size);
     }
 
-    void clear()
+    void clear() Q_DECL_NOEXCEPT_EXPR(std::is_nothrow_destructible<T>::value)
     {
-        QArrayDataPointer tmp(d, b, size);
-        d = Data::sharedNull();
-        b = reinterpret_cast<T *>(d);
-        size = 0;
+        QArrayDataPointer tmp;
+        swap(tmp);
     }
 
     bool detach()
     {
         if (d->needsDetach()) {
             QPair<Data *, T *> copy = clone(d->detachFlags());
-            QArrayDataPointer old(d, b, size);
+            QArrayDataPointer old(d, ptr, size);
             d = copy.first;
-            b = copy.second;
+            ptr = copy.second;
             return true;
         }
 
@@ -184,20 +180,20 @@ public:
     }
 
     // forwards from QArrayData
-    int allocatedCapacity() { return d->allocatedCapacity(); }
-    int constAllocatedCapacity() const { return d->constAllocatedCapacity(); }
-    int refCounterValue() const { return d->refCounterValue(); }
-    bool ref() { return d->ref(); }
-    bool deref() { return d->deref(); }
-    bool isMutable() const { return d->isMutable(); }
-    bool isStatic() const { return d->isStatic(); }
-    bool isShared() const { return d->isShared(); }
-    bool needsDetach() const { return d->needsDetach(); }
-    size_t detachCapacity(size_t newSize) const { return d->detachCapacity(newSize); }
-    typename Data::ArrayOptions &flags() { return reinterpret_cast<typename Data::ArrayOptions &>(d->flags); }
-    typename Data::ArrayOptions flags() const { return typename Data::ArrayOption(d->flags); }
-    typename Data::ArrayOptions detachFlags() const { return d->detachFlags(); }
-    typename Data::ArrayOptions cloneFlags() const { return d->cloneFlags(); }
+    size_t allocatedCapacity() noexcept { return d->allocatedCapacity(); }
+    size_t constAllocatedCapacity() const noexcept { return d->constAllocatedCapacity(); }
+    int refCounterValue() const noexcept { return d->refCounterValue(); }
+    bool ref() noexcept { return d->ref(); }
+    bool deref() noexcept { return d->deref(); }
+    bool isMutable() const noexcept { return d->isMutable(); }
+    bool isStatic() const noexcept { return d->isStatic(); }
+    bool isShared() const noexcept { return d->isShared(); }
+    bool needsDetach() const noexcept { return d->needsDetach(); }
+    size_t detachCapacity(size_t newSize) const noexcept { return d->detachCapacity(newSize); }
+    typename Data::ArrayOptions &flags() noexcept { return reinterpret_cast<typename Data::ArrayOptions &>(d->flags); }
+    typename Data::ArrayOptions flags() const noexcept { return typename Data::ArrayOption(d->flags); }
+    typename Data::ArrayOptions detachFlags() const noexcept { return d->detachFlags(); }
+    typename Data::ArrayOptions cloneFlags() const noexcept { return d->cloneFlags(); }
 
 private:
     Q_REQUIRED_RESULT QPair<Data *, T *> clone(QArrayData::ArrayOptions options) const
@@ -214,27 +210,28 @@ private:
         return pair;
     }
 
+protected:
     Data *d;
-    T *b;
+    T *ptr;
 
 public:
     uint size;
 };
 
 template <class T>
-inline bool operator==(const QArrayDataPointer<T> &lhs, const QArrayDataPointer<T> &rhs)
+inline bool operator==(const QArrayDataPointer<T> &lhs, const QArrayDataPointer<T> &rhs) noexcept
 {
     return lhs.data() == rhs.data() && lhs.size == rhs.size;
 }
 
 template <class T>
-inline bool operator!=(const QArrayDataPointer<T> &lhs, const QArrayDataPointer<T> &rhs)
+inline bool operator!=(const QArrayDataPointer<T> &lhs, const QArrayDataPointer<T> &rhs) noexcept
 {
     return lhs.data() != rhs.data() || lhs.size != rhs.size;
 }
 
 template <class T>
-inline void swap(QArrayDataPointer<T> &p1, QArrayDataPointer<T> &p2)
+inline void qSwap(QArrayDataPointer<T> &p1, QArrayDataPointer<T> &p2) noexcept
 {
     p1.swap(p2);
 }