diff options
Diffstat (limited to 'doc/qvaluelist.doc')
-rw-r--r-- | doc/qvaluelist.doc | 1200 |
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 +*/ |