Containers: add member-swap

Member-swap is required by the STL Sequence concept, but is also needed to write exception-safe code.

Merge-request: 871
Reviewed-by: Olivier Goffart <olivier.goffart@nokia.com>

24 files changed, 114 insertions, 0 deletions

diff --git a/src/corelib/tools/qbitarray.cpp b/src/corelib/tools/qbitarray.cpp
index 04018ba..a1ad787 100644
--- a/src/corelib/tools/qbitarray.cpp
+++ b/src/corelib/tools/qbitarray.cpp
@@ -418,6 +418,13 @@ void QBitArray::fill(bool value, int begin, int end)
     this bit array.
 */
 
+/*! \fn void QBitArray::swap(QBitArray &other)
+    \since 4.8
+
+    Swaps bit array \a other with this bit array. This operation is very
+    fast and never fails.
+*/
+
 /*! \fn bool QBitArray::operator==(const QBitArray &other) const
 
     Returns true if \a other is equal to this bit array; otherwise
diff --git a/src/corelib/tools/qbitarray.h b/src/corelib/tools/qbitarray.h
index bd79904..ddda5e7 100644
--- a/src/corelib/tools/qbitarray.h
+++ b/src/corelib/tools/qbitarray.h
@@ -68,6 +68,8 @@ public:
     { qSwap(d, other.d); return *this; }
 #endif
 
+    inline void swap(QBitArray &other) { qSwap(d, other.d); }
+
     inline int size() const { return (d.size() << 3) - *d.constData(); }
     inline int count() const { return (d.size() << 3) - *d.constData(); }
     int count(bool on) const;
diff --git a/src/corelib/tools/qbytearray.cpp b/src/corelib/tools/qbytearray.cpp
index 6ba9fd3..dc2e8e9 100644
--- a/src/corelib/tools/qbytearray.cpp
+++ b/src/corelib/tools/qbytearray.cpp
@@ -904,6 +904,13 @@ QByteArray &QByteArray::operator=(const char *str)
     return *this;
 }
 
+/*! \fn void QByteArray::swap(QByteArray &other)
+    \since 4.8
+
+    Swaps byte array \a other with this byte array. This operation is very
+    fast and never fails.
+*/
+
 /*! \fn int QByteArray::size() const
 
     Returns the number of bytes in this byte array.
diff --git a/src/corelib/tools/qbytearray.h b/src/corelib/tools/qbytearray.h
index 3cdcaab..b625f4c 100644
--- a/src/corelib/tools/qbytearray.h
+++ b/src/corelib/tools/qbytearray.h
@@ -149,6 +149,8 @@ public:
     { qSwap(d, other.d); return *this; }
 #endif
 
+    inline void swap(QByteArray &other) { qSwap(d, other.d); }
+
     inline int size() const;
     bool isEmpty() const;
     void resize(int size);
diff --git a/src/corelib/tools/qcontiguouscache.cpp b/src/corelib/tools/qcontiguouscache.cpp
index 3ba5186..7880bd3 100644
--- a/src/corelib/tools/qcontiguouscache.cpp
+++ b/src/corelib/tools/qcontiguouscache.cpp
@@ -194,6 +194,13 @@ MyRecord record(int row) const
     Assigns \a other to this cache and returns a reference to this cache.
 */
 
+/*! \fn void QContiguousCache::swap(QContiguousCache<T> &other)
+    \since 4.8
+
+    Swaps cache \a other with this cache. This operation is very
+    fast and never fails.
+*/
+
 /*! \fn bool QContiguousCache::operator==(const QContiguousCache<T> &other) const
 
     Returns true if \a other is equal to this cache; otherwise returns false.
diff --git a/src/corelib/tools/qcontiguouscache.h b/src/corelib/tools/qcontiguouscache.h
index 4c1a846..3d0a159 100644
--- a/src/corelib/tools/qcontiguouscache.h
+++ b/src/corelib/tools/qcontiguouscache.h
@@ -114,6 +114,7 @@ public:
     inline QContiguousCache<T> &operator=(QContiguousCache<T> &&other)
     { qSwap(d, other.d); return *this; }
 #endif
+    inline void swap(QContiguousCache<T> &other) { qSwap(d, other.d); }
     bool operator==(const QContiguousCache<T> &other) const;
     inline bool operator!=(const QContiguousCache<T> &other) const { return !(*this == other); }
 
diff --git a/src/corelib/tools/qhash.cpp b/src/corelib/tools/qhash.cpp
index 2971c06..5a8057d 100644
--- a/src/corelib/tools/qhash.cpp
+++ b/src/corelib/tools/qhash.cpp
@@ -730,6 +730,19 @@ void QHashData::checkSanity()
     Assigns \a other to this hash and returns a reference to this hash.
 */
 
