diff options
Diffstat (limited to 'src/corelib/tools/qlinkedlist.cpp')
| -rw-r--r-- | src/corelib/tools/qlinkedlist.cpp | 1170 |
1 files changed, 1170 insertions, 0 deletions
diff --git a/src/corelib/tools/qlinkedlist.cpp b/src/corelib/tools/qlinkedlist.cpp new file mode 100644 index 0000000000..724cace8e6 --- /dev/null +++ b/src/corelib/tools/qlinkedlist.cpp @@ -0,0 +1,1170 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtCore module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** 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, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qlinkedlist.h" + +QT_BEGIN_NAMESPACE + +QLinkedListData QLinkedListData::shared_null = { + &QLinkedListData::shared_null, &QLinkedListData::shared_null, + Q_BASIC_ATOMIC_INITIALIZER(1), 0, true +}; + +/*! \class QLinkedList + \brief The QLinkedList class is a template class that provides linked lists. + + \ingroup tools + \ingroup shared + + \reentrant + + QLinkedList\<T\> is one of Qt's generic \l{container classes}. It + stores a list of values and provides iterator-based access as + well as \l{constant time} insertions and removals. + + QList\<T\>, QLinkedList\<T\>, and QVector\<T\> provide similar + functionality. Here's an overview: + + \list + \i For most purposes, QList is the right class to use. Its + index-based API is more convenient than QLinkedList's + iterator-based API, and it is usually faster than + QVector because of the way it stores its items in + memory (see \l{Algorithmic Complexity} for details). + 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, + use QVector. + \endlist + + Here's an example of a QLinkedList that stores integers and a + QLinkedList that stores QTime values: + + \snippet doc/src/snippets/code/src_corelib_tools_qlinkedlist.cpp 0 + + QLinkedList stores a list of items. The default constructor + creates an empty list. To insert items into the list, you can use + operator<<(): + + \snippet doc/src/snippets/code/src_corelib_tools_qlinkedlist.cpp 1 + + If you want to get the first or last item in a linked list, use + first() or last(). If you want to remove an item from either end + of the list, use removeFirst() or removeLast(). If you want to + remove all occurrences of a given value in the list, use + removeAll(). + + A common requirement is to remove the first or last item in the + list and do something with it. For this, QLinkedList provides + takeFirst() and takeLast(). Here's a loop that removes the items + from a list one at a time and calls \c delete on them: + \snippet doc/src/snippets/code/src_corelib_tools_qlinkedlist.cpp 2 + + QLinkedList's value type must be an \l {assignable data type}. This + covers most data types that are commonly used, but the compiler + won't let you, for example, store a QWidget as a value; instead, + store a QWidget *. A few functions have additional requirements; + for example, contains() and removeAll() expect the value type to + support \c operator==(). These requirements are documented on a + per-function basis. + + If you want to insert, modify, or remove items in the middle of + the list, you must use an iterator. QLinkedList provides both + \l{Java-style iterators} (QLinkedListIterator and + QMutableLinkedListIterator) and \l{STL-style iterators} + (QLinkedList::const_iterator and QLinkedList::iterator). See the + documentation for these classes for details. + + \sa QLinkedListIterator, QMutableLinkedListIterator, QList, QVector +*/ + +/*! \fn QLinkedList::QLinkedList() + + Constructs an empty list. +*/ + +/*! \fn QLinkedList::QLinkedList(const QLinkedList<T> &other) + + Constructs a copy of \a other. + + This operation occurs in \l{constant time}, because QLinkedList + is \l{implicitly shared}. This makes returning a QLinkedList from + a function very fast. If a shared instance is modified, it will + be copied (copy-on-write), and this takes \l{linear time}. + + \sa operator=() +*/ + +/*! \fn QLinkedList::~QLinkedList() + + Destroys the list. References to the values in the list, and all + iterators over this list, become invalid. +*/ + +/*! \fn QLinkedList<T> &QLinkedList::operator=(const QLinkedList<T> &other) + + Assigns \a other to this list and returns a reference to this + 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 + false. + + Two lists are considered equal if they contain the same values in + the same order. + + This function requires the value type to implement \c + operator==(). + + \sa operator!=() +*/ + +/*! \fn bool QLinkedList::operator!=(const QLinkedList<T> &other) const + + Returns true if \a other is not equal to this list; otherwise + returns false. + + Two lists are considered equal if they contain the same values in + the same order. + + This function requires the value type to implement \c + operator==(). + + \sa operator==() +*/ + +/*! \fn int QLinkedList::size() const + + Returns the number of items in the list. + + \sa isEmpty(), count() +*/ + +/*! \fn void QLinkedList::detach() + + \internal +*/ + +/*! \fn bool QLinkedList::isDetached() const + + \internal +*/ + +/*! \fn void QLinkedList::setSharable(bool sharable) + + \internal +*/ + +/*! \fn bool QLinkedList::isSharedWith(const QLinkedList<T> &other) const + + \internal +*/ + +/*! \fn bool QLinkedList::isEmpty() const + + Returns true if the list contains no items; otherwise returns + false. + + \sa size() +*/ + +/*! \fn void QLinkedList::clear() + + Removes all the items in the list. + + \sa removeAll() +*/ + +/*! \fn void QLinkedList::append(const T &value) + + Inserts \a value at the end of the list. + + Example: + \snippet doc/src/snippets/code/src_corelib_tools_qlinkedlist.cpp 3 + + This is the same as list.insert(end(), \a value). + + \sa operator<<(), prepend(), insert() +*/ + +/*! \fn void QLinkedList::prepend(const T &value) + + Inserts \a value at the beginning of the list. + + Example: + \snippet doc/src/snippets/code/src_corelib_tools_qlinkedlist.cpp 4 + + This is the same as list.insert(begin(), \a value). + + \sa append(), insert() +*/ + +/*! \fn int QLinkedList::removeAll(const T &value) + + Removes all occurrences of \a value in the list. + + Example: + \snippet doc/src/snippets/code/src_corelib_tools_qlinkedlist.cpp 5 + + This function requires the value type to have an implementation of + \c operator==(). + + \sa insert() +*/ + +/*! + \fn bool QLinkedList::removeOne(const T &value) + \since 4.4 + + Removes the first occurrences of \a value in the list. Returns true on + success; otherwise returns false. + + Example: + \snippet doc/src/snippets/code/src_corelib_tools_qlinkedlist.cpp 6 + + This function requires the value type to have an implementation of + \c operator==(). + + \sa insert() +*/ + +/*! \fn bool QLinkedList::contains(const T &value) const + + Returns true if the list contains an occurrence of \a value; + otherwise returns false. + + This function requires the value type to have an implementation of + \c operator==(). + + \sa QLinkedListIterator::findNext(), QLinkedListIterator::findPrevious() +*/ + +/*! \fn int QLinkedList::count(const T &value) const + + Returns the number of occurrences of \a value in the list. + + This function requires the value type to have an implementation of + \c operator==(). + + \sa contains() +*/ + +/*! \fn bool QLinkedList::startsWith(const T &value) const + \since 4.5 + + Returns true if the list is not empty and its first + item is equal to \a value; otherwise returns false. + + \sa isEmpty(), first() +*/ + +/*! \fn bool QLinkedList::endsWith(const T &value) const + \since 4.5 + + Returns true if the list is not empty and its last + item is equal to \a value; otherwise returns false. + + \sa isEmpty(), last() +*/ + +/*! \fn QLinkedList::iterator QLinkedList::begin() + + Returns an \l{STL-style iterator} pointing to the first item in + the list. + + \sa constBegin(), end() +*/ + +/*! \fn QLinkedList::const_iterator QLinkedList::begin() const + + \overload +*/ + +/*! \fn QLinkedList::const_iterator QLinkedList::constBegin() const + + Returns a const \l{STL-style iterator} pointing to the first item + in the list. + + \sa begin(), constEnd() +*/ + +/*! \fn QLinkedList::iterator QLinkedList::end() + + Returns an \l{STL-style iterator} pointing to the imaginary item + after the last item in the list. + + \sa begin(), constEnd() +*/ + +/*! \fn QLinkedList::const_iterator QLinkedList::end() const + + \overload +*/ + +/*! \fn QLinkedList::const_iterator QLinkedList::constEnd() const + + Returns a const \l{STL-style iterator} pointing to the imaginary + item after the last item in the list. + + \sa constBegin(), end() +*/ + +/*! \fn QLinkedList::iterator QLinkedList::insert(iterator before, const T &value) + + Inserts \a value in front of the item pointed to by the iterator + \a before. Returns an iterator pointing at the inserted item. + + \sa erase() +*/ + +/*! \fn QLinkedList::iterator QLinkedList::erase(iterator pos) + + Removes the item pointed to by the iterator \a pos from the list, + and returns an iterator to the next item in the list (which may be + end()). + + \sa insert() +*/ + +/*! \fn QLinkedList::iterator QLinkedList::erase(iterator begin, iterator end) + + \overload + + Removes all the items from \a begin up to (but not including) \a + end. +*/ + +/*! \typedef QLinkedList::Iterator + + Qt-style synonym for QLinkedList::iterator. +*/ + +/*! \typedef QLinkedList::ConstIterator + + Qt-style synonym for QLinkedList::const_iterator. +*/ + +/*! + \typedef QLinkedList::size_type + + Typedef for int. Provided for STL compatibility. +*/ + +/*! + \typedef QLinkedList::value_type + + Typedef for T. Provided for STL compatibility. +*/ + +/*! + \typedef QLinkedList::pointer + + Typedef for T *. Provided for STL compatibility. +*/ + +/*! + \typedef QLinkedList::const_pointer + + Typedef for const T *. Provided for STL compatibility. +*/ + +/*! + \typedef QLinkedList::reference + + Typedef for T &. Provided for STL compatibility. +*/ + +/*! + \typedef QLinkedList::const_reference + + Typedef for const T &. Provided for STL compatibility. +*/ + +/*! + \typedef QLinkedList::difference_type + + Typedef for ptrdiff_t. Provided for STL compatibility. +*/ + +/*! \fn int QLinkedList::count() const + + Same as size(). +*/ + +/*! \fn T& QLinkedList::first() + + Returns a reference to the first item in the list. This function + assumes that the list isn't empty. + + \sa last(), isEmpty() +*/ + +/*! \fn const T& QLinkedList::first() const + + \overload +*/ + +/*! \fn T& QLinkedList::last() + + Returns a reference to the last item in the list. This function + assumes that the list isn't empty. + + \sa first(), isEmpty() +*/ + +/*! \fn const T& QLinkedList::last() const + + \overload +*/ + +/*! \fn void QLinkedList::removeFirst() + + Removes the first item in the list. + + This is the same as erase(begin()). + + \sa removeLast(), erase() +*/ + +/*! \fn void QLinkedList::removeLast() + + Removes the last item in the list. + + \sa removeFirst(), erase() +*/ + +/*! \fn T QLinkedList::takeFirst() + + Removes the first item in the list and returns it. + + If you don't use the return value, removeFirst() is more + efficient. + + \sa takeLast(), removeFirst() +*/ + +/*! \fn T QLinkedList::takeLast() + + Removes the last item in the list and returns it. + + If you don't use the return value, removeLast() is more + efficient. + + \sa takeFirst(), removeLast() +*/ + +/*! \fn void QLinkedList::push_back(const T &value) + + This function is provided for STL compatibility. It is equivalent + to append(\a value). +*/ + +/*! \fn void QLinkedList::push_front(const T &value) + + This function is provided for STL compatibility. It is equivalent + to prepend(\a value). +*/ + +/*! \fn T& QLinkedList::front() + + This function is provided for STL compatibility. It is equivalent + to first(). +*/ + +/*! \fn const T& QLinkedList::front() const + + \overload +*/ + +/*! \fn T& QLinkedList::back() + + This function is provided for STL compatibility. It is equivalent + to last(). +*/ + +/*! \fn const T& QLinkedList::back() const + + \overload +*/ + +/*! \fn void QLinkedList::pop_front() + + This function is provided for STL compatibility. It is equivalent + to removeFirst(). +*/ + +/*! \fn void QLinkedList::pop_back() + + This function is provided for STL compatibility. It is equivalent + to removeLast(). +*/ + +/*! \fn bool QLinkedList::empty() const + + This function is provided for STL compatibility. It is equivalent + to isEmpty() and returns true if the list is empty. +*/ + +/*! \fn QLinkedList<T> &QLinkedList::operator+=(const QLinkedList<T> &other) + + Appends the items of the \a other list to this list and returns a + reference to this list. + + \sa operator+(), append() +*/ + +/*! \fn void QLinkedList::operator+=(const T &value) + + \overload + + Appends \a value to the list. +*/ + +/*! \fn QLinkedList<T> QLinkedList::operator+(const QLinkedList<T> &other) const + + Returns a list that contains all the items in this list followed + by all the items in the \a other list. + + \sa operator+=() +*/ + +/*! \fn QLinkedList<T> &QLinkedList::operator<<(const QLinkedList<T> &other) + + Appends the items of the \a other list to this list and returns a + reference to this list. + + \sa operator+=(), append() +*/ + +/*! \fn QLinkedList<T> &QLinkedList::operator<<(const T &value) + + \overload + + Appends \a value to the list. +*/ + +/*! \class QLinkedList::iterator + \brief The QLinkedList::iterator class provides an STL-style non-const iterator for QLinkedList. + + QLinkedList features both \l{STL-style iterators} and + \l{Java-style iterators}. The STL-style iterators are more + low-level and more cumbersome to use; on the other hand, they are + slightly faster and, for developers who already know STL, have + the advantage of familiarity. + + QLinkedList\<T\>::iterator allows you to iterate over a + QLinkedList\<T\> and to modify the list item associated with the + iterator. If you want to iterate over a const QLinkedList, use + QLinkedList::const_iterator instead. It is generally good + practice to use QLinkedList::const_iterator on a non-const + QLinkedList as well, unless you need to change the QLinkedList + through the iterator. Const iterators are slightly faster, and + can improve code readability. + + The default QLinkedList::iterator constructor creates an + uninitialized iterator. You must initialize it using a + function like QLinkedList::begin(), QLinkedList::end(), or + QLinkedList::insert() before you can start iterating. Here's a + typical loop that prints all the items stored in a list: + + \snippet doc/src/snippets/code/src_corelib_tools_qlinkedlist.cpp 7 + + STL-style iterators can be used as arguments to \l{generic + algorithms}. For example, here's how to find an item in the list + using the qFind() algorithm: + + \snippet doc/src/snippets/code/src_corelib_tools_qlinkedlist.cpp 8 + + Let's see a few examples of things we can do with a + QLinkedList::iterator that we cannot do with a QLinkedList::const_iterator. + Here's an example that increments every value stored in a + QLinkedList\<int\> by 2: + + \snippet doc/src/snippets/code/src_corelib_tools_qlinkedlist.cpp 9 + + Here's an example that removes all the items that start with an + underscore character in a QLinkedList\<QString\>: + + \snippet doc/src/snippets/code/src_corelib_tools_qlinkedlist.cpp 10 + + The call to QLinkedList::erase() removes the item pointed to by + the iterator from the list, and returns an iterator to the next + item. Here's another way of removing an item while iterating: + + \snippet doc/src/snippets/code/src_corelib_tools_qlinkedlist.cpp 11 + + It might be tempting to write code like this: + + \snippet doc/src/snippets/code/src_corelib_tools_qlinkedlist.cpp 12 + + However, this will potentially crash in \c{++i}, because \c i is + a dangling iterator after the call to erase(). + + Multiple iterators can be used on the same list. If you add items + to the list, existing iterators will remain valid. If you remove + items from the list, iterators that point to the removed items + will become dangling iterators. However, because of how \l{implicit + sharing} works, you must not take a copy of a container while + iterators are active on that container. + + \sa QLinkedList::const_iterator, QMutableLinkedListIterator +*/ + +/*! \fn QLinkedList::iterator::iterator() + + Constructs an uninitialized iterator. + + Functions like operator*() and operator++() should not be called + on an uninitialized iterator. Use operator=() to assign a value + to it before using it. + + \sa QLinkedList::begin() QLinkedList::end() +*/ + +/*! \fn QLinkedList::iterator::iterator(Node *node) + + \internal +*/ + +/*! \typedef QLinkedList::iterator::iterator_category + + \internal +*/ + +/*! \typedef QLinkedList::iterator::difference_type + + \internal +*/ + +/*! \typedef QLinkedList::iterator::value_type + + \internal +*/ + +/*! \typedef QLinkedList::iterator::pointer + + \internal +*/ + +/*! \typedef QLinkedList::iterator::reference + + \internal +*/ + +/*! \fn QLinkedList::iterator::iterator(const iterator &other) + + Constructs a copy of \a other. +*/ + +/*! \fn QLinkedList::iterator &QLinkedList::iterator::operator=(const iterator &other) + + Assigns \a other to this iterator. +*/ + +/*! \fn T &QLinkedList::iterator::operator*() const + + Returns a modifiable reference to the current item. + + You can change the value of an item by using operator*() on the + left side of an assignment, for example: + + \snippet doc/src/snippets/code/src_corelib_tools_qlinkedlist.cpp 13 + + \sa operator->() +*/ + +/*! \fn T *QLinkedList::iterator::operator->() const + + Returns a pointer to the current item. + + \sa operator*() +*/ + +/*! + \fn bool QLinkedList::iterator::operator==(const iterator &other) const + \fn bool QLinkedList::iterator::operator==(const const_iterator &other) const + + Returns true if \a other points to the same item as this + iterator; otherwise returns false. + + \sa operator!=() +*/ + +/*! + \fn bool QLinkedList::iterator::operator!=(const iterator &other) const + \fn bool QLinkedList::iterator::operator!=(const const_iterator &other) const + + Returns true if \a other points to a different item than this + iterator; otherwise returns false. + + \sa operator==() +*/ + +/*! \fn QLinkedList::iterator &QLinkedList::iterator::operator++() + + The prefix ++ operator (\c{++it}) advances the iterator to the + next item in the list and returns an iterator to the new current + item. + + Calling this function on QLinkedList::end() leads to undefined + results. + + \sa operator--() +*/ + +/*! \fn QLinkedList::iterator QLinkedList::iterator::operator++(int) + + \overload + + The postfix ++ operator (\c{it++}) advances the iterator to the + next item in the list and returns an iterator to the previously + current item. +*/ + +/*! \fn QLinkedList::iterator &QLinkedList::iterator::operator--() + + The prefix -- operator (\c{--it}) makes the preceding item + current and returns an iterator to the new current item. + + Calling this function on QLinkedList::begin() leads to undefined + results. + + \sa operator++() +*/ + +/*! \fn QLinkedList::iterator QLinkedList::iterator::operator--(int) + + \overload + + The postfix -- operator (\c{it--}) makes the preceding item + current and returns an iterator to the previously current item. +*/ + +/*! \fn QLinkedList::iterator QLinkedList::iterator::operator+(int j) const + + Returns an iterator to the item at \a j positions forward from + this iterator. (If \a j is negative, the iterator goes backward.) + + This operation can be slow for large \a j values. + + \sa operator-() + +*/ + +/*! \fn QLinkedList::iterator QLinkedList::iterator::operator-(int j) const + + Returns an iterator to the item at \a j positions backward from + this iterator. (If \a j is negative, the iterator goes forward.) + + This operation can be slow for large \a j values. + + \sa operator+() +*/ + +/*! \fn QLinkedList::iterator &QLinkedList::iterator::operator+=(int j) + + Advances the iterator by \a j items. (If \a j is negative, the + iterator goes backward.) + + \sa operator-=(), operator+() +*/ + +/*! \fn QLinkedList::iterator &QLinkedList::iterator::operator-=(int j) + + Makes the iterator go back by \a j items. (If \a j is negative, + the iterator goes forward.) + + \sa operator+=(), operator-() +*/ + +/*! \class QLinkedList::const_iterator + \brief The QLinkedList::const_iterator class provides an STL-style const iterator for QLinkedList. + + QLinkedList features both \l{STL-style iterators} and + \l{Java-style iterators}. The STL-style iterators are more + low-level and more cumbersome to use; on the other hand, they are + slightly faster and, for developers who already know STL, have + the advantage of familiarity. + + QLinkedList\<T\>::const_iterator allows you to iterate over a + QLinkedList\<T\>. If you want modify the QLinkedList as you iterate + over it, you must use QLinkedList::iterator instead. It is + generally good practice to use QLinkedList::const_iterator on a + non-const QLinkedList as well, unless you need to change the + QLinkedList through the iterator. Const iterators are slightly + faster, and can improve code readability. + + The default QLinkedList::const_iterator constructor creates an + uninitialized iterator. You must initialize it using a function + like QLinkedList::constBegin(), QLinkedList::constEnd(), or + QLinkedList::insert() before you can start iterating. Here's a + typical loop that prints all the items stored in a list: + + \snippet doc/src/snippets/code/src_corelib_tools_qlinkedlist.cpp 14 + + STL-style iterators can be used as arguments to \l{generic + algorithms}. For example, here's how to find an item in the list + using the qFind() algorithm: + + \snippet doc/src/snippets/code/src_corelib_tools_qlinkedlist.cpp 15 + + Multiple iterators can be used on the same list. If you add items + to the list, existing iterators will remain valid. If you remove + items from the list, iterators that point to the removed items + will become dangling iterators. + + \sa QLinkedList::iterator, QLinkedListIterator +*/ + +/*! \fn QLinkedList::const_iterator::const_iterator() + + Constructs an uninitialized iterator. + + Functions like operator*() and operator++() should not be called + on an uninitialized iterator. Use operator=() to assign a value + to it before using it. + + \sa QLinkedList::constBegin() QLinkedList::constEnd() +*/ + +/*! \fn QLinkedList::const_iterator::const_iterator(Node *node) + + \internal +*/ + +/*! \typedef QLinkedList::const_iterator::iterator_category + + \internal +*/ + +/*! \typedef QLinkedList::const_iterator::difference_type + + \internal +*/ + +/*! \typedef QLinkedList::const_iterator::value_type + + \internal +*/ + +/*! \typedef QLinkedList::const_iterator::pointer + + \internal +*/ + +/*! \typedef QLinkedList::const_iterator::reference + + \internal +*/ + +/*! \fn QLinkedList::const_iterator::const_iterator(const const_iterator &other) + + Constructs a copy of \a other. +*/ + +/*! \fn QLinkedList::const_iterator::const_iterator(iterator other) + + Constructs a copy of \a other. +*/ + +/*! \fn QLinkedList::const_iterator &QLinkedList::const_iterator::operator=( \ + const const_iterator &other) + + Assigns \a other to this iterator. +*/ + +/*! \fn const T &QLinkedList::const_iterator::operator*() const + + Returns a reference to the current item. + + \sa operator->() +*/ + +/*! \fn const T *QLinkedList::const_iterator::operator->() const + + Returns a pointer to the current item. + + \sa operator*() +*/ + +/*! \fn bool QLinkedList::const_iterator::operator==(const const_iterator &other) const + + Returns true if \a other points to the same item as this + iterator; otherwise returns false. + + \sa operator!=() +*/ + +/*! \fn bool QLinkedList::const_iterator::operator!=(const const_iterator &other) const + + Returns true if \a other points to a different item than this + iterator; otherwise returns false. + + \sa operator==() +*/ + +/*! \fn QLinkedList::const_iterator &QLinkedList::const_iterator::operator++() + + The prefix ++ operator (\c{++it}) advances the iterator to the + next item in the list and returns an iterator to the new current + item. + + Calling this function on QLinkedList::constEnd() leads to + undefined results. + + \sa operator--() +*/ + +/*! \fn QLinkedList::const_iterator QLinkedList::const_iterator::operator++(int) + + \overload + + The postfix ++ operator (\c{it++}) advances the iterator to the + next item in the list and returns an iterator to the previously + current item. +*/ + +/*! \fn QLinkedList::const_iterator &QLinkedList::const_iterator::operator--() + + The prefix -- operator (\c{--it}) makes the preceding item + current and returns an iterator to the new current item. + + Calling this function on QLinkedList::begin() leads to undefined + results. + + \sa operator++() +*/ + +/*! \fn QLinkedList::const_iterator QLinkedList::const_iterator::operator--(int) + + \overload + + The postfix -- operator (\c{it--}) makes the preceding item + current and returns an iterator to the previously current item. +*/ + +/*! \fn QLinkedList::const_iterator QLinkedList::const_iterator::operator+(int j) const + + Returns an iterator to the item at \a j positions forward from + this iterator. (If \a j is negative, the iterator goes backward.) + + This operation can be slow for large \a j values. + + \sa operator-() +*/ + +/*! \fn QLinkedList::const_iterator QLinkedList::const_iterator::operator-(int j) const + + This function returns an iterator to the item at \a j positions backward from + this iterator. (If \a j is negative, the iterator goes forward.) + + This operation can be slow for large \a j values. + + \sa operator+() +*/ + +/*! \fn QLinkedList::const_iterator &QLinkedList::const_iterator::operator+=(int j) + + Advances the iterator by \a j items. (If \a j is negative, the + iterator goes backward.) + + This operation can be slow for large \a j values. + + \sa operator-=(), operator+() +*/ + +/*! \fn QLinkedList::const_iterator &QLinkedList::const_iterator::operator-=(int j) + + Makes the iterator go back by \a j items. (If \a j is negative, + the iterator goes forward.) + + This operation can be slow for large \a j values. + + \sa operator+=(), operator-() +*/ + +/*! \fn QDataStream &operator<<(QDataStream &out, const QLinkedList<T> &list) + \relates QLinkedList + + Writes the linked list \a list to stream \a out. + + This function requires the value type to implement \c + operator<<(). + + \sa \link datastreamformat.html Format of the QDataStream operators \endlink +*/ + +/*! \fn QDataStream &operator>>(QDataStream &in, QLinkedList<T> &list) + \relates QLinkedList + + Reads a linked list from stream \a in into \a list. + + This function requires the value type to implement \c operator>>(). + + \sa \link datastreamformat.html Format of the QDataStream operators \endlink +*/ + +/*! + \fn iterator QLinkedList::remove(iterator pos) + + Use erase() instead. +*/ + +/*! + \fn int QLinkedList::findIndex(const T& t) const + + If you need indexes then QList or QVector are better choices than + QLinkedList. + + \oldcode + int index = list->findIndex(value); + \newcode + int index = 0; + bool found = false; + for (const_iterator i = list->begin(); i != list->end(); ++i; ++index) + if (*i == value) { + found = true; + break; + } + if (!found) + index = -1; + \endcode +*/ + +/*! + \fn iterator QLinkedList::find(iterator from, const T& t) + + If you need random access to a data structure then QList, QVector, + QMap, or QHash, are all better choices than QLinkedList. + + \oldcode + QLinkedList::iterator i = list->find(from, value); + \newcode + QLinkedList::iterator i = from; + while (i != list->end() && *i != value) + ++i; + \endcode +*/ + +/*! + \fn iterator QLinkedList::find(const T& t) + + If you need random access to a data structure then QList, QVector, + QMap, or QHash, are all better choices than QLinkedList. + + \oldcode + QLinkedList::iterator i = list->find(value); + \newcode + QLinkedList::iterator i = list->begin(); + while (i != list->end() && *i != value) + ++i; + \endcode +*/ + +/*! + \fn const_iterator QLinkedList::find(const_iterator from, const T& t) const + + If you need random access to a data structure then QList, QVector, + QMap, or QHash, are all better choices than QLinkedList. + + \oldcode + QLinkedList::const_iterator i = list->find(from, value); + \newcode + QLinkedList::const_iterator i = from; + while (i != list->end() && *i != value) + ++i; + \endcode +*/ + +/*! + \fn const_iterator QLinkedList::find(const T& t) const + + If you need random access to a data structure then QList, QVector, + QMap, or QHash, are all better choices than QLinkedList. + + \oldcode + QLinkedList::const_iterator i = list->find(value); + \newcode + QLinkedList::const_iterator i = list->begin(); + while (i != list->end() && *i != value) + ++i; + \endcode +*/ + +/*! + \since 4.1 + \fn QLinkedList<T> QLinkedList<T>::fromStdList(const std::list<T> &list) + + Returns a QLinkedList object with the data contained in \a list. + The order of the elements in the QLinkedList is the same as in \a + list. + + Example: + + \snippet doc/src/snippets/code/src_corelib_tools_qlinkedlist.cpp 16 + + \sa toStdList() +*/ + +/*! + \since 4.1 + \fn std::list<T> QLinkedList<T>::toStdList() const + + Returns a std::list object with the data contained in this + QLinkedList. Example: + + \snippet doc/src/snippets/code/src_corelib_tools_qlinkedlist.cpp 17 + + \sa fromStdList() +*/ + +QT_END_NAMESPACE |