summaryrefslogtreecommitdiffstats
path: root/src/qt3support/tools/q3valuelist.qdoc
blob: e61cbf02cc18ef3319bb20463873b1a828f1fde3 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the documentation of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights.  These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/

/*!
    \class Q3ValueList
    \brief The Q3ValueList class is a value-based template class that
    provides lists.
    \compat

    Q3ValueList is a Qt implementation of an STL-like list container.
    It can be used in your application if the standard \c list is not
    available for your target platforms.

    Q3ValueList\<T\> defines a template instance to create a list of
    values that all have the class T. Note that Q3ValueList does not
    store pointers to the members of the list; it holds a copy of
    every member. This is why these kinds of classes are called "value
    based"; Q3PtrList and Q3Dict are "pointer based".

    Q3ValueList contains and manages a collection of objects of type T
    and provides iterators that allow the contained objects to be
    addressed. Q3ValueList owns the contained items. For more relaxed
    ownership semantics, see Q3PtrCollection and friends which are
    pointer-based containers.

    Some classes cannot be used within a Q3ValueList, for example, all
    classes derived from QObject and thus all classes that implement
    widgets. Only values can be used in a Q3ValueList. To qualify as a
    value the class must provide:
    \list
    \i a copy constructor;
    \i an assignment operator;
    \i a default constructor, i.e. a constructor that does not take any arguments.
    \endlist

    Note that C++ defaults to field-by-field assignment operators and
    copy constructors if no explicit version is supplied. In many
    cases this is sufficient.

    In addition, some compilers (e.g. Sun CC) might require that the
    class provides an equality operator (operator==()).

    Q3ValueList's function naming is consistent with the other Qt
    classes (e.g. count(), isEmpty()). Q3ValueList also provides extra
    functions for compatibility with STL algorithms, such as size()
    and empty(). Programmers already familiar with the STL \c list may
    prefer to use the STL-compatible functions.

    Example:
    \snippet doc/src/snippets/code/doc_src_q3valuelist.qdoc 0


    Notice that the latest changes to Mary's salary did not affect the
    value in the list because the list created a copy of Mary's entry.

    There are several ways to find items in the list. The begin() and
    end() functions return iterators to the beginning and end of the
    list. The advantage of getting an iterator is that you can move
    forward or backward from this position by
    incrementing/decrementing the iterator. The iterator returned by
    end() points to the item which is one \e past the last item in the
    container. The past-the-end iterator is still associated with the
    list it belongs to, however it is \e not dereferenceable;
    operator*() will not return a well-defined value. If the list is
    empty(), the iterator returned by begin() will equal the iterator
    returned by end().

    It is safe to have multiple iterators a the list at the same
    time. If some member of the list is removed, only iterators
    pointing to the removed member become invalid. Inserting into the
    list does not invalidate any iterator. For convenience, the
    function last() returns a reference to the last item in the list,
    and first() returns a reference to the first item. If the
    list is empty(), both last() and first() have undefined behavior
    (your application will crash or do unpredictable things). Use
    last() and first() with caution, for example:

    \snippet doc/src/snippets/code/doc_src_q3valuelist.qdoc 1

    Because Q3ValueList is value-based there is no need to be careful
    about deleting items in the list. The list holds its own copies
    and will free them if the corresponding member or the list itself
    is deleted. You can force the list to free all of its items with
    clear().

    Q3ValueList is shared implicitly, which means it can be copied in
    constant time, i.e. O(1). If multiple Q3ValueList instances share
    the same data and one needs to modify its contents, this modifying
    instance makes a copy and modifies its private copy; therefore it
    does not affect the other instances; this takes O(n) time. This is
    often called "copy on write". If a Q3ValueList is being used in a
    multi-threaded program, you must protect all access to the list.
    See \l QMutex.

    There are several ways to insert items into the list. The
    prepend() and append() functions insert items at the beginning and
    the end of the list respectively. The insert() function comes in
    several flavors and can be used to add one or more items at
    specific positions within the list.

    Items can also be removed from the list in several ways. There
    are several variants of the remove() function, which removes a
    specific item from the list. The remove() function will find and
    remove items according to a specific item value.

    \sa Q3ValueListIterator
*/

