summaryrefslogtreecommitdiffstats
path: root/doc/qvaluelist.doc
diff options
context:
space:
mode:
Diffstat (limited to 'doc/qvaluelist.doc')
-rw-r--r--doc/qvaluelist.doc1200
1 files changed, 1200 insertions, 0 deletions
diff --git a/doc/qvaluelist.doc b/doc/qvaluelist.doc
new file mode 100644
index 000000000..a9c837d9e
--- /dev/null
+++ b/doc/qvaluelist.doc
@@ -0,0 +1,1200 @@
+/****************************************************************************
+**
+** 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 retquirements 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 qvaluelist.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 qtl.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 retquire 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
+ qtl.html#qFind qFind()\endlink algorithm. For example:
+
+ \code
+ QValueList<int> list;
+ ...
+ QValueList<int>::iterator it = qFind( 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 qtl.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 qvaluelist.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 qtl.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 qvaluelist.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
+*/