1berry/qtbase
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add template text to \fn commands in container classes

Browse Source 
The \fn commands were not recognized by clang-qdoc because
the template stuff was missing from the \fn commands. This
update adds the correct template text and parameters. It
eliminates nearly 2000 qdoc warnings.

Change-Id: Ibe047424396a8f99f8bd64efea1b0d8cc7c7527d
Reviewed-by: Topi Reiniö <topi.reinio@qt.io>
This commit is contained in:
Martin Smith 2017-09-13 12:07:28 +02:00
parent 32326a4b3b
commit b23c52ea81
6 changed files with 882 additions and 761 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

250
src/corelib/tools/qhash.cpp
View File

@ -1242,7 +1242,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa QHashIterator, QMutableHashIterator, QMap, QSet
*/
/*! \fn QHash::QHash()
/*! \fn template <class Key, class T> QHash<Key, T>::QHash()
Constructs an empty hash.
@ -1250,7 +1250,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
*/
/*!
\fn QHash::QHash(QHash &&other)
\fn template <class Key, class T> QHash<Key, T>::QHash(QHash &&other)
Move-constructs a QHash instance, making it point at the same
object that \a other was pointing to.
@ -1258,7 +1258,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\since 5.2
*/
/*! \fn QHash::QHash(std::initializer_list<std::pair<Key,T> > list)
/*! \fn template <class Key, class T> QHash<Key, T>::QHash(std::initializer_list<std::pair<Key,T> > list)
\since 5.1
Constructs a hash with a copy of each of the elements in the
@ -1268,7 +1268,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
compiled in C++11 mode.
*/
/*! \fn QHash::QHash(const QHash &other)
/*! \fn template <class Key, class T> QHash<Key, T>::QHash(const QHash &other)
Constructs a copy of \a other.
@ -1280,40 +1280,40 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa operator=()
*/
/*! \fn QHash::~QHash()
/*! \fn template <class Key, class T> QHash<Key, T>::~QHash()
Destroys the hash. References to the values in the hash and all
iterators of this hash become invalid.
*/
/*! \fn QHash &QHash::operator=(const QHash &other)
/*! \fn template <class Key, class T> QHash &QHash<Key, T>::operator=(const QHash &other)
Assigns \a other to this hash and returns a reference to this hash.
*/
/*!
\fn QHash &QHash::operator=(QHash &&other)
\fn template <class Key, class T> QHash &QHash<Key, T>::operator=(QHash &&other)
Move-assigns \a other to this QHash instance.
\since 5.2
*/
/*! \fn void QHash::swap(QHash &other)
/*! \fn template <class Key, class T> void QHash<Key, T>::swap(QHash &other)
\since 4.8
Swaps hash \a other with this hash. This operation is very
fast and never fails.
*/
/*! \fn void QMultiHash::swap(QMultiHash &other)
/*! \fn template <class Key, class T> void QMultiHash<Key, T>::swap(QMultiHash &other)
\since 4.8
Swaps hash \a other with this hash. This operation is very
fast and never fails.
*/
/*! \fn bool QHash::operator==(const QHash &other) const
/*! \fn template <class Key, class T> bool QHash<Key, T>::operator==(const QHash &other) const
Returns \c true if \a other is equal to this hash; otherwise returns
false.
@ -1326,7 +1326,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa operator!=()
*/
/*! \fn bool QHash::operator!=(const QHash &other) const
/*! \fn template <class Key, class T> bool QHash<Key, T>::operator!=(const QHash &other) const
Returns \c true if \a other is not equal to this hash; otherwise
returns \c false.
@ -1339,14 +1339,14 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa operator==()
*/
/*! \fn int QHash::size() const
/*! \fn template <class Key, class T> int QHash<Key, T>::size() const
Returns the number of items in the hash.
\sa isEmpty(), count()
*/
/*! \fn bool QHash::isEmpty() const
/*! \fn template <class Key, class T> bool QHash<Key, T>::isEmpty() const
Returns \c true if the hash contains no items; otherwise returns
false.
@ -1354,7 +1354,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa size()
*/
/*! \fn int QHash::capacity() const
/*! \fn template <class Key, class T> int QHash<Key, T>::capacity() const
Returns the number of buckets in the QHash's internal hash table.
@ -1366,7 +1366,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa reserve(), squeeze()
*/
/*! \fn void QHash::reserve(int size)
/*! \fn template <class Key, class T> void QHash<Key, T>::reserve(int size)
Ensures that the QHash's internal hash table consists of at least
\a size buckets.
@ -1389,7 +1389,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa squeeze(), capacity()
*/
/*! \fn void QHash::squeeze()
/*! \fn template <class Key, class T> void QHash<Key, T>::squeeze()
Reduces the size of the QHash's internal hash table to save
memory.
@ -1401,7 +1401,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa reserve(), capacity()
*/
/*! \fn void QHash::detach()
/*! \fn template <class Key, class T> void QHash<Key, T>::detach()
\internal
@ -1411,7 +1411,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa isDetached()
*/
/*! \fn bool QHash::isDetached() const
/*! \fn template <class Key, class T> bool QHash<Key, T>::isDetached() const
\internal
@ -1421,24 +1421,24 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa detach()
*/
/*! \fn void QHash::setSharable(bool sharable)
/*! \fn template <class Key, class T> void QHash<Key, T>::setSharable(bool sharable)
\internal
*/
/*! \fn bool QHash::isSharedWith(const QHash &other) const
/*! \fn template <class Key, class T> bool QHash<Key, T>::isSharedWith(const QHash &other) const
\internal
*/
/*! \fn void QHash::clear()
/*! \fn template <class Key, class T> void QHash<Key, T>::clear()
Removes all items from the hash.
\sa remove()
*/
/*! \fn int QHash::remove(const Key &key)
/*! \fn template <class Key, class T> int QHash<Key, T>::remove(const Key &key)
Removes all the items that have the \a key from the hash.
Returns the number of items removed which is usually 1 but will
@ -1448,7 +1448,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa clear(), take(), QMultiHash::remove()
*/
/*! \fn T QHash::take(const Key &key)
/*! \fn template <class Key, class T> T QHash<Key, T>::take(const Key &key)
Removes the item with the \a key from the hash and returns
the value associated with it.
@ -1463,7 +1463,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa remove()
*/
/*! \fn bool QHash::contains(const Key &key) const
/*! \fn template <class Key, class T> bool QHash<Key, T>::contains(const Key &key) const
Returns \c true if the hash contains an item with the \a key;
otherwise returns \c false.
@ -1471,7 +1471,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa count(), QMultiHash::contains()
*/
/*! \fn const T QHash::value(const Key &key) const
/*! \fn template <class Key, class T> const T QHash<Key, T>::value(const Key &key) const
Returns the value associated with the \a key.
@ -1483,14 +1483,14 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa key(), values(), contains(), operator[]()
*/
/*! \fn const T QHash::value(const Key &key, const T &defaultValue) const
/*! \fn template <class Key, class T> const T QHash<Key, T>::value(const Key &key, const T &defaultValue) const
\overload
If the hash contains no item with the given \a key, the function returns
\a defaultValue.
*/
/*! \fn T &QHash::operator[](const Key &key)
/*! \fn template <class Key, class T> T &QHash<Key, T>::operator[](const Key &key)
Returns the value associated with the \a key as a modifiable
reference.
@ -1504,14 +1504,14 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa insert(), value()
*/
/*! \fn const T QHash::operator[](const Key &key) const
/*! \fn template <class Key, class T> const T QHash<Key, T>::operator[](const Key &key) const
\overload
Same as value().
*/
/*! \fn QList<Key> QHash::uniqueKeys() const
/*! \fn template <class Key, class T> QList<Key> QHash<Key, T>::uniqueKeys() const
\since 4.2
Returns a list containing all the keys in the map. Keys that occur multiple
@ -1521,7 +1521,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa keys(), values()
*/
/*! \fn QList<Key> QHash::keys() const
/*! \fn template <class Key, class T> QList<Key> QHash<Key, T>::keys() const
Returns a list containing all the keys in the hash, in an
arbitrary order. Keys that occur multiple times in the hash
@ -1536,7 +1536,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa uniqueKeys(), values(), key()
*/
/*! \fn QList<Key> QHash::keys(const T &value) const
/*! \fn template <class Key, class T> QList<Key> QHash<Key, T>::keys(const T &value) const
\overload
@ -1548,7 +1548,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
by value.
*/
/*! \fn QList<T> QHash::values() const
/*! \fn template <class Key, class T> QList<T> QHash<Key, T>::values() const
Returns a list containing all the values in the hash, in an
arbitrary order. If a key is associated with multiple values, all of
@ -1560,7 +1560,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa keys(), value()
*/
/*! \fn QList<T> QHash::values(const Key &key) const
/*! \fn template <class Key, class T> QList<T> QHash<Key, T>::values(const Key &key) const
\overload
@ -1570,7 +1570,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa count(), insertMulti()
*/
/*! \fn Key QHash::key(const T &value) const
/*! \fn template <class Key, class T> Key QHash<Key, T>::key(const T &value) const
Returns the first key mapped to \a value.
@ -1585,7 +1585,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
*/
/*!
\fn Key QHash::key(const T &value, const Key &defaultKey) const
\fn template <class Key, class T> Key QHash<Key, T>::key(const T &value, const Key &defaultKey) const
\since 4.3
\overload
@ -1597,21 +1597,21 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
by value.
*/
/*! \fn int QHash::count(const Key &key) const
/*! \fn template <class Key, class T> int QHash<Key, T>::count(const Key &key) const
Returns the number of items associated with the \a key.
\sa contains(), insertMulti()
*/
/*! \fn int QHash::count() const
/*! \fn template <class Key, class T> int QHash<Key, T>::count() const
\overload
Same as size().
*/
/*! \fn QHash::iterator QHash::begin()
/*! \fn template <class Key, class T> QHash<Key, T>::iterator QHash<Key, T>::begin()
Returns an \l{STL-style iterators}{STL-style iterator} pointing to the first item in
the hash.
@ -1619,12 +1619,12 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa constBegin(), end()
*/
/*! \fn QHash::const_iterator QHash::begin() const
/*! \fn template <class Key, class T> QHash<Key, T>::const_iterator QHash<Key, T>::begin() const
\overload
*/
/*! \fn QHash::const_iterator QHash::cbegin() const
/*! \fn template <class Key, class T> QHash<Key, T>::const_iterator QHash<Key, T>::cbegin() const
\since 5.0
Returns a const \l{STL-style iterators}{STL-style iterator} pointing to the first item
@ -1633,7 +1633,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa begin(), cend()
*/
/*! \fn QHash::const_iterator QHash::constBegin() const
/*! \fn template <class Key, class T> QHash<Key, T>::const_iterator QHash<Key, T>::constBegin() const
Returns a const \l{STL-style iterators}{STL-style iterator} pointing to the first item
in the hash.
@ -1641,7 +1641,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa begin(), constEnd()
*/
/*! \fn QHash::key_iterator QHash::keyBegin() const
/*! \fn template <class Key, class T> QHash<Key, T>::key_iterator QHash<Key, T>::keyBegin() const
\since 5.6
Returns a const \l{STL-style iterators}{STL-style iterator} pointing to the first key
@ -1650,7 +1650,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa keyEnd()
*/
/*! \fn QHash::iterator QHash::end()
/*! \fn template <class Key, class T> QHash<Key, T>::iterator QHash<Key, T>::end()
Returns an \l{STL-style iterators}{STL-style iterator} pointing to the imaginary item
after the last item in the hash.
@ -1658,12 +1658,12 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa begin(), constEnd()
*/
/*! \fn QHash::const_iterator QHash::end() const
/*! \fn template <class Key, class T> QHash<Key, T>::const_iterator QHash<Key, T>::end() const
\overload
*/
/*! \fn QHash::const_iterator QHash::constEnd() const
/*! \fn template <class Key, class T> QHash<Key, T>::const_iterator QHash<Key, T>::constEnd() const
Returns a const \l{STL-style iterators}{STL-style iterator} pointing to the imaginary
item after the last item in the hash.
@ -1671,7 +1671,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa constBegin(), end()
*/
/*! \fn QHash::const_iterator QHash::cend() const
/*! \fn template <class Key, class T> QHash<Key, T>::const_iterator QHash<Key, T>::cend() const
\since 5.0
Returns a const \l{STL-style iterators}{STL-style iterator} pointing to the imaginary
@ -1680,7 +1680,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa cbegin(), end()
*/
/*! \fn QHash::key_iterator QHash::keyEnd() const
/*! \fn template <class Key, class T> QHash<Key, T>::key_iterator QHash<Key, T>::keyEnd() const
\since 5.6
Returns a const \l{STL-style iterators}{STL-style iterator} pointing to the imaginary
@ -1689,7 +1689,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa keyBegin()
*/
/*! \fn QHash::key_value_iterator QHash::keyValueBegin()
/*! \fn template <class Key, class T> QHash<Key, T>::key_value_iterator QHash<Key, T>::keyValueBegin()
\since 5.10
Returns an \l{STL-style iterators}{STL-style iterator} pointing to the first entry
@ -1698,7 +1698,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa keyValueEnd()
*/
/*! \fn QHash::key_value_iterator QHash::keyValueEnd()
/*! \fn template <class Key, class T> QHash<Key, T>::key_value_iterator QHash<Key, T>::keyValueEnd()
\since 5.10
Returns an \l{STL-style iterators}{STL-style iterator} pointing to the imaginary
@ -1707,7 +1707,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa keyValueBegin()
*/
/*! \fn QHash::const_key_value_iterator QHash::keyValueBegin() const
/*! \fn template <class Key, class T> QHash<Key, T>::const_key_value_iterator QHash<Key, T>::keyValueBegin() const
\since 5.10
Returns a const \l{STL-style iterators}{STL-style iterator} pointing to the first entry
@ -1716,7 +1716,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa keyValueEnd()
*/
/*! \fn QHash::const_key_value_iterator QHash::constKeyValueBegin() const
/*! \fn template <class Key, class T> QHash<Key, T>::const_key_value_iterator QHash<Key, T>::constKeyValueBegin() const
\since 5.10
Returns a const \l{STL-style iterators}{STL-style iterator} pointing to the first entry
@ -1725,7 +1725,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa keyValueBegin()
*/
/*! \fn QHash::const_key_value_iterator QHash::keyValueEnd() const
/*! \fn template <class Key, class T> QHash<Key, T>::const_key_value_iterator QHash<Key, T>::keyValueEnd() const
\since 5.10
Returns a const \l{STL-style iterators}{STL-style iterator} pointing to the imaginary
@ -1734,7 +1734,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa keyValueBegin()
*/
/*! \fn QHash::const_key_value_iterator QHash::constKeyValueEnd() const
/*! \fn template <class Key, class T> QHash<Key, T>::const_key_value_iterator QHash<Key, T>::constKeyValueEnd() const
\since 5.10
Returns a const \l{STL-style iterators}{STL-style iterator} pointing to the imaginary
@ -1743,7 +1743,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa constKeyValueBegin()
*/
/*! \fn QHash::iterator QHash::erase(const_iterator pos)
/*! \fn template <class Key, class T> QHash<Key, T>::iterator QHash<Key, T>::erase(const_iterator pos)
\since 5.7
Removes the (key, value) pair associated with the iterator \a pos
@ -1760,11 +1760,11 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa remove(), take(), find()
*/
/*! \fn QHash::iterator QHash::erase(iterator pos)
/*! \fn template <class Key, class T> QHash<Key, T>::iterator QHash<Key, T>::erase(iterator pos)
\overload
*/
/*! \fn QHash::iterator QHash::find(const Key &key)
/*! \fn template <class Key, class T> QHash<Key, T>::iterator QHash<Key, T>::find(const Key &key)
Returns an iterator pointing to the item with the \a key in the
hash.
@ -1783,12 +1783,12 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa value(), values(), QMultiHash::find()
*/
/*! \fn QHash::const_iterator QHash::find(const Key &key) const
/*! \fn template <class Key, class T> QHash<Key, T>::const_iterator QHash<Key, T>::find(const Key &key) const
\overload
*/
/*! \fn QHash::const_iterator QHash::constFind(const Key &key) const
/*! \fn template <class Key, class T> QHash<Key, T>::const_iterator QHash<Key, T>::constFind(const Key &key) const
\since 4.1
Returns an iterator pointing to the item with the \a key in the
@ -1800,7 +1800,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa find(), QMultiHash::constFind()
*/
/*! \fn QHash::iterator QHash::insert(const Key &key, const T &value)
/*! \fn template <class Key, class T> QHash<Key, T>::iterator QHash<Key, T>::insert(const Key &key, const T &value)
Inserts a new item with the \a key and a value of \a value.
@ -1813,7 +1813,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa insertMulti()
*/
/*! \fn QHash::iterator QHash::insertMulti(const Key &key, const T &value)
/*! \fn template <class Key, class T> QHash<Key, T>::iterator QHash<Key, T>::insertMulti(const Key &key, const T &value)
Inserts a new item with the \a key and a value of \a value.
@ -1825,7 +1825,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa insert(), values()
*/
/*! \fn QHash &QHash::unite(const QHash &other)
/*! \fn template <class Key, class T> QHash &QHash<Key, T>::unite(const QHash &other)
Inserts all the items in the \a other hash into this hash. If a
key is common to both hashes, the resulting hash will contain the
@ -1834,14 +1834,14 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa insertMulti()
*/
/*! \fn bool QHash::empty() const
/*! \fn template <class Key, class T> bool QHash<Key, T>::empty() const
This function is provided for STL compatibility. It is equivalent
to isEmpty(), returning true if the hash is empty; otherwise
returns \c false.
*/
/*! \fn QPair<iterator, iterator> QHash::equal_range(const Key &key)
/*! \fn template <class Key, class T> QPair<iterator, iterator> QHash<Key, T>::equal_range(const Key &key)
\since 5.7
Returns a pair of iterators delimiting the range of values \c{[first, second)}, that
@ -1849,7 +1849,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
*/
/*!
\fn QPair<const_iterator, const_iterator> QHash::equal_range(const Key &key) const
\fn template <class Key, class T> QPair<const_iterator, const_iterator> QHash<Key, T>::equal_range(const Key &key) const
\overload
\since 5.7
*/
@ -2020,7 +2020,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa QHash::const_iterator, QHash::key_iterator, QMutableHashIterator
*/
/*! \fn QHash::iterator::iterator()
/*! \fn template <class Key, class T> QHash<Key, T>::iterator::iterator()
Constructs an uninitialized iterator.
@ -2031,12 +2031,12 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa QHash::begin(), QHash::end()
*/
/*! \fn QHash::iterator::iterator(void *node)
/*! \fn template <class Key, class T> QHash<Key, T>::iterator::iterator(void *node)
\internal
*/
/*! \fn const Key &QHash::iterator::key() const
/*! \fn template <class Key, class T> const Key &QHash<Key, T>::iterator::key() const
Returns the current item's key as a const reference.
@ -2047,7 +2047,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa value()
*/
/*! \fn T &QHash::iterator::value() const
/*! \fn template <class Key, class T> T &QHash<Key, T>::iterator::value() const
Returns a modifiable reference to the current item's value.
@ -2059,7 +2059,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa key(), operator*()
*/
/*! \fn T &QHash::iterator::operator*() const
/*! \fn template <class Key, class T> T &QHash<Key, T>::iterator::operator*() const
Returns a modifiable reference to the current item's value.
@ -2068,7 +2068,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa key()
*/
/*! \fn T *QHash::iterator::operator->() const
/*! \fn template <class Key, class T> T *QHash<Key, T>::iterator::operator->() const
Returns a pointer to the current item's value.
@ -2076,8 +2076,8 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
*/
/*!
\fn bool QHash::iterator::operator==(const iterator &other) const
\fn bool QHash::iterator::operator==(const const_iterator &other) const
\fn template <class Key, class T> bool QHash<Key, T>::iterator::operator==(const iterator &other) const
\fn template <class Key, class T> bool QHash<Key, T>::iterator::operator==(const const_iterator &other) const
Returns \c true if \a other points to the same item as this
iterator; otherwise returns \c false.
@ -2086,8 +2086,8 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
*/
/*!
\fn bool QHash::iterator::operator!=(const iterator &other) const
\fn bool QHash::iterator::operator!=(const const_iterator &other) const
\fn template <class Key, class T> bool QHash<Key, T>::iterator::operator!=(const iterator &other) const
\fn template <class Key, class T> bool QHash<Key, T>::iterator::operator!=(const const_iterator &other) const
Returns \c true if \a other points to a different item than this
iterator; otherwise returns \c false.
@ -2096,7 +2096,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
*/
/*!
\fn QHash::iterator &QHash::iterator::operator++()
\fn template <class Key, class T> QHash<Key, T>::iterator &QHash<Key, T>::iterator::operator++()
The prefix ++ operator (\c{++i}) advances the iterator to the
next item in the hash and returns an iterator to the new current
@ -2107,7 +2107,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa operator--()
*/
/*! \fn QHash::iterator QHash::iterator::operator++(int)
/*! \fn template <class Key, class T> QHash<Key, T>::iterator QHash<Key, T>::iterator::operator++(int)
\overload
@ -2117,7 +2117,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
*/
/*!
\fn QHash::iterator &QHash::iterator::operator--()
\fn template <class Key, class T> QHash<Key, T>::iterator &QHash<Key, T>::iterator::operator--()
The prefix -- operator (\c{--i}) makes the preceding item
current and returns an iterator pointing to the new current item.
@ -2129,7 +2129,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
*/
/*!
\fn QHash::iterator QHash::iterator::operator--(int)
\fn template <class Key, class T> QHash<Key, T>::iterator QHash<Key, T>::iterator::operator--(int)
\overload
@ -2138,7 +2138,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
current item.
*/
/*! \fn QHash::iterator QHash::iterator::operator+(int j) const
/*! \fn template <class Key, class T> QHash<Key, T>::iterator QHash<Key, T>::iterator::operator+(int j) const
Returns an iterator to the item at \a j positions forward from
this iterator. (If \a j is negative, the iterator goes backward.)
@ -2149,7 +2149,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
*/
/*! \fn QHash::iterator QHash::iterator::operator-(int j) const
/*! \fn template <class Key, class T> QHash<Key, T>::iterator QHash<Key, T>::iterator::operator-(int j) const
Returns an iterator to the item at \a j positions backward from
this iterator. (If \a j is negative, the iterator goes forward.)
@ -2159,7 +2159,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa operator+()
*/
/*! \fn QHash::iterator &QHash::iterator::operator+=(int j)
/*! \fn template <class Key, class T> QHash<Key, T>::iterator &QHash<Key, T>::iterator::operator+=(int j)
Advances the iterator by \a j items. (If \a j is negative, the
iterator goes backward.)
@ -2167,7 +2167,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa operator-=(), operator+()
*/
/*! \fn QHash::iterator &QHash::iterator::operator-=(int j)
/*! \fn template <class Key, class T> QHash<Key, T>::iterator &QHash<Key, T>::iterator::operator-=(int j)
Makes the iterator go back by \a j items. (If \a j is negative,
the iterator goes forward.)
@ -2222,7 +2222,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa QHash::iterator, QHashIterator
*/
/*! \fn QHash::const_iterator::const_iterator()
/*! \fn template <class Key, class T> QHash<Key, T>::const_iterator::const_iterator()
Constructs an uninitialized iterator.
@ -2233,31 +2233,31 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa QHash::constBegin(), QHash::constEnd()
*/
/*! \fn QHash::const_iterator::const_iterator(void *node)
/*! \fn template <class Key, class T> QHash<Key, T>::const_iterator::const_iterator(void *node)
\internal
*/
/*! \fn QHash::const_iterator::const_iterator(const iterator &other)
/*! \fn template <class Key, class T> QHash<Key, T>::const_iterator::const_iterator(const iterator &other)
Constructs a copy of \a other.
*/
/*! \fn const Key &QHash::const_iterator::key() const
/*! \fn template <class Key, class T> const Key &QHash<Key, T>::const_iterator::key() const
Returns the current item's key.
\sa value()
*/
/*! \fn const T &QHash::const_iterator::value() const
/*! \fn template <class Key, class T> const T &QHash<Key, T>::const_iterator::value() const
Returns the current item's value.
\sa key(), operator*()
*/
/*! \fn const T &QHash::const_iterator::operator*() const
/*! \fn template <class Key, class T> const T &QHash<Key, T>::const_iterator::operator*() const
Returns the current item's value.
@ -2266,14 +2266,14 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa key()
*/
/*! \fn const T *QHash::const_iterator::operator->() const
/*! \fn template <class Key, class T> const T *QHash<Key, T>::const_iterator::operator->() const
Returns a pointer to the current item's value.
\sa value()
*/
/*! \fn bool QHash::const_iterator::operator==(const const_iterator &other) const
/*! \fn template <class Key, class T> bool QHash<Key, T>::const_iterator::operator==(const const_iterator &other) const
Returns \c true if \a other points to the same item as this
iterator; otherwise returns \c false.
@ -2281,7 +2281,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa operator!=()
*/
/*! \fn bool QHash::const_iterator::operator!=(const const_iterator &other) const
/*! \fn template <class Key, class T> bool QHash<Key, T>::const_iterator::operator!=(const const_iterator &other) const
Returns \c true if \a other points to a different item than this
iterator; otherwise returns \c false.
@ -2290,7 +2290,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
*/
/*!
\fn QHash::const_iterator &QHash::const_iterator::operator++()
\fn template <class Key, class T> QHash<Key, T>::const_iterator &QHash<Key, T>::const_iterator::operator++()
The prefix ++ operator (\c{++i}) advances the iterator to the
next item in the hash and returns an iterator to the new current
@ -2301,7 +2301,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa operator--()
*/
/*! \fn QHash::const_iterator QHash::const_iterator::operator++(int)
/*! \fn template <class Key, class T> QHash<Key, T>::const_iterator QHash<Key, T>::const_iterator::operator++(int)
\overload
@ -2310,7 +2310,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
current item.
*/
/*! \fn QHash::const_iterator &QHash::const_iterator::operator--()
/*! \fn template <class Key, class T> QHash<Key, T>::const_iterator &QHash<Key, T>::const_iterator::operator--()
The prefix -- operator (\c{--i}) makes the preceding item
current and returns an iterator pointing to the new current item.
@ -2321,7 +2321,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa operator++()
*/
/*! \fn QHash::const_iterator QHash::const_iterator::operator--(int)
/*! \fn template <class Key, class T> QHash<Key, T>::const_iterator QHash<Key, T>::const_iterator::operator--(int)
\overload
@ -2330,7 +2330,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
current item.
*/
/*! \fn QHash::const_iterator QHash::const_iterator::operator+(int j) const
/*! \fn template <class Key, class T> QHash<Key, T>::const_iterator QHash<Key, T>::const_iterator::operator+(int j) const
Returns an iterator to the item at \a j positions forward from
this iterator. (If \a j is negative, the iterator goes backward.)
@ -2340,7 +2340,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa operator-()
*/
/*! \fn QHash::const_iterator QHash::const_iterator::operator-(int j) const
/*! \fn template <class Key, class T> QHash<Key, T>::const_iterator QHash<Key, T>::const_iterator::operator-(int j) const
Returns an iterator to the item at \a j positions backward from
this iterator. (If \a j is negative, the iterator goes forward.)
@ -2350,7 +2350,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa operator+()
*/
/*! \fn QHash::const_iterator &QHash::const_iterator::operator+=(int j)
/*! \fn template <class Key, class T> QHash<Key, T>::const_iterator &QHash<Key, T>::const_iterator::operator+=(int j)
Advances the iterator by \a j items. (If \a j is negative, the
iterator goes backward.)
@ -2360,7 +2360,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa operator-=(), operator+()
*/
/*! \fn QHash::const_iterator &QHash::const_iterator::operator-=(int j)
/*! \fn template <class Key, class T> QHash<Key, T>::const_iterator &QHash<Key, T>::const_iterator::operator-=(int j)
Makes the iterator go back by \a j items. (If \a j is negative,
the iterator goes forward.)
@ -2407,17 +2407,17 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa QHash::const_iterator, QHash::iterator
*/
/*! \fn const T &QHash::key_iterator::operator*() const
/*! \fn template <class Key, class T> const T &QHash<Key, T>::key_iterator::operator*() const
Returns the current item's key.
*/
/*! \fn const T *QHash::key_iterator::operator->() const
/*! \fn template <class Key, class T> const T *QHash<Key, T>::key_iterator::operator->() const
Returns a pointer to the current item's key.
*/
/*! \fn bool QHash::key_iterator::operator==(key_iterator other) const
/*! \fn template <class Key, class T> bool QHash<Key, T>::key_iterator::operator==(key_iterator other) const
Returns \c true if \a other points to the same item as this
iterator; otherwise returns \c false.
@ -2425,7 +2425,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa operator!=()
*/
/*! \fn bool QHash::key_iterator::operator!=(key_iterator other) const
/*! \fn template <class Key, class T> bool QHash<Key, T>::key_iterator::operator!=(key_iterator other) const
Returns \c true if \a other points to a different item than this
iterator; otherwise returns \c false.
@ -2434,7 +2434,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
*/
/*!
\fn QHash::key_iterator &QHash::key_iterator::operator++()
\fn template <class Key, class T> QHash<Key, T>::key_iterator &QHash<Key, T>::key_iterator::operator++()
The prefix ++ operator (\c{++i}) advances the iterator to the
next item in the hash and returns an iterator to the new current
@ -2445,7 +2445,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa operator--()
*/
/*! \fn QHash::key_iterator QHash::key_iterator::operator++(int)
/*! \fn template <class Key, class T> QHash<Key, T>::key_iterator QHash<Key, T>::key_iterator::operator++(int)
\overload
@ -2454,7 +2454,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
item.
*/
/*! \fn QHash::key_iterator &QHash::key_iterator::operator--()
/*! \fn template <class Key, class T> QHash<Key, T>::key_iterator &QHash<Key, T>::key_iterator::operator--()
The prefix -- operator (\c{--i}) makes the preceding item
current and returns an iterator pointing to the new current item.
@ -2465,7 +2465,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa operator++()
*/
/*! \fn QHash::key_iterator QHash::key_iterator::operator--(int)
/*! \fn template <class Key, class T> QHash<Key, T>::key_iterator QHash<Key, T>::key_iterator::operator--(int)
\overload
@ -2474,7 +2474,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
item.
*/
/*! \fn const_iterator QHash::key_iterator::base() const
/*! \fn template <class Key, class T> const_iterator QHash<Key, T>::key_iterator::base() const
Returns the underlying const_iterator this key_iterator is based on.
*/
@ -2490,7 +2490,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa QKeyValueIterator
*/
/*! \fn QDataStream &operator<<(QDataStream &out, const QHash<Key, T>& hash)
/*! \fn template <class Key, class T> QDataStream &operator<<(QDataStream &out, const QHash<Key, T>& hash)
\relates QHash
Writes the hash \a hash to stream \a out.
@ -2501,7 +2501,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa {Serializing Qt Data Types}
*/
/*! \fn QDataStream &operator>>(QDataStream &in, QHash<Key, T> &hash)
/*! \fn template <class Key, class T> QDataStream &operator>>(QDataStream &in, QHash<Key, T> &hash)
\relates QHash
Reads a hash from stream \a in into \a hash.
@ -2568,12 +2568,12 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa QHash, QHashIterator, QMutableHashIterator, QMultiMap
*/
/*! \fn QMultiHash::QMultiHash()
/*! \fn template <class Key, class T> QMultiHash<Key, T>::QMultiHash()
Constructs an empty hash.
*/
/*! \fn QMultiHash::QMultiHash(std::initializer_list<std::pair<Key,T> > list)
/*! \fn template <class Key, class T> QMultiHash<Key, T>::QMultiHash(std::initializer_list<std::pair<Key,T> > list)
\since 5.1
Constructs a multi-hash with a copy of each of the elements in the
@ -2583,7 +2583,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
compiled in C++11 mode.
*/
/*! \fn QMultiHash::QMultiHash(const QHash<Key, T> &other)
/*! \fn template <class Key, class T> QMultiHash<Key, T>::QMultiHash(const QHash<Key, T> &other)
Constructs a copy of \a other (which can be a QHash or a
QMultiHash).
@ -2591,7 +2591,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa operator=()
*/
/*! \fn QMultiHash::iterator QMultiHash::replace(const Key &key, const T &value)
/*! \fn template <class Key, class T> QMultiHash<Key, T>::iterator QMultiHash<Key, T>::replace(const Key &key, const T &value)
Inserts a new item with the \a key and a value of \a value.
@ -2604,7 +2604,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa insert()
*/
/*! \fn QMultiHash::iterator QMultiHash::insert(const Key &key, const T &value)
/*! \fn template <class Key, class T> QMultiHash<Key, T>::iterator QMultiHash<Key, T>::insert(const Key &key, const T &value)
Inserts a new item with the \a key and a value of \a value.
@ -2616,7 +2616,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa replace()
*/
/*! \fn QMultiHash &QMultiHash::operator+=(const QMultiHash &other)
/*! \fn template <class Key, class T> QMultiHash &QMultiHash<Key, T>::operator+=(const QMultiHash &other)
Inserts all the items in the \a other hash into this hash
and returns a reference to this hash.
@ -2624,7 +2624,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
\sa insert()
*/
/*! \fn QMultiHash QMultiHash::operator+(const QMultiHash &other) const
/*! \fn template <class Key, class T> QMultiHash QMultiHash<Key, T>::operator+(const QMultiHash &other) const
Returns a hash that contains all the items in this hash in
addition to all the items in \a other. If a key is common to both
@ -2634,7 +2634,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
*/
/*!
\fn bool QMultiHash::contains(const Key &key, const T &value) const
\fn template <class Key, class T> bool QMultiHash<Key, T>::contains(const Key &key, const T &value) const
\since 4.3
Returns \c true if the hash contains an item with the \a key and
@ -2644,7 +2644,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
*/
/*!
\fn int QMultiHash::remove(const Key &key, const T &value)
\fn template <class Key, class T> int QMultiHash<Key, T>::remove(const Key &key, const T &value)
\since 4.3
Removes all the items that have the \a key and the value \a
@ -2654,7 +2654,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
*/
/*!
\fn int QMultiHash::count(const Key &key, const T &value) const
\fn template <class Key, class T> int QMultiHash<Key, T>::count(const Key &key, const T &value) const
\since 4.3
Returns the number of items with the \a key and \a value.
@ -2663,7 +2663,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
*/
/*!
\fn typename QHash<Key, T>::iterator QMultiHash::find(const Key &key, const T &value)
\fn template <class Key, class T> typename QHash<Key, T>::iterator QMultiHash<Key, T>::find(const Key &key, const T &value)
\since 4.3
Returns an iterator pointing to the item with the \a key and \a value.
@ -2676,13 +2676,13 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
*/
/*!
\fn typename QHash<Key, T>::const_iterator QMultiHash::find(const Key &key, const T &value) const
\fn template <class Key, class T> typename QHash<Key, T>::const_iterator QMultiHash<Key, T>::find(const Key &key, const T &value) const
\since 4.3
\overload
*/
/*!
\fn typename QHash<Key, T>::const_iterator QMultiHash::constFind(const Key &key, const T &value) const
\fn template <class Key, class T> typename QHash<Key, T>::const_iterator QMultiHash<Key, T>::constFind(const Key &key, const T &value) const
\since 4.3
Returns an iterator pointing to the item with the \a key and the
@ -2695,7 +2695,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
*/
/*!
\fn uint qHash(const QHash<Key, T> &key, uint seed = 0)
\fn template <class Key, class T> uint qHash(const QHash<Key, T> &key, uint seed = 0)
\since 5.8
\relates QHash
@ -2705,7 +2705,7 @@ uint qHash(long double key, uint seed) Q_DECL_NOTHROW
*/
/*!
\fn uint qHash(const QMultiHash<Key, T> &key, uint seed = 0)
\fn template <class Key, class T> uint qHash(const QMultiHash<Key, T> &key, uint seed = 0)
\since 5.8
\relates QMultiHash

472
src/corelib/tools/qiterator.qdoc
View File

@ -25,6 +25,128 @@
**
****************************************************************************/
/*! \class QKeyValueIterator
\inmodule QtCore
\since 5.10
\brief Iterator over the key/value pairs of an associative container.
The QKeyValueIterator class provides an STL-style iterator for returning
key/value pairs from associative containers like QHash and QMap. It
supports the same API as the STL associative containers, i.e. getting a
key/value pair when iterating through the container.
This will allow for better interoperability between QMap, QHash and friends
and STL-style algorithms.
\warning Iterators on implicitly shared containers do not work
exactly like STL-iterators. You should avoid copying a container
while iterators are active on that container. For more information,
read \l{Implicit sharing iterator problem}.
*/
/*! \typedef QKeyValueIterator::iterator_category
\internal
*/
/*! \typedef QKeyValueIterator::difference_type
\internal
*/
/*! \typedef QKeyValueIterator::value_type
\internal
*/
/*! \typedef QKeyValueIterator::pointer
\internal
*/
/*! \typedef QKeyValueIterator::reference
\internal
*/
/*! \fn template<typename Key, typename T, class Iterator> QKeyValueIterator<Key, T, Iterator>::QKeyValueIterator()
Constructs a default QKeyValueIterator.
*/
/*! \fn template<typename Key, typename T, class Iterator> QKeyValueIterator<Key, T, Iterator>::QKeyValueIterator(Iterator o)
Constructs a QKeyValueIterator on top of \a o.
*/
/*! \fn template<typename Key, typename T, class Iterator> const T &QKeyValueIterator<Key, T, Iterator>::operator*() const
Returns the current entry as a pair.
*/
/*! \fn template<typename Key, typename T, class Iterator> bool operator==(QKeyValueIterator<Key, T, Iterator> lhs, QKeyValueIterator<Key, T, Iterator> rhs)
\relates QKeyValueIterator
Returns \c true if \a rhs points to the same item as \a lhs otherwise returns
\c false.
\sa operator!=()
*/
/*! \fn template<typename Key, typename T, class Iterator> bool operator!=(QKeyValueIterator<Key, T, Iterator> lhs, QKeyValueIterator<Key, T, Iterator> rhs) const
\relates QKeyValueIterator
Returns \c true if \a rhs points to a different item than \a lhs otherwise
returns \c false.
\sa operator==()
*/
/*!
\fn template<typename Key, typename T, class Iterator> QKeyValueIterator &QKeyValueIterator<Key, T, Iterator>::operator++()
The prefix ++ operator (\c{++i}) advances the iterator to the
next item in the container and returns the iterator.
\note Advancing the iterator past its container's end() constitutes
undefined behavior.
\sa operator--()
*/
/*! \fn template<typename Key, typename T, class Iterator> QKeyValueIterator QKeyValueIterator<Key, T, Iterator>::operator++(int)
\overload
The postfix ++ operator (\c{i++}) advances the iterator to the
next item in the container and returns the iterator's prior value.
\note Advancing the iterator past its container's end() constitutes
undefined behavior.
*/
/*! \fn template<typename Key, typename T, class Iterator> QKeyValueIterator &QKeyValueIterator<Key, T, Iterator>::operator--()
The prefix -- operator (\c{--i}) backs the iterator up to the previous item
in the container and returns the iterator.
\note Backing up an iterator to before its container's begin() constitutes
undefined behavior.
\sa operator++()
*/
/*! \fn template<typename Key, typename T, class Iterator> QKeyValueIterator QKeyValueIterator<Key, T, Iterator>::operator--(int)
\overload
The postfix -- operator (\c{i--}) backs the iterator up to the previous item
in the container and returns the iterator's prior value.
\note Backing up an iterator to before its container's begin() constitutes
undefined behavior.
*/
/*! \fn template<typename Key, typename T, class Iterator> Iterator QKeyValueIterator<Key, T, Iterator>::base() const
Returns the underlying iterator this QKeyValueIterator is based on.
*/
/*!
\class QListIterator
\inmodule QtCore
@ -470,10 +592,10 @@
*/
/*!
\fn QListIterator::QListIterator(const QList<T> &list)
\fn QLinkedListIterator::QLinkedListIterator(const QLinkedList<T> &list)
\fn QMutableListIterator::QMutableListIterator(QList<T> &list)
\fn QMutableLinkedListIterator::QMutableLinkedListIterator(QLinkedList<T> &list)
\fn template <class T> QListIterator<T>::QListIterator(const QList<T> &list)
\fn template <class T> QLinkedListIterator<T>::QLinkedListIterator(const QLinkedList<T> &list)
\fn template <class T> QMutableListIterator<T>::QMutableListIterator(QList<T> &list)
\fn template <class T> QMutableLinkedListIterator<T>::QMutableLinkedListIterator(QLinkedList<T> &list)
Constructs an iterator for traversing \a list. The iterator is
set to be at the front of the list (before the first item).
@ -482,8 +604,8 @@
*/
/*!
\fn QVectorIterator::QVectorIterator(const QVector<T> &vector)
\fn QMutableVectorIterator::QMutableVectorIterator(QVector<T> &vector)
\fn template <class T> QVectorIterator<T>::QVectorIterator(const QVector<T> &vector)
\fn template <class T> QMutableVectorIterator<T>::QMutableVectorIterator(QVector<T> &vector)
Constructs an iterator for traversing \a vector. The iterator is
set to be at the front of the vector (before the first item).
@ -492,8 +614,8 @@
*/
/*!
\fn QSetIterator::QSetIterator(const QSet<T> &set)
\fn QMutableSetIterator::QMutableSetIterator(QSet<T> &set)
\fn template <class T> QSetIterator<T>::QSetIterator(const QSet<T> &set)
\fn template <class T> QMutableSetIterator<T>::QMutableSetIterator(QSet<T> &set)
Constructs an iterator for traversing \a set. The iterator is
set to be at the front of the set (before the first item).
@ -501,10 +623,10 @@
\sa operator=()
*/
/*! \fn QMutableListIterator &QMutableListIterator::operator=(QList<T> &list)
\fn QMutableLinkedListIterator &QMutableLinkedListIterator::operator=(QLinkedList<T> &list)
\fn QListIterator &QListIterator::operator=(const QList<T> &list)
\fn QLinkedListIterator &QLinkedListIterator::operator=(const QLinkedList<T> &list)
/*! \fn template <class T> QMutableListIterator &QMutableListIterator<T>::operator=(QList<T> &list)
\fn template <class T> QMutableLinkedListIterator &QMutableLinkedListIterator<T>::operator=(QLinkedList<T> &list)
\fn template <class T> QListIterator &QListIterator<T>::operator=(const QList<T> &list)
\fn template <class T> QLinkedListIterator &QLinkedListIterator<T>::operator=(const QLinkedList<T> &list)
Makes the iterator operate on \a list. The iterator is set to be
at the front of the list (before the first item).
@ -512,8 +634,8 @@
\sa toFront(), toBack()
*/
/*! \fn QVectorIterator &QVectorIterator::operator=(const QVector<T> &vector)
\fn QMutableVectorIterator &QMutableVectorIterator::operator=(QVector<T> &vector)
/*! \fn template <class T> QVectorIterator &QVectorIterator<T>::operator=(const QVector<T> &vector)
\fn template <class T> QMutableVectorIterator &QMutableVectorIterator<T>::operator=(QVector<T> &vector)
Makes the iterator operate on \a vector. The iterator is set to be
at the front of the vector (before the first item).
@ -521,8 +643,8 @@
\sa toFront(), toBack()
*/
/*! \fn QSetIterator &QSetIterator::operator=(const QSet<T> &set)
\fn QMutableSetIterator &QMutableSetIterator::operator=(QSet<T> &set)
/*! \fn template <class T> QSetIterator &QSetIterator<T>::operator=(const QSet<T> &set)
\fn template <class T> QMutableSetIterator &QMutableSetIterator<T>::operator=(QSet<T> &set)
Makes the iterator operate on \a set. The iterator is set to be
at the front of the set (before the first item).
@ -530,14 +652,14 @@
\sa toFront(), toBack()
*/
/*! \fn void QListIterator::toFront()
\fn void QLinkedListIterator::toFront()
\fn void QVectorIterator::toFront()
\fn void QSetIterator::toFront()
\fn void QMutableListIterator::toFront()
\fn void QMutableLinkedListIterator::toFront()
\fn void QMutableVectorIterator::toFront()
\fn void QMutableSetIterator::toFront()
/*! \fn template <class T> void QListIterator<T>::toFront()
\fn template <class T> void QLinkedListIterator<T>::toFront()
\fn template <class T> void QVectorIterator<T>::toFront()
\fn template <class T> void QSetIterator<T>::toFront()
\fn template <class T> void QMutableListIterator<T>::toFront()
\fn template <class T> void QMutableLinkedListIterator<T>::toFront()
\fn template <class T> void QMutableVectorIterator<T>::toFront()
\fn template <class T> void QMutableSetIterator<T>::toFront()
Moves the iterator to the front of the container (before the
first item).
@ -545,14 +667,14 @@
\sa toBack(), next()
*/
/*! \fn void QListIterator::toBack()
\fn void QLinkedListIterator::toBack()
\fn void QVectorIterator::toBack()
\fn void QSetIterator::toBack()
\fn void QMutableListIterator::toBack()
\fn void QMutableLinkedListIterator::toBack()
\fn void QMutableVectorIterator::toBack()
\fn void QMutableSetIterator::toBack()
/*! \fn template <class T> void QListIterator<T>::toBack()
\fn template <class T> void QLinkedListIterator<T>::toBack()
\fn template <class T> void QVectorIterator<T>::toBack()
\fn template <class T> void QSetIterator<T>::toBack()
\fn template <class T> void QMutableListIterator<T>::toBack()
\fn template <class T> void QMutableLinkedListIterator<T>::toBack()
\fn template <class T> void QMutableVectorIterator<T>::toBack()
\fn template <class T> void QMutableSetIterator<T>::toBack()
Moves the iterator to the back of the container (after the last
item).
@ -560,14 +682,14 @@
\sa toFront(), previous()
*/
/*! \fn bool QListIterator::hasNext() const
\fn bool QLinkedListIterator::hasNext() const
\fn bool QVectorIterator::hasNext() const
\fn bool QSetIterator::hasNext() const
\fn bool QMutableListIterator::hasNext() const
\fn bool QMutableLinkedListIterator::hasNext() const
\fn bool QMutableVectorIterator::hasNext() const
\fn bool QMutableSetIterator::hasNext() const
/*! \fn template <class T> bool QListIterator<T>::hasNext() const
\fn template <class T> bool QLinkedListIterator<T>::hasNext() const
\fn template <class T> bool QVectorIterator<T>::hasNext() const
\fn template <class T> bool QSetIterator<T>::hasNext() const
\fn template <class T> bool QMutableListIterator<T>::hasNext() const
\fn template <class T> bool QMutableLinkedListIterator<T>::hasNext() const
\fn template <class T> bool QMutableVectorIterator<T>::hasNext() const
\fn template <class T> bool QMutableSetIterator<T>::hasNext() const
Returns \c true if there is at least one item ahead of the iterator,
i.e. the iterator is \e not at the back of the container;
@ -576,11 +698,11 @@
\sa hasPrevious(), next()
*/
/*! \fn const T &QListIterator::next()
\fn const T &QLinkedListIterator::next()
\fn const T &QVectorIterator::next()
\fn const T &QSetIterator::next()
\fn const T &QMutableSetIterator::next()
/*! \fn template <class T> const T &QListIterator<T>::next()
\fn template <class T> const T &QLinkedListIterator<T>::next()
\fn template <class T> const T &QVectorIterator<T>::next()
\fn template <class T> const T &QSetIterator<T>::next()
\fn template <class T> const T &QMutableSetIterator<T>::next()
Returns the next item and advances the iterator by one position.
@ -590,9 +712,9 @@
\sa hasNext(), peekNext(), previous()
*/
/*! \fn T &QMutableListIterator::next()
\fn T &QMutableLinkedListIterator::next()
\fn T &QMutableVectorIterator::next()
/*! \fn template <class T> T &QMutableListIterator<T>::next()
\fn template <class T> T &QMutableLinkedListIterator<T>::next()
\fn template <class T> T &QMutableVectorIterator<T>::next()
Returns a reference to the next item, and advances the iterator
by one position.
@ -603,11 +725,11 @@
\sa hasNext(), peekNext(), previous()
*/
/*! \fn const T &QListIterator::peekNext() const
\fn const T &QLinkedListIterator::peekNext() const
\fn const T &QVectorIterator::peekNext() const
\fn const T &QSetIterator::peekNext() const
\fn const T &QMutableSetIterator::peekNext() const
/*! \fn template <class T> const T &QListIterator<T>::peekNext() const
\fn template <class T> const T &QLinkedListIterator<T>::peekNext() const
\fn template <class T> const T &QVectorIterator<T>::peekNext() const
\fn template <class T> const T &QSetIterator<T>::peekNext() const
\fn template <class T> const T &QMutableSetIterator<T>::peekNext() const
Returns the next item without moving the iterator.
@ -617,9 +739,9 @@
\sa hasNext(), next(), peekPrevious()
*/
/*! \fn T &QMutableListIterator::peekNext() const
\fn T &QMutableLinkedListIterator::peekNext() const
\fn T &QMutableVectorIterator::peekNext() const
/*! \fn template <class T> T &QMutableListIterator<T>::peekNext() const
\fn template <class T> T &QMutableLinkedListIterator<T>::peekNext() const
\fn template <class T> T &QMutableVectorIterator<T>::peekNext() const
Returns a reference to the next item, without moving the iterator.
@ -629,14 +751,14 @@
\sa hasNext(), next(), peekPrevious()
*/
/*! \fn bool QListIterator::hasPrevious() const
\fn bool QLinkedListIterator::hasPrevious() const
\fn bool QVectorIterator::hasPrevious() const
\fn bool QSetIterator::hasPrevious() const
\fn bool QMutableListIterator::hasPrevious() const
\fn bool QMutableLinkedListIterator::hasPrevious() const
\fn bool QMutableVectorIterator::hasPrevious() const
\fn bool QMutableSetIterator::hasPrevious() const
/*! \fn template <class T> bool QListIterator<T>::hasPrevious() const
\fn template <class T> bool QLinkedListIterator<T>::hasPrevious() const
\fn template <class T> bool QVectorIterator<T>::hasPrevious() const
\fn template <class T> bool QSetIterator<T>::hasPrevious() const
\fn template <class T> bool QMutableListIterator<T>::hasPrevious() const
\fn template <class T> bool QMutableLinkedListIterator<T>::hasPrevious() const
\fn template <class T> bool QMutableVectorIterator<T>::hasPrevious() const
\fn template <class T> bool QMutableSetIterator<T>::hasPrevious() const
Returns \c true if there is at least one item behind the iterator,
i.e. the iterator is \e not at the front of the container;
@ -645,11 +767,11 @@
\sa hasNext(), previous()
*/
/*! \fn const T &QListIterator::previous()
\fn const T &QLinkedListIterator::previous()
\fn const T &QVectorIterator::previous()
\fn const T &QSetIterator::previous()
\fn const T &QMutableSetIterator::previous()
/*! \fn template <class T> const T &QListIterator<T>::previous()
\fn template <class T> const T &QLinkedListIterator<T>::previous()
\fn template <class T> const T &QVectorIterator<T>::previous()
\fn template <class T> const T &QSetIterator<T>::previous()
\fn template <class T> const T &QMutableSetIterator<T>::previous()
Returns the previous item and moves the iterator back by one
position.
@ -660,9 +782,9 @@
\sa hasPrevious(), peekPrevious(), next()
*/
/*! \fn T &QMutableListIterator::previous()
\fn T &QMutableLinkedListIterator::previous()
\fn T &QMutableVectorIterator::previous()
/*! \fn template <class T> T &QMutableListIterator<T>::previous()
\fn template <class T> T &QMutableLinkedListIterator<T>::previous()
\fn template <class T> T &QMutableVectorIterator<T>::previous()
Returns a reference to the previous item and moves the iterator
back by one position.
@ -673,11 +795,11 @@
\sa hasPrevious(), peekPrevious(), next()
*/
/*! \fn const T &QListIterator::peekPrevious() const
\fn const T &QLinkedListIterator::peekPrevious() const
\fn const T &QVectorIterator::peekPrevious() const
\fn const T &QSetIterator::peekPrevious() const
\fn const T &QMutableSetIterator::peekPrevious() const
/*! \fn template <class T> const T &QListIterator<T>::peekPrevious() const
\fn template <class T> const T &QLinkedListIterator<T>::peekPrevious() const
\fn template <class T> const T &QVectorIterator<T>::peekPrevious() const
\fn template <class T> const T &QSetIterator<T>::peekPrevious() const
\fn template <class T> const T &QMutableSetIterator<T>::peekPrevious() const
Returns the previous item without moving the iterator.
@ -687,9 +809,9 @@
\sa hasPrevious(), previous(), peekNext()
*/
/*! \fn T &QMutableListIterator::peekPrevious() const
\fn T &QMutableLinkedListIterator::peekPrevious() const
\fn T &QMutableVectorIterator::peekPrevious() const
/*! \fn template <class T> T &QMutableListIterator<T>::peekPrevious() const
\fn template <class T> T &QMutableLinkedListIterator<T>::peekPrevious() const
\fn template <class T> T &QMutableVectorIterator<T>::peekPrevious() const
Returns a reference to the previous item, without moving the iterator.
@ -699,14 +821,14 @@
\sa hasPrevious(), previous(), peekNext()
*/
/*! \fn bool QListIterator::findNext(const T &value)
\fn bool QLinkedListIterator::findNext(const T &value)
\fn bool QVectorIterator::findNext(const T &value)
\fn bool QSetIterator::findNext(const T &value)
\fn bool QMutableListIterator::findNext(const T &value)
\fn bool QMutableLinkedListIterator::findNext(const T &value)
\fn bool QMutableVectorIterator::findNext(const T &value)
\fn bool QMutableSetIterator::findNext(const T &value)
/*! \fn template <class T> bool QListIterator<T>::findNext(const T &value)
\fn template <class T> bool QLinkedListIterator<T>::findNext(const T &value)
\fn template <class T> bool QVectorIterator<T>::findNext(const T &value)
\fn template <class T> bool QSetIterator<T>::findNext(const T &value)
\fn template <class T> bool QMutableListIterator<T>::findNext(const T &value)
\fn template <class T> bool QMutableLinkedListIterator<T>::findNext(const T &value)
\fn template <class T> bool QMutableVectorIterator<T>::findNext(const T &value)
\fn template <class T> bool QMutableSetIterator<T>::findNext(const T &value)
Searches for \a value starting from the current iterator position
forward. Returns \c true if \a value is found; otherwise returns \c false.
@ -718,14 +840,14 @@
\sa findPrevious()
*/
/*! \fn bool QListIterator::findPrevious(const T &value)
\fn bool QLinkedListIterator::findPrevious(const T &value)
\fn bool QVectorIterator::findPrevious(const T &value)
\fn bool QSetIterator::findPrevious(const T &value)
\fn bool QMutableListIterator::findPrevious(const T &value)
\fn bool QMutableLinkedListIterator::findPrevious(const T &value)
\fn bool QMutableVectorIterator::findPrevious(const T &value)
\fn bool QMutableSetIterator::findPrevious(const T &value)
/*! \fn template <class T> bool QListIterator<T>::findPrevious(const T &value)
\fn template <class T> bool QLinkedListIterator<T>::findPrevious(const T &value)
\fn template <class T> bool QVectorIterator<T>::findPrevious(const T &value)
\fn template <class T> bool QSetIterator<T>::findPrevious(const T &value)
\fn template <class T> bool QMutableListIterator<T>::findPrevious(const T &value)
\fn template <class T> bool QMutableLinkedListIterator<T>::findPrevious(const T &value)
\fn template <class T> bool QMutableVectorIterator<T>::findPrevious(const T &value)
\fn template <class T> bool QMutableSetIterator<T>::findPrevious(const T &value)
Searches for \a value starting from the current iterator position
backward. Returns \c true if \a value is found; otherwise returns
@ -738,7 +860,7 @@
\sa findNext()
*/
/*! \fn void QMutableListIterator::remove()
/*! \fn template <class T> void QMutableListIterator<T>::remove()
Removes the last item that was jumped over using one of the
traversal functions (next(), previous(), findNext(), findPrevious()).
@ -749,7 +871,7 @@
\sa insert(), setValue()
*/
/*! \fn void QMutableLinkedListIterator::remove()
/*! \fn template <class T> void QMutableLinkedListIterator<T>::remove()
Removes the last item that was jumped over using one of the
traversal functions (next(), previous(), findNext(), findPrevious()).
@ -760,7 +882,7 @@
\sa insert(), setValue()
*/
/*! \fn void QMutableVectorIterator::remove()
/*! \fn template <class T> void QMutableVectorIterator<T>::remove()
Removes the last item that was jumped over using one of the
traversal functions (next(), previous(), findNext(), findPrevious()).
@ -771,7 +893,7 @@
\sa insert(), setValue()
*/
/*! \fn void QMutableSetIterator::remove()
/*! \fn template <class T> void QMutableSetIterator<T>::remove()
Removes the last item that was jumped over using one of the
traversal functions (next(), previous(), findNext(), findPrevious()).
@ -782,7 +904,7 @@
\sa value()
*/
/*! \fn void QMutableListIterator::setValue(const T &value) const
/*! \fn template <class T> void QMutableListIterator<T>::setValue(const T &value) const
Replaces the value of the last item that was jumped over using
one of the traversal functions with \a value.
@ -796,7 +918,7 @@
\sa value(), remove(), insert()
*/
/*! \fn void QMutableLinkedListIterator::setValue(const T &value) const
/*! \fn template <class T> void QMutableLinkedListIterator<T>::setValue(const T &value) const
Replaces the value of the last item that was jumped over using
one of the traversal functions with \a value.
@ -810,7 +932,7 @@
\sa value(), remove(), insert()
*/
/*! \fn void QMutableVectorIterator::setValue(const T &value) const
/*! \fn template <class T> void QMutableVectorIterator<T>::setValue(const T &value) const
Replaces the value of the last item that was jumped over using
one of the traversal functions with \a value.
@ -824,10 +946,10 @@
\sa value(), remove(), insert()
*/
/*! \fn const T &QMutableListIterator::value() const
\fn const T &QMutableLinkedListIterator::value() const
\fn const T &QMutableVectorIterator::value() const
\fn const T &QMutableSetIterator::value() const
/*! \fn template <class T> const T &QMutableListIterator<T>::value() const
\fn template <class T> const T &QMutableLinkedListIterator<T>::value() const
\fn template <class T> const T &QMutableVectorIterator<T>::value() const
\fn template <class T> const T &QMutableSetIterator<T>::value() const
Returns the value of the last item that was jumped over using one
of the traversal functions (next(), previous(), findNext(),
@ -839,18 +961,18 @@
*/
/*!
\fn T &QMutableListIterator::value()
\fn T &QMutableLinkedListIterator::value()
\fn T &QMutableVectorIterator::value()
\fn template <class T> T &QMutableListIterator<T>::value()
\fn template <class T> T &QMutableLinkedListIterator<T>::value()
\fn template <class T> T &QMutableVectorIterator<T>::value()
\overload
Returns a non-const reference to the value of the last item that
was jumped over using one of the traversal functions.
*/
/*! \fn void QMutableListIterator::insert(const T &value)
\fn void QMutableLinkedListIterator::insert(const T &value)
\fn void QMutableVectorIterator::insert(const T &value)
/*! \fn template <class T> void QMutableListIterator<T>::insert(const T &value)
\fn template <class T> void QMutableLinkedListIterator<T>::insert(const T &value)
\fn template <class T> void QMutableVectorIterator<T>::insert(const T &value)
Inserts \a value at the current iterator position. After the
call, the iterator is located just after the inserted item.
@ -1092,8 +1214,8 @@
\sa QHashIterator, QHash::iterator
*/
/*! \fn QMapIterator::QMapIterator(const QMap<Key, T> &map)
\fn QMutableMapIterator::QMutableMapIterator(QMap<Key, T> &map)
/*! \fn template <class Key, class T> QMapIterator<Key, T>::QMapIterator(const QMap<Key, T> &map)
\fn template <class Key, class T> QMutableMapIterator<Key, T>::QMutableMapIterator(QMap<Key, T> &map)
Constructs an iterator for traversing \a map. The iterator is set
to be at the front of the map (before the first item).
@ -1101,8 +1223,8 @@
\sa operator=()
*/
/*! \fn QHashIterator::QHashIterator(const QHash<Key, T> &hash)
\fn QMutableHashIterator::QMutableHashIterator(QHash<Key, T> &hash)
/*! \fn template <class Key, class T> QHashIterator<Key, T>::QHashIterator(const QHash<Key, T> &hash)
\fn template <class Key, class T> QMutableHashIterator<Key, T>::QMutableHashIterator(QHash<Key, T> &hash)
Constructs an iterator for traversing \a hash. The iterator is
set to be at the front of the hash (before the first item).
@ -1110,8 +1232,8 @@
\sa operator=()
*/
/*! \fn QMapIterator &QMapIterator::operator=(const QMap<Key, T> &map)
\fn QMutableMapIterator &QMutableMapIterator::operator=(QMap<Key, T> &map)
/*! \fn template <class Key, class T> QMapIterator &QMapIterator<Key, T>::operator=(const QMap<Key, T> &map)
\fn template <class Key, class T> QMutableMapIterator &QMutableMapIterator<Key, T>::operator=(QMap<Key, T> &map)
Makes the iterator operate on \a map. The iterator is set to be
at the front of the map (before the first item).
@ -1119,8 +1241,8 @@
\sa toFront(), toBack()
*/
/*! \fn QHashIterator &QHashIterator::operator=(const QHash<Key, T> &hash)
\fn QMutableHashIterator &QMutableHashIterator::operator=(QHash<Key, T> &hash)
/*! \fn template <class Key, class T> QHashIterator &QHashIterator<Key, T>::operator=(const QHash<Key, T> &hash)
\fn template <class Key, class T> QMutableHashIterator &QMutableHashIterator<Key, T>::operator=(QHash<Key, T> &hash)
Makes the iterator operate on \a hash. The iterator is set to be
at the front of the hash (before the first item).
@ -1128,10 +1250,10 @@
\sa toFront(), toBack()
*/
/*! \fn void QMapIterator::toFront()
\fn void QHashIterator::toFront()
\fn void QMutableMapIterator::toFront()
\fn void QMutableHashIterator::toFront()
/*! \fn template <class Key, class T> void QMapIterator<Key, T>::toFront()
\fn template <class Key, class T> void QHashIterator<Key, T>::toFront()
\fn template <class Key, class T> void QMutableMapIterator<Key, T>::toFront()
\fn template <class Key, class T> void QMutableHashIterator<Key, T>::toFront()
Moves the iterator to the front of the container (before the
first item).
@ -1139,10 +1261,10 @@
\sa toBack(), next()
*/
/*! \fn void QMapIterator::toBack()
\fn void QHashIterator::toBack()
\fn void QMutableMapIterator::toBack()
\fn void QMutableHashIterator::toBack()
/*! \fn template <class Key, class T> void QMapIterator<Key, T>::toBack()
\fn template <class Key, class T> void QHashIterator<Key, T>::toBack()
\fn template <class Key, class T> void QMutableMapIterator<Key, T>::toBack()
\fn template <class Key, class T> void QMutableHashIterator<Key, T>::toBack()
Moves the iterator to the back of the container (after the last
item).
@ -1150,10 +1272,10 @@
\sa toFront(), previous()
*/
/*! \fn bool QMapIterator::hasNext() const
\fn bool QHashIterator::hasNext() const
\fn bool QMutableMapIterator::hasNext() const
\fn bool QMutableHashIterator::hasNext() const
/*! \fn template <class Key, class T> bool QMapIterator<Key, T>::hasNext() const
\fn template <class Key, class T> bool QHashIterator<Key, T>::hasNext() const
\fn template <class Key, class T> bool QMutableMapIterator<Key, T>::hasNext() const
\fn template <class Key, class T> bool QMutableHashIterator<Key, T>::hasNext() const
Returns \c true if there is at least one item ahead of the iterator,
i.e. the iterator is \e not at the back of the container;
@ -1162,8 +1284,8 @@
\sa hasPrevious(), next()
*/
/*! \fn QMapIterator::Item QMapIterator::next()
\fn QHashIterator::Item QHashIterator::next()
/*! \fn template <class Key, class T> QMapIterator<Key, T>::Item QMapIterator<Key, T>::next()
\fn template <class Key, class T> QHashIterator<Key, T>::Item QHashIterator<Key, T>::next()
Returns the next item and advances the iterator by one position.
@ -1176,8 +1298,8 @@
\sa hasNext(), peekNext(), previous()
*/
/*! \fn QMutableMapIterator::Item QMutableMapIterator::next()
\fn QMutableHashIterator::Item QMutableHashIterator::next()
/*! \fn template <class Key, class T> QMutableMapIterator<Key, T>::Item QMutableMapIterator<Key, T>::next()
\fn template <class Key, class T> QMutableHashIterator<Key, T>::Item QMutableHashIterator<Key, T>::next()
Returns the next item and advances the iterator by one position.
@ -1190,8 +1312,8 @@
\sa hasNext(), peekNext(), previous()
*/
/*! \fn QMapIterator::Item QMapIterator::peekNext() const
\fn QHashIterator::Item QHashIterator::peekNext() const
/*! \fn template <class Key, class T> QMapIterator<Key, T>::Item QMapIterator<Key, T>::peekNext() const
\fn template <class Key, class T> QHashIterator<Key, T>::Item QHashIterator<Key, T>::peekNext() const
Returns the next item without moving the iterator.
@ -1204,8 +1326,8 @@
\sa hasNext(), next(), peekPrevious()
*/
/*! \fn QMutableMapIterator::Item QMutableMapIterator::peekNext() const
\fn QMutableHashIterator::Item QMutableHashIterator::peekNext() const
/*! \fn template <class Key, class T> QMutableMapIterator<Key, T>::Item QMutableMapIterator<Key, T>::peekNext() const
\fn template <class Key, class T> QMutableHashIterator<Key, T>::Item QMutableHashIterator<Key, T>::peekNext() const
Returns a reference to the next item without moving the iterator.
@ -1218,10 +1340,10 @@
\sa hasNext(), next(), peekPrevious()
*/
/*! \fn bool QMapIterator::hasPrevious() const
\fn bool QHashIterator::hasPrevious() const
\fn bool QMutableMapIterator::hasPrevious() const
\fn bool QMutableHashIterator::hasPrevious() const
/*! \fn template <class Key, class T> bool QMapIterator<Key, T>::hasPrevious() const
\fn template <class Key, class T> bool QHashIterator<Key, T>::hasPrevious() const
\fn template <class Key, class T> bool QMutableMapIterator<Key, T>::hasPrevious() const
\fn template <class Key, class T> bool QMutableHashIterator<Key, T>::hasPrevious() const
Returns \c true if there is at least one item behind the iterator,
i.e. the iterator is \e not at the front of the container;
@ -1230,8 +1352,8 @@
\sa hasNext(), previous()
*/
/*! \fn QMapIterator::Item QMapIterator::previous()
\fn QHashIterator::Item QHashIterator::previous()
/*! \fn template <class Key, class T> QMapIterator<Key, T>::Item QMapIterator<Key, T>::previous()
\fn template <class Key, class T> QHashIterator<Key, T>::Item QHashIterator<Key, T>::previous()
Returns the previous item and moves the iterator back by one
position.
@ -1245,8 +1367,8 @@
\sa hasPrevious(), peekPrevious(), next()
*/
/*! \fn QMutableMapIterator::Item QMutableMapIterator::previous()
\fn QMutableHashIterator::Item QMutableHashIterator::previous()
/*! \fn template <class Key, class T> QMutableMapIterator<Key, T>::Item QMutableMapIterator<Key, T>::previous()
\fn template <class Key, class T> QMutableHashIterator<Key, T>::Item QMutableHashIterator<Key, T>::previous()
Returns the previous item and moves the iterator back by one
position.
@ -1260,8 +1382,8 @@
\sa hasPrevious(), peekPrevious(), next()
*/
/*! \fn QMapIterator::Item QMapIterator::peekPrevious() const
\fn QHashIterator::Item QHashIterator::peekPrevious() const
/*! \fn template <class Key, class T> QMapIterator<Key, T>::Item QMapIterator<Key, T>::peekPrevious() const
\fn template <class Key, class T> QHashIterator<Key, T>::Item QHashIterator<Key, T>::peekPrevious() const
Returns the previous item without moving the iterator.
@ -1274,8 +1396,8 @@
\sa hasPrevious(), previous(), peekNext()
*/
/*! \fn QMutableMapIterator::Item QMutableMapIterator::peekPrevious() const
\fn QMutableHashIterator::Item QMutableHashIterator::peekPrevious() const
/*! \fn template <class Key, class T> QMutableMapIterator<Key, T>::Item QMutableMapIterator<Key, T>::peekPrevious() const
\fn template <class Key, class T> QMutableHashIterator<Key, T>::Item QMutableHashIterator<Key, T>::peekPrevious() const
Returns the previous item without moving the iterator.
@ -1288,8 +1410,8 @@
\sa hasPrevious(), previous(), peekNext()
*/
/*! \fn const T &QMapIterator::value() const
\fn const T &QHashIterator::value() const
/*! \fn template <class Key, class T> const T &QMapIterator<Key, T>::value() const
\fn template <class Key, class T> const T &QHashIterator<Key, T>::value() const
Returns the value of the last item that was jumped over using one
of the traversal functions (next(), previous(), findNext(),
@ -1303,8 +1425,8 @@
*/
/*!
\fn const T &QMutableMapIterator::value() const
\fn const T &QMutableHashIterator::value() const
\fn template <class Key, class T> const T &QMutableMapIterator<Key, T>::value() const
\fn template <class Key, class T> const T &QMutableHashIterator<Key, T>::value() const
Returns the value of the last item that was jumped over using one
of the traversal functions (next(), previous(), findNext(),
@ -1318,8 +1440,8 @@
*/
/*!
\fn T &QMutableMapIterator::value()
\fn T &QMutableHashIterator::value()
\fn template <class Key, class T> T &QMutableMapIterator<Key, T>::value()
\fn template <class Key, class T> T &QMutableHashIterator<Key, T>::value()
\overload
Returns a non-const reference to the value of
@ -1327,10 +1449,10 @@
of the traversal functions.
*/
/*! \fn const Key &QMapIterator::key() const
\fn const Key &QHashIterator::key() const
\fn const Key &QMutableMapIterator::key() const
\fn const Key &QMutableHashIterator::key() const
/*! \fn template <class Key, class T> const Key &QMapIterator<Key, T>::key() const
\fn template <class Key, class T> const Key &QHashIterator<Key, T>::key() const
\fn template <class Key, class T> const Key &QMutableMapIterator<Key, T>::key() const
\fn template <class Key, class T> const Key &QMutableHashIterator<Key, T>::key() const
Returns the key of the last item that was jumped over using one
of the traversal functions (next(), previous(), findNext(),
@ -1343,10 +1465,10 @@
\sa value()
*/
/*! \fn bool QMapIterator::findNext(const T &value)
\fn bool QHashIterator::findNext(const T &value)
\fn bool QMutableMapIterator::findNext(const T &value)
\fn bool QMutableHashIterator::findNext(const T &value)
/*! \fn template <class Key, class T> bool QMapIterator<Key, T>::findNext(const T &value)
\fn template <class Key, class T> bool QHashIterator<Key, T>::findNext(const T &value)
\fn template <class Key, class T> bool QMutableMapIterator<Key, T>::findNext(const T &value)
\fn template <class Key, class T> bool QMutableHashIterator<Key, T>::findNext(const T &value)
Searches for \a value starting from the current iterator position
forward. Returns \c true if a (key, value) pair with value \a value
@ -1359,10 +1481,10 @@
\sa findPrevious()
*/
/*! \fn bool QMapIterator::findPrevious(const T &value)
\fn bool QHashIterator::findPrevious(const T &value)
\fn bool QMutableMapIterator::findPrevious(const T &value)
\fn bool QMutableHashIterator::findPrevious(const T &value)
/*! \fn template <class Key, class T> bool QMapIterator<Key, T>::findPrevious(const T &value)
\fn template <class Key, class T> bool QHashIterator<Key, T>::findPrevious(const T &value)
\fn template <class Key, class T> bool QMutableMapIterator<Key, T>::findPrevious(const T &value)
\fn template <class Key, class T> bool QMutableHashIterator<Key, T>::findPrevious(const T &value)
Searches for \a value starting from the current iterator position
backward. Returns \c true if a (key, value) pair with value \a value
@ -1375,8 +1497,8 @@
\sa findNext()
*/
/*! \fn void QMutableMapIterator::remove()
\fn void QMutableHashIterator::remove()
/*! \fn template <class Key, class T> void QMutableMapIterator<Key, T>::remove()
\fn template <class Key, class T> void QMutableHashIterator<Key, T>::remove()
Removes the last item that was jumped over using one of the
traversal functions (next(), previous(), findNext(), findPrevious()).
@ -1384,8 +1506,8 @@
\sa setValue()
*/
/*! \fn void QMutableMapIterator::setValue(const T &value)
\fn void QMutableHashIterator::setValue(const T &value)
/*! \fn template <class Key, class T> void QMutableMapIterator<Key, T>::setValue(const T &value)
\fn template <class Key, class T> void QMutableHashIterator<Key, T>::setValue(const T &value)
Replaces the value of the last item that was jumped over using
one of the traversal functions with \a value.

211
src/corelib/tools/qlinkedlist.cpp
View File

@ -118,13 +118,13 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa QLinkedListIterator, QMutableLinkedListIterator, QList, QVector
*/
/*! \fn QLinkedList::QLinkedList()
/*! \fn template <class T> QLinkedList<T>::QLinkedList()
Constructs an empty list.
*/
/*!
\fn QLinkedList::QLinkedList(QLinkedList<T> &&other)
\fn template <class T> QLinkedList<T>::QLinkedList(QLinkedList<T> &&other)
Move-constructs a QLinkedList instance, making it point at the same
object that \a other was pointing to.
@ -132,7 +132,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\since 5.2
*/
/*! \fn QLinkedList::QLinkedList(const QLinkedList<T> &other)
/*! \fn template <class T> QLinkedList<T>::QLinkedList(const QLinkedList<T> &other)
Constructs a copy of \a other.
@ -144,7 +144,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa operator=()
*/
/*! \fn QLinkedList::QLinkedList(std::initializer_list<T> list)
/*! \fn template <class T> QLinkedList<T>::QLinkedList(std::initializer_list<T> list)
\since 5.2
Constructs a list from the std::initializer_list specified by \a list.
@ -153,26 +153,26 @@ const QLinkedListData QLinkedListData::shared_null = {
initializer lists.
*/
/*! \fn QLinkedList::~QLinkedList()
/*! \fn template <class T> QLinkedList<T>::~QLinkedList()
Destroys the list. References to the values in the list, and all
iterators over this list, become invalid.
*/
/*! \fn QLinkedList<T> &QLinkedList::operator=(const QLinkedList<T> &other)
/*! \fn template <class T> QLinkedList<T> &QLinkedList<T>::operator=(const QLinkedList<T> &other)
Assigns \a other to this list and returns a reference to this
list.
*/
/*! \fn void QLinkedList::swap(QLinkedList<T> &other)
/*! \fn template <class T> void QLinkedList<T>::swap(QLinkedList<T> &other)
\since 4.8
Swaps list \a other with this list. This operation is very
fast and never fails.
*/
/*! \fn bool QLinkedList::operator==(const QLinkedList<T> &other) const
/*! \fn template <class T> bool QLinkedList<T>::operator==(const QLinkedList<T> &other) const
Returns \c true if \a other is equal to this list; otherwise returns
false.
@ -186,7 +186,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa operator!=()
*/
/*! \fn bool QLinkedList::operator!=(const QLinkedList<T> &other) const
/*! \fn template <class T> bool QLinkedList<T>::operator!=(const QLinkedList<T> &other) const
Returns \c true if \a other is not equal to this list; otherwise
returns \c false.
@ -200,34 +200,34 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa operator==()
*/
/*! \fn int QLinkedList::size() const
/*! \fn template <class T> int QLinkedList<T>::size() const
Returns the number of items in the list.
\sa isEmpty(), count()
*/
/*! \fn void QLinkedList::detach()
/*! \fn template <class T> void QLinkedList<T>::detach()
\internal
*/
/*! \fn bool QLinkedList::isDetached() const
/*! \fn template <class T> bool QLinkedList<T>::isDetached() const
\internal
*/
/*! \fn void QLinkedList::setSharable(bool sharable)
/*! \fn template <class T> void QLinkedList<T>::setSharable(bool sharable)
\internal
*/
/*! \fn bool QLinkedList::isSharedWith(const QLinkedList<T> &other) const
/*! \fn template <class T> bool QLinkedList<T>::isSharedWith(const QLinkedList<T> &other) const
\internal
*/
/*! \fn bool QLinkedList::isEmpty() const
/*! \fn template <class T> bool QLinkedList<T>::isEmpty() const
Returns \c true if the list contains no items; otherwise returns
false.
@ -235,14 +235,14 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa size()
*/
/*! \fn void QLinkedList::clear()
/*! \fn template <class T> void QLinkedList<T>::clear()
Removes all the items in the list.
\sa removeAll()
*/
/*! \fn void QLinkedList::append(const T &value)
/*! \fn template <class T> void QLinkedList<T>::append(const T &value)
Inserts \a value at the end of the list.
@ -254,7 +254,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa operator<<(), prepend(), insert()
*/
/*! \fn void QLinkedList::prepend(const T &value)
/*! \fn template <class T> void QLinkedList<T>::prepend(const T &value)
Inserts \a value at the beginning of the list.
@ -266,7 +266,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa append(), insert()
*/
/*! \fn int QLinkedList::removeAll(const T &value)
/*! \fn template <class T> int QLinkedList<T>::removeAll(const T &value)
Removes all occurrences of \a value in the list.
@ -280,7 +280,7 @@ const QLinkedListData QLinkedListData::shared_null = {
*/
/*!
\fn bool QLinkedList::removeOne(const T &value)
\fn template <class T> bool QLinkedList<T>::removeOne(const T &value)
\since 4.4
Removes the first occurrences of \a value in the list. Returns \c true on
@ -295,7 +295,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa insert()
*/
/*! \fn bool QLinkedList::contains(const T &value) const
/*! \fn template <class T> bool QLinkedList<T>::contains(const T &value) const
Returns \c true if the list contains an occurrence of \a value;
otherwise returns \c false.
@ -306,7 +306,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa QLinkedListIterator::findNext(), QLinkedListIterator::findPrevious()
*/
/*! \fn int QLinkedList::count(const T &value) const
/*! \fn template <class T> int QLinkedList<T>::count(const T &value) const
Returns the number of occurrences of \a value in the list.
@ -316,7 +316,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa contains()
*/
/*! \fn bool QLinkedList::startsWith(const T &value) const
/*! \fn template <class T> bool QLinkedList<T>::startsWith(const T &value) const
\since 4.5
Returns \c true if the list is not empty and its first
@ -325,7 +325,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa isEmpty(), first()
*/
/*! \fn bool QLinkedList::endsWith(const T &value) const
/*! \fn template <class T> bool QLinkedList<T>::endsWith(const T &value) const
\since 4.5
Returns \c true if the list is not empty and its last
@ -334,7 +334,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa isEmpty(), last()
*/
/*! \fn QLinkedList::iterator QLinkedList::begin()
/*! \fn template <class T> QLinkedList<T>::iterator QLinkedList<T>::begin()
Returns an \l{STL-style iterators}{STL-style iterator} pointing to the first item in
the list.
@ -342,12 +342,12 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa constBegin(), end()
*/
/*! \fn QLinkedList::const_iterator QLinkedList::begin() const
/*! \fn template <class T> QLinkedList<T>::const_iterator QLinkedList<T>::begin() const
\overload
*/
/*! \fn QLinkedList::const_iterator QLinkedList::cbegin() const
/*! \fn template <class T> QLinkedList<T>::const_iterator QLinkedList<T>::cbegin() const
\since 5.0
Returns a const \l{STL-style iterators}{STL-style iterator} pointing to the first item
@ -356,7 +356,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa begin(), cend()
*/
/*! \fn QLinkedList::const_iterator QLinkedList::constBegin() const
/*! \fn template <class T> QLinkedList<T>::const_iterator QLinkedList<T>::constBegin() const
Returns a const \l{STL-style iterators}{STL-style iterator} pointing to the first item
in the list.
@ -364,7 +364,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa begin(), constEnd()
*/
/*! \fn QLinkedList::iterator QLinkedList::end()
/*! \fn template <class T> QLinkedList<T>::iterator QLinkedList<T>::end()
Returns an \l{STL-style iterators}{STL-style iterator} pointing to the imaginary item
after the last item in the list.
@ -372,12 +372,12 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa begin(), constEnd()
*/
/*! \fn QLinkedList::const_iterator QLinkedList::end() const
/*! \fn template <class T> QLinkedList<T>::const_iterator QLinkedList<T>::end() const
\overload
*/
/*! \fn QLinkedList::const_iterator QLinkedList::cend() const
/*! \fn template <class T> QLinkedList<T>::const_iterator QLinkedList<T>::cend() const
\since 5.0
Returns a const \l{STL-style iterators}{STL-style iterator} pointing to the imaginary
@ -386,7 +386,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa cbegin(), end()
*/
/*! \fn QLinkedList::const_iterator QLinkedList::constEnd() const
/*! \fn template <class T> QLinkedList<T>::const_iterator QLinkedList<T>::constEnd() const
Returns a const \l{STL-style iterators}{STL-style iterator} pointing to the imaginary
item after the last item in the list.
@ -394,7 +394,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa constBegin(), end()
*/
/*! \fn QLinkedList::reverse_iterator QLinkedList::rbegin()
/*! \fn template <class T> QLinkedList<T>::reverse_iterator QLinkedList<T>::rbegin()
\since 5.6
Returns a \l{STL-style iterators}{STL-style} reverse iterator pointing to the first
@ -403,12 +403,12 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa begin(), crbegin(), rend()
*/
/*! \fn QLinkedList::const_reverse_iterator QLinkedList::rbegin() const
/*! \fn template <class T> QLinkedList<T>::const_reverse_iterator QLinkedList<T>::rbegin() const
\since 5.6
\overload
*/
/*! \fn QLinkedList::const_reverse_iterator QLinkedList::crbegin() const
/*! \fn template <class T> QLinkedList<T>::const_reverse_iterator QLinkedList<T>::crbegin() const
\since 5.6
Returns a const \l{STL-style iterators}{STL-style} reverse iterator pointing to the first
@ -417,7 +417,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa begin(), rbegin(), rend()
*/
/*! \fn QLinkedList::reverse_iterator QLinkedList::rend()
/*! \fn template <class T> QLinkedList<T>::reverse_iterator QLinkedList<T>::rend()
\since 5.6
Returns a \l{STL-style iterators}{STL-style} reverse iterator pointing to one past
@ -426,12 +426,12 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa end(), crend(), rbegin()
*/
/*! \fn QLinkedList::const_reverse_iterator QLinkedList::rend() const
/*! \fn template <class T> QLinkedList<T>::const_reverse_iterator QLinkedList<T>::rend() const
\since 5.6
\overload
*/
/*! \fn QLinkedList::const_reverse_iterator QLinkedList::crend() const
/*! \fn template <class T> QLinkedList<T>::const_reverse_iterator QLinkedList<T>::crend() const
\since 5.6
Returns a const \l{STL-style iterators}{STL-style} reverse iterator pointing to one
@ -440,7 +440,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa end(), rend(), rbegin()
*/
/*! \fn QLinkedList::iterator QLinkedList::insert(iterator before, const T &value)
/*! \fn template <class T> QLinkedList<T>::iterator QLinkedList<T>::insert(iterator before, const T &value)
Inserts \a value in front of the item pointed to by the iterator
\a before. Returns an iterator pointing at the inserted item.
@ -448,7 +448,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa erase()
*/
/*! \fn QLinkedList::iterator QLinkedList::erase(iterator pos)
/*! \fn template <class T> QLinkedList<T>::iterator QLinkedList<T>::erase(iterator pos)
Removes the item pointed to by the iterator \a pos from the list,
and returns an iterator to the next item in the list (which may be
@ -457,7 +457,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa insert()
*/
/*! \fn QLinkedList::iterator QLinkedList::erase(iterator begin, iterator end)
/*! \fn template <class T> QLinkedList<T>::iterator QLinkedList<T>::erase(iterator begin, iterator end)
\overload
@ -549,12 +549,12 @@ const QLinkedListData QLinkedListData::shared_null = {
Typedef for ptrdiff_t. Provided for STL compatibility.
*/
/*! \fn int QLinkedList::count() const
/*! \fn template <class T> int QLinkedList<T>::count() const
Same as size().
*/
/*! \fn T& QLinkedList::first()
/*! \fn template <class T> T& QLinkedList<T>::first()
Returns a reference to the first item in the list. This function
assumes that the list isn't empty.
@ -562,12 +562,12 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa last(), isEmpty()
*/
/*! \fn const T& QLinkedList::first() const
/*! \fn template <class T> const T& QLinkedList<T>::first() const
\overload
*/
/*! \fn T& QLinkedList::last()
/*! \fn template <class T> T& QLinkedList<T>::last()
Returns a reference to the last item in the list. This function
assumes that the list isn't empty.
@ -575,12 +575,12 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa first(), isEmpty()
*/
/*! \fn const T& QLinkedList::last() const
/*! \fn template <class T> const T& QLinkedList<T>::last() const
\overload
*/
/*! \fn void QLinkedList::removeFirst()
/*! \fn template <class T> void QLinkedList<T>::removeFirst()
Removes the first item in the list.
@ -589,14 +589,14 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa removeLast(), erase()
*/
/*! \fn void QLinkedList::removeLast()
/*! \fn template <class T> void QLinkedList<T>::removeLast()
Removes the last item in the list.
\sa removeFirst(), erase()
*/
/*! \fn T QLinkedList::takeFirst()
/*! \fn template <class T> T QLinkedList<T>::takeFirst()
Removes the first item in the list and returns it.
@ -606,7 +606,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa takeLast(), removeFirst()
*/
/*! \fn T QLinkedList::takeLast()
/*! \fn template <class T> T QLinkedList<T>::takeLast()
Removes the last item in the list and returns it.
@ -616,59 +616,59 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa takeFirst(), removeLast()
*/
/*! \fn void QLinkedList::push_back(const T &value)
/*! \fn template <class T> void QLinkedList<T>::push_back(const T &value)
This function is provided for STL compatibility. It is equivalent
to append(\a value).
*/
/*! \fn void QLinkedList::push_front(const T &value)
/*! \fn template <class T> void QLinkedList<T>::push_front(const T &value)
This function is provided for STL compatibility. It is equivalent
to prepend(\a value).
*/
/*! \fn T& QLinkedList::front()
/*! \fn template <class T> T& QLinkedList<T>::front()
This function is provided for STL compatibility. It is equivalent
to first().
*/
/*! \fn const T& QLinkedList::front() const
/*! \fn template <class T> const T& QLinkedList<T>::front() const
\overload
*/
/*! \fn T& QLinkedList::back()
/*! \fn template <class T> T& QLinkedList<T>::back()
This function is provided for STL compatibility. It is equivalent
to last().
*/
/*! \fn const T& QLinkedList::back() const
/*! \fn template <class T> const T& QLinkedList<T>::back() const
\overload
*/
/*! \fn void QLinkedList::pop_front()
/*! \fn template <class T> void QLinkedList<T>::pop_front()
This function is provided for STL compatibility. It is equivalent
to removeFirst().
*/
/*! \fn void QLinkedList::pop_back()
/*! \fn template <class T> void QLinkedList<T>::pop_back()
This function is provided for STL compatibility. It is equivalent
to removeLast().
*/
/*! \fn bool QLinkedList::empty() const
/*! \fn template <class T> bool QLinkedList<T>::empty() const
This function is provided for STL compatibility. It is equivalent
to isEmpty() and returns \c true if the list is empty.
*/
/*! \fn QLinkedList<T> &QLinkedList::operator+=(const QLinkedList<T> &other)
/*! \fn template <class T> QLinkedList<T> &QLinkedList<T>::operator+=(const QLinkedList<T> &other)
Appends the items of the \a other list to this list and returns a
reference to this list.
@ -676,14 +676,14 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa operator+(), append()
*/
/*! \fn void QLinkedList::operator+=(const T &value)
/*! \fn template <class T> void QLinkedList<T>::operator+=(const T &value)
\overload
Appends \a value to the list.
*/
/*! \fn QLinkedList<T> QLinkedList::operator+(const QLinkedList<T> &other) const
/*! \fn template <class T> QLinkedList<T> QLinkedList<T>::operator+(const QLinkedList<T> &other) const
Returns a list that contains all the items in this list followed
by all the items in the \a other list.
@ -691,7 +691,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa operator+=()
*/
/*! \fn QLinkedList<T> &QLinkedList::operator<<(const QLinkedList<T> &other)
/*! \fn template <class T> QLinkedList<T> &QLinkedList<T>::operator<<(const QLinkedList<T> &other)
Appends the items of the \a other list to this list and returns a
reference to this list.
@ -699,7 +699,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa operator+=(), append()
*/
/*! \fn QLinkedList<T> &QLinkedList::operator<<(const T &value)
/*! \fn template <class T> QLinkedList<T> &QLinkedList<T>::operator<<(const T &value)
\overload
@ -777,7 +777,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa QLinkedList::const_iterator, QMutableLinkedListIterator
*/
/*! \fn QLinkedList::iterator::iterator()
/*! \fn template <class T> QLinkedList<T>::iterator::iterator()
Constructs an uninitialized iterator.
@ -788,7 +788,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa QLinkedList::begin(), QLinkedList::end()
*/
/*! \fn QLinkedList::iterator::iterator(Node *node)
/*! \fn template <class T> QLinkedList<T>::iterator::iterator(Node *node)
\internal
*/
@ -818,25 +818,25 @@ const QLinkedListData QLinkedListData::shared_null = {
\internal
*/
/*! \fn QLinkedList::iterator::iterator(const iterator &other)
/*! \fn template <class T> QLinkedList<T>::iterator::iterator(const iterator &other)
Constructs a copy of \a other.
*/
/*! \fn QLinkedList::iterator &QLinkedList::iterator::operator=(const iterator &other)
/*! \fn template <class T> QLinkedList<T>::iterator &QLinkedList<T>::iterator::operator=(const iterator &other)
Assigns \a other to this iterator.
*/
/*!
\fn QLinkedList<T> &QLinkedList::operator=(QLinkedList<T> &&other)
\fn template <class T> QLinkedList<T> &QLinkedList<T>::operator=(QLinkedList<T> &&other)
Move-assigns \a other to this QLinkedList instance.
\since 5.2
*/
/*! \fn T &QLinkedList::iterator::operator*() const
/*! \fn template <class T> T &QLinkedList<T>::iterator::operator*() const
Returns a modifiable reference to the current item.
@ -848,7 +848,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa operator->()
*/
/*! \fn T *QLinkedList::iterator::operator->() const
/*! \fn template <class T> T *QLinkedList<T>::iterator::operator->() const
Returns a pointer to the current item.
@ -856,8 +856,8 @@ const QLinkedListData QLinkedListData::shared_null = {
*/
/*!
\fn bool QLinkedList::iterator::operator==(const iterator &other) const
\fn bool QLinkedList::iterator::operator==(const const_iterator &other) const
\fn template <class T> bool QLinkedList<T>::iterator::operator==(const iterator &other) const
\fn template <class T> bool QLinkedList<T>::iterator::operator==(const const_iterator &other) const
Returns \c true if \a other points to the same item as this
iterator; otherwise returns \c false.
@ -866,8 +866,8 @@ const QLinkedListData QLinkedListData::shared_null = {
*/
/*!
\fn bool QLinkedList::iterator::operator!=(const iterator &other) const
\fn bool QLinkedList::iterator::operator!=(const const_iterator &other) const
\fn template <class T> bool QLinkedList<T>::iterator::operator!=(const iterator &other) const
\fn template <class T> bool QLinkedList<T>::iterator::operator!=(const const_iterator &other) const
Returns \c true if \a other points to a different item than this
iterator; otherwise returns \c false.
@ -875,7 +875,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa operator==()
*/
/*! \fn QLinkedList::iterator &QLinkedList::iterator::operator++()
/*! \fn template <class T> QLinkedList<T>::iterator &QLinkedList<T>::iterator::operator++()
The prefix ++ operator (\c{++it}) advances the iterator to the
next item in the list and returns an iterator to the new current
@ -887,7 +887,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa operator--()
*/
/*! \fn QLinkedList::iterator QLinkedList::iterator::operator++(int)
/*! \fn template <class T> QLinkedList<T>::iterator QLinkedList<T>::iterator::operator++(int)
\overload
@ -896,7 +896,7 @@ const QLinkedListData QLinkedListData::shared_null = {
current item.
*/
/*! \fn QLinkedList::iterator &QLinkedList::iterator::operator--()
/*! \fn template <class T> QLinkedList<T>::iterator &QLinkedList<T>::iterator::operator--()
The prefix -- operator (\c{--it}) makes the preceding item
current and returns an iterator to the new current item.
@ -907,7 +907,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa operator++()
*/
/*! \fn QLinkedList::iterator QLinkedList::iterator::operator--(int)
/*! \fn template <class T> QLinkedList<T>::iterator QLinkedList<T>::iterator::operator--(int)
\overload
@ -915,7 +915,7 @@ const QLinkedListData QLinkedListData::shared_null = {
current and returns an iterator to the previously current item.
*/
/*! \fn QLinkedList::iterator QLinkedList::iterator::operator+(int j) const
/*! \fn template <class T> QLinkedList<T>::iterator QLinkedList<T>::iterator::operator+(int j) const
Returns an iterator to the item at \a j positions forward from
this iterator. (If \a j is negative, the iterator goes backward.)
@ -926,7 +926,7 @@ const QLinkedListData QLinkedListData::shared_null = {
*/
/*! \fn QLinkedList::iterator QLinkedList::iterator::operator-(int j) const
/*! \fn template <class T> QLinkedList<T>::iterator QLinkedList<T>::iterator::operator-(int j) const
Returns an iterator to the item at \a j positions backward from
this iterator. (If \a j is negative, the iterator goes forward.)
@ -936,7 +936,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa operator+()
*/
/*! \fn QLinkedList::iterator &QLinkedList::iterator::operator+=(int j)
/*! \fn template <class T> QLinkedList<T>::iterator &QLinkedList<T>::iterator::operator+=(int j)
Advances the iterator by \a j items. (If \a j is negative, the
iterator goes backward.)
@ -944,7 +944,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa operator-=(), operator+()
*/
/*! \fn QLinkedList::iterator &QLinkedList::iterator::operator-=(int j)
/*! \fn template <class T> QLinkedList<T>::iterator &QLinkedList<T>::iterator::operator-=(int j)
Makes the iterator go back by \a j items. (If \a j is negative,
the iterator goes forward.)
@ -997,7 +997,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa QLinkedList::iterator, QLinkedListIterator
*/
/*! \fn QLinkedList::const_iterator::const_iterator()
/*! \fn template <class T> QLinkedList<T>::const_iterator::const_iterator()
Constructs an uninitialized iterator.
@ -1008,7 +1008,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa QLinkedList::constBegin(), QLinkedList::constEnd()
*/
/*! \fn QLinkedList::const_iterator::const_iterator(Node *node)
/*! \fn template <class T> QLinkedList<T>::const_iterator::const_iterator(Node *node)
\internal
*/
@ -1038,37 +1038,36 @@ const QLinkedListData QLinkedListData::shared_null = {
\internal
*/
/*! \fn QLinkedList::const_iterator::const_iterator(const const_iterator &other)
/*! \fn template <class T> QLinkedList<T>::const_iterator::const_iterator(const const_iterator &other)
Constructs a copy of \a other.
*/
/*! \fn QLinkedList::const_iterator::const_iterator(iterator other)
/*! \fn template <class T> QLinkedList<T>::const_iterator::const_iterator(iterator other)
Constructs a copy of \a other.
*/
/*! \fn QLinkedList::const_iterator &QLinkedList::const_iterator::operator=( \
const const_iterator &other)
/*! \fn template <class T> typename QLinkedList<T>::const_iterator &QLinkedList<T>::const_iterator::operator=(const const_iterator &other)
Assigns \a other to this iterator.
*/
/*! \fn const T &QLinkedList::const_iterator::operator*() const
/*! \fn template <class T> const T &QLinkedList<T>::const_iterator::operator*() const
Returns a reference to the current item.
\sa operator->()
*/
/*! \fn const T *QLinkedList::const_iterator::operator->() const
/*! \fn template <class T> const T *QLinkedList<T>::const_iterator::operator->() const
Returns a pointer to the current item.
\sa operator*()
*/
/*! \fn bool QLinkedList::const_iterator::operator==(const const_iterator &other) const
/*! \fn template <class T> bool QLinkedList<T>::const_iterator::operator==(const const_iterator &other) const
Returns \c true if \a other points to the same item as this
iterator; otherwise returns \c false.
@ -1076,7 +1075,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa operator!=()
*/
/*! \fn bool QLinkedList::const_iterator::operator!=(const const_iterator &other) const
/*! \fn template <class T> bool QLinkedList<T>::const_iterator::operator!=(const const_iterator &other) const
Returns \c true if \a other points to a different item than this
iterator; otherwise returns \c false.
@ -1084,19 +1083,19 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa operator==()
*/
/*! \fn QLinkedList::const_iterator &QLinkedList::const_iterator::operator++()
/*! \fn template <class T> QLinkedList<T>::const_iterator &QLinkedList<T>::const_iterator::operator++()
The prefix ++ operator (\c{++it}) advances the iterator to the
next item in the list and returns an iterator to the new current
item.
Calling this function on QLinkedList::constEnd() leads to
Calling this function on QLinkedList<T>::constEnd() leads to
undefined results.
\sa operator--()
*/
/*! \fn QLinkedList::const_iterator QLinkedList::const_iterator::operator++(int)
/*! \fn template <class T> QLinkedList<T>::const_iterator QLinkedList<T>::const_iterator::operator++(int)
\overload
@ -1105,7 +1104,7 @@ const QLinkedListData QLinkedListData::shared_null = {
current item.
*/
/*! \fn QLinkedList::const_iterator &QLinkedList::const_iterator::operator--()
/*! \fn template <class T> QLinkedList<T>::const_iterator &QLinkedList<T>::const_iterator::operator--()
The prefix -- operator (\c{--it}) makes the preceding item
current and returns an iterator to the new current item.
@ -1116,7 +1115,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa operator++()
*/
/*! \fn QLinkedList::const_iterator QLinkedList::const_iterator::operator--(int)
/*! \fn template <class T> QLinkedList<T>::const_iterator QLinkedList<T>::const_iterator::operator--(int)
\overload
@ -1124,7 +1123,7 @@ const QLinkedListData QLinkedListData::shared_null = {
current and returns an iterator to the previously current item.
*/
/*! \fn QLinkedList::const_iterator QLinkedList::const_iterator::operator+(int j) const
/*! \fn template <class T> QLinkedList<T>::const_iterator QLinkedList<T>::const_iterator::operator+(int j) const
Returns an iterator to the item at \a j positions forward from
this iterator. (If \a j is negative, the iterator goes backward.)
@ -1134,7 +1133,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa operator-()
*/
/*! \fn QLinkedList::const_iterator QLinkedList::const_iterator::operator-(int j) const
/*! \fn template <class T> QLinkedList<T>::const_iterator QLinkedList<T>::const_iterator::operator-(int j) const
This function returns an iterator to the item at \a j positions backward from
this iterator. (If \a j is negative, the iterator goes forward.)
@ -1144,7 +1143,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa operator+()
*/
/*! \fn QLinkedList::const_iterator &QLinkedList::const_iterator::operator+=(int j)
/*! \fn template <class T> QLinkedList<T>::const_iterator &QLinkedList<T>::const_iterator::operator+=(int j)
Advances the iterator by \a j items. (If \a j is negative, the
iterator goes backward.)
@ -1154,7 +1153,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa operator-=(), operator+()
*/
/*! \fn QLinkedList::const_iterator &QLinkedList::const_iterator::operator-=(int j)
/*! \fn template <class T> QLinkedList<T>::const_iterator &QLinkedList<T>::const_iterator::operator-=(int j)
Makes the iterator go back by \a j items. (If \a j is negative,
the iterator goes forward.)
@ -1164,7 +1163,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa operator+=(), operator-()
*/
/*! \fn QDataStream &operator<<(QDataStream &out, const QLinkedList<T> &list)
/*! \fn template <class T> QDataStream &operator<<(QDataStream &out, const QLinkedList<T> &list)
\relates QLinkedList
Writes the linked list \a list to stream \a out.
@ -1175,7 +1174,7 @@ const QLinkedListData QLinkedListData::shared_null = {
\sa{Serializing Qt Data Types}{Format of the QDataStream operators}
*/
/*! \fn QDataStream &operator>>(QDataStream &in, QLinkedList<T> &list)
/*! \fn template <class T> QDataStream &operator>>(QDataStream &in, QLinkedList<T> &list)
\relates QLinkedList
Reads a linked list from stream \a in into \a list.
@ -1187,7 +1186,7 @@ const QLinkedListData QLinkedListData::shared_null = {
/*!
\since 4.1
\fn QLinkedList<T> QLinkedList<T>::fromStdList(const std::list<T> &list)
\fn template <class T> QLinkedList<T> QLinkedList<T>::fromStdList(const std::list<T> &list)
Returns a QLinkedList object with the data contained in \a list.
The order of the elements in the QLinkedList is the same as in \a
@ -1202,7 +1201,7 @@ const QLinkedListData QLinkedListData::shared_null = {
/*!
\since 4.1
\fn std::list<T> QLinkedList<T>::toStdList() const
\fn template <class T> std::list<T> QLinkedList<T>::toStdList() const
Returns a std::list object with the data contained in this
QLinkedList. Example:

294
src/corelib/tools/qlist.cpp
View File

File diff suppressed because it is too large Load Diff

196
src/corelib/tools/qset.qdoc
View File

@ -96,14 +96,14 @@
*/
/*!
\fn QSet::QSet()
\fn template <class T> QSet<T>::QSet()
Constructs an empty set.
\sa clear()
*/
/*! \fn QSet::QSet(std::initializer_list<T> list)
/*! \fn template <class T> QSet<T>::QSet(std::initializer_list<T> list)
\since 5.1
Constructs a set with a copy of each of the elements in the
@ -114,14 +114,14 @@
*/
/*!
\fn void QSet::swap(QSet<T> &other)
\fn template <class T> void QSet<T>::swap(QSet<T> &other)
Swaps set \a other with this set. This operation is very fast and
never fails.
*/
/*!
\fn bool QSet::operator==(const QSet<T> &other) const
\fn template <class T> bool QSet<T>::operator==(const QSet<T> &other) const
Returns \c true if the \a other set is equal to this set; otherwise
returns \c false.
@ -134,7 +134,7 @@
*/
/*!
\fn bool QSet::operator!=(const QSet<T> &other) const
\fn template <class T> bool QSet<T>::operator!=(const QSet<T> &other) const
Returns \c true if the \a other set is not equal to this set; otherwise
returns \c false.
@ -147,7 +147,7 @@
*/
/*!
\fn int QSet::size() const
\fn template <class T> int QSet<T>::size() const
Returns the number of items in the set.
@ -155,7 +155,7 @@
*/
/*!
\fn bool QSet::isEmpty() const
\fn template <class T> bool QSet<T>::isEmpty() const
Returns \c true if the set contains no elements; otherwise returns
false.
@ -164,7 +164,7 @@
*/
/*!
\fn int QSet::capacity() const
\fn template <class T> int QSet<T>::capacity() const
Returns the number of buckets in the set's internal hash
table.
@ -177,7 +177,7 @@
\sa reserve(), squeeze()
*/
/*! \fn void QSet::reserve(int size)
/*! \fn template <class T> void QSet<T>::reserve(int size)
Ensures that the set's internal hash table consists of at
least \a size buckets.
@ -201,7 +201,7 @@
*/
/*!
\fn void QSet::squeeze()
\fn template <class T> void QSet<T>::squeeze()
Reduces the size of the set's internal hash table to save
memory.
@ -214,7 +214,7 @@
*/
/*!
\fn void QSet::detach()
\fn template <class T> void QSet<T>::detach()
\internal
@ -224,7 +224,7 @@
\sa isDetached()
*/
/*! \fn bool QSet::isDetached() const
/*! \fn template <class T> bool QSet<T>::isDetached() const
\internal
@ -235,12 +235,12 @@
*/
/*!
\fn void QSet::setSharable(bool sharable)
\fn template <class T> void QSet<T>::setSharable(bool sharable)
\internal
*/
/*!
\fn void QSet::clear()
\fn template <class T> void QSet<T>::clear()
Removes all elements from the set.
@ -248,7 +248,7 @@
*/
/*!
\fn bool QSet::remove(const T &value)
\fn template <class T> bool QSet<T>::remove(const T &value)
Removes any occurrence of item \a value from the set. Returns
true if an item was actually removed; otherwise returns \c false.
@ -257,7 +257,7 @@
*/
/*!
\fn QSet::iterator QSet::erase(const_iterator pos)
\fn template <class T> QSet<T>::iterator QSet<T>::erase(const_iterator pos)
\since 5.7
Removes the item at the iterator position \a pos from the set, and
@ -271,12 +271,12 @@
*/
/*!
\fn QSet::iterator QSet::erase(iterator pos)
\fn template <class T> QSet<T>::iterator QSet<T>::erase(iterator pos)
\since 4.2
\overload
*/
/*! \fn QSet::const_iterator QSet::find(const T &value) const
/*! \fn template <class T> QSet<T>::const_iterator QSet<T>::find(const T &value) const
\since 4.2
Returns a const iterator positioned at the item \a value in the
@ -286,7 +286,7 @@
\sa constFind(), contains()
*/
/*! \fn QSet::iterator QSet::find(const T &value)
/*! \fn template <class T> QSet<T>::iterator QSet<T>::find(const T &value)
\since 4.2
\overload
@ -295,7 +295,7 @@
returns end().
*/
/*! \fn QSet::const_iterator QSet::constFind(const T &value) const
/*! \fn template <class T> QSet<T>::const_iterator QSet<T>::constFind(const T &value) const
\since 4.2
Returns a const iterator positioned at the item \a value in the
@ -306,7 +306,7 @@
*/
/*!
\fn bool QSet::contains(const T &value) const
\fn template <class T> bool QSet<T>::contains(const T &value) const
Returns \c true if the set contains item \a value; otherwise returns
false.
@ -315,7 +315,7 @@
*/
/*!
\fn bool QSet::contains(const QSet<T> &other) const
\fn template <class T> bool QSet<T>::contains(const QSet<T> &other) const
\since 4.6
Returns \c true if the set contains all items from the \a other set;
@ -324,7 +324,7 @@
\sa insert(), remove(), find()
*/
/*! \fn QSet::const_iterator QSet::begin() const
/*! \fn template <class T> QSet<T>::const_iterator QSet<T>::begin() const
Returns a const \l{STL-style iterators}{STL-style iterator} positioned at the first
item in the set.
@ -332,7 +332,7 @@
\sa constBegin(), end()
*/
/*! \fn QSet::iterator QSet::begin()
/*! \fn template <class T> QSet<T>::iterator QSet<T>::begin()
\since 4.2
\overload
@ -340,7 +340,7 @@
item in the set.
*/
/*! \fn QSet::const_iterator QSet::cbegin() const
/*! \fn template <class T> QSet<T>::const_iterator QSet<T>::cbegin() const
\since 5.0
Returns a const \l{STL-style iterators}{STL-style iterator} positioned at the first
@ -349,7 +349,7 @@
\sa begin(), cend()
*/
/*! \fn QSet::const_iterator QSet::constBegin() const
/*! \fn template <class T> QSet<T>::const_iterator QSet<T>::constBegin() const
Returns a const \l{STL-style iterators}{STL-style iterator} positioned at the first
item in the set.
@ -357,7 +357,7 @@
\sa begin(), constEnd()
*/
/*! \fn QSet::const_iterator QSet::end() const
/*! \fn template <class T> QSet<T>::const_iterator QSet<T>::end() const
Returns a const \l{STL-style iterators}{STL-style iterator} positioned at the imaginary
item after the last item in the set.
@ -365,7 +365,7 @@
\sa constEnd(), begin()
*/
/*! \fn QSet::iterator QSet::end()
/*! \fn template <class T> QSet<T>::iterator QSet<T>::end()
\since 4.2
\overload
@ -373,7 +373,7 @@
imaginary item after the last item in the set.
*/
/*! \fn QSet::const_iterator QSet::cend() const
/*! \fn template <class T> QSet<T>::const_iterator QSet<T>::cend() const
\since 5.0
Returns a const \l{STL-style iterators}{STL-style iterator} pointing to the imaginary
@ -382,7 +382,7 @@
\sa cbegin(), end()
*/
/*! \fn QSet::const_iterator QSet::constEnd() const
/*! \fn template <class T> QSet<T>::const_iterator QSet<T>::constEnd() const
Returns a const \l{STL-style iterators}{STL-style iterator} pointing to the imaginary
item after the last item in the set.
@ -390,7 +390,7 @@
\sa constBegin(), end()
*/
/*! \fn QSet::reverse_iterator QSet::rbegin()
/*! \fn template <class T> QSet<T>::reverse_iterator QSet<T>::rbegin()
\since 5.6
Returns a \l{STL-style iterators}{STL-style} reverse iterator pointing to the first
@ -399,12 +399,12 @@
\sa begin(), crbegin(), rend()
*/
/*! \fn QSet::const_reverse_iterator QSet::rbegin() const
/*! \fn template <class T> QSet<T>::const_reverse_iterator QSet<T>::rbegin() const
\since 5.6
\overload
*/
/*! \fn QSet::const_reverse_iterator QSet::crbegin() const
/*! \fn template <class T> QSet<T>::const_reverse_iterator QSet<T>::crbegin() const
\since 5.6
Returns a const \l{STL-style iterators}{STL-style} reverse iterator pointing to the first
@ -413,7 +413,7 @@
\sa begin(), rbegin(), rend()
*/
/*! \fn QSet::reverse_iterator QSet::rend()
/*! \fn template <class T> QSet<T>::reverse_iterator QSet<T>::rend()
\since 5.6
Returns a \l{STL-style iterators}{STL-style} reverse iterator pointing to one past
@ -422,12 +422,12 @@
\sa end(), crend(), rbegin()
*/
/*! \fn QSet::const_reverse_iterator QSet::rend() const
/*! \fn template <class T> QSet<T>::const_reverse_iterator QSet<T>::rend() const
\since 5.6
\overload
*/
/*! \fn QSet::const_reverse_iterator QSet::crend() const
/*! \fn template <class T> QSet<T>::const_reverse_iterator QSet<T>::crend() const
\since 5.6
Returns a const \l{STL-style iterators}{STL-style} reverse iterator pointing to one
@ -530,7 +530,7 @@
*/
/*!
\fn QSet::insert(const T &value)
\fn template <class T> QSet<T>::insert(const T &value)
Inserts item \a value into the set, if \a value isn't already
in the set, and returns an iterator pointing at the inserted
@ -540,7 +540,7 @@
*/
/*!
\fn QSet<T> &QSet::unite(const QSet<T> &other)
\fn template <class T> QSet<T> &QSet<T>::unite(const QSet<T> &other)
Each item in the \a other set that isn't already in this set is
inserted into this set. A reference to this set is returned.
@ -549,7 +549,7 @@
*/
/*!
\fn QSet<T> &QSet::intersect(const QSet<T> &other)
\fn template <class T> QSet<T> &QSet<T>::intersect(const QSet<T> &other)
Removes all items from this set that are not contained in the
\a other set. A reference to this set is returned.
@ -558,7 +558,7 @@
*/
/*!
\fn bool QSet::intersects(const QSet<T> &other) const
\fn template <class T> bool QSet<T>::intersects(const QSet<T> &other) const
\since 5.6
Returns \c true if this set has at least one item in common with
@ -568,7 +568,7 @@
*/
/*!
\fn QSet<T> &QSet::subtract(const QSet<T> &other)
\fn template <class T> QSet<T> &QSet<T>::subtract(const QSet<T> &other)
Removes all items from this set that are contained in the
\a other set. Returns a reference to this set.
@ -577,22 +577,22 @@
*/
/*!
\fn bool QSet::empty() const
\fn template <class T> bool QSet<T>::empty() const
Returns \c true if the set is empty. This function is provided
for STL compatibility. It is equivalent to isEmpty().
*/
/*!
\fn bool QSet::count() const
\fn template <class T> bool QSet<T>::count() const
Same as size().
*/
/*!
\fn QSet<T> &QSet::operator<<(const T &value)
\fn QSet<T> &QSet::operator+=(const T &value)
\fn QSet<T> &QSet::operator|=(const T &value)
\fn template <class T> QSet<T> &QSet<T>::operator<<(const T &value)
\fn template <class T> QSet<T> &QSet<T>::operator+=(const T &value)
\fn template <class T> QSet<T> &QSet<T>::operator|=(const T &value)
Inserts a new item \a value and returns a reference to the set.
If \a value already exists in the set, the set is left unchanged.
@ -601,7 +601,7 @@
*/
/*!
\fn QSet<T> &QSet::operator-=(const T &value)
\fn template <class T> QSet<T> &QSet<T>::operator-=(const T &value)
Removes the occurrence of item \a value from the set, if
it is found, and returns a reference to the set. If the
@ -611,8 +611,8 @@
*/
/*!
\fn QSet<T> &QSet::operator|=(const QSet<T> &other)
\fn QSet<T> &QSet::operator+=(const QSet<T> &other)
\fn template <class T> QSet<T> &QSet<T>::operator|=(const QSet<T> &other)
\fn template <class T> QSet<T> &QSet<T>::operator+=(const QSet<T> &other)
Same as unite(\a other).
@ -620,7 +620,7 @@
*/
/*!
\fn QSet<T> &QSet::operator&=(const QSet<T> &other)
\fn template <class T> QSet<T> &QSet<T>::operator&=(const QSet<T> &other)
Same as intersect(\a other).
@ -628,7 +628,7 @@
*/
/*!
\fn QSet<T> &QSet::operator&=(const T &value)
\fn template <class T> QSet<T> &QSet<T>::operator&=(const T &value)
\overload
@ -638,7 +638,7 @@
/*!
\fn QSet<T> &QSet::operator-=(const QSet<T> &other)
\fn template <class T> QSet<T> &QSet<T>::operator-=(const QSet<T> &other)
Same as subtract(\a{other}).
@ -646,8 +646,8 @@
*/
/*!
\fn QSet<T> QSet::operator|(const QSet<T> &other) const
\fn QSet<T> QSet::operator+(const QSet<T> &other) const
\fn template <class T> QSet<T> QSet<T>::operator|(const QSet<T> &other) const
\fn template <class T> QSet<T> QSet<T>::operator+(const QSet<T> &other) const
Returns a new QSet that is the union of this set and the
\a other set.
@ -656,7 +656,7 @@
*/
/*!
\fn QSet<T> QSet::operator&(const QSet<T> &other) const
\fn template <class T> QSet<T> QSet<T>::operator&(const QSet<T> &other) const
Returns a new QSet that is the intersection of this set and the
\a other set.
@ -665,7 +665,7 @@
*/
/*!
\fn QSet<T> QSet::operator-(const QSet<T> &other) const
\fn template <class T> QSet<T> QSet<T>::operator-(const QSet<T> &other) const
Returns a new QSet that is the set difference of this set and
the \a other set, i.e., this set - \a other set.
@ -766,8 +766,8 @@
*/
/*!
\fn QSet::iterator::iterator()
\fn QSet::const_iterator::const_iterator()
\fn template <class T> QSet<T>::iterator::iterator()
\fn template <class T> QSet<T>::const_iterator::const_iterator()
Constructs an uninitialized iterator.
@ -779,8 +779,8 @@
*/
/*!
\fn QSet::iterator::iterator(typename Hash::iterator i)
\fn QSet::const_iterator::const_iterator(typename Hash::const_iterator i)
\fn template <class T> QSet<T>::iterator::iterator(typename Hash::iterator i)
\fn template <class T> QSet<T>::const_iterator::const_iterator(typename Hash::const_iterator i)
\internal
*/
@ -822,14 +822,14 @@
*/
/*!
\fn QSet::iterator::iterator(const iterator &other)
\fn QSet::const_iterator::const_iterator(const const_iterator &other)
\fn template <class T> QSet<T>::iterator::iterator(const iterator &other)
\fn template <class T> QSet<T>::const_iterator::const_iterator(const const_iterator &other)
Constructs a copy of \a other.
*/
/*!
\fn QSet::const_iterator::const_iterator(const iterator &other)
\fn template <class T> QSet<T>::const_iterator::const_iterator(const iterator &other)
\since 4.2
\overload
@ -837,15 +837,15 @@
*/
/*!
\fn QSet::iterator &QSet::iterator::operator=(const iterator &other)
\fn QSet::const_iterator &QSet::const_iterator::operator=(const const_iterator &other)
\fn template <class T> QSet<T>::iterator &QSet<T>::iterator::operator=(const iterator &other)
\fn template <class T> QSet<T>::const_iterator &QSet<T>::const_iterator::operator=(const const_iterator &other)
Assigns \a other to this iterator.
*/
/*!
\fn const T &QSet::iterator::operator*() const
\fn const T &QSet::const_iterator::operator*() const
\fn template <class T> const T &QSet<T>::iterator::operator*() const
\fn template <class T> const T &QSet<T>::const_iterator::operator*() const
Returns a reference to the current item.
@ -853,8 +853,8 @@
*/
/*!
\fn const T *QSet::iterator::operator->() const
\fn const T *QSet::const_iterator::operator->() const
\fn template <class T> const T *QSet<T>::iterator::operator->() const
\fn template <class T> const T *QSet<T>::const_iterator::operator->() const
Returns a pointer to the current item.
@ -862,8 +862,8 @@
*/
/*!
\fn bool QSet::iterator::operator==(const iterator &other) const
\fn bool QSet::const_iterator::operator==(const const_iterator &other) const
\fn template <class T> bool QSet<T>::iterator::operator==(const iterator &other) const
\fn template <class T> bool QSet<T>::const_iterator::operator==(const const_iterator &other) const
Returns \c true if \a other points to the same item as this
iterator; otherwise returns \c false.
@ -872,15 +872,15 @@
*/
/*!
\fn bool QSet::iterator::operator==(const const_iterator &other) const
\fn bool QSet::iterator::operator!=(const const_iterator &other) const
\fn template <class T> bool QSet<T>::iterator::operator==(const const_iterator &other) const
\fn template <class T> bool QSet<T>::iterator::operator!=(const const_iterator &other) const
\overload
*/
/*!
\fn bool QSet::iterator::operator!=(const iterator &other) const
\fn bool QSet::const_iterator::operator!=(const const_iterator &other) const
\fn template <class T> bool QSet<T>::iterator::operator!=(const iterator &other) const
\fn template <class T> bool QSet<T>::const_iterator::operator!=(const const_iterator &other) const
Returns \c true if \a other points to a different item than this
iterator; otherwise returns \c false.
@ -889,22 +889,22 @@
*/
/*!
\fn QSet::iterator &QSet::iterator::operator++()
\fn QSet::const_iterator &QSet::const_iterator::operator++()
\fn template <class T> QSet<T>::iterator &QSet<T>::iterator::operator++()
\fn template <class T> QSet<T>::const_iterator &QSet<T>::const_iterator::operator++()
The prefix ++ operator (\c{++it}) advances the iterator to the
next item in the set and returns an iterator to the new current
item.
Calling this function on QSet::constEnd() leads to
Calling this function on QSet<T>::constEnd() leads to
undefined results.
\sa operator--()
*/
/*!
\fn QSet::iterator QSet::iterator::operator++(int)
\fn QSet::const_iterator QSet::const_iterator::operator++(int)
\fn template <class T> QSet<T>::iterator QSet<T>::iterator::operator++(int)
\fn template <class T> QSet<T>::const_iterator QSet<T>::const_iterator::operator++(int)
\overload
@ -914,8 +914,8 @@
*/
/*!
\fn QSet::iterator &QSet::iterator::operator--()
\fn QSet::const_iterator &QSet::const_iterator::operator--()
\fn template <class T> QSet<T>::iterator &QSet<T>::iterator::operator--()
\fn template <class T> QSet<T>::const_iterator &QSet<T>::const_iterator::operator--()
The prefix -- operator (\c{--it}) makes the preceding item
current and returns an iterator to the new current item.
@ -927,8 +927,8 @@
*/
/*!
\fn QSet::iterator QSet::iterator::operator--(int)
\fn QSet::const_iterator QSet::const_iterator::operator--(int)
\fn template <class T> QSet<T>::iterator QSet<T>::iterator::operator--(int)
\fn template <class T> QSet<T>::const_iterator QSet<T>::const_iterator::operator--(int)
\overload
@ -937,8 +937,8 @@
*/
/*!
\fn QSet::iterator QSet::iterator::operator+(int j) const
\fn QSet::const_iterator QSet::const_iterator::operator+(int j) const
\fn template <class T> QSet<T>::iterator QSet<T>::iterator::operator+(int j) const
\fn template <class T> QSet<T>::const_iterator QSet<T>::const_iterator::operator+(int j) const
Returns an iterator to the item at \a j positions forward from
this iterator. (If \a j is negative, the iterator goes backward.)
@ -949,8 +949,8 @@
*/
/*!
\fn QSet::iterator QSet::iterator::operator-(int j) const
\fn QSet::const_iterator QSet::const_iterator::operator-(int j) const
\fn template <class T> QSet<T>::iterator QSet<T>::iterator::operator-(int j) const
\fn template <class T> QSet<T>::const_iterator QSet<T>::const_iterator::operator-(int j) const
Returns an iterator to the item at \a j positions backward from
this iterator. (If \a j is negative, the iterator goes forward.)
@ -961,8 +961,8 @@
*/
/*!
\fn QSet::iterator &QSet::iterator::operator+=(int j)
\fn QSet::const_iterator &QSet::const_iterator::operator+=(int j)
\fn template <class T> QSet<T>::iterator &QSet<T>::iterator::operator+=(int j)
\fn template <class T> QSet<T>::const_iterator &QSet<T>::const_iterator::operator+=(int j)
Advances the iterator by \a j items. (If \a j is negative, the
iterator goes backward.)
@ -973,8 +973,8 @@
*/
/*!
\fn QSet::iterator &QSet::iterator::operator-=(int j)
\fn QSet::const_iterator &QSet::const_iterator::operator-=(int j)
\fn template <class T> QSet<T>::iterator &QSet<T>::iterator::operator-=(int j)
\fn template <class T> QSet<T>::const_iterator &QSet<T>::const_iterator::operator-=(int j)
Makes the iterator go back by \a j items. (If \a j is negative,
the iterator goes forward.)
@ -984,7 +984,7 @@
\sa operator+=(), operator-()
*/
/*! \fn QList<T> QSet<T>::toList() const
/*! \fn template <class T> QList<T> QSet<T>::toList() const
Returns a new QList containing the elements in the set. The
order of the elements in the QList is undefined.
@ -996,7 +996,7 @@
\sa fromList(), QList::fromSet()
*/
/*! \fn QList<T> QSet<T>::values() const
/*! \fn template <class T> QList<T> QSet<T>::values() const
Returns a new QList containing the elements in the set. The
order of the elements in the QList is undefined.
@ -1007,7 +1007,7 @@
*/
/*! \fn QSet<T> QSet<T>::fromList(const QList<T> &list)
/*! \fn template <class T> QSet<T> QSet<T>::fromList(const QList<T> &list)
Returns a new QSet object containing the data contained in \a
list. Since QSet doesn't allow duplicates, the resulting QSet
@ -1022,7 +1022,7 @@
*/
/*!
\fn QDataStream &operator<<(QDataStream &out, const QSet<T> &set)
\fn template <class T> QDataStream &operator<<(QDataStream &out, const QSet<T> &set)
\relates QSet
Writes the \a set to stream \a out.
@ -1033,7 +1033,7 @@
*/
/*!
\fn QDataStream &operator>>(QDataStream &in, QSet<T> &set)
\fn template <class T> QDataStream &operator>>(QDataStream &in, QSet<T> &set)
\relates QSet
Reads a set from stream \a in into \a set.
@ -1044,7 +1044,7 @@
*/
/*!
\fn uint qHash(const QSet<T> &key, uint seed = 0)
\fn template <class T> uint qHash(const QSet<T> &key, uint seed = 0)
\relates QHash
\since 5.5

220
src/corelib/tools/qvector.qdoc
View File

@ -189,7 +189,7 @@
*/
/*!
\fn QVector<T> QVector::mid(int pos, int length = -1) const
\fn template <typename T> QVector<T> QVector<T>::mid(int pos, int length = -1) const
Returns a sub-vector which contains elements from this vector,
starting at position \a pos. If \a length is -1 (the default), all
@ -199,7 +199,7 @@
*/
/*! \fn QVector::QVector()
/*! \fn template <typename T> QVector<T>::QVector()
Constructs an empty vector.
@ -207,7 +207,7 @@
*/
/*!
\fn QVector::QVector(QVector<T> &&other)
\fn template <typename T> QVector<T>::QVector(QVector<T> &&other)
Move-constructs a QVector instance, making it point at the same
object that \a other was pointing to.
@ -215,7 +215,7 @@
\since 5.2
*/
/*! \fn QVector::QVector(int size)
/*! \fn template <typename T> QVector<T>::QVector(int size)
Constructs a vector with an initial size of \a size elements.
@ -225,7 +225,7 @@
\sa resize()
*/
/*! \fn QVector::QVector(int size, const T &value)
/*! \fn template <typename T> QVector<T>::QVector(int size, const T &value)
Constructs a vector with an initial size of \a size elements.
Each element is initialized with \a value.
@ -233,7 +233,7 @@
\sa resize(), fill()
*/
/*! \fn QVector::QVector(const QVector<T> &other)
/*! \fn template <typename T> QVector<T>::QVector(const QVector<T> &other)
Constructs a copy of \a other.
@ -246,7 +246,7 @@
\sa operator=()
*/
/*! \fn QVector::QVector(std::initializer_list<T> args)
/*! \fn template <typename T> QVector<T>::QVector(std::initializer_list<T> args)
\since 4.8
Constructs a vector from the std::initializer_list given by \a args.
@ -256,33 +256,33 @@
*/
/*! \fn QVector::~QVector()
/*! \fn template <typename T> QVector<T>::~QVector()
Destroys the vector.
*/
/*! \fn QVector<T> &QVector::operator=(const QVector<T> &other)
/*! \fn template <typename T> QVector<T> &QVector<T>::operator=(const QVector<T> &other)
Assigns \a other to this vector and returns a reference to this
vector.
*/
/*!
\fn QVector<T> &QVector::operator=(QVector<T> &&other)
\fn template <typename T> QVector<T> &QVector<T>::operator=(QVector<T> &&other)
Move-assigns \a other to this QVector instance.
\since 5.2
*/
/*! \fn void QVector::swap(QVector<T> &other)
/*! \fn template <typename T> void QVector<T>::swap(QVector<T> &other)
\since 4.8
Swaps vector \a other with this vector. This operation is very fast and
never fails.
*/
/*! \fn bool QVector::operator==(const QVector<T> &other) const
/*! \fn template <typename T> bool QVector<T>::operator==(const QVector<T> &other) const
Returns \c true if \a other is equal to this vector; otherwise
returns \c false.
@ -296,7 +296,7 @@
\sa operator!=()
*/
/*! \fn bool QVector::operator!=(const QVector<T> &other) const
/*! \fn template <typename T> bool QVector<T>::operator!=(const QVector<T> &other) const
Returns \c true if \a other is not equal to this vector; otherwise
returns \c false.
@ -310,7 +310,7 @@
\sa operator==()
*/
/*! \fn bool operator<(const QVector<T> &lhs, const QVector<T> &rhs)
/*! \fn template <typename T> bool operator<(const QVector<T> &lhs, const QVector<T> &rhs)
\since 5.6
\relates QVector
@ -322,7 +322,7 @@
of \c operator<().
*/
/*! \fn bool operator<=(const QVector<T> &lhs, const QVector<T> &rhs)
/*! \fn template <typename T> bool operator<=(const QVector<T> &lhs, const QVector<T> &rhs)
\since 5.6
\relates QVector
@ -334,7 +334,7 @@
of \c operator<().
*/
/*! \fn bool operator>(const QVector<T> &lhs, const QVector<T> &rhs)
/*! \fn template <typename T> bool operator>(const QVector<T> &lhs, const QVector<T> &rhs)
\since 5.6
\relates QVector
@ -346,7 +346,7 @@
of \c operator<().
*/
/*! \fn bool operator>=(const QVector<T> &lhs, const QVector<T> &rhs)
/*! \fn template <typename T> bool operator>=(const QVector<T> &lhs, const QVector<T> &rhs)
\since 5.6
\relates QVector
@ -359,7 +359,7 @@
*/
/*!
\fn uint qHash(const QVector<T> &key, uint seed = 0)
\fn template <typename T> uint qHash(const QVector<T> &key, uint seed = 0)
\since 5.6
\relates QVector
@ -369,21 +369,21 @@
This function requires qHash() to be overloaded for the value type \c T.
*/
/*! \fn int QVector::size() const
/*! \fn template <typename T> int QVector<T>::size() const
Returns the number of items in the vector.
\sa isEmpty(), resize()
*/
/*! \fn bool QVector::isEmpty() const
/*! \fn template <typename T> bool QVector<T>::isEmpty() const
Returns \c true if the vector has size 0; otherwise returns \c false.
\sa size(), resize()
*/
/*! \fn void QVector::resize(int size)
/*! \fn template <typename T> void QVector<T>::resize(int size)
Sets the size of the vector to \a size. If \a size is greater than the
current size, elements are added to the end; the new elements are
@ -396,7 +396,7 @@
\sa size()
*/
/*! \fn int QVector::capacity() const
/*! \fn template <typename T> int QVector<T>::capacity() const
Returns the maximum number of items that can be stored in the
vector without forcing a reallocation.
@ -409,7 +409,7 @@
\sa reserve(), squeeze()
*/
/*! \fn void QVector::reserve(int size)
/*! \fn template <typename T> void QVector<T>::reserve(int size)
Attempts to allocate memory for at least \a size elements. If you
know in advance how large the vector will be, you should call this
@ -434,7 +434,7 @@
\sa squeeze(), capacity()
*/
/*! \fn void QVector::squeeze()
/*! \fn template <typename T> void QVector<T>::squeeze()
Releases any memory not required to store the items.
@ -445,27 +445,27 @@
\sa reserve(), capacity()
*/
/*! \fn void QVector::detach()
/*! \fn template <typename T> void QVector<T>::detach()
\internal
*/
/*! \fn bool QVector::isDetached() const
/*! \fn template <typename T> bool QVector<T>::isDetached() const
\internal
*/
/*! \fn void QVector::setSharable(bool sharable)
/*! \fn template <typename T> void QVector<T>::setSharable(bool sharable)
\internal
*/
/*! \fn bool QVector::isSharedWith(const QVector<T> &other) const
/*! \fn template <typename T> bool QVector<T>::isSharedWith(const QVector<T> &other) const
\internal
*/
/*! \fn T *QVector::data()
/*! \fn template <typename T> T *QVector<T>::data()
Returns a pointer to the data stored in the vector. The pointer
can be used to access and modify the items in the vector.
@ -482,12 +482,12 @@
\sa constData(), operator[]()
*/
/*! \fn const T *QVector::data() const
/*! \fn template <typename T> const T *QVector<T>::data() const
\overload
*/
/*! \fn const T *QVector::constData() const
/*! \fn template <typename T> const T *QVector<T>::constData() const
Returns a const pointer to the data stored in the vector. The
pointer can be used to access the items in the vector.
@ -500,7 +500,7 @@
\sa data(), operator[]()
*/
/*! \fn void QVector::clear()
/*! \fn template <typename T> void QVector<T>::clear()
Removes all the elements from the vector.
@ -517,7 +517,7 @@
\sa squeeze()
*/
/*! \fn const T &QVector::at(int i) const
/*! \fn template <typename T> const T &QVector<T>::at(int i) const
Returns the item at index position \a i in the vector.
@ -527,7 +527,7 @@
\sa value(), operator[]()
*/
/*! \fn T &QVector::operator[](int i)
/*! \fn template <typename T> T &QVector<T>::operator[](int i)
Returns the item at index position \a i as a modifiable reference.
@ -540,7 +540,7 @@
\sa at(), value()
*/
/*! \fn const T &QVector::operator[](int i) const
/*! \fn template <typename T> const T &QVector<T>::operator[](int i) const
\overload
@ -548,7 +548,7 @@
*/
/*!
\fn void QVector::append(const T &value)
\fn template <typename T> void QVector<T>::append(const T &value)
Inserts \a value at the end of the vector.
@ -566,7 +566,7 @@
*/
/*!
\fn void QVector::append(T &&value)
\fn template <typename T> void QVector<T>::append(T &&value)
\since 5.6
\overload
@ -575,7 +575,7 @@
\snippet code/src_corelib_tools_qvector.cpp move-append
*/
/*! \fn void QVector::append(const QVector<T> &value)
/*! \fn template <typename T> void QVector<T>::append(const QVector<T> &value)
\overload
@ -587,7 +587,7 @@
*/
/*! \fn void QVector::prepend(const T &value)
/*! \fn template <typename T> void QVector<T>::prepend(const T &value)
Inserts \a value at the beginning of the vector.
@ -605,7 +605,7 @@
\sa append(), insert()
*/
/*! \fn void QVector::insert(int i, const T &value)
/*! \fn template <typename T> void QVector<T>::insert(int i, const T &value)
Inserts \a value at index position \a i in the vector. If \a i is
0, the value is prepended to the vector. If \a i is size(), the
@ -623,7 +623,7 @@
\sa append(), prepend(), remove()
*/
/*! \fn void QVector::insert(int i, int count, const T &value)
/*! \fn template <typename T> void QVector<T>::insert(int i, int count, const T &value)
\overload
@ -634,7 +634,7 @@
\snippet code/src_corelib_tools_qvector.cpp 10
*/
/*! \fn QVector::iterator QVector::insert(iterator before, const T &value)
/*! \fn template <typename T> QVector<T>::iterator QVector<T>::insert(iterator before, const T &value)
\overload
@ -642,14 +642,14 @@
\a before. Returns an iterator pointing at the inserted item.
*/
/*! \fn QVector::iterator QVector::insert(iterator before, int count, const T &value)
/*! \fn template <typename T> QVector<T>::iterator QVector<T>::insert(iterator before, int count, const T &value)
Inserts \a count copies of \a value in front of the item pointed to
by the iterator \a before. Returns an iterator pointing at the
first of the inserted items.
*/
/*! \fn void QVector::replace(int i, const T &value)
/*! \fn template <typename T> void QVector<T>::replace(int i, const T &value)
Replaces the item at index position \a i with \a value.
@ -659,7 +659,7 @@
\sa operator[](), remove()
*/
/*! \fn void QVector::remove(int i)
/*! \fn template <typename T> void QVector<T>::remove(int i)
\overload
@ -668,7 +668,7 @@
\sa insert(), replace(), fill()
*/
/*! \fn void QVector::remove(int i, int count)
/*! \fn template <typename T> void QVector<T>::remove(int i, int count)
\overload
@ -678,7 +678,7 @@
\sa insert(), replace(), fill()
*/
/*! \fn void QVector::removeAt(int i)
/*! \fn template <typename T> void QVector<T>::removeAt(int i)
\since 5.2
Removes the element at index position \a i.
@ -692,7 +692,7 @@
\sa remove(), QList::removeAt()
*/
/*! \fn int QVector::removeAll(const T &t)
/*! \fn template <typename T> int QVector<T>::removeAll(const T &t)
\since 5.4
Removes all elements that compare equal to \a t from the
@ -703,7 +703,7 @@
\sa removeOne(), QList::removeAll()
*/
/*! \fn bool QVector::removeOne(const T &t)
/*! \fn template <typename T> bool QVector<T>::removeOne(const T &t)
\since 5.4
Removes the first element that compares equal to \a t from the
@ -714,7 +714,7 @@
\sa removeAll(), QList::removeOne()
*/
/*! \fn int QVector::length() const
/*! \fn template <typename T> int QVector<T>::length() const
\since 5.2
Same as size() and count().
@ -724,7 +724,7 @@
\sa size(), count(), QList::length()
*/
/*! \fn T QVector::takeAt(int i)
/*! \fn template <typename T> T QVector<T>::takeAt(int i)
\since 5.2
Removes the element at index position \a i and returns it.
@ -741,7 +741,7 @@
\sa takeFirst(), takeLast(), QList::takeAt()
*/
/*! \fn void QVector::move(int from, int to)
/*! \fn template <typename T> void QVector<T>::move(int from, int to)
\since 5.6
Moves the item at index position \a from to index position \a to.
@ -751,7 +751,7 @@
\sa QList::move()
*/
/*! \fn void QVector::removeFirst()
/*! \fn template <typename T> void QVector<T>::removeFirst()
\since 5.1
Removes the first item in the vector. Calling this function is
equivalent to calling remove(0). The vector must not be empty. If
@ -761,7 +761,7 @@
\sa remove(), takeFirst(), isEmpty()
*/
/*! \fn void QVector::removeLast()
/*! \fn template <typename T> void QVector<T>::removeLast()
\since 5.1
Removes the last item in the vector. Calling this function is
equivalent to calling remove(size() - 1). The vector must not be
@ -771,7 +771,7 @@
\sa remove(), takeLast(), removeFirst(), isEmpty()
*/
/*! \fn T QVector::takeFirst()
/*! \fn template <typename T> T QVector<T>::takeFirst()
\since 5.1
Removes the first item in the vector and returns it. This function
@ -781,7 +781,7 @@
\sa takeLast(), removeFirst()
*/
/*! \fn T QVector::takeLast()
/*! \fn template <typename T> T QVector<T>::takeLast()
\since 5.1
Removes the last item in the list and returns it. This function
@ -795,7 +795,7 @@
*/
/*! \fn QVector &QVector::fill(const T &value, int size = -1)
/*! \fn template <typename T> QVector &QVector<T>::fill(const T &value, int size = -1)
Assigns \a value to all items in the vector. If \a size is
different from -1 (the default), the vector is resized to size \a
@ -807,7 +807,7 @@
\sa resize()
*/
/*! \fn int QVector::indexOf(const T &value, int from = 0) const
/*! \fn template <typename T> int QVector<T>::indexOf(const T &value, int from = 0) const
Returns the index position of the first occurrence of \a value in
the vector, searching forward from index position \a from.
@ -822,7 +822,7 @@
\sa lastIndexOf(), contains()
*/
/*! \fn int QVector::lastIndexOf(const T &value, int from = -1) const
/*! \fn template <typename T> int QVector<T>::lastIndexOf(const T &value, int from = -1) const
Returns the index position of the last occurrence of the value \a
value in the vector, searching backward from index position \a
@ -838,7 +838,7 @@
\sa indexOf()
*/
/*! \fn bool QVector::contains(const T &value) const
/*! \fn template <typename T> bool QVector<T>::contains(const T &value) const
Returns \c true if the vector contains an occurrence of \a value;
otherwise returns \c false.
@ -849,7 +849,7 @@
\sa indexOf(), count()
*/
/*! \fn bool QVector::startsWith(const T &value) const
/*! \fn template <typename T> bool QVector<T>::startsWith(const T &value) const
\since 4.5
Returns \c true if this vector is not empty and its first
@ -858,7 +858,7 @@
\sa isEmpty(), first()
*/
/*! \fn bool QVector::endsWith(const T &value) const
/*! \fn template <typename T> bool QVector<T>::endsWith(const T &value) const
\since 4.5
Returns \c true if this vector is not empty and its last
@ -868,7 +868,7 @@
*/
/*! \fn int QVector::count(const T &value) const
/*! \fn template <typename T> int QVector<T>::count(const T &value) const
Returns the number of occurrences of \a value in the vector.
@ -878,14 +878,14 @@
\sa contains(), indexOf()
*/
/*! \fn int QVector::count() const
/*! \fn template <typename T> int QVector<T>::count() const
\overload
Same as size().
*/
/*! \fn QVector::iterator QVector::begin()
/*! \fn template <typename T> QVector<T>::iterator QVector<T>::begin()
Returns an \l{STL-style iterators}{STL-style iterator} pointing to the first item in
the vector.
@ -893,12 +893,12 @@
\sa constBegin(), end()
*/
/*! \fn QVector::const_iterator QVector::begin() const
/*! \fn template <typename T> QVector<T>::const_iterator QVector<T>::begin() const
\overload
*/
/*! \fn QVector::const_iterator QVector::cbegin() const
/*! \fn template <typename T> QVector<T>::const_iterator QVector<T>::cbegin() const
\since 5.0
Returns a const \l{STL-style iterators}{STL-style iterator} pointing to the first item
@ -907,7 +907,7 @@
\sa begin(), cend()
*/
/*! \fn QVector::const_iterator QVector::constBegin() const
/*! \fn template <typename T> QVector<T>::const_iterator QVector<T>::constBegin() const
Returns a const \l{STL-style iterators}{STL-style iterator} pointing to the first item
in the vector.
@ -915,7 +915,7 @@
\sa begin(), constEnd()
*/
/*! \fn QVector::iterator QVector::end()
/*! \fn template <typename T> QVector<T>::iterator QVector<T>::end()
Returns an \l{STL-style iterators}{STL-style iterator} pointing to the imaginary item
after the last item in the vector.
@ -923,12 +923,12 @@
\sa begin(), constEnd()
*/
/*! \fn QVector::const_iterator QVector::end() const
/*! \fn template <typename T> QVector<T>::const_iterator QVector<T>::end() const
\overload
*/
/*! \fn QVector::const_iterator QVector::cend() const
/*! \fn template <typename T> QVector<T>::const_iterator QVector<T>::cend() const
\since 5.0
Returns a const \l{STL-style iterators}{STL-style iterator} pointing to the imaginary
@ -937,7 +937,7 @@
\sa cbegin(), end()
*/
/*! \fn QVector::const_iterator QVector::constEnd() const
/*! \fn template <typename T> QVector<T>::const_iterator QVector<T>::constEnd() const
Returns a const \l{STL-style iterators}{STL-style iterator} pointing to the imaginary
item after the last item in the vector.
@ -945,7 +945,7 @@
\sa constBegin(), end()
*/
/*! \fn QVector::reverse_iterator QVector::rbegin()
/*! \fn template <typename T> QVector<T>::reverse_iterator QVector<T>::rbegin()
\since 5.6
Returns a \l{STL-style iterators}{STL-style} reverse iterator pointing to the first
@ -954,12 +954,12 @@
\sa begin(), crbegin(), rend()
*/
/*! \fn QVector::const_reverse_iterator QVector::rbegin() const
/*! \fn template <typename T> QVector<T>::const_reverse_iterator QVector<T>::rbegin() const
\since 5.6
\overload
*/
/*! \fn QVector::const_reverse_iterator QVector::crbegin() const
/*! \fn template <typename T> QVector<T>::const_reverse_iterator QVector<T>::crbegin() const
\since 5.6
Returns a const \l{STL-style iterators}{STL-style} reverse iterator pointing to the first
@ -968,7 +968,7 @@
\sa begin(), rbegin(), rend()
*/
/*! \fn QVector::reverse_iterator QVector::rend()
/*! \fn template <typename T> QVector<T>::reverse_iterator QVector<T>::rend()
\since 5.6
Returns a \l{STL-style iterators}{STL-style} reverse iterator pointing to one past
@ -977,12 +977,12 @@
\sa end(), crend(), rbegin()
*/
/*! \fn QVector::const_reverse_iterator QVector::rend() const
/*! \fn template <typename T> QVector<T>::const_reverse_iterator QVector<T>::rend() const
\since 5.6
\overload
*/
/*! \fn QVector::const_reverse_iterator QVector::crend() const
/*! \fn template <typename T> QVector<T>::const_reverse_iterator QVector<T>::crend() const
\since 5.6
Returns a const \l{STL-style iterators}{STL-style} reverse iterator pointing to one
@ -991,7 +991,7 @@
\sa end(), rend(), rbegin()
*/
/*! \fn QVector::iterator QVector::erase(iterator pos)
/*! \fn template <typename T> QVector<T>::iterator QVector<T>::erase(iterator pos)
Removes the item pointed to by the iterator \a pos from the
vector, and returns an iterator to the next item in the vector
@ -1000,7 +1000,7 @@
\sa insert(), remove()
*/
/*! \fn QVector::iterator QVector::erase(iterator begin, iterator end)
/*! \fn template <typename T> QVector<T>::iterator QVector<T>::erase(iterator begin, iterator end)
\overload
@ -1009,7 +1009,7 @@
before the call.
*/
/*! \fn T& QVector::first()
/*! \fn template <typename T> T& QVector<T>::first()
Returns a reference to the first item in the vector. This
function assumes that the vector isn't empty.
@ -1017,12 +1017,12 @@
\sa last(), isEmpty(), constFirst()
*/
/*! \fn const T& QVector::first() const
/*! \fn template <typename T> const T& QVector<T>::first() const
\overload
*/
/*! \fn const T& QVector::constFirst() const
/*! \fn template <typename T> const T& QVector<T>::constFirst() const
\since 5.6
Returns a const reference to the first item in the vector. This
@ -1031,7 +1031,7 @@
\sa constLast(), isEmpty(), first()
*/
/*! \fn T& QVector::last()
/*! \fn template <typename T> T& QVector<T>::last()
Returns a reference to the last item in the vector. This function
assumes that the vector isn't empty.
@ -1039,12 +1039,12 @@
\sa first(), isEmpty(), constLast()
*/
/*! \fn const T& QVector::last() const
/*! \fn template <typename T> const T& QVector<T>::last() const
\overload
*/
/*! \fn const T& QVector::constLast() const
/*! \fn template <typename T> const T& QVector<T>::constLast() const
\since 5.6
Returns a const reference to the last item in the vector. This function
@ -1053,7 +1053,7 @@
\sa constFirst(), isEmpty(), last()
*/
/*! \fn T QVector::value(int i) const
/*! \fn template <typename T> T QVector<T>::value(int i) const
Returns the value at index position \a i in the vector.
@ -1065,7 +1065,7 @@
\sa at(), operator[]()
*/
/*! \fn T QVector::value(int i, const T &defaultValue) const
/*! \fn template <typename T> T QVector<T>::value(int i, const T &defaultValue) const
\overload
@ -1073,72 +1073,72 @@
\a defaultValue.
*/
/*! \fn void QVector::push_back(const T &value)
/*! \fn template <typename T> void QVector<T>::push_back(const T &value)
This function is provided for STL compatibility. It is equivalent
to append(\a value).
*/
/*! \fn void QVector::push_back(T &&value)
/*! \fn template <typename T> void QVector<T>::push_back(T &&value)
\since 5.6
\overload
*/
/*! \fn void QVector::push_front(const T &value)
/*! \fn template <typename T> void QVector<T>::push_front(const T &value)
This function is provided for STL compatibility. It is equivalent
to prepend(\a value).
*/
/*! \fn void QVector::pop_front()
/*! \fn template <typename T> void QVector<T>::pop_front()
This function is provided for STL compatibility. It is equivalent
to removeFirst().
*/
/*! \fn void QVector::pop_back()
/*! \fn template <typename T> void QVector<T>::pop_back()
This function is provided for STL compatibility. It is equivalent
to removeLast().
*/
/*! \fn T& QVector::front()
/*! \fn template <typename T> T& QVector<T>::front()
This function is provided for STL compatibility. It is equivalent
to first().
*/
/*! \fn QVector::const_reference QVector::front() const
/*! \fn template <typename T> QVector<T>::const_reference QVector<T>::front() const
\overload
*/
/*! \fn QVector::reference QVector::back()
/*! \fn template <typename T> QVector<T>::reference QVector<T>::back()
This function is provided for STL compatibility. It is equivalent
to last().
*/
/*! \fn QVector::const_reference QVector::back() const
/*! \fn template <typename T> QVector<T>::const_reference QVector<T>::back() const
\overload
*/
/*! \fn void QVector::shrink_to_fit()
/*! \fn template <typename T> void QVector<T>::shrink_to_fit()
\since 5.10
This function is provided for STL compatibility. It is equivalent
to squeeze().
*/
/*! \fn bool QVector::empty() const
/*! \fn template <typename T> bool QVector<T>::empty() const
This function is provided for STL compatibility. It is equivalent
to isEmpty(), returning \c true if the vector is empty; otherwise
returns \c false.
*/
/*! \fn QVector<T> &QVector::operator+=(const QVector<T> &other)
/*! \fn template <typename T> QVector<T> &QVector<T>::operator+=(const QVector<T> &other)
Appends the items of the \a other vector to this vector and
returns a reference to this vector.
@ -1146,7 +1146,7 @@
\sa operator+(), append()
*/
/*! \fn void QVector::operator+=(const T &value)
/*! \fn template <typename T> void QVector<T>::operator+=(const T &value)
\overload
@ -1155,7 +1155,7 @@
\sa append(), operator<<()
*/
/*! \fn QVector<T> QVector::operator+(const QVector<T> &other) const
/*! \fn template <typename T> QVector<T> QVector<T>::operator+(const QVector<T> &other) const
Returns a vector that contains all the items in this vector
followed by all the items in the \a other vector.
@ -1163,7 +1163,7 @@
\sa operator+=()
*/
/*! \fn QVector<T> &QVector::operator<<(const T &value)
/*! \fn template <typename T> QVector<T> &QVector<T>::operator<<(const T &value)
Appends \a value to the vector and returns a reference to this
vector.
@ -1171,7 +1171,7 @@
\sa append(), operator+=()
*/
/*! \fn QVector<T> &QVector::operator<<(const QVector<T> &other)
/*! \fn template <typename T> QVector<T> &QVector<T>::operator<<(const QVector<T> &other)
Appends \a other to the vector and returns a reference to the
vector.
@ -1288,7 +1288,7 @@
Typedef for T. Provided for STL compatibility.
*/
/*! \fn QList<T> QVector<T>::toList() const
/*! \fn template <typename T> QList<T> QVector<T>::toList() const
Returns a QList object with the data contained in this QVector.
@ -1299,7 +1299,7 @@
\sa fromList(), QList::fromVector()
*/
/*! \fn QVector<T> QVector<T>::fromList(const QList<T> &list)
/*! \fn template <typename T> QVector<T> QVector<T>::fromList(const QList<T> &list)
Returns a QVector object with the data contained in \a list.
@ -1310,7 +1310,7 @@
\sa toList(), QList::toVector()
*/
/*! \fn QVector<T> QVector<T>::fromStdVector(const std::vector<T> &vector)
/*! \fn template <typename T> QVector<T> QVector<T>::fromStdVector(const std::vector<T> &vector)
Returns a QVector object with the data contained in \a vector. The
order of the elements in the QVector is the same as in \a vector.
@ -1322,7 +1322,7 @@
\sa toStdVector(), QList::fromStdList()
*/
/*! \fn std::vector<T> QVector<T>::toStdVector() const
/*! \fn template <typename T> std::vector<T> QVector<T>::toStdVector() const
Returns a std::vector object with the data contained in this QVector.
Example:
@ -1332,7 +1332,7 @@
\sa fromStdVector(), QList::toStdList()
*/
/*! \fn QDataStream &operator<<(QDataStream &out, const QVector<T> &vector)
/*! \fn template <typename T> QDataStream &operator<<(QDataStream &out, const QVector<T> &vector)
\relates QVector
Writes the vector \a vector to stream \a out.
@ -1342,7 +1342,7 @@
\sa{Serializing Qt Data Types}{Format of the QDataStream operators}
*/
/*! \fn QDataStream &operator>>(QDataStream &in, QVector<T> &vector)
/*! \fn template <typename T> QDataStream &operator>>(QDataStream &in, QVector<T> &vector)
\relates QVector
Reads a vector from stream \a in into \a vector.