Long live QByteArrayList!
Initial submission of a new class QByteArrayList with the purpose of aggregating and then joining QByteArray instances. [ChangeLog][QtCore] Added new QByteArrayList class. Done-with: Marc Mutz <marc.mutz@kdab.com> Change-Id: I503af58f125d7f44fef10360177490c933e5840f Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>bb10
Glen Mabey
Oswald Buddenhagen
parent
a332322de9
commit
35105f173e
|
|
@ -0,0 +1,51 @@
|
|||
/****************************************************************************
|
||||
**
|
||||
** Copyright (C) 2014 by Southwest Research Institute (R)
|
||||
** Contact: http://www.qt-project.org/legal
|
||||
**
|
||||
** This file is part of the QtCore module of the Qt Toolkit.
|
||||
**
|
||||
** $QT_BEGIN_LICENSE:LGPL$
|
||||
** Commercial License Usage
|
||||
** Licensees holding valid commercial Qt licenses may use this file in
|
||||
** accordance with the commercial license agreement provided with the
|
||||
** Software or, alternatively, in accordance with the terms contained in
|
||||
** a written agreement between you and Digia. For licensing terms and
|
||||
** conditions see http://qt.digia.com/licensing. For further information
|
||||
** use the contact form at http://qt.digia.com/contact-us.
|
||||
**
|
||||
** GNU Lesser General Public License Usage
|
||||
** Alternatively, this file may be used under the terms of the GNU Lesser
|
||||
** General Public License version 2.1 as published by the Free Software
|
||||
** Foundation and appearing in the file LICENSE.LGPL included in the
|
||||
** packaging of this file. Please review the following information to
|
||||
** ensure the GNU Lesser General Public License version 2.1 requirements
|
||||
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
|
||||
**
|
||||
** In addition, as a special exception, Digia gives you certain additional
|
||||
** rights. These rights are described in the Digia Qt LGPL Exception
|
||||
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
|
||||
**
|
||||
** GNU General Public License Usage
|
||||
** Alternatively, this file may be used under the terms of the GNU
|
||||
** General Public License version 3.0 as published by the Free Software
|
||||
** Foundation and appearing in the file LICENSE.GPL included in the
|
||||
** packaging of this file. Please review the following information to
|
||||
** ensure the GNU General Public License version 3.0 requirements will be
|
||||
** met: http://www.gnu.org/copyleft/gpl.html.
|
||||
**
|
||||
**
|
||||
** $QT_END_LICENSE$
|
||||
**
|
||||
****************************************************************************/
|
||||
|
||||
|
||||
#include <QByteArrayList>
|
||||
|
||||
int main(int, char **)
|
||||
{
|
||||
QByteArray ba1, ba2, ba3;
|
||||
//! [0]
|
||||
QByteArrayList longerList = (QByteArrayList() << ba1 << ba2 << ba3);
|
||||
//! [0]
|
||||
}
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
QT = core
|
||||
SOURCES = main.cpp
|
||||
|
|
@ -0,0 +1,294 @@
|
|||
/****************************************************************************
|
||||
**
|
||||
** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
|
||||
** Copyright (C) 2014 by Southwest Research Institute (R)
|
||||
** Contact: http://www.qt-project.org/legal
|
||||
**
|
||||
** This file is part of the QtCore module of the Qt Toolkit.
|
||||
**
|
||||
** $QT_BEGIN_LICENSE:LGPL$
|
||||
** Commercial License Usage
|
||||
** Licensees holding valid commercial Qt licenses may use this file in
|
||||
** accordance with the commercial license agreement provided with the
|
||||
** Software or, alternatively, in accordance with the terms contained in
|
||||
** a written agreement between you and Digia. For licensing terms and
|
||||
** conditions see http://qt.digia.com/licensing. For further information
|
||||
** use the contact form at http://qt.digia.com/contact-us.
|
||||
**
|
||||
** GNU Lesser General Public License Usage
|
||||
** Alternatively, this file may be used under the terms of the GNU Lesser
|
||||
** General Public License version 2.1 as published by the Free Software
|
||||
** Foundation and appearing in the file LICENSE.LGPL included in the
|
||||
** packaging of this file. Please review the following information to
|
||||
** ensure the GNU Lesser General Public License version 2.1 requirements
|
||||
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
|
||||
**
|
||||
** In addition, as a special exception, Digia gives you certain additional
|
||||
** rights. These rights are described in the Digia Qt LGPL Exception
|
||||
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
|
||||
**
|
||||
** GNU General Public License Usage
|
||||
** Alternatively, this file may be used under the terms of the GNU
|
||||
** General Public License version 3.0 as published by the Free Software
|
||||
** Foundation and appearing in the file LICENSE.GPL included in the
|
||||
** packaging of this file. Please review the following information to
|
||||
** ensure the GNU General Public License version 3.0 requirements will be
|
||||
** met: http://www.gnu.org/copyleft/gpl.html.
|
||||
**
|
||||
**
|
||||
** $QT_END_LICENSE$
|
||||
**
|
||||
****************************************************************************/
|
||||
|
||||
#include <qbytearraylist.h>
|
||||
|
||||
QT_BEGIN_NAMESPACE
|
||||
|
||||
/*! \typedef QByteArrayListIterator
|
||||
\relates QByteArrayList
|
||||
|
||||
The QByteArrayListIterator type definition provides a Java-style const
|
||||
iterator for QByteArrayList.
|
||||
|
||||
QByteArrayList provides both \l{Java-style iterators} and
|
||||
\l{STL-style iterators}. The Java-style const iterator is simply
|
||||
a type definition for QListIterator<QByteArray>.
|
||||
|
||||
\sa QMutableByteArrayListIterator, QByteArrayList::const_iterator
|
||||
*/
|
||||
|
||||
/*! \typedef QMutableByteArrayListIterator
|
||||
\relates QByteArrayList
|
||||
|
||||
The QByteArrayListIterator type definition provides a Java-style
|
||||
non-const iterator for QByteArrayList.
|
||||
|
||||
QByteArrayList provides both \l{Java-style iterators} and
|
||||
\l{STL-style iterators}. The Java-style non-const iterator is
|
||||
simply a type definition for QMutableListIterator<QByteArray>.
|
||||
|
||||
\sa QByteArrayListIterator, QByteArrayList::iterator
|
||||
*/
|
||||
|
||||
/*!
|
||||
\class QByteArrayList
|
||||
\inmodule QtCore
|
||||
\since 5.4
|
||||
\brief The QByteArrayList class provides a list of byte arrays.
|
||||
|
||||
\ingroup tools
|
||||
\ingroup shared
|
||||
\ingroup string-processing
|
||||
|
||||
\reentrant
|
||||
|
||||
QByteArrayList inherits from QList<QByteArray>. Like QList, QByteArrayList is
|
||||
\l{implicitly shared}. It provides fast index-based access as well as fast
|
||||
insertions and removals. Passing string lists as value parameters is both
|
||||
fast and safe.
|
||||
|
||||
All of QList's functionality also applies to QByteArrayList. For example, you
|
||||
can use isEmpty() to test whether the list is empty, and you can call
|
||||
functions like append(), prepend(), insert(), replace(), removeAll(),
|
||||
removeAt(), removeFirst(), removeLast(), and removeOne() to modify a
|
||||
QByteArrayList. In addition, QByteArrayList provides several join()
|
||||
methods for concatenating the list into a single QByteArray.
|
||||
|
||||
The purpose of QByteArrayList is quite different from that of QStringList.
|
||||
Whereas QStringList has many methods for manipulation of elements within
|
||||
the list, QByteArrayList does not.
|
||||
Normally, QStringList should be used whenever working with a list of printable
|
||||
strings. QByteArrayList should be used to handle and efficiently join large blobs
|
||||
of binary data, as when sequentially receiving serialized data through a
|
||||
QIODevice.
|
||||
|
||||
\sa QByteArray, QStringList
|
||||
*/
|
||||
|
||||
/*!
|
||||
\fn QByteArrayList::QByteArrayList()
|
||||
|
||||
Constructs an empty byte array list.
|
||||
*/
|
||||
|
||||
/*!
|
||||
\fn QByteArrayList::QByteArrayList(const QByteArray &ba)
|
||||
|
||||
Constructs a byte array list that contains the given byte array,
|
||||
\a ba. Longer lists are easily created like this:
|
||||
|
||||
\snippet qbytearraylist/main.cpp 0
|
||||
|
||||
\sa append()
|
||||
*/
|
||||
|
||||
/*!
|
||||
\fn QByteArrayList::QByteArrayList(const QList<QByteArray> &other)
|
||||
|
||||
Constructs a copy of \a other.
|
||||
|
||||
This operation takes \l{constant time}, because QByteArrayList is
|
||||
\l{implicitly shared}. This makes returning a QByteArrayList from a
|
||||
function very fast. If a shared instance is modified, it will be
|
||||
copied (copy-on-write), and that takes \l{linear time}.
|
||||
|
||||
\sa operator=()
|
||||
*/
|
||||
|
||||
/*!
|
||||
\fn QByteArrayList::QByteArrayList(QList<QByteArray> &&other)
|
||||
|
||||
\overload
|
||||
|
||||
Move-constructs from \a other.
|
||||
|
||||
This constructor is only enabled if the compiler supports C++11
|
||||
move semantics.
|
||||
|
||||
\sa operator=()
|
||||
*/
|
||||
|
||||
/*! \fn QByteArrayList::QByteArrayList(std::initializer_list<QByteArray> args)
|
||||
|
||||
Constructs a list from a std::initializer_list given by \a args.
|
||||
|
||||
This constructor is only enabled if the compiler supports C++11 initializer
|
||||
lists.
|
||||
*/
|
||||
|
||||
/*!
|
||||
\fn QByteArrayList &QByteArrayList::operator=(const QList<QByteArray> &other)
|
||||
|
||||
Assigns the contents of \a other to this byte array list and returns
|
||||
a reference to \c *this.
|
||||
*/
|
||||
|
||||
/*!
|
||||
\fn QByteArrayList &QByteArrayList::operator=(QList<QByteArray> &&other)
|
||||
|
||||
\overload
|
||||
|
||||
Move-assigns the contents of \a other to this byte array list and returns
|
||||
a reference to \c *this.
|
||||
|
||||
This operator is only enabled if the compiler supports C++11 move
|
||||
semantics.
|
||||
*/
|
||||
|
||||
/*!
|
||||
\fn QByteArrayList &QByteArrayList::operator=(std::initializer_list<QByteArray> args)
|
||||
|
||||
\overload
|
||||
|
||||
Assigns the byte arrays from the initializer_list \a args to this byte array
|
||||
list and returns a reference to \c *this.
|
||||
|
||||
This operator is only enabled if the compiler supports C++11 initializer
|
||||
lists.
|
||||
*/
|
||||
|
||||
/*!
|
||||
\fn QByteArray QByteArrayList::join() const
|
||||
|
||||
Joins all the byte arrays into a single byte array.
|
||||
*/
|
||||
|
||||
/*!
|
||||
\fn QByteArray QByteArrayList::join(const QByteArray &separator) const
|
||||
|
||||
Joins all the byte arrays into a single byte array with each
|
||||
element separated by the given \a separator.
|
||||
*/
|
||||
|
||||
/*!
|
||||
\fn QByteArray QByteArrayList::join(char separator) const
|
||||
|
||||
Joins all the byte arrays into a single byte array with each
|
||||
element separated by the given \a separator.
|
||||
*/
|
||||
|
||||
static int QByteArrayList_joinedSize(const QByteArrayList *that, int seplen)
|
||||
{
|
||||
int totalLength = 0;
|
||||
const int size = that->size();
|
||||
|
||||
for (int i = 0; i < size; ++i)
|
||||
totalLength += that->at(i).size();
|
||||
|
||||
if (size > 0)
|
||||
totalLength += seplen * (size - 1);
|
||||
|
||||
return totalLength;
|
||||
}
|
||||
|
||||
QByteArray QtPrivate::QByteArrayList_join(const QByteArrayList *that, const char *sep, int seplen)
|
||||
{
|
||||
QByteArray res;
|
||||
if (const int joinedSize = QByteArrayList_joinedSize(that, seplen))
|
||||
res.reserve(joinedSize); // don't call reserve(0) - it allocates one byte for the NUL
|
||||
const int size = that->size();
|
||||
for (int i = 0; i < size; ++i) {
|
||||
if (i)
|
||||
res.append(sep, seplen);
|
||||
res += that->at(i);
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
/*!
|
||||
\fn QByteArrayList operator+(const QByteArrayList &list1, const QByteArrayList &list2)
|
||||
\fn QByteArrayList operator+(const QByteArrayList &list1, const QList<QByteArray> &list2)
|
||||
\fn QByteArrayList operator+(const QList<QByteArray> &list1, const QByteArrayList &list2)
|
||||
\fn QByteArrayList operator+(QByteArrayList &&list1, const QByteArrayList &list2)
|
||||
\fn QByteArrayList operator+(QByteArrayList &&list1, const QList<QByteArray> &list2)
|
||||
\relates QByteArrayList
|
||||
|
||||
Returns a byte array list that is the concatenation of \a list1 and \a list2.
|
||||
*/
|
||||
|
||||
/*!
|
||||
\fn QByteArrayList& operator+=(QByteArrayList &list1, const QList<QByteArray> &list2)
|
||||
\relates QByteArrayList
|
||||
|
||||
Appends \a list2 (which may be a QByteArrayList itself) to \a
|
||||
list1 and returns a reference to \a list1.
|
||||
*/
|
||||
|
||||
/*!
|
||||
\fn QByteArrayList &QByteArrayList::operator<<(const QByteArray &ba)
|
||||
|
||||
Appends the given byte array, \a ba, to this byte array list and returns
|
||||
a reference to the byte array list.
|
||||
|
||||
\sa append()
|
||||
*/
|
||||
|
||||
/*!
|
||||
\fn QByteArrayList &QByteArrayList::operator<<(const QList<QByteArray> &other)
|
||||
|
||||
\overload
|
||||
|
||||
Appends the list of byte arrays \a other (which may be a
|
||||
QByteArrayList itself) to this byte array list and returns a
|
||||
reference to \c *this. */
|
||||
|
||||
/*!
|
||||
\fn QDataStream &operator>>(QDataStream &in, QByteArrayList &list)
|
||||
\relates QByteArrayList
|
||||
|
||||
Reads a byte array list from the given \a in stream into the specified
|
||||
\a list.
|
||||
|
||||
\sa {Serializing Qt Data Types}
|
||||
*/
|
||||
|
||||
/*!
|
||||
\fn QDataStream &operator<<(QDataStream &out, const QByteArrayList &list)
|
||||
\relates QByteArrayList
|
||||
|
||||
Writes the given byte array \a list to the specified \a out stream.
|
||||
|
||||
\sa {Serializing Qt Data Types}
|
||||
*/
|
||||
|
||||
QT_END_NAMESPACE
|
||||
|
|
@ -0,0 +1,186 @@
|
|||
/****************************************************************************
|
||||
**
|
||||
** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
|
||||
** Copyright (C) 2014 by Southwest Research Institute (R)
|
||||
** Contact: http://www.qt-project.org/legal
|
||||
**
|
||||
** This file is part of the QtCore module of the Qt Toolkit.
|
||||
**
|
||||
** $QT_BEGIN_LICENSE:LGPL$
|
||||
** Commercial License Usage
|
||||
** Licensees holding valid commercial Qt licenses may use this file in
|
||||
** accordance with the commercial license agreement provided with the
|
||||
** Software or, alternatively, in accordance with the terms contained in
|
||||
** a written agreement between you and Digia. For licensing terms and
|
||||
** conditions see http://qt.digia.com/licensing. For further information
|
||||
** use the contact form at http://qt.digia.com/contact-us.
|
||||
**
|
||||
** GNU Lesser General Public License Usage
|
||||
** Alternatively, this file may be used under the terms of the GNU Lesser
|
||||
** General Public License version 2.1 as published by the Free Software
|
||||
** Foundation and appearing in the file LICENSE.LGPL included in the
|
||||
** packaging of this file. Please review the following information to
|
||||
** ensure the GNU Lesser General Public License version 2.1 requirements
|
||||
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
|
||||
**
|
||||
** In addition, as a special exception, Digia gives you certain additional
|
||||
** rights. These rights are described in the Digia Qt LGPL Exception
|
||||
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
|
||||
**
|
||||
** GNU General Public License Usage
|
||||
** Alternatively, this file may be used under the terms of the GNU
|
||||
** General Public License version 3.0 as published by the Free Software
|
||||
** Foundation and appearing in the file LICENSE.GPL included in the
|
||||
** packaging of this file. Please review the following information to
|
||||
** ensure the GNU General Public License version 3.0 requirements will be
|
||||
** met: http://www.gnu.org/copyleft/gpl.html.
|
||||
**
|
||||
**
|
||||
** $QT_END_LICENSE$
|
||||
**
|
||||
****************************************************************************/
|
||||
|
||||
|
||||
#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);
|
||||
|
||||
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
|
||||
#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
|
||||
|
||||
QT_END_NAMESPACE
|
||||
|
||||
#endif // QBYTEARRAYLIST_H
|
||||
|
|
@ -9,6 +9,7 @@ HEADERS += \
|
|||
tools/qarraydatapointer.h \
|
||||
tools/qbitarray.h \
|
||||
tools/qbytearray.h \
|
||||
tools/qbytearraylist.h \
|
||||
tools/qbytearraymatcher.h \
|
||||
tools/qbytedata_p.h \
|
||||
tools/qcache.h \
|
||||
|
|
@ -77,6 +78,7 @@ SOURCES += \
|
|||
tools/qarraydata.cpp \
|
||||
tools/qbitarray.cpp \
|
||||
tools/qbytearray.cpp \
|
||||
tools/qbytearraylist.cpp \
|
||||
tools/qbytearraymatcher.cpp \
|
||||
tools/qcollator.cpp \
|
||||
tools/qcommandlineoption.cpp \
|
||||
|
|
|
|||
|
|
@ -0,0 +1,4 @@
|
|||
CONFIG += testcase parallel_test
|
||||
TARGET = tst_qbytearraylist
|
||||
QT = core testlib
|
||||
SOURCES = tst_qbytearraylist.cpp
|
||||
|
|
@ -0,0 +1,292 @@
|
|||
/****************************************************************************
|
||||
**
|
||||
** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
|
||||
** Copyright (C) 2014 by Southwest Research Institute (R)
|
||||
** Contact: http://www.qt-project.org/legal
|
||||
**
|
||||
** This file is part of the QtCore module of the Qt Toolkit.
|
||||
**
|
||||
** $QT_BEGIN_LICENSE:LGPL$
|
||||
** Commercial License Usage
|
||||
** Licensees holding valid commercial Qt licenses may use this file in
|
||||
** accordance with the commercial license agreement provided with the
|
||||
** Software or, alternatively, in accordance with the terms contained in
|
||||
** a written agreement between you and Digia. For licensing terms and
|
||||
** conditions see http://qt.digia.com/licensing. For further information
|
||||
** use the contact form at http://qt.digia.com/contact-us.
|
||||
**
|
||||
** GNU Lesser General Public License Usage
|
||||
** Alternatively, this file may be used under the terms of the GNU Lesser
|
||||
** General Public License version 2.1 as published by the Free Software
|
||||
** Foundation and appearing in the file LICENSE.LGPL included in the
|
||||
** packaging of this file. Please review the following information to
|
||||
** ensure the GNU Lesser General Public License version 2.1 requirements
|
||||
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
|
||||
**
|
||||
** In addition, as a special exception, Digia gives you certain additional
|
||||
** rights. These rights are described in the Digia Qt LGPL Exception
|
||||
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
|
||||
**
|
||||
** GNU General Public License Usage
|
||||
** Alternatively, this file may be used under the terms of the GNU
|
||||
** General Public License version 3.0 as published by the Free Software
|
||||
** Foundation and appearing in the file LICENSE.GPL included in the
|
||||
** packaging of this file. Please review the following information to
|
||||
** ensure the GNU General Public License version 3.0 requirements will be
|
||||
** met: http://www.gnu.org/copyleft/gpl.html.
|
||||
**
|
||||
**
|
||||
** $QT_END_LICENSE$
|
||||
**
|
||||
****************************************************************************/
|
||||
|
||||
#include <QtTest/QtTest>
|
||||
#include <qbytearraylist.h>
|
||||
|
||||
#include <qmetatype.h>
|
||||
|
||||
Q_DECLARE_METATYPE(QByteArrayList)
|
||||
|
||||
class tst_QByteArrayList : public QObject
|
||||
{
|
||||
Q_OBJECT
|
||||
private slots:
|
||||
void join() const;
|
||||
void join_data() const;
|
||||
void joinByteArray() const;
|
||||
void joinByteArray_data() const;
|
||||
void joinChar() const;
|
||||
void joinChar_data() const;
|
||||
void joinEmptiness() const;
|
||||
|
||||
void operator_plus() const;
|
||||
void operator_plus_data() const;
|
||||
|
||||
void initializerList() const;
|
||||
};
|
||||
|
||||
void tst_QByteArrayList::join() const
|
||||
{
|
||||
QFETCH(QByteArrayList, input);
|
||||
QFETCH(QByteArray, expectedResult);
|
||||
|
||||
QCOMPARE(input.join(), expectedResult);
|
||||
}
|
||||
|
||||
void tst_QByteArrayList::join_data() const
|
||||
{
|
||||
QTest::addColumn<QByteArrayList>("input");
|
||||
QTest::addColumn<QByteArray>("expectedResult");
|
||||
|
||||
QTest::newRow("data1") << QByteArrayList()
|
||||
<< QByteArray();
|
||||
|
||||
QTest::newRow("data2") << QByteArrayList("one")
|
||||
<< QByteArray("one");
|
||||
|
||||
QTest::newRow("data3") << (QByteArrayList() << "a" << "b")
|
||||
<< QByteArray("ab");
|
||||
|
||||
QTest::newRow("data4") << (QByteArrayList() << "a" << "b" << "c")
|
||||
<< QByteArray("abc");
|
||||
}
|
||||
|
||||
void tst_QByteArrayList::joinByteArray() const
|
||||
{
|
||||
QFETCH(QByteArrayList, input);
|
||||
QFETCH(QByteArray, separator);
|
||||
QFETCH(QByteArray, expectedResult);
|
||||
|
||||
QCOMPARE(input.join(separator), expectedResult);
|
||||
}
|
||||
|
||||
void tst_QByteArrayList::joinByteArray_data() const
|
||||
{
|
||||
QTest::addColumn<QByteArrayList>("input");
|
||||
QTest::addColumn<QByteArray>("separator");
|
||||
QTest::addColumn<QByteArray>("expectedResult");
|
||||
|
||||
QTest::newRow("data1") << QByteArrayList()
|
||||
<< QByteArray()
|
||||
<< QByteArray();
|
||||
|
||||
QTest::newRow("data2") << QByteArrayList()
|
||||
<< QByteArray("separator")
|
||||
<< QByteArray();
|
||||
|
||||
QTest::newRow("data3") << QByteArrayList("one")
|
||||
<< QByteArray("separator")
|
||||
<< QByteArray("one");
|
||||
|
||||
QTest::newRow("data4") << (QByteArrayList() << "a" << "b")
|
||||
<< QByteArray(" ")
|
||||
<< QByteArray("a b");
|
||||
|
||||
QTest::newRow("data5") << (QByteArrayList() << "a" << "b" << "c")
|
||||
<< QByteArray(" ")
|
||||
<< QByteArray("a b c");
|
||||
|
||||
QTest::newRow("data6") << (QByteArrayList() << "a" << "b" << "c")
|
||||
<< QByteArray()
|
||||
<< QByteArray("abc");
|
||||
|
||||
QTest::newRow("data7") << (QByteArrayList() << "a" << "b" << "c")
|
||||
<< QByteArray("") //empty
|
||||
<< QByteArray("abc");
|
||||
}
|
||||
|
||||
void tst_QByteArrayList::joinChar() const
|
||||
{
|
||||
QFETCH(QByteArrayList, input);
|
||||
QFETCH(char, separator);
|
||||
QFETCH(QByteArray, expectedResult);
|
||||
|
||||
QCOMPARE(input.join(separator), expectedResult);
|
||||
}
|
||||
|
||||
void tst_QByteArrayList::joinChar_data() const
|
||||
{
|
||||
QTest::addColumn<QByteArrayList>("input");
|
||||
QTest::addColumn<char>("separator");
|
||||
QTest::addColumn<QByteArray>("expectedResult");
|
||||
|
||||
QTest::newRow("data1") << QByteArrayList()
|
||||
<< ' '
|
||||
<< QByteArray();
|
||||
|
||||
QTest::newRow("data2") << (QByteArrayList() << "a a" << "b")
|
||||
<< ' '
|
||||
<< QByteArray("a a b");
|
||||
|
||||
QTest::newRow("data3") << (QByteArrayList() << "a" << "b" << "c c")
|
||||
<< ' '
|
||||
<< QByteArray("a b c c");
|
||||
}
|
||||
|
||||
void tst_QByteArrayList::joinEmptiness() const
|
||||
{
|
||||
QByteArrayList list;
|
||||
QByteArray string = list.join(QByteArray());
|
||||
|
||||
QVERIFY(string.isEmpty());
|
||||
QVERIFY(string.isNull());
|
||||
}
|
||||
|
||||
void tst_QByteArrayList::operator_plus() const
|
||||
{
|
||||
QFETCH(QByteArrayList, lhs);
|
||||
QFETCH(QByteArrayList, rhs);
|
||||
QFETCH(QByteArrayList, expectedResult);
|
||||
|
||||
// operator+ for const lvalues
|
||||
{
|
||||
const QByteArrayList bal1 = lhs;
|
||||
const QByteArrayList bal2 = rhs;
|
||||
QCOMPARE(bal1 + bal2, expectedResult);
|
||||
}
|
||||
{
|
||||
const QList<QByteArray> lba1 = lhs;
|
||||
const QByteArrayList bal2 = rhs;
|
||||
QCOMPARE(lba1 + bal2, expectedResult);
|
||||
}
|
||||
{
|
||||
const QByteArrayList bal1 = lhs;
|
||||
const QList<QByteArray> lba2 = rhs;
|
||||
QCOMPARE(bal1 + lba2, expectedResult);
|
||||
}
|
||||
{
|
||||
const QList<QByteArray> lba1 = lhs;
|
||||
const QList<QByteArray> lba2 = rhs;
|
||||
QCOMPARE(lba1 + lba2, QList<QByteArray>(expectedResult)); // check we don't mess with old code
|
||||
}
|
||||
|
||||
// operator+ for rvalues (only lhs)
|
||||
{
|
||||
QByteArrayList bal1 = lhs;
|
||||
const QByteArrayList bal2 = rhs;
|
||||
QCOMPARE(qMove(bal1) + bal2, expectedResult);
|
||||
}
|
||||
{
|
||||
QList<QByteArray> lba1 = lhs;
|
||||
const QByteArrayList bal2 = rhs;
|
||||
QCOMPARE(qMove(lba1) + bal2, expectedResult);
|
||||
}
|
||||
{
|
||||
QByteArrayList bal1 = lhs;
|
||||
const QList<QByteArray> lba2 = rhs;
|
||||
QCOMPARE(qMove(bal1) + lba2, expectedResult);
|
||||
}
|
||||
{
|
||||
QList<QByteArray> lba1 = lhs;
|
||||
const QList<QByteArray> lba2 = rhs;
|
||||
QCOMPARE(qMove(lba1) + lba2, QList<QByteArray>(expectedResult)); // check we don't mess with old code
|
||||
}
|
||||
|
||||
// operator += for const lvalues
|
||||
{
|
||||
QByteArrayList bal1 = lhs;
|
||||
const QByteArrayList bal2 = rhs;
|
||||
QCOMPARE(bal1 += bal2, expectedResult);
|
||||
}
|
||||
{
|
||||
QByteArrayList bal1 = lhs;
|
||||
const QList<QByteArray> lba2 = rhs;
|
||||
QCOMPARE(bal1 += lba2, expectedResult);
|
||||
}
|
||||
{
|
||||
QList<QByteArray> lba1 = lhs;
|
||||
const QByteArrayList bal2 = rhs;
|
||||
QCOMPARE(lba1 += bal2, QList<QByteArray>(expectedResult));
|
||||
}
|
||||
|
||||
QByteArrayList t1 = lhs;
|
||||
QByteArrayList t2 = rhs;
|
||||
|
||||
QCOMPARE(qMove(t1) + t2, expectedResult);
|
||||
}
|
||||
|
||||
void tst_QByteArrayList::operator_plus_data() const
|
||||
{
|
||||
QTest::addColumn<QByteArrayList>("lhs");
|
||||
QTest::addColumn<QByteArrayList>("rhs");
|
||||
QTest::addColumn<QByteArrayList>("expectedResult");
|
||||
|
||||
QTest::newRow("simpl") << ( QByteArrayList() << "a" )
|
||||
<< ( QByteArrayList() << "b" << "c" )
|
||||
<< ( QByteArrayList() << "a" << "b" << "c" );
|
||||
|
||||
QTest::newRow("blank1") << QByteArrayList()
|
||||
<< QByteArrayList()
|
||||
<< QByteArrayList();
|
||||
|
||||
QTest::newRow("blank2") << ( QByteArrayList() )
|
||||
<< ( QByteArrayList() << "b" << "c" )
|
||||
<< ( QByteArrayList() << "b" << "c" );
|
||||
|
||||
QTest::newRow("empty1") << ( QByteArrayList() << "" )
|
||||
<< ( QByteArrayList() << "b" << "c" )
|
||||
<< ( QByteArrayList() << "" << "b" << "c" );
|
||||
|
||||
QTest::newRow("empty2") << ( QByteArrayList() << "a" )
|
||||
<< ( QByteArrayList() << "" << "c" )
|
||||
<< ( QByteArrayList() << "a" << "" << "c" );
|
||||
}
|
||||
|
||||
void tst_QByteArrayList::initializerList() const
|
||||
{
|
||||
#ifdef Q_COMPILER_INITIALIZER_LISTS
|
||||
// constructor
|
||||
QByteArrayList v1 = {QByteArray("hello"),"world",QByteArray("plop")};
|
||||
QCOMPARE(v1, (QByteArrayList() << "hello" << "world" << "plop"));
|
||||
QCOMPARE(v1, (QByteArrayList{"hello","world","plop"}));
|
||||
// assignment operator (through implicit temporary)
|
||||
QByteArrayList v2;
|
||||
v2 = {QByteArray("hello"),"world",QByteArray("plop")};
|
||||
QCOMPARE(v2, v1);
|
||||
#else
|
||||
QSKIP("This test requires C++11 initializer_list support in the compiler.");
|
||||
#endif
|
||||
}
|
||||
|
||||
QTEST_APPLESS_MAIN(tst_QByteArrayList)
|
||||
#include "tst_qbytearraylist.moc"
|
||||
|
|
@ -6,6 +6,7 @@ SUBDIRS=\
|
|||
qarraydata_strictiterators \
|
||||
qbitarray \
|
||||
qbytearray \
|
||||
qbytearraylist \
|
||||
qbytearraymatcher \
|
||||
qbytedatabuffer \
|
||||
qcache \
|
||||
|
|
|
|||
Loading…
Reference in New Issue