/****************************************************************************

**

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the documentation 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$

**

****************************************************************************/

/*! 

    \class QListIterator

    \inmodule QtCore

    \brief The QListIterator class provides a Java-style const iterator for QList and QQueue.

    QList 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.

    An alternative to using iterators is to use index positions. Most

    QList member functions take an index as their first parameter,

    making it possible to access, modify, and remove items without

    using iterators.

    QListIterator\<T\> allows you to iterate over a QList\<T\> (or a

    QQueue\<T\>). If you want to modify the list as you iterate over

    it, use QMutableListIterator\<T\> instead.

    The QListIterator constructor takes a QList 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.qdoc 0

    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.qdoc 1

    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 QListIterator is active, the QListIterator will

    continue iterating over the original list, ignoring the modified

    copy.

    \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.qdoc 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.qdoc 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

    \inmodule QtCore

    \brief The QVectorIterator class provides a Java-style const iterator for QVector and QStack.

    QVector 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.

    An alternative to using iterators is to use index positions. Most

    QVector member functions take an index as their first parameter,

    making it possible to access, insert, and remove items without

    using iterators.

    QVectorIterator\<T\> allows you to iterate over a QVector\<T\>

    (or a QStack\<T\>). If you want to modify the vector as you

    iterate over it, use QMutableVectorIterator\<T\> instead.

    The QVectorIterator constructor takes a QVector as argument.

    After construction, the iterator is located at the very beginning

    of the vector (before the first item). Here's how to iterate over

    all the elements sequentially:

    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 4

    The next() function returns the next item in the vector 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.qdoc 5

    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 vector. If the vector

    is modified while a QVectorIterator is active, the QVectorIterator

    will continue iterating over the original vector, ignoring the

    modified copy.

    \sa QMutableVectorIterator, QVector::const_iterator

*/

/*! 

    \class QSetIterator

    \inmodule QtCore

    \brief The QSetIterator class provides a Java-style const iterator for QSet.

    QSet supports 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.

    QSetIterator\<T\> allows you to iterate over a QSet\<T\>. If you

    want to modify the set as you iterate over it, use

    QMutableSetIterator\<T\> instead.

    The constructor takes a QSet as argument. After construction, the

    iterator is located at the very beginning of the set (before

    the first item). Here's how to iterate over all the elements

    sequentially:

    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 6

    The next() function returns the next item in the set 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.qdoc 7

    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 set. If the set

    is modified while a QSetIterator is active, the QSetIterator

    will continue iterating over the original set, ignoring the

    modified copy.

    \sa QMutableSetIterator, QSet::const_iterator

*/

/*! 

    \class QMutableListIterator

    \inmodule QtCore

    \brief The QMutableListIterator class provides a Java-style non-const iterator for QList and QQueue.

    QList 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.

    An alternative to using iterators is to use index positions. Most

    QList member functions take an index as their first parameter,

    making it possible to access, insert, and remove items without

    using iterators.

    QMutableListIterator\<T\> allows you to iterate over a QList\<T\>

    (or a QQueue\<T\>) and modify the list. If you don't want to

    modify the list (or have a const QList), use the slightly faster

    QListIterator\<T\> instead.

    The QMutableListIterator constructor takes a QList 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.qdoc 8

    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.qdoc 9

    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.qdoc 10

    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 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.qdoc 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.qdoc 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.qdoc 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

    \inmodule QtCore

    \brief The QMutableVectorIterator class provides a Java-style non-const iterator for QVector and QStack.

    QVector 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.

    An alternative to using iterators is to use index positions. Most

    QVector member functions take an index as their first parameter,

    making it possible to access, insert, and remove items without

    using iterators.

    QMutableVectorIterator\<T\> allows you to iterate over a

    QVector\<T\> and modify the vector. If you don't want to modify

    the vector (or have a const QVector), use the slightly faster

    QVectorIterator\<T\> instead.

    The QMutableVectorIterator constructor takes a QVector 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.qdoc 14

    The next() function returns the next item in the vector 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.qdoc 15

    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 vector, use

    remove(). If you want to modify the value of an item, use

    setValue(). If you want to insert a new item in the vector, use

    insert().

    Example:

    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 16

    The example traverses a vector, replacing negative numbers with

    their absolute values, and eliminating zeroes.

    Only one mutable iterator can be active on a given vector at any

    time. Furthermore, no changes should be done directly to the

    vector while the iterator is active (as opposed to through the

    iterator), since this could invalidate the iterator and lead to

    undefined behavior.

    \sa QVectorIterator, QVector::iterator

*/

/*! 

    \class QMutableSetIterator

    \inmodule QtCore

    \since 4.2

    \brief The QMutableSetIterator class provides a Java-style non-const iterator for QSet.

    QSet 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.

    QMutableSetIterator\<T\> allows you to iterate over a QSet\<T\>

    and remove items from the set as you iterate. If you don't want

    to modify the set (or have a const QSet), use the slightly faster

    QSetIterator\<T\> instead.

    The QMutableSetIterator constructor takes a QSet as argument.

    After construction, the iterator is located at the very beginning

    of the set (before the first item). Here's how to iterate over

    all the elements sequentially:

    \snippet doc/src/snippets/code/doc_src_qiterator.qdoc 17

    The next() function returns the next item in the set 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.qdoc 18

    If you want to remove items as you iterate over the set, use

    remove().

    Only one mutable iterator can be active on a given set at any

    time. Furthermore, no changes should be done directly to the set

    while the iterator is active (as opposed to through the

    iterator), since this could invalidate the iterator and lead to

    undefined behavior.

    \sa QSetIterator, QSet::iterator

*/

/*!

    \fn QListIterator::QListIterator(const QList<T> &list)

    \fn QLinkedListIterator::QLinkedListIterator(const QLinkedList<T> &list)

    \fn QMutableListIterator::QMutableListIterator(QList<T> &list)

    \fn QMutableLinkedListIterator::QMutableLinkedListIterator(QLinkedList<T> &list)

    Constructs an iterator for traversing \a list. The iterator is

    set to be at the front of the list (before the first item).

    \sa operator=()

*/

/*!

    \fn QVectorIterator::QVectorIterator(const QVector<T> &vector)

    \fn QMutableVectorIterator::QMutableVectorIterator(QVector<T> &vector)

    Constructs an iterator for traversing \a vector. The iterator is

    set to be at the front of the vector (before the first item).

    \sa operator=()

*/

/*!

    \fn QSetIterator::QSetIterator(const QSet<T> &set)

    \fn QMutableSetIterator::QMutableSetIterator(QSet<T> &set)

    Constructs an iterator for traversing \a set. The iterator is

    set to be at the front of the set (before the first item).

    \sa operator=()

*/

/*!

    \fn QMutableListIterator::~QMutableListIterator()

    \fn QMutableLinkedListIterator::~QMutableLinkedListIterator()

    \fn QMutableVectorIterator::~QMutableVectorIterator()

    \fn QMutableSetIterator::~QMutableSetIterator()

    Destroys the iterator.

    \sa operator=()

*/