/*! \typedef Q3ValueList::iterator
	The list's iterator type, Q3ValueListIterator. */
/*! \typedef Q3ValueList::const_iterator
	The list's const iterator type, Q3ValueListConstIterator. */
/*! \typedef Q3ValueList::value_type
	The type of the object stored in the list, T. */
/*! \typedef Q3ValueList::pointer
	The pointer to T type. */
/*! \typedef Q3ValueList::const_pointer
	The const pointer to T type. */
/*! \typedef Q3ValueList::reference
	The reference to T type. */
/*! \typedef Q3ValueList::const_reference
	The const reference to T type. */
/*! \typedef Q3ValueList::size_type
	An unsigned integral type, used to represent various sizes. */
/*! \typedef Q3ValueList::difference_type
    \internal
*/
/*!
    \fn Q3ValueList::Q3ValueList()

    Constructs an empty list.
*/

/*!
    \fn Q3ValueList::Q3ValueList( const Q3ValueList<T>& l )
    \fn Q3ValueList::Q3ValueList( const QList<T>& l )
    \fn Q3ValueList::Q3ValueList( const QLinkedList<T>& l )

    Constructs a copy of \a l.
*/

/*!
    \fn Q3ValueList::Q3ValueList( const std::list<T>& l )

    Contructs a copy of \a l.

    This constructor is provided for compatibility with STL
    containers.
*/

/*!
    \fn Q3ValueList::~Q3ValueList()

    Destroys the list. References to the values in the list and all
    iterators of this list become invalidated. Note that it is
    impossible for an iterator to check whether or not it is valid:
    Q3ValueList is highly tuned for performance, not for error
    checking.
*/

/*!
    \fn bool Q3ValueList::operator== ( const Q3ValueList<T>& l ) const

    Compares both lists.

    Returns TRUE if this list and \a l are equal; otherwise returns
    FALSE.
*/

/*!
    \fn bool Q3ValueList::operator== ( const std::list<T>& l ) const

    \overload

    Returns TRUE if this list and \a l are equal; otherwise returns
    FALSE.

    This operator is provided for compatibility with STL containers.
*/

/*!
    \fn Q3ValueList<T>& Q3ValueList::operator= ( const Q3ValueList<T>& l )

    Assigns \a l to this list and returns a reference to this list.

    All iterators of the current list become invalidated by this
    operation. The cost of such an assignment is O(1) since Q3ValueList
    is implicitly shared.
*/

/*!
    \fn Q3ValueList<T>& Q3ValueList::operator= ( const QList<T>& l )

    Assigns \a l to this list and returns a reference to this list.

    All iterators of the current list become invalidated by this
    operation.
*/

/*!
    \fn Q3ValueList<T>& Q3ValueList::operator= ( const std::list<T>& l )

    \overload

    Assigns the contents of \a l to the list.

    All iterators of the current list become invalidated by this
    operation.
*/

/*!
    \fn bool Q3ValueList::operator!= ( const Q3ValueList<T>& l ) const

    Compares both lists.

    Returns TRUE if this list and \a l are unequal; otherwise returns
    FALSE.
*/

/*!
    \fn iterator Q3ValueList::insert( typename Q3ValueList<T>::Iterator it, const T& x )

    Inserts the value \a x in front of the item pointed to by the
    iterator, \a it.

    Returns an iterator pointing at the inserted item.

    \sa append(), prepend()
*/

/*!
    \fn uint Q3ValueList::remove( const T& x )

    \overload

    Removes all items that have value \a x and returns the number of
    removed items.
*/

/*!
    \fn QDataStream& operator>>( QDataStream& s, Q3ValueList<T>& l )

    \relates Q3ValueList

    Reads a list, \a l, from the stream \a s. The type T stored in the
    list must implement the streaming operator.
*/

/*!
    \fn QDataStream& operator<<( QDataStream& s, const Q3ValueList<T>& l )

    \overload
    \relates Q3ValueList

    Writes a list, \a l, to the stream \a s. The type T stored in the
    list must implement the streaming operator.
*/