+/*! \fn void QHash::swap(QHash<Key, T> &other)
+    \since 4.8
+
+    Swaps hash \a other with this hash. This operation is very
+    fast and never fails.
+*/
+
+/*! \fn void QMultiHash::swap(QMultiHash<Key, T> &other)
+
+    Swaps hash \a other with this hash. This operation is very
+    fast and never fails.
+*/
+
 /*! \fn bool QHash::operator==(const QHash<Key, T> &other) const
 
     Returns true if \a other is equal to this hash; otherwise returns
diff --git a/src/corelib/tools/qhash.h b/src/corelib/tools/qhash.h
index 992ff33..21fca2d 100644
--- a/src/corelib/tools/qhash.h
+++ b/src/corelib/tools/qhash.h
@@ -287,6 +287,7 @@ public:
     inline QHash<Key, T> &operator=(QHash<Key, T> &&other)
     { qSwap(d, other.d); return *this; }
 #endif
+    inline void swap(QHash<Key, T> &other) { qSwap(d, other.d); }
 
     bool operator==(const QHash<Key, T> &other) const;
     inline bool operator!=(const QHash<Key, T> &other) const { return !(*this == other); }
@@ -925,6 +926,7 @@ class QMultiHash : public QHash<Key, T>
 public:
     QMultiHash() {}
     QMultiHash(const QHash<Key, T> &other) : QHash<Key, T>(other) {}
+    inline void swap(QMultiHash<Key, T> &other) { QHash<Key, T>::swap(other); } // prevent QMultiHash<->QHash swaps
 
     inline typename QHash<Key, T>::iterator replace(const Key &key, const T &value)
     { return QHash<Key, T>::insert(key, value); }
diff --git a/src/corelib/tools/qlinkedlist.cpp b/src/corelib/tools/qlinkedlist.cpp
index 7213c6e..7b452fc 100644
--- a/src/corelib/tools/qlinkedlist.cpp
+++ b/src/corelib/tools/qlinkedlist.cpp
@@ -147,6 +147,13 @@ QLinkedListData QLinkedListData::shared_null = {
     list.
 */
 
+/*! \fn void QLinkedList::swap(QLinkedList<T> &other)
+    \since 4.8
+
+    Swaps list \a other with this list. This operation is very
+    fast and never fails.
+*/
+
 /*! \fn bool QLinkedList::operator==(const QLinkedList<T> &other) const
 
     Returns true if \a other is equal to this list; otherwise returns
diff --git a/src/corelib/tools/qlinkedlist.h b/src/corelib/tools/qlinkedlist.h
index c087944..849bfd3 100644
--- a/src/corelib/tools/qlinkedlist.h
+++ b/src/corelib/tools/qlinkedlist.h
@@ -89,6 +89,7 @@ public:
     inline QLinkedList<T> &operator=(QLinkedList<T> &&other)
     { qSwap(d, other.d); return *this; }
 #endif
+    inline void swap(QLinkedList<T> &other) { qSwap(d, other.d); }
     bool operator==(const QLinkedList<T> &l) const;
     inline bool operator!=(const QLinkedList<T> &l) const { return !(*this == l); }
 
diff --git a/src/corelib/tools/qlist.cpp b/src/corelib/tools/qlist.cpp
index 9ba3768..5706171 100644
--- a/src/corelib/tools/qlist.cpp
+++ b/src/corelib/tools/qlist.cpp
@@ -602,6 +602,13 @@ void **QListData::erase(void **xi)
     list.
 */
 
