Katana_mirror/katie
1
0
Fork 0
mirror of https://bitbucket.org/smil3y/katie.git synced 2025-02-23 18:32:55 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

get rid of QLinkedList<T>

Browse source 
Signed-off-by: Ivailo Monev <xakepa10@gmail.com>
This commit is contained in:
Ivailo Monev 2022-01-29 05:25:38 +02:00
parent d4785c2987
commit a25d34bb05
26 changed files with 49 additions and 1856 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
CMakeLists.txt
View file

@ -699,9 +699,6 @@ katie_generate_obsolete(QLatin1Char QtCore qchar.h)
katie_generate_obsolete(QLatin1String QtCore qstring.h) katie_generate_obsolete(QLatin1String QtCore qstring.h)
katie_generate_obsolete(QLinearGradient QtGui qbrush.h) katie_generate_obsolete(QLinearGradient QtGui qbrush.h)
katie_generate_obsolete(QLineF QtCore qline.h) katie_generate_obsolete(QLineF QtCore qline.h)
katie_generate_obsolete(QLinkedListData QtCore qlinkedlist.h)
katie_generate_obsolete(QLinkedListIterator QtCore qlinkedlist.h)
katie_generate_obsolete(QLinkedListNode QtCore qlinkedlist.h)
katie_generate_obsolete(QListData QtCore qlist.h) katie_generate_obsolete(QListData QtCore qlist.h)
katie_generate_obsolete(QListIterator QtCore qlist.h) katie_generate_obsolete(QListIterator QtCore qlist.h)
katie_generate_obsolete(QListWidgetItem QtGui qlistwidget.h) katie_generate_obsolete(QListWidgetItem QtGui qlistwidget.h)

5
package/freebsd/pkg-plist
View file

@ -76,10 +76,6 @@ include/katie/QtCore/QLibrary
include/katie/QtCore/QLibraryInfo include/katie/QtCore/QLibraryInfo
include/katie/QtCore/QLine include/katie/QtCore/QLine
include/katie/QtCore/QLineF include/katie/QtCore/QLineF
include/katie/QtCore/QLinkedList
include/katie/QtCore/QLinkedListData
include/katie/QtCore/QLinkedListIterator
include/katie/QtCore/QLinkedListNode
include/katie/QtCore/QList include/katie/QtCore/QList
include/katie/QtCore/QListData include/katie/QtCore/QListData
include/katie/QtCore/QListIterator include/katie/QtCore/QListIterator
@ -251,7 +247,6 @@ include/katie/QtCore/qjsondocument.h
include/katie/QtCore/qlibrary.h include/katie/QtCore/qlibrary.h
include/katie/QtCore/qlibraryinfo.h include/katie/QtCore/qlibraryinfo.h
include/katie/QtCore/qline.h include/katie/QtCore/qline.h
include/katie/QtCore/qlinkedlist.h
include/katie/QtCore/qlist.h include/katie/QtCore/qlist.h
include/katie/QtCore/qlocale.h include/katie/QtCore/qlocale.h
include/katie/QtCore/qmap.h include/katie/QtCore/qmap.h

5
package/netbsd/PLIST
View file

@ -79,10 +79,6 @@ include/katie/QtCore/QLibrary
include/katie/QtCore/QLibraryInfo include/katie/QtCore/QLibraryInfo
include/katie/QtCore/QLine include/katie/QtCore/QLine
include/katie/QtCore/QLineF include/katie/QtCore/QLineF
include/katie/QtCore/QLinkedList
include/katie/QtCore/QLinkedListData
include/katie/QtCore/QLinkedListIterator
include/katie/QtCore/QLinkedListNode
include/katie/QtCore/QList include/katie/QtCore/QList
include/katie/QtCore/QListData include/katie/QtCore/QListData
include/katie/QtCore/QListIterator include/katie/QtCore/QListIterator
@ -254,7 +250,6 @@ include/katie/QtCore/qjsondocument.h
include/katie/QtCore/qlibrary.h include/katie/QtCore/qlibrary.h
include/katie/QtCore/qlibraryinfo.h include/katie/QtCore/qlibraryinfo.h
include/katie/QtCore/qline.h include/katie/QtCore/qline.h
include/katie/QtCore/qlinkedlist.h
include/katie/QtCore/qlist.h include/katie/QtCore/qlist.h
include/katie/QtCore/qlocale.h include/katie/QtCore/qlocale.h
include/katie/QtCore/qmap.h include/katie/QtCore/qmap.h

5
package/openbsd/pkg/PLIST
View file

@ -79,10 +79,6 @@ include/katie/QtCore/QLibrary
include/katie/QtCore/QLibraryInfo include/katie/QtCore/QLibraryInfo
include/katie/QtCore/QLine include/katie/QtCore/QLine
include/katie/QtCore/QLineF include/katie/QtCore/QLineF
include/katie/QtCore/QLinkedList
include/katie/QtCore/QLinkedListData
include/katie/QtCore/QLinkedListIterator
include/katie/QtCore/QLinkedListNode
include/katie/QtCore/QList include/katie/QtCore/QList
include/katie/QtCore/QListData include/katie/QtCore/QListData
include/katie/QtCore/QListIterator include/katie/QtCore/QListIterator
@ -254,7 +250,6 @@ include/katie/QtCore/qjsondocument.h
include/katie/QtCore/qlibrary.h include/katie/QtCore/qlibrary.h
include/katie/QtCore/qlibraryinfo.h include/katie/QtCore/qlibraryinfo.h
include/katie/QtCore/qline.h include/katie/QtCore/qline.h
include/katie/QtCore/qlinkedlist.h
include/katie/QtCore/qlist.h include/katie/QtCore/qlist.h
include/katie/QtCore/qlocale.h include/katie/QtCore/qlocale.h
include/katie/QtCore/qmap.h include/katie/QtCore/qmap.h

3
scripts/incfsck.py
View file