/*!
    \fn void Q3ValueList::insert( typename Q3ValueList<T>::Iterator pos,
                                  typename Q3ValueList<T>::size_type n, const T& x )

    \overload

    Inserts \a n copies of \a x before position \a pos.
*/

/*!
    \fn Q3ValueList<T>& Q3ValueList::operator<< ( const T& x )

    Adds the value \a x to the end of the list.

    Returns a reference to the list.
*/

/*!
    \fn const T& Q3ValueList::operator[] ( typename Q3ValueList<T>::size_type i ) const

    Returns a const reference to the item with index \a i in the list.
    It is up to you to check whether this item really exists. You can
    do that easily with the count() function. However this operator
    does not check whether \a i is in range and will deliver undefined
    results if it does not exist.

    \warning This function uses a linear search and can be extremely
    slow for large lists. Q3ValueList is not optimized for random item
    access. If you need random access use a different container, such
    as Q3ValueVector.
*/

/*!
    \fn T& Q3ValueList::operator[] ( typename Q3ValueList<T>::size_type i )

    \overload

    Returns a non-const reference to the item with index \a i.
*/

/*!
    \fn const_iterator Q3ValueList::at( typename Q3ValueList<T>::size_type i ) const

    Returns an iterator pointing to the item at position \a i in the
    list, or an undefined value if the index is out of range.

    \warning This function uses a linear search and can be extremely
    slow for large lists. Q3ValueList is not optimized for random item
    access. If you need random access use a different container, such
    as Q3ValueVector.
*/

/*!
    \fn iterator Q3ValueList::at( typename Q3ValueList<T>::size_type i )

    \overload

    Returns an iterator pointing to the item at position \a i in the
    list, or an undefined value if the index is out of range.

*/

/*!
    \fn iterator Q3ValueList::fromLast()

    \overload

    Returns an iterator to the last item in the list, or end() if
    there is no last item.

    Use the end() function instead. For example:

    \snippet doc/src/snippets/code/doc_src_q3valuelist.qdoc 2

*/

/*!
    \fn const_iterator Q3ValueList::fromLast() const

    Returns an iterator to the last item in the list, or end() if
    there is no last item.

    Use the end() function instead. For example:

    \snippet doc/src/snippets/code/doc_src_q3valuelist.qdoc 3

*/

/*!
    \fn Q3ValueList<T> Q3ValueList::operator+( const Q3ValueList<T>& l ) const

    Creates a new list and fills it with the items of this list. Then
    the items of \a l are appended. Returns the new list.
*/

/*!
    \fn Q3ValueList<T>& Q3ValueList::operator+= ( const Q3ValueList<T>& l )

    Appends the items of \a l to this list. Returns a reference to
    this list.
*/

/*!
    \fn Q3ValueList<T>& Q3ValueList::operator+= ( const T& x )

    \overload

    Appends the value \a x to the list. Returns a reference to the
    list.
*/

/*!
    \fn iterator Q3ValueList::append( const T& x )

    Inserts \a x at the end of the list.

    \sa insert(), prepend()
*/

/*!
    \fn iterator Q3ValueList::prepend( const T& x )

    Inserts \a x at the beginning of the list.

    \sa insert(), append()
*/

/*!
    \fn iterator Q3ValueList::remove( typename Q3ValueList<T>::Iterator it )

    Removes the item pointed to by \a it from the list. No iterators
    other than \a it or other iterators pointing at the same item as
    \a it are invalidated. Returns an iterator to the next item after
    \a it, or end() if there is no such item.

    \sa clear()
*/

/*!
    \fn uint Q3ValueList::contains( const T& x ) const

    Returns the number of occurrences of the value \a x in the list.
*/