+/*! \fn void QList::swap(QList<T> &other)
+    \since 4.8
+
+    Swaps list \a other with this list. This operation is very
+    fast and never fails.
+*/
+
 /*! \fn bool QList::operator==(const QList<T> &other) const
 
     Returns true if \a other is equal to this list; otherwise returns
diff --git a/src/corelib/tools/qlist.h b/src/corelib/tools/qlist.h
index 8f988d6..b1fcabf 100644
--- a/src/corelib/tools/qlist.h
+++ b/src/corelib/tools/qlist.h
@@ -126,6 +126,7 @@ public:
     inline QList &operator=(QList &&other)
     { qSwap(d, other.d); return *this; }
 #endif
+    inline void swap(QList<T> &other) { qSwap(d, other.d); }
 #ifdef Q_COMPILER_INITIALIZER_LISTS
     inline QList(std::initializer_list<T> args) : d(&QListData::shared_null)
     { d->ref.ref(); qCopy(args.begin(), args.end(), std::back_inserter(*this)); }
diff --git a/src/corelib/tools/qmap.cpp b/src/corelib/tools/qmap.cpp
index 3143ee4..7b814b3 100644
--- a/src/corelib/tools/qmap.cpp
+++ b/src/corelib/tools/qmap.cpp
@@ -404,6 +404,19 @@ void QMapData::dump()
     Assigns \a other to this map and returns a reference to this map.
 */
 
+/*! \fn void QMap::swap(QMap<Key, T> &other)
+    \since 4.8
+
+    Swaps map \a other with this map. This operation is very
+    fast and never fails.
+*/
+
+/*! \fn void QMultiMap::swap(QMultiMap<Key, T> &other)
+
+    Swaps map \a other with this map. This operation is very
+    fast and never fails.
+*/
+
 /*! \fn bool QMap::operator==(const QMap<Key, T> &other) const
 
     Returns true if \a other is equal to this map; otherwise returns
diff --git a/src/corelib/tools/qmap.h b/src/corelib/tools/qmap.h
index ce8fd75..2897529 100644
--- a/src/corelib/tools/qmap.h
+++ b/src/corelib/tools/qmap.h
@@ -189,6 +189,7 @@ public:
     inline QMap<Key, T> &operator=(QMap<Key, T> &&other)
     { qSwap(d, other.d); return *this; }
 #endif
+    inline void swap(QMap<Key, T> &other) { qSwap(d, other.d); }
 #ifndef QT_NO_STL
     explicit QMap(const typename std::map<Key, T> &other);
     std::map<Key, T> toStdMap() const;
@@ -973,6 +974,7 @@ class QMultiMap : public QMap<Key, T>
 public:
     QMultiMap() {}
     QMultiMap(const QMap<Key, T> &other) : QMap<Key, T>(other) {}
+    inline void swap(QMultiMap<Key, T> &other) { QMap<Key, T>::swap(other); }
 
     inline typename QMap<Key, T>::iterator replace(const Key &key, const T &value)
     { return QMap<Key, T>::insert(key, value); }
diff --git a/src/corelib/tools/qqueue.cpp b/src/corelib/tools/qqueue.cpp
index 849bb0b..3602695 100644
--- a/src/corelib/tools/qqueue.cpp
+++ b/src/corelib/tools/qqueue.cpp
@@ -91,6 +91,14 @@
 */
 
 /*!
+    \fn void QQueue::swap(QQueue<T> &other)
+    \since 4.8
+
+    Swaps queue \a other with this queue. This operation is very
+    fast and never fails.
+*/
+
+/*!
     \fn void QQueue::enqueue(const T& t)
 
     Adds value \a t to the tail of the queue.
diff --git a/src/corelib/tools/qqueue.h b/src/corelib/tools/qqueue.h
index c29134b..4ef1a61 100644
--- a/src/corelib/tools/qqueue.h
+++ b/src/corelib/tools/qqueue.h
@@ -56,6 +56,7 @@ class QQueue : public QList<T>
 public:
     inline QQueue() {}
     inline ~QQueue() {}
+    inline void swap(QQueue<T> &other) { QList<T>::swap(other); } // prevent QList<->QQueue swaps
     inline void enqueue(const T &t) { QList<T>::append(t); }
     inline T dequeue() { return QList<T>::takeFirst(); }
     inline T &head() { return QList<T>::first(); }
diff --git a/src/corelib/tools/qset.h b/src/corelib/tools/qset.h
index dc3c45a..472078f 100644
--- a/src/corelib/tools/qset.h
+++ b/src/corelib/tools/qset.h
@@ -65,6 +65,7 @@ public:
     inline QSet<T> &operator=(QSet<T> &&other)
         { qSwap(q_hash, other.q_hash); return *this; }
 #endif
+    inline void swap(QSet<T> &other) { q_hash.swap(other.q_hash); }
 
     inline bool operator==(const QSet<T> &other) const
         { return q_hash == other.q_hash; }
diff --git a/src/corelib/tools/qset.qdoc b/src/corelib/tools/qset.qdoc
index 0bc2d2d..57368f0 100644
--- a/src/corelib/tools/qset.qdoc
+++ b/src/corelib/tools/qset.qdoc
@@ -123,6 +123,13 @@
 */
 
 /*!
+    \fn void QSet::swap(QSet<T> &other)
+
+    Swaps set \a other with this set. This operation is very fast and
+    never fails.
+*/
+
+/*!
     \fn bool QSet::operator==(const QSet<T> &other) const
 
     Returns true if the \a other set is equal to this set; otherwise
diff --git a/src/corelib/tools/qstack.cpp b/src/corelib/tools/qstack.cpp
index fa14900..b42fe3b 100644
--- a/src/corelib/tools/qstack.cpp
+++ b/src/corelib/tools/qstack.cpp
@@ -91,6 +91,14 @@
 */
 
 /*!
+    \fn void QStack::swap(QStack<T> &other)
+    \since 4.8
+
+    Swaps stack \a other with this stack. This operation is very fast and
+    never fails.
+*/
+
+/*!
     \fn void QStack::push(const T& t)
 
     Adds element \a t to the top of the stack.
diff --git a/src/corelib/tools/qstack.h b/src/corelib/tools/qstack.h
index 526c705..6ddc381 100644
--- a/src/corelib/tools/qstack.h
+++ b/src/corelib/tools/qstack.h
@@ -56,6 +56,7 @@ class QStack : public QVector<T>
 public:
     inline QStack() {}
     inline ~QStack() {}
+    inline void swap(QStack<T> &other) { QVector<T>::swap(other); } // prevent QVector<->QStack swaps
     inline void push(const T &t) { QVector<T>::append(t); }
     T pop();
     T &top();
diff --git a/src/corelib/tools/qstring.cpp b/src/corelib/tools/qstring.cpp
index 2737574..a3d89f2 100644
--- a/src/corelib/tools/qstring.cpp
+++ b/src/corelib/tools/qstring.cpp
@@ -1174,6 +1174,13 @@ QString::QString(QChar ch)
 */
 
 
