/****************************************************************************
**
** QValueList and QValueListIterator class documentation
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of the Qt GUI Toolkit.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free
** Software Foundation and appearing in the files LICENSE.GPL2
** and LICENSE.GPL3 included in the packaging of this file.
** Alternatively you may (at your option) use any later version
** of the GNU General Public License if such license has been
** publicly approved by Trolltech ASA (or its successors, if any)
** and the KDE Free Qt Foundation.
**
** Please review the following information to ensure GNU General
** Public Licensing requirements will be met:
** http://trolltech.com/products/qt/licenses/licensing/opensource/.
** If you are unsure which license is appropriate for your use, please
** review the following information:
** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
** or contact the sales department at sales@trolltech.com.
**
** This file may be used under the terms of the Q Public License as
** defined by Trolltech ASA and appearing in the file LICENSE.QPL
** included in the packaging of this file. Licensees holding valid Qt
** Commercial licenses may use this file in accordance with the Qt
** Commercial License Agreement provided with the Software.
**
** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
** herein.
**
**********************************************************************/
/*****************************************************************************
QValueList documentation
*****************************************************************************/
/*!
\class QValueList ntqvaluelist.h
\brief The QValueList class is a value-based template class that
provides lists.
\ingroup qtl
\ingroup tools
\ingroup shared
\mainclass
\reentrant
QValueList is a Qt implementation of an STL-like list container.
It can be used in your application if the standard \c list is not
available for your target platform(s). QValueList is part of the
\link ntqtl.html Qt Template Library\endlink.
QValueList\<T\> defines a template instance to create a list of
values that all have the class T. Note that QValueList does not
store pointers to the members of the list; it holds a copy of
every member. This is why these kinds of classes are called "value
based"; QPtrList and QDict are "pointer based".
QValueList contains and manages a collection of objects of type T
and provides iterators that allow the contained objects to be
addressed. QValueList owns the contained items. For more relaxed
ownership semantics, see QPtrCollection and friends which are
pointer-based containers.
Some classes cannot be used within a QValueList, for example, all
classes derived from QObject and thus all classes that implement
widgets. Only values can be used in a QValueList. To qualify as a
value the class must provide:
\list
\i a copy constructor;
\i an assignment operator;
\i a default constructor, i.e. a constructor that does not take any arguments.
\endlist
Note that C++ defaults to field-by-field assignment operators and
copy constructors if no explicit version is supplied. In many
cases this is sufficient.
In addition, some compilers (e.g. Sun CC) might require that the
class provides an equality operator (operator==()).
QValueList's function naming is consistent with the other Qt
classes (e.g. count(), isEmpty()). QValueList also provides extra
functions for compatibility with STL algorithms, such as size()
and empty(). Programmers already familiar with the STL \c list may
prefer to use the STL-compatible functions.
Example:
\code
class Employee
{
public:
Employee(): sn(0) {}
Employee( const QString& forename, const QString& surname, int salary )
: fn(forename), sn(surname), sal(salary)
{}
QString forename() const { return fn; }
QString surname() const { return sn; }
int salary() const { return sal; }
void setSalary( int salary ) { sal = salary; }
private:
QString fn;
QString sn;
int sal;
};
typedef QValueList<Employee> EmployeeList;
EmployeeList list;
list.append( Employee("John", "Doe", 50000) );
list.append( Employee("Jane", "Williams", 80000) );
list.append( Employee("Tom", "Jones", 60000) );
Employee mary( "Mary", "Hawthorne", 90000 );
list.append( mary );
mary.setSalary( 100000 );
EmployeeList::iterator it;
for ( it = list.begin(); it != list.end(); ++it )
cout << (*it).surname().latin1() << ", " <<
(*it).forename().latin1() << " earns " <<
(*it).salary() << endl;
// Output:
// Doe, John earns 50000
// Williams, Jane earns 80000
// Hawthorne, Mary earns 90000
// Jones, Tom earns 60000
\endcode
Notice that the latest changes to Mary's salary did not affect the
value in the list because the list created a copy of Mary's entry.
There are several ways to find items in the list. The begin() and
end() functions return iterators to the beginning and end of the
list. The advantage of getting an iterator is that you can move
forward or backward from this position by
incrementing/decrementing the iterator. The iterator returned by
end() points to the item which is one \e past the last item in the
container. The past-the-end iterator is still associated with the
list it belongs to, however it is \e not dereferenceable;
operator*() will not return a well-defined value. If the list is
empty(), the iterator returned by begin() will equal the iterator
returned by end().
Another way to find an item in the list is by using the \link
ntqtl.html#qFind tqFind()\endlink algorithm. For example:
\code
QValueList<int> list;
...
QValueList<int>::iterator it = tqFind( list.begin(), list.end(), 3 );
if ( it != list.end() )
// it points to the found item
\endcode
It is safe to have multiple iterators a the list at the same
time. If some member of the list is removed, only iterators
pointing to the removed member become invalid. Inserting into the
list does not invalidate any iterator. For convenience, the
function last() returns a reference to the last item in the list,
and first() returns a reference to the the first item. If the
list is empty(), both last() and first() have undefined behavior
(your application will crash or do unpredictable things). Use
last() and first() with caution, for example:
\code
QValueList<int> list;
list.append( 1 );
list.append( 2 );
list.append( 3 );
...
if ( !list.empty() ) {
// OK, modify the first item
int& i = list.first();
i = 18;
}
...
QValueList<double> dlist;
double d = dlist.last(); // undefined
\endcode
Because QValueList is value-based there is no need to be careful
about deleting items in the list. The list holds its own copies
and will free them if the corresponding member or the list itself
is deleted. You can force the list to free all of its items with
clear().
QValueList is shared implicitly, which means it can be copied in
constant time, i.e. O(1). If multiple QValueList instances share
the same data and one needs to modify its contents, this modifying
instance makes a copy and modifies its private copy; therefore it
does not affect the other instances; this takes O(n) time. This is
often called "copy on write". If a QValueList is being used in a
multi-threaded program, you must protect all access to the list.
See \l QMutex.
There are several ways to insert items into the list. The
prepend() and append() functions insert items at the beginning and
the end of the list respectively. The insert() function comes in
several flavors and can be used to add one or more items at
specific positions within the list.
Items can also be removed from the list in several ways. There
are several variants of the remove() function, which removes a
specific item from the list. The remove() function will find and
remove items according to a specific item value.
Lists can also be sorted using the \link ntqtl.html Qt Template
Library\endlink. For example with qHeapSort():
Example:
\code
QValueList<int> list;
list.append( 5 );
list.append( 8 );
list.append( 3 );
list.append( 4 );
qHeapSort( list );
\endcode
\sa QValueListIterator
*/
/*! \enum QValueList::iterator
The list's iterator type, QValueListIterator. */
/*! \enum QValueList::const_iterator
The list's const iterator type, QValueListConstIterator. */
/*! \enum QValueList::value_type
The type of the object stored in the list, T. */
/*! \enum QValueList::pointer
The pointer to T type. */
/*! \enum QValueList::const_pointer
The const pointer to T type. */
/*! \enum QValueList::reference
The reference to T type. */
/*! \enum QValueList::const_reference
The const reference to T type. */
/*! \enum QValueList::size_type
An unsigned integral type, used to represent various sizes. */
/*! \enum QValueList::difference_type
\internal
*/
/*! \enum QValueList::ValueType
\internal
*/
/*!
\fn QValueList::QValueList()
Constructs an empty list.
*/
/*!
\fn QValueList::QValueList( const QValueList<T>& l )
Constructs a copy of \a l.
This operation takes O(1) time because QValueList is implicitly
shared.
The first modification to a list will take O(n) time.
*/
/*!
\fn QValueList::QValueList( const std::list<T>& l )
Contructs a copy of \a l.
This constructor is provided for compatibility with STL
containers.
*/
/*!
\fn QValueList::~QValueList()
Destroys the list. References to the values in the list and all
iterators of this list become invalidated. Note that it is
impossible for an iterator to check whether or not it is valid:
QValueList is highly tuned for performance, not for error
checking.
*/
/*! \enum QValueListIterator::NodePtr
\internal */
/*! \enum QValueListIterator::iterator_category
\internal */
/*! \enum QValueListIterator::size_type
\internal */
/*! \enum QValueListIterator::difference_type
\internal */
/*!
\fn QValueListIterator::QValueListIterator( NodePtr p )
\internal
*/
/*!
\fn bool QValueList::operator== ( const QValueList<T>& l ) const
Compares both lists.
Returns TRUE if this list and \a l are equal; otherwise returns
FALSE.
*/
/*!
\fn bool QValueList::operator== ( const std::list<T>& l ) const
\overload
Returns TRUE if this list and \a l are equal; otherwise returns
FALSE.
This operator is provided for compatibility with STL containers.
*/
/*!
\fn QValueList<T>& QValueList::operator= ( const QValueList<T>& l )
Assigns \a l to this list and returns a reference to this list.
All iterators of the current list become invalidated by this
operation. The cost of such an assignment is O(1) since QValueList
is implicitly shared.
*/
/*!
\fn QValueList<T>& QValueList::operator= ( const std::list<T>& l )
\overload
Assigns the contents of \a l to the list.
All iterators of the current list become invalidated by this
operation.
*/
/*!
\fn bool QValueList::operator!= ( const QValueList<T>& l ) const
Compares both lists.
Returns TRUE if this list and \a l are unequal; otherwise returns
FALSE.
*/
/*!
\fn iterator QValueList::insert( iterator it, const T& x )
Inserts the value \a x in front of the item pointed to by the
iterator, \a it.
Returns an iterator pointing at the inserted item.
\sa append(), prepend()
*/
/*!
\fn uint QValueList::remove( const T& x )
\overload
Removes all items that have value \a x and returns the number of
removed items.
*/
/*!
\fn void QValueList::clear()
Removes all items from the list.
\sa remove()
*/
/*!
\fn iterator QValueList::begin()
\overload
Returns an iterator pointing to the first item in the list. This
iterator equals end() if the list is empty.
\sa first(), end()
*/
/*!
\fn const_iterator QValueList::begin() const
Returns an iterator pointing to the first item in the list. This
iterator equals end() if the list is empty.
\sa first(), end(), constBegin()
*/
/*!
\fn const_iterator QValueList::constBegin() const
Returns an iterator pointing to the first item in the list. This
iterator equals constEnd() if the list is empty.
\sa begin()
*/
/*!
\fn iterator QValueList::end()
Returns an iterator pointing \e past the last item in the list.
This iterator equals begin() if the list is empty.
\sa last(), begin(), constEnd()
*/
/*!
\fn const_iterator QValueList::end() const
\overload
Returns an iterator pointing \e past the last item in the list.
This iterator equals begin() if the list is empty.
\sa last(), begin()
*/
/*!
\fn const_iterator QValueList::constEnd() const
Returns an iterator pointing \e past the last item in the list.
This iterator equals constBegin() if the list is empty.
\sa end()
*/
/*!
\fn QDataStream& operator>>( QDataStream& s, QValueList<T>& l )
\relates QValueList
Reads a list, \a l, from the stream \a s. The type T stored in the
list must implement the streaming operator.
*/
/*!
\fn QDataStream& operator<<( QDataStream& s, const QValueList<T>& l )
\overload
\relates QValueList
Writes a list, \a l, to the stream \a s. The type T stored in the
list must implement the streaming operator.
*/
/*!
\fn size_type QValueList::size() const
Returns the number of items in the list.
This function is provided for STL compatibility. It is equivalent
to count().
\sa empty()
*/
/*!
\fn bool QValueList::empty() const
Returns TRUE if the list contains no items; otherwise returns
FALSE.
\sa size()
*/
/*!
\fn void QValueList::push_front( const T& x )
Inserts \a x at the beginning of the list.
This function is provided for STL compatibility. It is equivalent
to prepend().
*/
/*!
\fn void QValueList::push_back( const T& x )
Inserts \a x at the end of the list.
This function is provided for STL compatibility. It is equivalent
to append().
*/
/*!
\fn iterator QValueList::erase( iterator it )
Removes the item pointed to by \a it from the list. No iterators
other than \a it or other iterators pointing at the same item as
\a it are invalidated. Returns an iterator to the next item after
\a it, or end() if there is no such item.
This function is provided for STL compatibility. It is equivalent
to remove().
*/
/*!
\fn iterator QValueList::erase( iterator first, iterator last )
\overload
Deletes all items from \a first to \a last (not including \a
last). No iterators are invalidated, except those pointing to the
removed items themselves. Returns \a last.
*/
/*!
\fn reference QValueList::front()
Returns a reference to the first item. If the list contains no
first item (i.e. empty() returns TRUE), the return value is
undefined.
This function is provided for STL compatibility. It is equivalent
to first().
\sa back()
*/
/*!
\fn const_reference QValueList::front() const
\overload
*/
/*!
\fn reference QValueList::back()
Returns a reference to the last item. If the list contains no last
item (i.e. empty() returns TRUE), the return value is undefined.
This function is provided for STL compatibility. It is equivalent
to last().
\sa front()
*/
/*!
\fn const_reference QValueList::back() const
\overload
*/
/*!
\fn void QValueList::pop_front()
Removes the first item. If there is no first item, this operation
is undefined.
This function is provided for STL compatibility.
*/
/*!
\fn void QValueList::pop_back()
Removes the last item. If there is no last item, this operation is
undefined.
This function is provided for STL compatibility.
*/
/*!
\fn void QValueList::insert( iterator pos, size_type n, const T& x )
\overload
Inserts \a n copies of \a x before position \a pos.
*/
/*!
\fn void QValueList::detach()
\internal
*/
/*!
\fn QValueList<T>& QValueList::operator<< ( const T& x )
Adds the value \a x to the end of the list.
Returns a reference to the list.
*/
/*!
\fn const T& QValueList::operator[] ( size_type i ) const
Returns a const reference to the item with index \a i in the list.
It is up to you to check whether this item really exists. You can
do that easily with the count() function. However this operator
does not check whether \a i is in range and will deliver undefined
results if it does not exist.
\warning This function uses a linear search and can be extremely
slow for large lists. QValueList is not optimized for random item
access. If you need random access use a different container, such
as QValueVector.
*/
/*!
\fn T& QValueList::operator[] ( size_type i )
\overload
Returns a non-const reference to the item with index \a i.
*/
/*!
\fn const_iterator QValueList::at( size_type i ) const
Returns an iterator pointing to the item at position \a i in the
list, or an undefined value if the index is out of range.
\warning This function uses a linear search and can be extremely
slow for large lists. QValueList is not optimized for random item
access. If you need random access use a different container, such
as QValueVector.
*/
/*!
\fn iterator QValueList::at( size_type i )
\overload
Returns an iterator pointing to the item at position \a i in the
list, or an undefined value if the index is out of range.
*/
/*!
\fn iterator QValueList::fromLast()
\overload
Returns an iterator to the last item in the list, or end() if
there is no last item.
Use the end() function instead. For example:
\code
QValueList<int> l;
...
QValueList<int>::iterator it = l.end();
--it;
if ( it != end() )
// ...
\endcode
*/
/*!
\fn const_iterator QValueList::fromLast() const
Returns an iterator to the last item in the list, or end() if
there is no last item.
Use the end() function instead. For example:
\code
QValueList<int> l;
...
QValueList<int>::iterator it = l.end();
--it;
if ( it != end() )
// ...
\endcode
*/
/*!
\fn QValueList<T> QValueList::operator+( const QValueList<T>& l ) const
Creates a new list and fills it with the items of this list. Then
the items of \a l are appended. Returns the new list.
*/
/*!
\fn QValueList<T>& QValueList::operator+= ( const QValueList<T>& l )
Appends the items of \a l to this list. Returns a reference to
this list.
*/
/*!
\fn QValueList<T>& QValueList::operator+= ( const T& x )
\overload
Appends the value \a x to the list. Returns a reference to the
list.
*/
/*!
\fn uint QValueList::count() const
Returns the number of items in the list.
\sa isEmpty()
*/
/*!
\fn bool QValueList::isEmpty() const
Returns TRUE if the list contains no items; otherwise returns
FALSE.
\sa count()
*/
/*!
\fn iterator QValueList::append( const T& x )
Inserts \a x at the end of the list.
\sa insert(), prepend()
*/
/*!
\fn iterator QValueList::prepend( const T& x )
Inserts \a x at the beginning of the list.
\sa insert(), append()
*/
/*!
\fn iterator QValueList::remove( iterator it )
Removes the item pointed to by \a it from the list. No iterators
other than \a it or other iterators pointing at the same item as
\a it are invalidated. Returns an iterator to the next item after
\a it, or end() if there is no such item.
\sa clear()
*/
/*!
\fn iterator QValueList::find( const T& x )
Returns an iterator pointing to the first occurrence of \a x in
the list.
Returns end() is no item matched.
*/
/*!
\fn const_iterator QValueList::find( const T& x ) const
\overload
Returns an iterator pointing to the first occurrence of \a x in
the list.
Returns end() if no item matched.
*/
/*!
\fn iterator QValueList::find( iterator it, const T& x )
\overload
Finds the first occurrence of \a x in the list starting at the
position given by \a it.
Returns end() if no item matched.
*/
/*!
\fn const_iterator QValueList::find( const_iterator it, const T& x ) const
\overload
Finds the first occurrence of \a x in the list starting at the
position given by \a it.
Returns end() if no item matched.
*/
/*!
\fn uint QValueList::contains( const T& x ) const
Returns the number of occurrences of the value \a x in the list.
*/
/*!
\fn int QValueList::findIndex( const T& x ) const
Returns the index of the first occurrence of the value \a x.
Returns -1 if no item matched.
*/
/*!
\fn T& QValueList::first()
Returns a reference to the first item. If the list contains no
first item (i.e. isEmpty() returns TRUE), the return value is
undefined.
\sa last()
*/
/*!
\fn const T& QValueList::first() const
\overload
*/
/*!
\fn T& QValueList::last()
Returns a reference to the last item. If the list contains no last
item (i.e. empty() returns TRUE), the return value is undefined.
*/
/*!
\fn const T& QValueList::last() const
\overload
*/
/*****************************************************************************
QValueListIterator documentation
*****************************************************************************/
/*!
\class QValueListIterator ntqvaluelist.h
\brief The QValueListIterator class provides an iterator for QValueList.
\ingroup qtl
\ingroup tools
\reentrant
An iterator is a class for accessing the items of a container
class: a generalization of the index in an array. A pointer
into a "const char *" and an index into an "int[]" are both
iterators, and the general idea is to provide that functionality
for any data structure.
The QValueListIterator class is an iterator for QValueList
instantiations. You can create the appropriate iterator type by
using the \c iterator typedef provided by QValueList.
The only way to access the items in a QValueList is to use an
iterator.
Example (see QValueList for the complete code):
\code
EmployeeList::iterator it;
for ( it = list.begin(); it != list.end(); ++it )
cout << (*it).surname().latin1() << ", " <<
(*it).forename().latin1() << " earns " <<
(*it).salary() << endl;
// Output:
// Doe, John earns 50000
// Williams, Jane earns 80000
// Hawthorne, Mary earns 90000
// Jones, Tom earns 60000
\endcode
QValueList is highly optimized for performance and memory usage.
This means that you must be careful: QValueList does not know
about all its iterators and the iterators don't know to which list
they belong. This makes things very fast, but if you're not
careful, you can get spectacular bugs. Always make sure iterators
are valid before dereferencing them or using them as parameters to
generic algorithms in the STL or the \link ntqtl.html QTL\endlink.
Using an invalid iterator is undefined (your application will
probably crash). Many Qt functions return const value lists; to
iterate over these you should make a copy and iterate over the
copy.
For every Iterator there is a ConstIterator. When accessing a
QValueList in a const environment or if the reference or pointer
to the list is itself const, then you must use the ConstIterator.
Its semantics are the same as the Iterator, but it only returns
const references.
\sa QValueList, QValueListConstIterator
*/
/*! \enum QValueListIterator::value_type
The type of value, T. */
/*! \enum QValueListIterator::pointer
Pointer to value_type. */
/*! \enum QValueListIterator::reference
Reference to value_type. */
/*!
\fn QValueListIterator::QValueListIterator()
Creates un uninitialized iterator.
*/
/*
\fn QValueListIterator::QValueListIterator( NodePtr p )
\overload
\internal
*/
/*!
\fn QValueListIterator::QValueListIterator( const QValueListIterator<T>& it )
\overload
Constructs a copy of the iterator \a it.
*/
/* Unfortunately not with MSVC
\fn T *QValueListIterator::operator->()
Pointer operator. Returns a pointer to the current iterator item.
The great advantage of this operator is that you can treat the
iterator like a pointer.
Example:
\code
QValueList<int>::Iterator it = list.begin();
for( ; it != end(); ++it )
it->show();
\endcode
*/
/*!
\fn T& QValueListIterator::operator*()
Asterisk operator. Returns a reference to the current iterator item.
*/
/*!
\fn const T& QValueListIterator::operator*() const
\overload
Asterisk operator. Returns a reference to the current iterator item.
*/
/*!
\fn QValueListIterator<T>& QValueListIterator::operator++()
Prefix ++ makes the succeeding item current and returns an
iterator pointing to the new current item. The iterator cannot
check whether it reached the end of the list. Incrementing the
iterator returned by end() causes undefined results.
*/
/*!
\fn QValueListIterator<T> QValueListIterator::operator++(int)
\overload
Postfix ++ makes the succeeding item current and returns an
iterator pointing to the new current item. The iterator cannot
check whether it reached the end of the list. Incrementing the
iterator returned by end() causes undefined results.
*/
/*!
\fn QValueListIterator<T>& QValueListIterator::operator--()
Prefix -- makes the previous item current and returns an iterator
pointing to the new current item. The iterator cannot check
whether it reached the beginning of the list. Decrementing the
iterator returned by begin() causes undefined results.
*/
/*!
\fn QValueListIterator<T> QValueListIterator::operator--(int)
\overload
Postfix -- makes the previous item current and returns an iterator
pointing to the new current item. The iterator cannot check
whether it reached the beginning of the list. Decrementing the
iterator returned by begin() causes undefined results.
*/
/*!
\fn QValueListIterator<T>& QValueListIterator::operator+=(int j)
Postfix -- jumps \a j steps forward in the list. The iterator
cannot check whether it reached the end of the list. Jumping past
the end() causes undefined results.
*/
/*!
\fn QValueListIterator<T>& QValueListIterator::operator-=(int j)
Postfix -- jumps \a j steps backward in the list. The iterator
cannot check whether it reached the beginning of the list. Jumping
past begin() causes undefined results.
*/
/*!
\fn bool QValueListIterator::operator==( const QValueListIterator<T>& it ) const
Compares this iterator and \a it and returns TRUE if they point to
the same item; otherwise returns FALSE.
*/
/*!
\fn bool QValueListIterator::operator!=( const QValueListIterator<T>& it ) const
Compares this iterator and \a it and returns TRUE if they point to
different items; otherwise returns FALSE.
*/
/*****************************************************************************
QValueListConstIterator documentation
*****************************************************************************/
/*!
\class QValueListConstIterator ntqvaluelist.h
\brief The QValueListConstIterator class provides a const iterator
for QValueList.
\ingroup qtl
\ingroup tools
\reentrant
In contrast to QValueListIterator, this class is used to iterate
over a const list. It does not allow modification of the values of
the list since that would break const semantics.
You can create the appropriate const iterator type by using the \c
const_iterator typedef provided by QValueList.
For more information on QValueList iterators, see
QValueListIterator.
\sa QValueListIterator, QValueList
*/
/*! \enum QValueListConstIterator::value_type
The type of value. */
/*! \enum QValueListConstIterator::pointer
Pointer to value_type. */
/*! \enum QValueListConstIterator::reference
Reference to value_type. */
/*! \enum QValueListConstIterator::NodePtr
\internal */
/*! \enum QValueListConstIterator::iterator_category
\internal */
/*! \enum QValueListConstIterator::size_type
\internal */
/*! \enum QValueListConstIterator::difference_type
\internal */
/*!
\fn QValueListConstIterator::QValueListConstIterator()
Creates un uninitialized iterator.
*/
/*!
\fn QValueListConstIterator::QValueListConstIterator( NodePtr p )
\overload
\internal
*/
/*!
\fn QValueListConstIterator::QValueListConstIterator( const QValueListConstIterator<T>& it )
\overload
Constructs a copy of the iterator \a it.
*/
/*!
\fn QValueListConstIterator::QValueListConstIterator( const QValueListIterator<T>& it )
Constructs a copy of the iterator \a it.
*/
/* Unfortunately not with MSVC
\fn const T *QValueListConstIterator::operator->()
Pointer operator. Returns a pointer to the current iterator item.
The great advantage of this operator is that you can treat the
iterator like a pointer.
Example:
\code
QValueList<int>::Iterator it = list.begin();
for( ; it != end(); ++it )
it->show();
\endcode
*/
/*!
\fn const T& QValueListConstIterator::operator*() const
Asterisk operator. Returns a reference to the current iterator item.
*/
/*!
\fn QValueListConstIterator<T>& QValueListConstIterator::operator++()
Prefix ++ makes the succeeding item current and returns an
iterator pointing to the new current item. The iterator cannot
check whether it reached the end of the list. Incrementing the
iterator returned by end() causes undefined results.
*/
/*!
\fn QValueListConstIterator<T> QValueListConstIterator::operator++(int)
\overload
Postfix ++ makes the succeeding item current and returns an
iterator pointing to the new current item. The iterator cannot
check whether it reached the end of the list. Incrementing the
iterator returned by end() causes undefined results.
*/
/*!
\fn QValueListConstIterator<T>& QValueListConstIterator::operator--()
Prefix -- makes the previous item current and returns an iterator
pointing to the new current item. The iterator cannot check
whether it reached the beginning of the list. Decrementing the
iterator returned by begin() causes undefined results.
*/
/*!
\fn QValueListConstIterator<T> QValueListConstIterator::operator--(int)
\overload
Postfix -- makes the previous item current and returns an iterator
pointing to the new current item. The iterator cannot check
whether it reached the beginning of the list. Decrementing the
iterator returned by begin() causes undefined results.
*/
/*!
\fn bool QValueListConstIterator::operator==( const QValueListConstIterator<T>& it ) const
Compares this iterator with \a it and returns TRUE if they point
to the same item; otherwise returns FALSE.
*/
/*!
\fn bool QValueListConstIterator::operator!=( const QValueListConstIterator<T>& it ) const
Compares this iterator with \a it and returns TRUE if they point
to different items; otherwise returns FALSE.
*/
/*!
\enum QValueList::Iterator
This iterator is an instantiation of QValueListIterator for the
same type as this QValueList. In other words, if you instantiate
QValueList<int>, Iterator is a QValueListIterator<int>. Several
member function use it, such as QValueList::begin(), which returns
an iterator pointing to the first item in the list.
Functionally, this is almost the same as ConstIterator. The only
difference is that you cannot use ConstIterator for non-const
operations, and that the compiler can often generate better code
if you use ConstIterator.
\sa QValueListIterator ConstIterator
*/
/*!
\enum QValueList::ConstIterator
This iterator is an instantiation of QValueListConstIterator for
the same type as this QValueList. In other words, if you
instantiate QValueList<int>, ConstIterator is a
QValueListConstIterator<int>. Several member function use it, such
as QValueList::begin(), which returns an iterator pointing to the
first item in the list.
Functionally, this is almost the same as Iterator. The only
difference is you cannot use ConstIterator for non-const
operations, and that the compiler can often generate better code
if you use ConstIterator.
\sa QValueListIterator Iterator
*/