Move the special QByteArrayList methods into QList

and make QByteArrayList be a simple typedef.

As a side-effect, the constructor taking a QByteArray is no longer
available since I couldn't find a way to add it to QList<T> when T is
QByteArray. My template-foo failed me. I tried:

 - QEnableIf<is_same<T, QByteArray>::value, QByteArray>::type
   => makes QList fail to compile for any T that isn't QByteArray
 - make the constructor a template member
   => it compiles if the parameter is a QByteArray, but not a const
      char[4] like the test was
 - inheriting constructors
   => runs into ICC and Clang bugs that I could not work around

Besides, the constructor with std::initializer_list is a superior
solution anyway.

Change-Id: Ic86fbadc1104142bfd907a5c4147199bf839fb89
Reviewed-by: Marc Mutz <marc.mutz@kdab.com>
Reviewed-by: Jędrzej Nowacki <jedrzej.nowacki@digia.com>

1 files changed, 18 insertions, 123 deletions

diff --git a/src/corelib/tools/qbytearraylist.h b/src/corelib/tools/qbytearraylist.h
index efcba8e7ea..9d7e776028 100644
--- a/src/corelib/tools/qbytearraylist.h
+++ b/src/corelib/tools/qbytearraylist.h
@@ -40,146 +40,41 @@
 **
 ****************************************************************************/
 
+#include <QtCore/qlist.h>
 
 #ifndef QBYTEARRAYLIST_H
 #define QBYTEARRAYLIST_H
 
-#include <QtCore/qdatastream.h>
-#include <QtCore/qlist.h>
 #include <QtCore/qbytearray.h>
 
 QT_BEGIN_NAMESPACE
 
-
 typedef QListIterator<QByteArray> QByteArrayListIterator;
 typedef QMutableListIterator<QByteArray> QMutableByteArrayListIterator;
-
-class QByteArrayList : public QList<QByteArray>
-{
-public:
-    QByteArrayList() { }
-    explicit QByteArrayList(const QByteArray &i) { append(i); }
-    QByteArrayList(const QList<QByteArray> &l) : QList<QByteArray>(l) { }
-#ifdef Q_COMPILER_RVALUE_REFS
-    QByteArrayList(QList<QByteArray> &&l) : QList<QByteArray>(qMove(l)) { }
-#endif
-#ifdef Q_COMPILER_INITIALIZER_LISTS
-    QByteArrayList(std::initializer_list<QByteArray> args) : QList<QByteArray>(args) { }
-#endif
-    // compiler-generated copy/move ctor/assignment operators are ok
-    // compiler-generated dtor is ok
-    // inherited swap() is ok (sic!)
-
-    // For the operators, we could just say using QList<QByteArray>::operator{=,<<},
-    // but they would not return QByteArrayList&, so we need to write inline forwarders:
-    QByteArrayList &operator=(const QList<QByteArray> &other)
-    { QList<QByteArray>::operator=(other); return *this; }
-#ifdef Q_COMPILER_RVALUE_REFS
-    QByteArrayList &operator=(QList<QByteArray> &&other)
-    { QList<QByteArray>::operator=(qMove(other)); return *this; }
-#endif
-    // if this is missing, assignment from an initializer_list is ambiguous:
-#ifdef Q_COMPILER_INITIALIZER_LISTS
-    QByteArrayList &operator=(std::initializer_list<QByteArray> args)
-    { QByteArrayList copy(args); swap(copy); return *this; }
-#endif
-    QByteArrayList &operator<<(const QByteArray &str)
-    { QList<QByteArray>::operator<<(str); return *this; }
-    QByteArrayList &operator<<(const QList<QByteArray> &l)
-    { QList<QByteArray>::operator<<(l); return *this; }
-
-    //
-    // actual functionality provided on top of what QList<QByteArray> provides starts here:
-    //
-    inline QByteArray join() const;
-    inline QByteArray join(const QByteArray &sep) const;
-    inline QByteArray join(char sep) const;
-};
-
-Q_DECLARE_TYPEINFO(QByteArrayList, Q_MOVABLE_TYPE);
+typedef QList<QByteArray> QByteArrayList;
 
 namespace QtPrivate {
     QByteArray Q_CORE_EXPORT QByteArrayList_join(const QByteArrayList *that, const char *separator, int separatorLength);
 }
 
-inline QByteArray QByteArrayList::join() const
-{
-    return QtPrivate::QByteArrayList_join(this, 0, 0);
-}
-
-inline QByteArray QByteArrayList::join(const QByteArray &sep) const
-{
-    return QtPrivate::QByteArrayList_join(this, sep.constData(), sep.size());
-}
-
-inline QByteArray QByteArrayList::join(char sep) const
-{
-    return QtPrivate::QByteArrayList_join(this, &sep, 1);
-}
-
-inline QByteArrayList operator+(const QByteArrayList &lhs, const QByteArrayList &rhs)
-{
-    QByteArrayList res = lhs;
-    res += rhs;
-    return res;
-}
-
-#ifdef Q_COMPILER_RVALUE_REFS
-inline QByteArrayList operator+(QByteArrayList &&lhs, const QByteArrayList &rhs)
-{
-    lhs += rhs;
-    return qMove(lhs);
-}
-#endif
-
-inline QByteArrayList operator+(const QByteArrayList &lhs, const QList<QByteArray> &rhs)
-{
-    QByteArrayList res = lhs;
-    res += rhs;
-    return res;
-}
-
-#ifdef Q_COMPILER_RVALUE_REFS
-inline QByteArrayList operator+(QByteArrayList &&lhs, const QList<QByteArray> &rhs)
-{
-    lhs += rhs;
-    return qMove(lhs);
-}
-#endif
-
-inline QByteArrayList operator+(const QList<QByteArray> &lhs, const QByteArrayList &rhs)
-{
-    QByteArrayList res = lhs;
-    res += rhs;
-    return res;
-}
-
-#if 0 // ambiguous with QList<QByteArray>::operator+(const QList<QByteArray> &) const
-#ifdef Q_COMPILER_RVALUE_REFS
-inline QByteArrayList operator+(QList<QByteArray> &&lhs, const QByteArrayList &rhs)
-{
-    lhs += rhs;
-    return qMove(lhs);
-}
-#endif
+#ifdef Q_QDOC
+class QByteArrayList : public QList<QByteArray>
+#else
+template <> struct QListSpecialMethods<QByteArray>
 #endif
-
-inline QByteArrayList& operator+=(QByteArrayList &lhs, const QList<QByteArray> &rhs)
 {
-    lhs.append(rhs);
-    return lhs;
-}
-
-#ifndef QT_NO_DATASTREAM
-inline QDataStream &operator>>(QDataStream &in, QByteArrayList &list)
-{
-    return operator>>(in, static_cast<QList<QByteArray> &>(list));
-}
-inline QDataStream &operator<<(QDataStream &out, const QByteArrayList &list)
-{
-    return operator<<(out, static_cast<const QList<QByteArray> &>(list));
-}
-#endif // QT_NO_DATASTREAM
+    inline QByteArray join() const
+    { return QtPrivate::QByteArrayList_join(self(), 0, 0); }
+    inline QByteArray join(const QByteArray &sep) const
+    { return QtPrivate::QByteArrayList_join(self(), sep.constData(), sep.size()); }
+    inline QByteArray join(char sep) const
+    { return QtPrivate::QByteArrayList_join(self(), &sep, 1); }
+
+private:
+    typedef QList<QByteArray> Self;
+    Self *self() { return static_cast<Self *>(this); }
+    const Self *self() const { return static_cast<const Self *>(this); }
+};
 
 QT_END_NAMESPACE