+/*! \fn void QString::swap(QString &other)
+    \since 4.8
+
+    Swaps string \a other with this string. This operation is very fast and
+    never fails.
+*/
+
 /*! \fn void QString::detach()
 
     \internal
diff --git a/src/corelib/tools/qstring.h b/src/corelib/tools/qstring.h
index 589fdc2..07f43ca 100644
--- a/src/corelib/tools/qstring.h
+++ b/src/corelib/tools/qstring.h
@@ -108,6 +108,7 @@ public:
     inline QString &operator=(QString &&other)
     { qSwap(d, other.d); return *this; }
 #endif
+    inline void swap(QString &other) { qSwap(d, other.d); }
     inline int size() const { return d->size; }
     inline int count() const { return d->size; }
     inline int length() const;
diff --git a/src/corelib/tools/qvector.cpp b/src/corelib/tools/qvector.cpp
index 3a13540..0497211 100644
--- a/src/corelib/tools/qvector.cpp
+++ b/src/corelib/tools/qvector.cpp
@@ -285,6 +285,13 @@ int QVectorData::grow(int sizeofTypedData, int size, int sizeofT, bool excessive
     vector.
 */
 
+/*! \fn void QVector::swap(QVector<T> &other)
+    \since 4.8
+
+    Swaps vector \a other with this vector. This operation is very fast and
+    never fails.
+*/
+
 /*! \fn bool QVector::operator==(const QVector<T> &other) const
 
     Returns true if \a other is equal to this vector; otherwise
diff --git a/src/corelib/tools/qvector.h b/src/corelib/tools/qvector.h
index c16aefb..4044a66 100644
--- a/src/corelib/tools/qvector.h
+++ b/src/corelib/tools/qvector.h
@@ -125,6 +125,7 @@ public:
     inline QVector<T> operator=(QVector<T> &&other)
     { qSwap(p, other.p); return *this; }
 #endif
+    inline void swap(QVector<T> &other) { qSwap(d, other.d); }
 #ifdef Q_COMPILER_INITIALIZER_LISTS
     inline QVector(std::initializer_list<T> args);
 #endif