@ -37,9 +37,6 @@ incmap = {
'QLatin1Char': 'qchar.h', 'QLatin1Char': 'qchar.h',
'QLatin1String': 'qstring.h', 'QLatin1String': 'qstring.h',
'QLineF': 'qline.h', 'QLineF': 'qline.h',
'QLinkedListData': 'qlinkedlist.h',
'QLinkedListIterator': 'qlinkedlist.h',
'QLinkedListNode': 'qlinkedlist.h',
'QListData': 'qlist.h', 'QListData': 'qlist.h',
'QListIterator': 'qlist.h', 'QListIterator': 'qlist.h',
'QMapData': 'qmap.h', 'QMapData': 'qmap.h',

4
scripts/namefsck.py
View file

@ -343,10 +343,6 @@ classlist = [
"QLinearGradient", "QLinearGradient",
"QLineEdit", "QLineEdit",
"QLineF", "QLineF",
"QLinkedList",
"QLinkedListData",
"QLinkedListIterator",
"QLinkedListNode",
"QList", "QList",
"QListData", "QListData",
"QListIterator", "QListIterator",

3
src/core/CMakeLists.txt
View file

@ -62,7 +62,6 @@ set(CORE_PUBLIC_HEADERS
QFutureWatcher QFutureWatcher
QVector QVector
QLibraryInfo QLibraryInfo
QLinkedList
QSemaphore QSemaphore
QFutureSynchronizer QFutureSynchronizer
QStack QStack
@ -246,7 +245,6 @@ set(CORE_HEADERS
${CMAKE_CURRENT_SOURCE_DIR}/tools/qhash.h ${CMAKE_CURRENT_SOURCE_DIR}/tools/qhash.h
${CMAKE_CURRENT_SOURCE_DIR}/tools/qjsondocument.h ${CMAKE_CURRENT_SOURCE_DIR}/tools/qjsondocument.h
${CMAKE_CURRENT_SOURCE_DIR}/tools/qline.h ${CMAKE_CURRENT_SOURCE_DIR}/tools/qline.h
${CMAKE_CURRENT_SOURCE_DIR}/tools/qlinkedlist.h
${CMAKE_CURRENT_SOURCE_DIR}/tools/qlist.h ${CMAKE_CURRENT_SOURCE_DIR}/tools/qlist.h
${CMAKE_CURRENT_SOURCE_DIR}/tools/qlocale.h ${CMAKE_CURRENT_SOURCE_DIR}/tools/qlocale.h
${CMAKE_CURRENT_SOURCE_DIR}/tools/qlocale_p.h ${CMAKE_CURRENT_SOURCE_DIR}/tools/qlocale_p.h
@ -376,7 +374,6 @@ set(CORE_SOURCES
${CMAKE_CURRENT_SOURCE_DIR}/tools/qhash.cpp ${CMAKE_CURRENT_SOURCE_DIR}/tools/qhash.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tools/qjsondocument.cpp ${CMAKE_CURRENT_SOURCE_DIR}/tools/qjsondocument.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tools/qline.cpp ${CMAKE_CURRENT_SOURCE_DIR}/tools/qline.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tools/qlinkedlist.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tools/qlist.cpp ${CMAKE_CURRENT_SOURCE_DIR}/tools/qlist.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tools/qlocale.cpp ${CMAKE_CURRENT_SOURCE_DIR}/tools/qlocale.cpp
${CMAKE_CURRENT_SOURCE_DIR}/tools/qlocale_tools.cpp ${CMAKE_CURRENT_SOURCE_DIR}/tools/qlocale_tools.cpp

2
src/core/io/qdatastream.cpp
View file

@ -141,7 +141,7 @@ QT_BEGIN_NAMESPACE
\section1 Reading and writing Qt collection classes \section1 Reading and writing Qt collection classes
The Qt container classes can also be serialized to a QDataStream. The Qt container classes can also be serialized to a QDataStream.
These include QList, QLinkedList, QVector, QSet, QHash, and QMap. These include QList, QVector, QSet, QHash, and QMap.
The stream operators are declared as non-members of the classes. The stream operators are declared as non-members of the classes.
\target Serializing Qt Classes \target Serializing Qt Classes

28
src/core/io/qdatastream.h
View file

@ -31,7 +31,6 @@ QT_BEGIN_NAMESPACE
class QByteArray; class QByteArray;
template <typename T> class QList; template <typename T> class QList;
template <typename T> class QLinkedList;
template <typename T> class QVector; template <typename T> class QVector;
template <typename T> class QSet; template <typename T> class QSet;
template <class Key, class T> class QHash; template <class Key, class T> class QHash;
@ -213,33 +212,6 @@ QDataStream& operator<<(QDataStream& s, const QList<T>& l)
return s; return s;
} }
template <typename T>
QDataStream& operator>>(QDataStream& s, QLinkedList<T>& l)
{
l.clear();
quint32 c;
s >> c;
for(quint32 i = 0; i < c; ++i)
{
T t;
s >> t;
l.append(t);
if (s.atEnd())
break;
}
return s;
}
template <typename T>
QDataStream& operator<<(QDataStream& s, const QLinkedList<T>& l)
{
s << quint32(l.size());
typename QLinkedList<T>::const_iterator it = l.constBegin();
for(; it != l.constEnd(); ++it)
s << *it;
return s;
}
template<typename T> template<typename T>
QDataStream& operator>>(QDataStream& s, QVector<T>& v) QDataStream& operator>>(QDataStream& s, QVector<T>& v)
{ {

2
src/core/tools/qalgorithms.qdoc
View file

@ -28,7 +28,7 @@
<QtAlgorithms> that work on containers and perform well-know <QtAlgorithms> that work on containers and perform well-know
algorithms. You can use these algorithms with any \l {container algorithms. You can use these algorithms with any \l {container
class} that provides STL-style iterators, including Qt's QList, class} that provides STL-style iterators, including Qt's QList,
QLinkedList, QVector, QMap, and QHash classes. QVector, QMap, and QHash classes.
These functions have taken their inspiration from similar These functions have taken their inspiration from similar
functions available in the STL \c <algorithm> header. Most of them functions available in the STL \c <algorithm> header. Most of them

1
src/core/tools/qcontainerfwd.h
View file

@ -29,7 +29,6 @@ QT_BEGIN_NAMESPACE
template <class Key, class T> class QCache; template <class Key, class T> class QCache;
template <class Key, class T> class QHash; template <class Key, class T> class QHash;
template <class T> class QLinkedList;
template <class T> class QList; template <class T> class QList;
template <class Key, class T> class QMap; template <class Key, class T> class QMap;
template <class Key, class T> class QMultiHash; template <class Key, class T> class QMultiHash;

123
src/core/tools/qiterator.qdoc
View file

@ -70,54 +70,6 @@
\sa QMutableListIterator, QList::const_iterator \sa QMutableListIterator, QList::const_iterator
*/ */
/*!
\class QLinkedListIterator
\inmodule QtCore
\brief The QLinkedListIterator class provides a Java-style const iterator for QLinkedList.
QLinkedList has both \l{Java-style iterators} and
\l{STL-style iterators}. The Java-style iterators are more
high-level and easier to use than the STL-style iterators; on the
other hand, they are slightly less efficient.
QLinkedListIterator\<T\> allows you to iterate over a
QLinkedList\<T\>. If you want to modify the list as you iterate
over it, use QMutableLinkedListIterator\<T\> instead.
The QLinkedListIterator constructor takes a QLinkedList as
argument. After construction, the iterator is located at the very
beginning of the list (before the first item). Here's how to
iterate over all the elements sequentially:
\snippet doc/src/snippets/code/doc_src_qiterator.cpp 2
The next() function returns the next item in the list and
advances the iterator. Unlike STL-style iterators, Java-style
iterators point \e between items rather than directly \e at
items. The first call to next() advances the iterator to the
position between the first and second item, and returns the first
item; the second call to next() advances the iterator to the
position between the second and third item, and returns the second
item; and so on.
\img javaiterators1.png
Here's how to iterate over the elements in reverse order:
\snippet doc/src/snippets/code/doc_src_qiterator.cpp 3
If you want to find all occurrences of a particular value, use
findNext() or findPrevious() in a loop.
Multiple iterators can be used on the same list. If the list is
modified while a QLinkedListIterator is active, the
QLinkedListIterator will continue iterating over the original
list, ignoring the modified copy.
\sa QMutableLinkedListIterator, QLinkedList::const_iterator
*/
/*! /*!
\class QVectorIterator \class QVectorIterator
\inmodule QtCore \inmodule QtCore
@ -283,67 +235,6 @@
\sa QListIterator, QList::iterator \sa QListIterator, QList::iterator
*/ */
/*!
\class QMutableLinkedListIterator
\inmodule QtCore
\brief The QMutableLinkedListIterator class provides a Java-style non-const iterator for QLinkedList.
QLinkedList has both \l{Java-style iterators} and
\l{STL-style iterators}. The Java-style iterators are more
high-level and easier to use than the STL-style iterators; on the
other hand, they are slightly less efficient.
QMutableLinkedListIterator\<T\> allows you to iterate over a
QLinkedList\<T\> and modify the list. If you don't want to modify
the list (or have a const QLinkedList), use the slightly faster
QLinkedListIterator\<T\> instead.
The QMutableLinkedListIterator constructor takes a QLinkedList as
argument. After construction, the iterator is located at the very
beginning of the list (before the first item). Here's how to
iterate over all the elements sequentially:
\snippet doc/src/snippets/code/doc_src_qiterator.cpp 11
The next() function returns the next item in the list and
advances the iterator. Unlike STL-style iterators, Java-style
iterators point \e between items rather than directly \e at
items. The first call to next() advances the iterator to the
position between the first and second item, and returns the first
item; the second call to next() advances the iterator to the
position between the second and third item, returning the second
item; and so on.
\img javaiterators1.png
Here's how to iterate over the elements in reverse order:
\snippet doc/src/snippets/code/doc_src_qiterator.cpp 12
If you want to find all occurrences of a particular value, use
findNext() or findPrevious() in a loop.
If you want to remove items as you iterate over the list, use
remove(). If you want to modify the value of an item, use
setValue(). If you want to insert a new item in the list, use
insert().
Example:
\snippet doc/src/snippets/code/doc_src_qiterator.cpp 13
The example traverses a list, replacing negative numbers with
their absolute values, and eliminating zeroes.
Only one mutable iterator can be active on a given list at any
time. Furthermore, no changes should be done directly to the list
while the iterator is active (as opposed to through the
iterator), since this could invalidate the iterator and lead to
undefined behavior.
\sa QLinkedListIterator, QLinkedList::iterator
*/
/*! /*!
\class QMutableVectorIterator \class QMutableVectorIterator
\inmodule QtCore \inmodule QtCore
@ -463,9 +354,7 @@
/*! /*!
\fn QListIterator::QListIterator(const QList<T> &list) \fn QListIterator::QListIterator(const QList<T> &list)
\fn QLinkedListIterator::QLinkedListIterator(const QLinkedList<T> &list)
\fn QMutableListIterator::QMutableListIterator(QList<T> &list) \fn QMutableListIterator::QMutableListIterator(QList<T> &list)
\fn QMutableLinkedListIterator::QMutableLinkedListIterator(QLinkedList<T> &list)
Constructs an iterator for traversing \a list. The iterator is Constructs an iterator for traversing \a list. The iterator is
set to be at the front of the list (before the first item). set to be at the front of the list (before the first item).
@ -505,9 +394,7 @@
*/ */
/*! \fn QMutableListIterator &QMutableListIterator::operator=(QList<T> &list) /*! \fn QMutableListIterator &QMutableListIterator::operator=(QList<T> &list)
\fn QMutableLinkedListIterator &QMutableLinkedListIterator::operator=(QLinkedList<T> &list)
\fn QListIterator &QListIterator::operator=(const QList<T> &list) \fn QListIterator &QListIterator::operator=(const QList<T> &list)
\fn QLinkedListIterator &QLinkedListIterator::operator=(const QLinkedList<T> &list)
Makes the iterator operate on \a list. The iterator is set to be Makes the iterator operate on \a list. The iterator is set to be
at the front of the list (before the first item). at the front of the list (before the first item).
@ -534,7 +421,6 @@
*/ */
/*! \fn void QListIterator::toFront() /*! \fn void QListIterator::toFront()
\fn void QLinkedListIterator::toFront()
\fn void QVectorIterator::toFront() \fn void QVectorIterator::toFront()
\fn void QSetIterator::toFront() \fn void QSetIterator::toFront()
\fn void QMutableListIterator::toFront() \fn void QMutableListIterator::toFront()
@ -549,7 +435,6 @@
*/ */
/*! \fn void QListIterator::toBack() /*! \fn void QListIterator::toBack()
\fn void QLinkedListIterator::toBack()
\fn void QVectorIterator::toBack() \fn void QVectorIterator::toBack()
\fn void QSetIterator::toBack() \fn void QSetIterator::toBack()
\fn void QMutableListIterator::toBack() \fn void QMutableListIterator::toBack()
@ -564,7 +449,6 @@
*/ */
/*! \fn bool QListIterator::hasNext() const /*! \fn bool QListIterator::hasNext() const
\fn bool QLinkedListIterator::hasNext() const
\fn bool QVectorIterator::hasNext() const \fn bool QVectorIterator::hasNext() const
\fn bool QSetIterator::hasNext() const \fn bool QSetIterator::hasNext() const
\fn bool QMutableListIterator::hasNext() const \fn bool QMutableListIterator::hasNext() const
@ -580,7 +464,6 @@
*/ */
/*! \fn const T &QListIterator::next() /*! \fn const T &QListIterator::next()
\fn const T &QLinkedListIterator::next()
\fn const T &QVectorIterator::next() \fn const T &QVectorIterator::next()
\fn const T &QSetIterator::next() \fn const T &QSetIterator::next()
\fn const T &QMutableSetIterator::next() \fn const T &QMutableSetIterator::next()
@ -607,7 +490,6 @@
*/ */
/*! \fn const T &QListIterator::peekNext() const /*! \fn const T &QListIterator::peekNext() const
\fn const T &QLinkedListIterator::peekNext() const
\fn const T &QVectorIterator::peekNext() const \fn const T &QVectorIterator::peekNext() const
\fn const T &QSetIterator::peekNext() const \fn const T &QSetIterator::peekNext() const
\fn const T &QMutableSetIterator::peekNext() const \fn const T &QMutableSetIterator::peekNext() const
@ -633,7 +515,6 @@
*/ */
/*! \fn bool QListIterator::hasPrevious() const /*! \fn bool QListIterator::hasPrevious() const
\fn bool QLinkedListIterator::hasPrevious() const
\fn bool QVectorIterator::hasPrevious() const \fn bool QVectorIterator::hasPrevious() const
\fn bool QSetIterator::hasPrevious() const \fn bool QSetIterator::hasPrevious() const
\fn bool QMutableListIterator::hasPrevious() const \fn bool QMutableListIterator::hasPrevious() const
@ -649,7 +530,6 @@
*/ */
/*! \fn const T &QListIterator::previous() /*! \fn const T &QListIterator::previous()
\fn const T &QLinkedListIterator::previous()
\fn const T &QVectorIterator::previous() \fn const T &QVectorIterator::previous()
\fn const T &QSetIterator::previous() \fn const T &QSetIterator::previous()
\fn const T &QMutableSetIterator::previous() \fn const T &QMutableSetIterator::previous()
@ -677,7 +557,6 @@
*/ */
/*! \fn const T &QListIterator::peekPrevious() const /*! \fn const T &QListIterator::peekPrevious() const
\fn const T &QLinkedListIterator::peekPrevious() const
\fn const T &QVectorIterator::peekPrevious() const \fn const T &QVectorIterator::peekPrevious() const
\fn const T &QSetIterator::peekPrevious() const \fn const T &QSetIterator::peekPrevious() const
\fn const T &QMutableSetIterator::peekPrevious() const \fn const T &QMutableSetIterator::peekPrevious() const
@ -703,7 +582,6 @@
*/ */
/*! \fn bool QListIterator::findNext(const T &value) /*! \fn bool QListIterator::findNext(const T &value)
\fn bool QLinkedListIterator::findNext(const T &value)
\fn bool QVectorIterator::findNext(const T &value) \fn bool QVectorIterator::findNext(const T &value)
\fn bool QSetIterator::findNext(const T &value) \fn bool QSetIterator::findNext(const T &value)
\fn bool QMutableListIterator::findNext(const T &value) \fn bool QMutableListIterator::findNext(const T &value)
@ -722,7 +600,6 @@
*/ */
/*! \fn bool QListIterator::findPrevious(const T &value) /*! \fn bool QListIterator::findPrevious(const T &value)
\fn bool QLinkedListIterator::findPrevious(const T &value)
\fn bool QVectorIterator::findPrevious(const T &value) \fn bool QVectorIterator::findPrevious(const T &value)
\fn bool QSetIterator::findPrevious(const T &value) \fn bool QSetIterator::findPrevious(const T &value)
\fn bool QMutableListIterator::findPrevious(const T &value) \fn bool QMutableListIterator::findPrevious(const T &value)

1135
src/core/tools/qlinkedlist.cpp
View file

File diff suppressed because it is too large Load diff

458
src/core/tools/qlinkedlist.h
View file

@ -1,458 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2015 The Qt Company Ltd.
** Copyright (C) 2016 Ivailo Monev
**
** This file is part of the QtCore module of the Katie Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
**
** GNU Lesser General Public License Usage
** 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.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QLINKEDLIST_H
#define QLINKEDLIST_H
#include <QtCore/qiterator.h>
#include <QtCore/qatomic.h>
#include <iterator>
#include <list>
QT_BEGIN_NAMESPACE
struct Q_CORE_EXPORT QLinkedListData
{
QLinkedListData *n, *p;
QAtomicInt ref;
int size;
static QLinkedListData shared_null;
};
template <typename T>
struct QLinkedListNode
{
inline QLinkedListNode(const T &arg): t(arg) { }
QLinkedListNode *n, *p;
T t;
};
template <class T>
class Q_CORE_EXPORT QLinkedList
{
typedef QLinkedListNode<T> Node;
union { QLinkedListData *d; QLinkedListNode<T> *e; };
public:
inline QLinkedList() : d(&QLinkedListData::shared_null) { d->ref.ref(); }
inline QLinkedList(const QLinkedList<T> &l) : d(l.d) { d->ref.ref(); }
~QLinkedList();
QLinkedList<T> &operator=(const QLinkedList<T> &);
inline QLinkedList<T> &operator=(QLinkedList<T> &&other)
{ qSwap(d, other.d); return *this; }
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); }
inline int size() const { return d->size; }
inline bool isEmpty() const { return d->size == 0; }
void clear();
void append(const T &);
void prepend(const T &);
T takeFirst();
T takeLast();
int removeAll(const T &t);
bool removeOne(const T &t);
bool contains(const T &t) const;
int count(const T &t) const;
class const_iterator;
class iterator
{
public:
typedef std::bidirectional_iterator_tag iterator_category;
typedef qptrdiff difference_type;
typedef T value_type;
typedef T *pointer;
typedef T &reference;
Node *i;
inline iterator() : i(nullptr) {}
inline iterator(Node *n) : i(n) {}
inline iterator(const iterator &o) : i(o.i) {}
inline iterator &operator=(const iterator &o) { i = o.i; return *this; }
inline T &operator*() const { return i->t; }
inline T *operator->() const { return &i->t; }
inline bool operator==(const iterator &o) const { return i == o.i; }
inline bool operator!=(const iterator &o) const { return i != o.i; }
inline bool operator==(const const_iterator &o) const
{ return i == o.i; }
inline bool operator!=(const const_iterator &o) const
{ return i != o.i; }
inline iterator &operator++() { i = i->n; return *this; }
inline iterator operator++(int) { Node *n = i; i = i->n; return n; }
inline iterator &operator--() { i = i->p; return *this; }
inline iterator operator--(int) { Node *n = i; i = i->p; return n; }
inline iterator operator+(int j) const
{ Node *n = i; if (j > 0) while (j--) n = n->n; else while (j++) n = n->p; return n; }
inline iterator operator-(int j) const { return operator+(-j); }
inline iterator &operator+=(int j) { return *this = *this + j; }
inline iterator &operator-=(int j) { return *this = *this - j; }
};
friend class iterator;
class const_iterator
{
public:
typedef std::bidirectional_iterator_tag iterator_category;
typedef qptrdiff difference_type;
typedef T value_type;
typedef const T *pointer;
typedef const T &reference;
Node *i;
inline const_iterator() : i(nullptr) {}
inline const_iterator(Node *n) : i(n) {}
inline const_iterator(const const_iterator &o) : i(o.i){}
inline const_iterator(iterator ci) : i(ci.i){}
inline const_iterator &operator=(const const_iterator &o) { i = o.i; return *this; }
inline const T &operator*() const { return i->t; }
inline const T *operator->() const { return &i->t; }
inline bool operator==(const const_iterator &o) const { return i == o.i; }
inline bool operator!=(const const_iterator &o) const { return i != o.i; }
inline const_iterator &operator++() { i = i->n; return *this; }
inline const_iterator operator++(int) { Node *n = i; i = i->n; return n; }
inline const_iterator &operator--() { i = i->p; return *this; }
inline const_iterator operator--(int) { Node *n = i; i = i->p; return n; }
inline const_iterator operator+(int j) const
{ Node *n = i; if (j > 0) while (j--) n = n->n; else while (j++) n = n->p; return n; }
inline const_iterator operator-(int j) const { return operator+(-j); }
inline const_iterator &operator+=(int j) { return *this = *this + j; }
inline const_iterator &operator-=(int j) { return *this = *this - j; }
};
friend class const_iterator;
// stl style
inline iterator begin() { detach(); return e->n; }
inline const_iterator begin() const { return e->n; }
inline const_iterator constBegin() const { return e->n; }
inline iterator end() { detach(); return e; }
inline const_iterator end() const { return e; }
inline const_iterator constEnd() const { return e; }
iterator insert(iterator before, const T &t);
iterator erase(iterator pos);
iterator erase(iterator first, iterator last);
// more Qt
typedef iterator Iterator;
typedef const_iterator ConstIterator;
inline int count() const { return d->size; }
inline T& first() { Q_ASSERT(!isEmpty()); return *begin(); }
inline const T& first() const { Q_ASSERT(!isEmpty()); return *begin(); }
T& last() { Q_ASSERT(!isEmpty()); return *(--end()); }
const T& last() const { Q_ASSERT(!isEmpty()); return *(--end()); }
inline void removeFirst() { Q_ASSERT(!isEmpty()); erase(begin()); }
inline void removeLast() { Q_ASSERT(!isEmpty()); erase(--end()); }
inline bool startsWith(const T &t) const { return !isEmpty() && first() == t; }
inline bool endsWith(const T &t) const { return !isEmpty() && last() == t; }
// stl compatibility
inline void push_back(const T &t) { append(t); }
inline void push_front(const T &t) { prepend(t); }
inline T& front() { return first(); }
inline const T& front() const { return first(); }
inline T& back() { return last(); }
inline const T& back() const { return last(); }
inline void pop_front() { removeFirst(); }
inline void pop_back() { removeLast(); }
inline bool empty() const { return isEmpty(); }
typedef int size_type;
typedef T value_type;
typedef value_type *pointer;
typedef const value_type *const_pointer;
typedef value_type &reference;
typedef const value_type &const_reference;
typedef qptrdiff difference_type;
static inline QLinkedList<T> fromStdList(const std::list<T> &list)
{ QLinkedList<T> tmp; qCopy(list.begin(), list.end(), std::back_inserter(tmp)); return tmp; }
inline std::list<T> toStdList() const
{ std::list<T> tmp; qCopy(constBegin(), constEnd(), std::back_inserter(tmp)); return tmp; }
// comfort
QLinkedList<T> &operator+=(const QLinkedList<T> &l);
QLinkedList<T> operator+(const QLinkedList<T> &l) const;
inline QLinkedList<T> &operator+=(const T &t) { append(t); return *this; }
inline QLinkedList<T> &operator<< (const T &t) { append(t); return *this; }
inline QLinkedList<T> &operator<<(const QLinkedList<T> &l) { *this += l; return *this; }
private:
inline void detach() { if (d->ref != 1) detach_helper(); }
void detach_helper();
void freeData(QLinkedListData*);
};
template <typename T>
inline QLinkedList<T>::~QLinkedList()
{
if (!d->ref.deref())
freeData(d);
}
template <typename T>
void QLinkedList<T>::detach_helper()
{
union { QLinkedListData *d; Node *e; } x;
x.d = new QLinkedListData;
x.d->ref = 1;
x.d->size = d->size;
Node *original = e->n;
Node *copy = x.e;
while (original != e) {
copy->n = new Node(original->t);
copy->n->p = copy;
original = original->n;
copy = copy->n;
}
copy->n = x.e;
x.e->p = copy;
if (!d->ref.deref())
freeData(d);
d = x.d;
}
template <typename T>
void QLinkedList<T>::freeData(QLinkedListData *x)
{
Node *y = reinterpret_cast<Node*>(x);
Node *i = y->n;
if (x->ref == 0) {
while(i != y) {
Node *n = i;
i = i->n;
delete n;
}
delete x;
}
}
template <typename T>
void QLinkedList<T>::clear()
{
*this = QLinkedList<T>();
}
template <typename T>
QLinkedList<T> &QLinkedList<T>::operator=(const QLinkedList<T> &l)
{
if (d != l.d) {
QLinkedListData *o = l.d;
o->ref.ref();
if (!d->ref.deref())
freeData(d);
d = o;
}
return *this;
}
template <typename T>
bool QLinkedList<T>::operator== (const QLinkedList<T> &l) const
{
if (d->size != l.d->size)
return false;
if (e == l.e)
return true;
Node *i = e->n;
Node *il = l.e->n;
while (i != e) {
if (! (i->t == il->t))
return false;
i = i->n;
il = il->n;
}
return true;
}
template <typename T>
void QLinkedList<T>::append(const T &t)
{
detach();
Node *i = new Node(t);
i->n = e;
i->p = e->p;
i->p->n = i;
e->p = i;
d->size++;
}
template <typename T>
void QLinkedList<T>::prepend(const T &t)
{
detach();
Node *i = new Node(t);
i->n = e->n;
i->p = e;
i->n->p = i;
e->n = i;
d->size++;
}
template <typename T>
int QLinkedList<T>::removeAll(const T &_t)
{
detach();
const T t = _t;
Node *i = e->n;
int c = 0;
while (i != e) {
if (i->t == t) {
Node *n = i;
i->n->p = i->p;
i->p->n = i->n;
i = i->n;
delete n;
c++;
} else {
i = i->n;
}
}
d->size-=c;
return c;
}
template <typename T>
bool QLinkedList<T>::removeOne(const T &_t)
{
detach();
iterator it = qFind(begin(), end(), _t);
if (it != end()) {
erase(it);
return true;
}
return false;
}
template <typename T>
inline T QLinkedList<T>::takeFirst()
{
T t = first();
removeFirst();
return t;
}
template <typename T>
inline T QLinkedList<T>::takeLast()
{
T t = last();
removeLast();
return t;
}
template <typename T>
bool QLinkedList<T>::contains(const T &t) const
{
Node *i = e;
while ((i = i->n) != e)
if (i->t == t)
return true;
return false;
}
template <typename T>
int QLinkedList<T>::count(const T &t) const
{
Node *i = e;
int c = 0;
while ((i = i->n) != e)
if (i->t == t)
c++;
return c;
}
template <typename T>
typename QLinkedList<T>::iterator QLinkedList<T>::insert(iterator before, const T &t)
{
Node *i = before.i;
Node *m = new Node(t);
m->n = i;
m->p = i->p;
m->p->n = m;
i->p = m;
d->size++;
return m;
}
template <typename T>
typename QLinkedList<T>::iterator QLinkedList<T>::erase(typename QLinkedList<T>::iterator afirst,
typename QLinkedList<T>::iterator alast)
{
while (afirst != alast)
erase(afirst++);
return alast;
}
template <typename T>
typename QLinkedList<T>::iterator QLinkedList<T>::erase(iterator pos)
{
detach();
Node *i = pos.i;
if (i != e) {
Node *n = i;
i->n->p = i->p;
i->p->n = i->n;
i = i->n;
delete n;
d->size--;
}
return i;
}
template <typename T>
QLinkedList<T> &QLinkedList<T>::operator+=(const QLinkedList<T> &l)
{
detach();
int n = l.d->size;
d->size += n;
Node *original = l.e->n;
while (n--) {
Node *copy = new Node(original->t);
original = original->n;
copy->n = e;
copy->p = e->p;
copy->p->n = copy;
e->p = copy;
}
return *this;
}
template <typename T>
QLinkedList<T> QLinkedList<T>::operator+(const QLinkedList<T> &l) const
{
QLinkedList<T> n = *this;
n += l;
return n;
}
Q_DECLARE_SEQUENTIAL_ITERATOR(LinkedList)
Q_DECLARE_MUTABLE_SEQUENTIAL_ITERATOR(LinkedList)
QT_END_NAMESPACE
#endif // QLINKEDLIST_H

26
src/core/tools/qlist.cpp
View file

@ -280,18 +280,14 @@ void **QListData::erase(void **xi)
stores a list of values and provides fast index-based access as stores a list of values and provides fast index-based access as
well as fast insertions and removals. well as fast insertions and removals.
QList\<T\>, QLinkedList\<T\>, and QVector\<T\> provide similar QList\<T\>, and QVector\<T\> provide similar functionality.
functionality. Here's an overview: Here's an overview:
\list \list
\i For most purposes, QList is the right class to use. Its \i For most purposes, QList is the right class to use. It is
index-based API is more convenient than QLinkedList's usually faster than QVector because of the way it stores
iterator-based API, and it is usually faster than its items in memory. It also expands to less code in your
QVector because of the way it stores its items in executable.
memory. It also expands to less code in your executable.
\i If you need a real linked list, with guarantees of \l{constant
time} insertions in the middle of the list and iterators to
items rather than indexes, use QLinkedList.
\i If you want the items to occupy adjacent memory positions, \i If you want the items to occupy adjacent memory positions,
use QVector. use QVector.
\endlist \endlist
@ -415,7 +411,7 @@ void **QListData::erase(void **xi)
value that might not be in the valid range, check that it is less value that might not be in the valid range, check that it is less
than the value returned by size() but \e not less than 0. than the value returned by size() but \e not less than 0.
\sa QListIterator, QMutableListIterator, QLinkedList, QVector \sa QListIterator, QMutableListIterator, QVector
*/ */
/*! /*!
@ -1162,9 +1158,7 @@ void **QListData::erase(void **xi)
Multiple iterators can be used on the same list. However, be Multiple iterators can be used on the same list. However, be
aware that any non-const function call performed on the QList aware that any non-const function call performed on the QList
will render all existing iterators undefined. If you need to keep will render all existing iterators undefined.
iterators over a long period of time, we recommend that you use
QLinkedList rather than QList.
\sa QList::const_iterator, QMutableListIterator \sa QList::const_iterator, QMutableListIterator
*/ */
@ -1411,9 +1405,7 @@ void **QListData::erase(void **xi)
Multiple iterators can be used on the same list. However, be Multiple iterators can be used on the same list. However, be
aware that any non-const function call performed on the QList aware that any non-const function call performed on the QList
will render all existing iterators undefined. If you need to keep will render all existing iterators undefined.
iterators over a long period of time, we recommend that you use
QLinkedList rather than QList.
\sa QList::iterator, QListIterator \sa QList::iterator, QListIterator
*/ */

9
src/core/tools/qvarlengtharray.qdoc
View file

@ -78,7 +78,7 @@
places inside Qt and was added to Qt's public API for the places inside Qt and was added to Qt's public API for the
convenience of advanced users. convenience of advanced users.
\sa QVector, QList, QLinkedList \sa QVector, QList
*/ */
/*! \fn QVarLengthArray::QVarLengthArray(int size) /*! \fn QVarLengthArray::QVarLengthArray(int size)
@ -354,8 +354,7 @@
For large arrays, this operation can be slow (\l{linear time}), For large arrays, this operation can be slow (\l{linear time}),
because it requires moving all the items in the vector by one because it requires moving all the items in the vector by one
position further in memory. If you want a container class that position further in memory. If you want a container class that
provides a fast prepend() function, use QList or QLinkedList provides a fast prepend() function, use QList instead.
instead.
\sa append(), insert() \sa append(), insert()
*/ */
@ -468,9 +467,7 @@
For large arrays, this operation can be slow (\l{linear time}), For large arrays, this operation can be slow (\l{linear time}),
because it requires moving all the items at indexes \a i and because it requires moving all the items at indexes \a i and
above by one position further in memory. If you want a container above by one position further in memory.
class that provides a fast insert() function, use QLinkedList
instead.
\sa remove() \sa remove()
*/ */

24
src/core/tools/qvector.cpp
View file

@ -89,20 +89,15 @@ int QVectorData::grow(int sizeofTypedData, int size, int sizeofT, bool excessive
stores its items in adjacent memory locations and provides fast stores its items in adjacent memory locations and provides fast
index-based access. index-based access.
QList\<T\>, QLinkedList\<T\>, and QVarLengthArray\<T\> provide QList\<T\> and QVarLengthArray\<T\> provide similar functionality.
similar functionality. Here's an overview: Here's an overview:
\list \list
\i For most purposes, QList is the right class to use. Operations \i For most purposes, QList is the right class to use. Operations
like prepend() and insert() are usually faster than with like prepend() and insert() are usually faster than with
QVector because of the way QList stores its items in memory QVector because of the way QList stores its items in memory
(see \l{Algorithmic Complexity} for details), (see \l{Algorithmic Complexity} for details). It also expands
and its index-based API is more convenient than QLinkedList's to less code in your executable.
iterator-based API. It also expands to less code in your
executable.
\i If you need a real linked list, with guarantees of \l{constant
time} insertions in the middle of the list and iterators to
items rather than indexes, use QLinkedList.
\i If you want the items to occupy adjacent memory positions, or \i If you want the items to occupy adjacent memory positions, or
if your items are larger than a pointer and you want to avoid if your items are larger than a pointer and you want to avoid
the overhead of allocating them on the heap individually at the overhead of allocating them on the heap individually at
@ -171,7 +166,7 @@ int QVectorData::grow(int sizeofTypedData, int size, int sizeofT, bool excessive
(\l{linear time}) for large vectors, because they require moving many (\l{linear time}) for large vectors, because they require moving many
items in the vector by one position in memory. If you want a container items in the vector by one position in memory. If you want a container
class that provides fast insertion/removal in the middle, use class that provides fast insertion/removal in the middle, use
QList or QLinkedList instead. QList instead.
Unlike plain C++ arrays, QVectors can be resized at any time by Unlike plain C++ arrays, QVectors can be resized at any time by
calling resize(). If the new size is larger than the old size, calling resize(). If the new size is larger than the old size,
@ -210,7 +205,7 @@ int QVectorData::grow(int sizeofTypedData, int size, int sizeofT, bool excessive
with references to its own values. Doing so will cause your application to with references to its own values. Doing so will cause your application to
abort with an error message. abort with an error message.
\sa QVectorIterator, QMutableVectorIterator, QList, QLinkedList \sa QVectorIterator, QMutableVectorIterator, QList
*/ */
/*! /*!
@ -486,8 +481,7 @@ int QVectorData::grow(int sizeofTypedData, int size, int sizeofT, bool excessive
For large vectors, this operation can be slow (\l{linear time}), For large vectors, this operation can be slow (\l{linear time}),
because it requires moving all the items in the vector by one because it requires moving all the items in the vector by one
position further in memory. If you want a container class that position further in memory. If you want a container class that
provides a fast prepend() function, use QList or QLinkedList provides a fast prepend() function, use QList instead.
instead.
\sa append(), insert() \sa append(), insert()
*/ */
@ -503,9 +497,7 @@ int QVectorData::grow(int sizeofTypedData, int size, int sizeofT, bool excessive
For large vectors, this operation can be slow (\l{linear time}), For large vectors, this operation can be slow (\l{linear time}),
because it requires moving all the items at indexes \a i and because it requires moving all the items at indexes \a i and
above by one position further in memory. If you want a container above by one position further in memory.
class that provides a fast insert() function, use QLinkedList
instead.
\sa append(), prepend(), remove() \sa append(), prepend(), remove()
*/ */

8
src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
View file

@ -21,7 +21,7 @@
#include <QtGui/qwidget.h> #include <QtGui/qwidget.h>
#include <QtGui/qapplication.h> #include <QtGui/qapplication.h>
#include <QtCore/qlinkedlist.h> #include <QtCore/qlist.h>
#include <QtCore/qstack.h> #include <QtCore/qstack.h>
#include <QtCore/qqueue.h> #include <QtCore/qqueue.h>
@ -2482,7 +2482,7 @@ QGraphicsAnchorLayoutPrivate::getGraphParts(Orientation orientation)
edgeL1 = graph[orientation].edgeData(layoutFirstVertex[orientation], layoutLastVertex[orientation]); edgeL1 = graph[orientation].edgeData(layoutFirstVertex[orientation], layoutLastVertex[orientation]);
} }
QLinkedList<QSimplexConstraint *> remainingConstraints; QList<QSimplexConstraint *> remainingConstraints;
for (int i = 0; i < constraints[orientation].count(); ++i) { for (int i = 0; i < constraints[orientation].count(); ++i) {
remainingConstraints += constraints[orientation].at(i); remainingConstraints += constraints[orientation].at(i);
} }
@ -2501,7 +2501,7 @@ QGraphicsAnchorLayoutPrivate::getGraphParts(Orientation orientation)
do { do {
dirty = false; dirty = false;
QLinkedList<QSimplexConstraint *>::iterator it = remainingConstraints.begin(); QList<QSimplexConstraint *>::iterator it = remainingConstraints.begin();
while (it != remainingConstraints.end()) { while (it != remainingConstraints.end()) {
QSimplexConstraint *c = *it; QSimplexConstraint *c = *it;
bool match = false; bool match = false;
@ -2541,7 +2541,7 @@ QGraphicsAnchorLayoutPrivate::getGraphParts(Orientation orientation)
if (!remainingConstraints.isEmpty()) { if (!remainingConstraints.isEmpty()) {
QList<QSimplexConstraint *> nonTrunkConstraints; QList<QSimplexConstraint *> nonTrunkConstraints;
QLinkedList<QSimplexConstraint *>::iterator it = remainingConstraints.begin(); QList<QSimplexConstraint *>::iterator it = remainingConstraints.begin();
while (it != remainingConstraints.end()) { while (it != remainingConstraints.end()) {
nonTrunkConstraints += *it; nonTrunkConstraints += *it;
++it; ++it;

3
src/gui/itemviews/qtableview_p.h
View file

@ -34,7 +34,6 @@
// //
#include <QtCore/QList> #include <QtCore/QList>
#include <QtCore/QLinkedList>
#include <QtCore/QMap> #include <QtCore/QMap>
#include <QtCore/QSet> #include <QtCore/QSet>
#include <QtCore/QDebug> #include <QtCore/QDebug>
@ -92,7 +91,7 @@ public:
void updateRemovedRows(int start, int end); void updateRemovedRows(int start, int end);
void updateRemovedColumns(int start, int end); void updateRemovedColumns(int start, int end);
typedef QLinkedList<Span *> SpanList; typedef QList<Span *> SpanList;
SpanList spans; //lists of all spans SpanList spans; //lists of all spans
private: private:
//the indexes are negative so the QMap::lowerBound do what i need. //the indexes are negative so the QMap::lowerBound do what i need.

8
src/script/api/qscriptvalueiterator.cpp
View file

@ -26,7 +26,7 @@
#include "qscriptengine.h" #include "qscriptengine.h"
#include "qscriptengine_p.h" #include "qscriptengine_p.h"
#include "qscriptvalue_p.h" #include "qscriptvalue_p.h"
#include "qlinkedlist.h" #include "qlist.h"
#include "JSObject.h" #include "JSObject.h"
@ -123,9 +123,9 @@ public:
} }
QScriptValue objectValue; QScriptValue objectValue;
QLinkedList<JSC::Identifier> propertyNames; QList<JSC::Identifier> propertyNames;
QLinkedList<JSC::Identifier>::iterator it; QList<JSC::Identifier>::iterator it;
QLinkedList<JSC::Identifier>::iterator current; QList<JSC::Identifier>::iterator current;
bool initialized; bool initialized;
}; };

2
src/tools/uic/cpp/cppwriteincludes.cpp
View file

@ -358,8 +358,6 @@ static const struct ClassTblData {
{ QLatin1String("QLineEdit"), QLatin1String("QtGui/qlineedit.h") }, { QLatin1String("QLineEdit"), QLatin1String("QtGui/qlineedit.h") },
{ QLatin1String("QLineF"), QLatin1String("QtCore/qline.h") }, { QLatin1String("QLineF"), QLatin1String("QtCore/qline.h") },
{ QLatin1String("QLinearGradient"), QLatin1String("QtGui/qbrush.h") }, { QLatin1String("QLinearGradient"), QLatin1String("QtGui/qbrush.h") },
{ QLatin1String("QLinkedList"), QLatin1String("QtCore/qlinkedlist.h") },
{ QLatin1String("QLinkedListData"), QLatin1String("QtCore/qlinkedlist.h") },
{ QLatin1String("QList"), QLatin1String("QtCore/qlist.h") }, { QLatin1String("QList"), QLatin1String("QtCore/qlist.h") },
{ QLatin1String("QListData"), QLatin1String("QtCore/qlist.h") }, { QLatin1String("QListData"), QLatin1String("QtCore/qlist.h") },
{ QLatin1String("QListView"), QLatin1String("QtGui/qlistview.h") }, { QLatin1String("QListView"), QLatin1String("QtGui/qlistview.h") },

19
tests/auto/qdatastream/tst_qdatastream.cpp
View file

@ -22,7 +22,7 @@
#include <QtTest/QtTest> #include <QtTest/QtTest>
#include <QtCore/QBuffer> #include <QtCore/QBuffer>
#include <QLinkedList> #include <QList>
#include <QtCore/qendian.h> #include <QtCore/qendian.h>
#include <QtGui/QtGui> #include <QtGui/QtGui>
#include <QtSvg/QtSvg> #include <QtSvg/QtSvg>
@ -167,7 +167,7 @@ private slots:
void status_QHash_QMap(); void status_QHash_QMap();
void status_QLinkedList_QList_QVector(); void status_QList_QVector();
void streamToAndFromQByteArray(); void streamToAndFromQByteArray();
@ -2814,17 +2814,6 @@ void tst_QDataStream::status_QHash_QMap()
QCOMPARE(list.size(), expectedList.size()); \ QCOMPARE(list.size(), expectedList.size()); \
QCOMPARE(list, expectedList); \ QCOMPARE(list, expectedList); \
} \ } \
{ \
LinkedList expectedLinkedList; \
for (int i = 0; i < expectedList.count(); ++i) \
expectedLinkedList << expectedList.at(i); \
QByteArray ba = byteArray; \
QDataStream stream(&ba, QIODevice::ReadOnly); \
stream >> linkedList; \
QCOMPARE((int)stream.status(), (int)expectedStatus); \
QCOMPARE(linkedList.size(), expectedLinkedList.size()); \
QCOMPARE(linkedList, expectedLinkedList); \
} \
{ \ { \
Vector expectedVector; \ Vector expectedVector; \
for (int i = 0; i < expectedList.count(); ++i) \ for (int i = 0; i < expectedList.count(); ++i) \
@ -2837,12 +2826,10 @@ void tst_QDataStream::status_QHash_QMap()
QCOMPARE(vector, expectedVector); \ QCOMPARE(vector, expectedVector); \
} }
void tst_QDataStream::status_QLinkedList_QList_QVector() void tst_QDataStream::status_QList_QVector()
{ {
typedef QLinkedList<QString> LinkedList;
typedef QList<QString> List; typedef QList<QString> List;
typedef QVector<QString> Vector; typedef QVector<QString> Vector;
LinkedList linkedList;
List list; List list;
Vector vector; Vector vector;

2
util/qlalr/cppgenerator.cpp
View file

@ -205,7 +205,7 @@ void CppGenerator::operator () ()
<< endl; << endl;
} }
QBitArray used_rules (grammar.rules.count ()); QBitArray used_rules (grammar.rules.size ());
int q = 0; int q = 0;
for (StatePointer state = aut.states.begin (); state != aut.states.end (); ++state, ++q) for (StatePointer state = aut.states.begin (); state != aut.states.end (); ++state, ++q)

4
util/qlalr/lalr.cpp
View file

@ -313,7 +313,7 @@ QPair<StatePointer, bool> Automaton::internState (const State &state)
struct _Bucket struct _Bucket
{ {
QLinkedList<ItemPointer> items; QList<ItemPointer> items;
void insert (ItemPointer item) void insert (ItemPointer item)
{ items.push_back (item); } { items.push_back (item); }
@ -322,7 +322,7 @@ struct _Bucket
{ {
State st (aut->_M_grammar); State st (aut->_M_grammar);
for (QLinkedList<ItemPointer>::iterator item = items.begin (); item != items.end (); ++item) for (QList<ItemPointer>::iterator item = items.begin (); item != items.end (); ++item)
st.insert ((*item)->next ()); st.insert ((*item)->next ());
return st; return st;

21
util/qlalr/lalr.h
View file

@ -27,11 +27,12 @@
#include <QtCore/QSet> #include <QtCore/QSet>
#include <QtCore/QStack> #include <QtCore/QStack>
#include <QtCore/QMap> #include <QtCore/QMap>
#include <QtCore/QLinkedList>
#include <QtCore/QString> #include <QtCore/QString>
#include <QtCore/QTextStream> #include <QtCore/QTextStream>
#include <QtCore/QPair> #include <QtCore/QPair>
#include <vector>
QT_BEGIN_NAMESPACE QT_BEGIN_NAMESPACE
class Rule; class Rule;
@ -127,21 +128,21 @@ public:
}; };
// names // names
typedef QLinkedList<QString>::iterator Name; typedef std::vector<QString>::iterator Name;
typedef QLinkedList<Name> NameList; typedef std::vector<Name> NameList;
typedef OrderedSet<Name> NameSet; typedef OrderedSet<Name> NameSet;
// items // items
typedef QLinkedList<Item> ItemList; typedef std::vector<Item> ItemList;
typedef ItemList::iterator ItemPointer; typedef ItemList::iterator ItemPointer;
// rules // rules
typedef QLinkedList<Rule> debug_infot; typedef std::vector<Rule> debug_infot;
typedef debug_infot::iterator RulePointer; typedef debug_infot::iterator RulePointer;
typedef QMultiMap<Name, RulePointer> RuleMap; typedef QMultiMap<Name, RulePointer> RuleMap;
// states // states
typedef QLinkedList<State> StateList; typedef std::vector<State> StateList;
typedef StateList::iterator StatePointer; typedef StateList::iterator StatePointer;
// arrows // arrows
@ -239,7 +240,7 @@ class Node
public: public:
typedef OrderedSet<Node<_Tp> > Repository; typedef OrderedSet<Node<_Tp> > Repository;
typedef typename Repository::iterator iterator; typedef typename Repository::iterator iterator;
typedef typename QLinkedList<iterator>::iterator edge_iterator; typedef typename std::vector<iterator>::iterator edge_iterator;
public: public:
static iterator get (_Tp data); static iterator get (_Tp data);
@ -277,7 +278,7 @@ public: // attributes
mutable bool root; mutable bool root;
mutable int dfn; mutable int dfn;
mutable _Tp data; mutable _Tp data;
mutable QLinkedList<iterator> outs; mutable std::vector<iterator> outs;
protected: protected:
inline Node () {} inline Node () {}
@ -299,7 +300,7 @@ typename Node<_Tp>::iterator Node<_Tp>::get (_Tp data)
} }
template <typename _Tp> template <typename _Tp>
QPair<typename QLinkedList<typename Node<_Tp>::iterator>::iterator, bool> Node<_Tp>::insertEdge (typename Node<_Tp>::iterator other) const QPair<typename std::vector<typename Node<_Tp>::iterator>::iterator, bool> Node<_Tp>::insertEdge (typename Node<_Tp>::iterator other) const
{ {
edge_iterator it = qFind (outs.begin (), outs.end (), other); edge_iterator it = qFind (outs.begin (), outs.end (), other);
@ -335,7 +336,7 @@ public:
QString decl_file_name; QString decl_file_name;
QString impl_file_name; QString impl_file_name;
QString token_prefix; QString token_prefix;
QLinkedList<QString> names; std::vector<QString> names;
Name start; Name start;
NameSet terminals; NameSet terminals;
NameSet non_terminals; NameSet non_terminals;

2
util/qlalr/main.cpp
View file

@ -104,7 +104,7 @@ int main (int argc, char *argv[])
if (! p.parse (file_name)) if (! p.parse (file_name))
exit (EXIT_FAILURE); exit (EXIT_FAILURE);
if (grammar.rules.isEmpty ()) if (grammar.rules.size() == 0)
{ {
qerr << "*** Fatal. No rules!" << endl; qerr << "*** Fatal. No rules!" << endl;
exit (EXIT_FAILURE); exit (EXIT_FAILURE);