/*!
    \class Q3ValueListIterator
    \brief The Q3ValueListIterator class provides an iterator for Q3ValueList.
    \compat

    An iterator is a class for accessing the items of a container
    class: a generalization of the index in an array. A pointer
    into a "const char *" and an index into an "int[]" are both
    iterators, and the general idea is to provide that functionality
    for any data structure.

    The Q3ValueListIterator class is an iterator for Q3ValueList
    instantiations. You can create the appropriate iterator type by
    using the \c iterator typedef provided by Q3ValueList.

    The only way to access the items in a Q3ValueList is to use an
    iterator.

    Example (see Q3ValueList for the complete code):
    \snippet doc/src/snippets/code/doc_src_q3valuelist.qdoc 4

    Q3ValueList is highly optimized for performance and memory usage.
    This means that you must be careful: Q3ValueList does not know
    about all its iterators and the iterators don't know to which list
    they belong. This makes things very fast, but if you're not
    careful, you can get spectacular bugs. Always make sure iterators
    are valid before dereferencing them or using them as parameters to
    generic algorithms in the STL.

    Using an invalid iterator is undefined (your application will
    probably crash). Many Qt functions return const value lists; to
    iterate over these you should make a copy and iterate over the
    copy.

    For every Iterator there is a ConstIterator. When accessing a
    Q3ValueList in a const environment or if the reference or pointer
    to the list is itself const, then you must use the ConstIterator.
    Its semantics are the same as the Iterator, but it only returns
    const references.

    \sa Q3ValueList, Q3ValueListConstIterator
*/

/*!
    \fn Q3ValueListIterator::Q3ValueListIterator()

    Constructs an unitialized iterator.
*/

/*!
    \fn Q3ValueListIterator::Q3ValueListIterator(const Q3ValueListIterator &o)
    \fn Q3ValueListIterator::Q3ValueListIterator(const typename QLinkedList<T>::iterator &o)

    Constucts a copy of iterator \a o.
*/

/*!
    \class Q3ValueListConstIterator
    \brief The Q3ValueListConstIterator class provides a const iterator
    for Q3ValueList.
    \compat

    In contrast to Q3ValueListIterator, this class is used to iterate
    over a const list. It does not allow modification of the values of
    the list since that would break const semantics.

    You can create the appropriate const iterator type by using the \c
    const_iterator typedef provided by Q3ValueList.

    For more information on Q3ValueList iterators, see
    Q3ValueListIterator.

    \sa Q3ValueListIterator, Q3ValueList
*/

/*!
    \fn Q3ValueListConstIterator::Q3ValueListConstIterator()

    Constructs an unitialized iterator.
*/

/*!
    \fn Q3ValueListConstIterator::Q3ValueListConstIterator(const Q3ValueListConstIterator &o)
    \fn Q3ValueListConstIterator::Q3ValueListConstIterator(const typename QLinkedList<T>::const_iterator &o)
    \fn Q3ValueListConstIterator::Q3ValueListConstIterator(const typename QLinkedList<T>::iterator &o)

    Constructs a copy of iterator \a o.
*/

/*!
    \typedef Q3ValueList::Iterator

    This iterator is an instantiation of Q3ValueListIterator for the
    same type as this Q3ValueList. In other words, if you instantiate
    Q3ValueList<int>, Iterator is a Q3ValueListIterator<int>. Several
    member function use it, such as Q3ValueList::begin(), which returns
    an iterator pointing to the first item in the list.

    Functionally, this is almost the same as ConstIterator. The only
    difference is that you cannot use ConstIterator for non-const
    operations, and that the compiler can often generate better code
    if you use ConstIterator.

    \sa Q3ValueListIterator ConstIterator
*/

/*!
    \typedef Q3ValueList::ConstIterator

    This iterator is an instantiation of Q3ValueListConstIterator for
    the same type as this Q3ValueList. In other words, if you
    instantiate Q3ValueList<int>, ConstIterator is a
    Q3ValueListConstIterator<int>. Several member function use it, such
    as Q3ValueList::begin(), which returns an iterator pointing to the
    first item in the list.

    Functionally, this is almost the same as Iterator. The only
    difference is you cannot use ConstIterator for non-const
    operations, and that the compiler can often generate better code
    if you use ConstIterator.

    \sa Q3ValueListIterator Iterator
*/

/*!
    \fn Q3ValueList::operator QList<T>() const

    Automatically converts a Q3ValueList<T> into a QList<T>.
*/