Root/
Source at commit 1322 created 12 years 7 months ago. By meklort, Add doxygen to utils folder | |
---|---|
1 | /****************************************************************************␊ |
2 | ** ␊ |
3 | **␊ |
4 | ** Implementation of QGList and QGListIterator classes␊ |
5 | **␊ |
6 | ** Created : 920624␊ |
7 | **␊ |
8 | ** Copyright (C) 1992-2000 Trolltech AS. All rights reserved.␊ |
9 | **␊ |
10 | ** This file is part of the tools module of the Qt GUI Toolkit.␊ |
11 | **␊ |
12 | ** This file may be distributed under the terms of the Q Public License␊ |
13 | ** as defined by Trolltech AS of Norway and appearing in the file␊ |
14 | ** LICENSE.QPL included in the packaging of this file.␊ |
15 | **␊ |
16 | ** This file may be distributed and/or modified under the terms of the␊ |
17 | ** GNU General Public License version 2 as published by the Free Software␊ |
18 | ** Foundation and appearing in the file LICENSE.GPL included in the␊ |
19 | ** packaging of this file.␊ |
20 | **␊ |
21 | ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition␊ |
22 | ** licenses may use this file in accordance with the Qt Commercial License␊ |
23 | ** Agreement provided with the Software.␊ |
24 | **␊ |
25 | ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE␊ |
26 | ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.␊ |
27 | **␊ |
28 | ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for␊ |
29 | ** information about Qt Commercial License Agreements.␊ |
30 | ** See http://www.trolltech.com/qpl/ for QPL licensing information.␊ |
31 | ** See http://www.trolltech.com/gpl/ for GPL licensing information.␊ |
32 | **␊ |
33 | ** Contact info@trolltech.com if any conditions of this licensing are␊ |
34 | ** not clear to you.␊ |
35 | **␊ |
36 | **********************************************************************/␊ |
37 | ␊ |
38 | #include "qglist.h"␊ |
39 | #include "qgvector.h"␊ |
40 | #include "qdatastream.h"␊ |
41 | ␊ |
42 | ␊ |
43 | // NOT REVISED␊ |
44 | /*!␊ |
45 | \class QLNode qglist.h␊ |
46 | \brief The QLNode class is an internal class for the QList template collection.␊ |
47 | ␊ |
48 | QLNode is a doubly linked list node; it has three pointers:␊ |
49 | <ol>␊ |
50 | <li> Pointer to the previous node.␊ |
51 | <li> Pointer to the next node.␊ |
52 | <li> Pointer to the actual data.␊ |
53 | </ol>␊ |
54 | ␊ |
55 | Sometimes it might be practical to have direct access to the list nodes␊ |
56 | in a QList, but it is seldom required.␊ |
57 | ␊ |
58 | \warning Be very careful if you want to access the list nodes. The heap␊ |
59 | can easily get corrupted if you make a mistake.␊ |
60 | ␊ |
61 | \sa QList::currentNode(), QList::removeNode(), QList::takeNode()␊ |
62 | */␊ |
63 | ␊ |
64 | /*!␊ |
65 | \fn QCollection::Item QLNode::getData()␊ |
66 | Returns a pointer (\c void*) to the actual data in the list node.␊ |
67 | */␊ |
68 | ␊ |
69 | ␊ |
70 | /*!␊ |
71 | \class QGList qglist.h␊ |
72 | \brief The QGList class is an internal class for implementing Qt collection classes.␊ |
73 | ␊ |
74 | QGList is a strictly internal class that acts as a base class for several␊ |
75 | \link collection.html collection classes\endlink; QList, QQueue and␊ |
76 | QStack.␊ |
77 | ␊ |
78 | QGList has some virtual functions that can be reimplemented to customize␊ |
79 | the subclasses.␊ |
80 | <ul>␊ |
81 | <li> compareItems() compares two collection/list items.␊ |
82 | <li> read() reads a collection/list item from a QDataStream.␊ |
83 | <li> write() writes a collection/list item to a QDataStream.␊ |
84 | </ul>␊ |
85 | Normally, you do not have to reimplement any of these functions.␊ |
86 | If you still want to reimplement them, see the QStrList class (qstrlist.h),␊ |
87 | which is a good example.␊ |
88 | */␊ |
89 | ␊ |
90 | ␊ |
91 | /*****************************************************************************␊ |
92 | Default implementation of virtual functions␊ |
93 | *****************************************************************************/␊ |
94 | ␊ |
95 | /*!␊ |
96 | This virtual function compares two list items.␊ |
97 | ␊ |
98 | Returns:␊ |
99 | <ul>␊ |
100 | <li> 0 if \e item1 == \e item2␊ |
101 | <li> non-zero if \e item1 != \e item2␊ |
102 | </ul>␊ |
103 | ␊ |
104 | This function returns \e int rather than \e bool so that␊ |
105 | reimplementations can return three values and use it to sort by:␊ |
106 | ␊ |
107 | <ul>␊ |
108 | <li> 0 if \e item1 == \e item2␊ |
109 | <li> \> 0 (positive integer) if \e item1 \> \e item2␊ |
110 | <li> \< 0 (negative integer) if \e item1 \< \e item2␊ |
111 | </ul>␊ |
112 | ␊ |
113 | The QList::inSort() function requires that compareItems() is implemented␊ |
114 | as described here.␊ |
115 | ␊ |
116 | This function should not modify the list because some const functions␊ |
117 | call compareItems().␊ |
118 | ␊ |
119 | The default implementation compares the pointers:␊ |
120 | \code␊ |
121 | ␊ |
122 | \endcode␊ |
123 | */␊ |
124 | ␊ |
125 | int QGList::compareItems( QCollection::Item item1, QCollection::Item item2 )␊ |
126 | {␊ |
127 | return item1 != item2;␉␉␉// compare pointers␊ |
128 | }␊ |
129 | ␊ |
130 | #ifndef QT_NO_DATASTREAM␊ |
131 | /*!␊ |
132 | Reads a collection/list item from the stream \a s and returns a reference␊ |
133 | to the stream.␊ |
134 | ␊ |
135 | The default implementation sets \a item to 0.␊ |
136 | ␊ |
137 | \sa write()␊ |
138 | */␊ |
139 | ␊ |
140 | QDataStream &QGList::read( QDataStream &s, QCollection::Item &item )␊ |
141 | {␊ |
142 | item = 0;␊ |
143 | return s;␊ |
144 | }␊ |
145 | ␊ |
146 | /*!␊ |
147 | Writes a collection/list item to the stream \a s and returns a reference␊ |
148 | to the stream.␊ |
149 | ␊ |
150 | The default implementation does nothing.␊ |
151 | ␊ |
152 | \sa read()␊ |
153 | */␊ |
154 | ␊ |
155 | QDataStream &QGList::write( QDataStream &s, QCollection::Item ) const␊ |
156 | {␊ |
157 | return s;␊ |
158 | }␊ |
159 | #endif // QT_NO_DATASTREAM␊ |
160 | ␊ |
161 | /*****************************************************************************␊ |
162 | QGList member functions␊ |
163 | *****************************************************************************/␊ |
164 | ␊ |
165 | /*!␊ |
166 | \internal␊ |
167 | Constructs an empty list.␊ |
168 | */␊ |
169 | ␊ |
170 | QGList::QGList()␊ |
171 | {␊ |
172 | firstNode = lastNode = curNode = 0;␉␉// initialize list␊ |
173 | numNodes = 0;␊ |
174 | curIndex = -1;␊ |
175 | iterators = 0;␉␉␉␉// initialize iterator list␊ |
176 | }␊ |
177 | ␊ |
178 | /*!␊ |
179 | \internal␊ |
180 | Constructs a copy of \e list.␊ |
181 | */␊ |
182 | ␊ |
183 | QGList::QGList( const QGList & list )␊ |
184 | : QCollection( list )␊ |
185 | {␊ |
186 | firstNode = lastNode = curNode = 0;␉␉// initialize list␊ |
187 | numNodes = 0;␊ |
188 | curIndex = -1;␊ |
189 | iterators = 0;␉␉␉␉// initialize iterator list␊ |
190 | QLNode *n = list.firstNode;␊ |
191 | while ( n ) {␉␉␉␉// copy all items from list␊ |
192 | ␉append( n->data );␊ |
193 | ␉n = n->next;␊ |
194 | }␊ |
195 | }␊ |
196 | ␊ |
197 | /*!␊ |
198 | \internal␊ |
199 | Removes all items from the list and destroys the list.␊ |
200 | */␊ |
201 | ␊ |
202 | QGList::~QGList()␊ |
203 | {␊ |
204 | clear();␊ |
205 | if ( !iterators )␉␉␉␉// no iterators for this list␊ |
206 | ␉return;␊ |
207 | QGListIterator *i = (QGListIterator*)iterators->first();␊ |
208 | while ( i ) {␉␉␉␉// notify all iterators that␊ |
209 | ␉i->list = 0;␉␉␉␉// this list is deleted␊ |
210 | ␉i->curNode = 0;␊ |
211 | ␉i = (QGListIterator*)iterators->next();␊ |
212 | }␊ |
213 | delete iterators;␊ |
214 | }␊ |
215 | ␊ |
216 | ␊ |
217 | /*!␊ |
218 | \internal␊ |
219 | Assigns \e list to this list.␊ |
220 | */␊ |
221 | ␊ |
222 | QGList& QGList::operator=( const QGList &list )␊ |
223 | {␊ |
224 | clear();␊ |
225 | if ( list.count() > 0 ) {␊ |
226 | ␉QLNode *n = list.firstNode;␊ |
227 | ␉while ( n ) {␉␉␉␉// copy all items from list␊ |
228 | ␉ append( n->data );␊ |
229 | ␉ n = n->next;␊ |
230 | ␉}␊ |
231 | ␉curNode␉ = firstNode;␊ |
232 | ␉curIndex = 0;␊ |
233 | }␊ |
234 | return *this;␊ |
235 | }␊ |
236 | ␊ |
237 | /*!␊ |
238 | Compares this list with \a list. Retruns TRUE if the lists␊ |
239 | contain the same data, else FALSE.␊ |
240 | */␊ |
241 | ␊ |
242 | bool QGList::operator==( const QGList &list ) const␊ |
243 | {␊ |
244 | if ( count() != list.count() )␊ |
245 | ␉return FALSE;␊ |
246 | ␊ |
247 | if ( count() == 0 )␊ |
248 | ␉return TRUE;␊ |
249 | ␊ |
250 | QLNode *n1 = firstNode;␊ |
251 | QLNode *n2 = list.firstNode;␊ |
252 | while ( n1 && n2 ) {␊ |
253 | ␉// should be mutable␊ |
254 | ␉if ( ( (QGList*)this )->compareItems( n1->data, n2->data ) != 0 )␊ |
255 | ␉ return FALSE;␊ |
256 | ␉n1 = n1->next;␊ |
257 | ␉n2 = n2->next;␊ |
258 | }␊ |
259 | ␊ |
260 | return TRUE;␊ |
261 | }␊ |
262 | ␊ |
263 | /*!␊ |
264 | \fn uint QGList::count() const␊ |
265 | \internal␊ |
266 | Returns the number of items in the list.␊ |
267 | */␊ |
268 | ␊ |
269 | ␊ |
270 | /*!␊ |
271 | \internal␊ |
272 | Returns the node at position \e index. Sets this node to current.␊ |
273 | */␊ |
274 | ␊ |
275 | QLNode *QGList::locate( uint index )␊ |
276 | {␊ |
277 | if ( index == (uint)curIndex )␉␉// current node ?␊ |
278 | ␉return curNode;␊ |
279 | if ( !curNode && firstNode ) {␉␉// set current node␊ |
280 | ␉curNode␉ = firstNode;␊ |
281 | ␉curIndex = 0;␊ |
282 | }␊ |
283 | register QLNode *node;␊ |
284 | int␉ distance = index - curIndex;␉␉// node distance to cur node␊ |
285 | bool forward;␉␉␉␉// direction to traverse␊ |
286 | ␊ |
287 | if ( index >= numNodes ) {␊ |
288 | #if defined(CHECK_RANGE)␊ |
289 | ␉qWarning( "QGList::locate: Index %d out of range", index );␊ |
290 | #endif␊ |
291 | ␉return 0;␊ |
292 | }␊ |
293 | ␊ |
294 | if ( distance < 0 )␊ |
295 | ␉distance = -distance;␊ |
296 | if ( (uint)distance < index && (uint)distance < numNodes - index ) {␊ |
297 | ␉node =␉curNode;␉␉␉// start from current node␊ |
298 | ␉forward = index > (uint)curIndex;␊ |
299 | } else if ( index < numNodes - index ) {␉// start from first node␊ |
300 | ␉node = firstNode;␊ |
301 | ␉distance = index;␊ |
302 | ␉forward = TRUE;␊ |
303 | } else {␉␉␉␉␉// start from last node␊ |
304 | ␉node = lastNode;␊ |
305 | ␉distance = numNodes - index - 1;␊ |
306 | ␉if ( distance < 0 )␊ |
307 | ␉ distance = 0;␊ |
308 | ␉forward = FALSE;␊ |
309 | }␊ |
310 | if ( forward ) {␉␉␉␉// now run through nodes␊ |
311 | ␉while ( distance-- )␊ |
312 | ␉ node = node->next;␊ |
313 | } else {␊ |
314 | ␉while ( distance-- )␊ |
315 | ␉ node = node->prev;␊ |
316 | }␊ |
317 | curIndex = index;␉␉␉␉// must update index␊ |
318 | return curNode = node;␊ |
319 | }␊ |
320 | ␊ |
321 | ␊ |
322 | /*!␊ |
323 | \internal␊ |
324 | Inserts an item at its sorted position in the list.␊ |
325 | */␊ |
326 | ␊ |
327 | void QGList::inSort( QCollection::Item d )␊ |
328 | {␊ |
329 | int index = 0;␊ |
330 | register QLNode *n = firstNode;␊ |
331 | while ( n && compareItems(n->data,d) < 0 ){ // find position in list␊ |
332 | ␉n = n->next;␊ |
333 | ␉index++;␊ |
334 | }␊ |
335 | insertAt( index, d );␊ |
336 | }␊ |
337 | ␊ |
338 | ␊ |
339 | /*!␊ |
340 | \internal␊ |
341 | Inserts an item at the start of the list.␊ |
342 | */␊ |
343 | ␊ |
344 | void QGList::prepend( QCollection::Item d )␊ |
345 | {␊ |
346 | register QLNode *n = new QLNode( newItem(d) );␊ |
347 | CHECK_PTR( n );␊ |
348 | n->prev = 0;␊ |
349 | if ( (n->next = firstNode) )␉␉// list is not empty␊ |
350 | ␉firstNode->prev = n;␊ |
351 | else␉␉␉␉␉// initialize list␊ |
352 | ␉lastNode = n;␊ |
353 | firstNode = curNode = n;␉␉␉// curNode affected␊ |
354 | numNodes++;␊ |
355 | curIndex = 0;␊ |
356 | }␊ |
357 | ␊ |
358 | ␊ |
359 | /*!␊ |
360 | \internal␊ |
361 | Inserts an item at the end of the list.␊ |
362 | */␊ |
363 | ␊ |
364 | void QGList::append( QCollection::Item d )␊ |
365 | {␊ |
366 | register QLNode *n = new QLNode( newItem(d) );␊ |
367 | CHECK_PTR( n );␊ |
368 | n->next = 0;␊ |
369 | if ( (n->prev = lastNode) )␉␉␉// list is not empty␊ |
370 | ␉lastNode->next = n;␊ |
371 | else␉␉␉␉␉// initialize list␊ |
372 | ␉firstNode = n;␊ |
373 | lastNode = curNode = n;␉␉␉// curNode affected␊ |
374 | curIndex = numNodes;␊ |
375 | numNodes++;␊ |
376 | }␊ |
377 | ␊ |
378 | ␊ |
379 | /*!␊ |
380 | \internal␊ |
381 | Inserts an item at position \e index in the list.␊ |
382 | */␊ |
383 | ␊ |
384 | bool QGList::insertAt( uint index, QCollection::Item d )␊ |
385 | {␊ |
386 | if ( index == 0 ) {␉␉␉␉// insert at head of list␊ |
387 | ␉prepend( d );␊ |
388 | ␉return TRUE;␊ |
389 | } else if ( index == numNodes ) {␉␉// append at tail of list␊ |
390 | ␉append( d );␊ |
391 | ␉return TRUE;␊ |
392 | }␊ |
393 | QLNode *nextNode = locate( index );␊ |
394 | if ( !nextNode )␉␉␉␉// illegal position␊ |
395 | ␉return FALSE;␊ |
396 | QLNode *prevNode = nextNode->prev;␊ |
397 | register QLNode *n = new QLNode( newItem(d) );␊ |
398 | CHECK_PTR( n );␊ |
399 | nextNode->prev = n;␊ |
400 | prevNode->next = n;␊ |
401 | n->prev = prevNode;␉␉␉␉// link new node into list␊ |
402 | n->next = nextNode;␊ |
403 | curNode = n;␉␉␉␉// curIndex set by locate()␊ |
404 | numNodes++;␊ |
405 | return TRUE;␊ |
406 | }␊ |
407 | ␊ |
408 | ␊ |
409 | /*!␊ |
410 | \internal␊ |
411 | Relinks node \e n and makes it the first node in the list.␊ |
412 | */␊ |
413 | ␊ |
414 | void QGList::relinkNode( QLNode *n )␊ |
415 | {␊ |
416 | if ( n == firstNode )␉␉␉// already first␊ |
417 | ␉return;␊ |
418 | curNode = n;␊ |
419 | unlink();␊ |
420 | n->prev = 0;␊ |
421 | if ( (n->next = firstNode) )␉␉// list is not empty␊ |
422 | ␉firstNode->prev = n;␊ |
423 | else␉␉␉␉␉// initialize list␊ |
424 | ␉lastNode = n;␊ |
425 | firstNode = curNode = n;␉␉␉// curNode affected␊ |
426 | numNodes++;␊ |
427 | curIndex = 0;␊ |
428 | }␊ |
429 | ␊ |
430 | ␊ |
431 | /*!␊ |
432 | \internal␊ |
433 | Unlinks the current list node and returns a pointer to this node.␊ |
434 | */␊ |
435 | ␊ |
436 | QLNode *QGList::unlink()␊ |
437 | {␊ |
438 | if ( curNode == 0 )␉␉␉␉// null current node␊ |
439 | ␉return 0;␊ |
440 | register QLNode *n = curNode;␉␉// unlink this node␊ |
441 | if ( n == firstNode ) {␉␉␉// removing first node ?␊ |
442 | ␉if ( (firstNode = n->next) ) {␊ |
443 | ␉ firstNode->prev = 0;␊ |
444 | ␉} else {␊ |
445 | ␉ lastNode = curNode = 0;␉␉// list becomes empty␊ |
446 | ␉ curIndex = -1;␊ |
447 | ␉}␊ |
448 | } else {␊ |
449 | ␉if ( n == lastNode ) {␉␉␉// removing last node ?␊ |
450 | ␉ lastNode = n->prev;␊ |
451 | ␉ lastNode->next = 0;␊ |
452 | ␉} else {␉␉␉␉// neither last nor first node␊ |
453 | ␉ n->prev->next = n->next;␊ |
454 | ␉ n->next->prev = n->prev;␊ |
455 | ␉}␊ |
456 | }␊ |
457 | if ( n->next ) {␉␉␉␉// change current node␊ |
458 | ␉curNode = n->next;␊ |
459 | } else if ( n->prev ) {␊ |
460 | ␉curNode = n->prev;␊ |
461 | ␉curIndex--;␊ |
462 | }␊ |
463 | if ( iterators && iterators->count() ) {␉// update iterators␊ |
464 | ␉QGListIterator *i = (QGListIterator*)iterators->first();␊ |
465 | ␉while ( i ) {␉␉␉␉// fix all iterators that␊ |
466 | ␉ if ( i->curNode == n )␉␉// refers to pending node␊ |
467 | ␉␉i->curNode = curNode;␊ |
468 | ␉ i = (QGListIterator*)iterators->next();␊ |
469 | ␉}␊ |
470 | }␊ |
471 | numNodes--;␊ |
472 | return n;␊ |
473 | }␊ |
474 | ␊ |
475 | ␊ |
476 | /*!␊ |
477 | \internal␊ |
478 | Removes the node \e n from the list.␊ |
479 | */␊ |
480 | ␊ |
481 | bool QGList::removeNode( QLNode *n )␊ |
482 | {␊ |
483 | #if defined(CHECK_NULL)␊ |
484 | if ( n == 0 || (n->prev && n->prev->next != n) ||␊ |
485 | ␉ (n->next && n->next->prev != n) ) {␊ |
486 | ␉qWarning( "QGList::removeNode: Corrupted node" );␊ |
487 | ␉return FALSE;␊ |
488 | }␊ |
489 | #endif␊ |
490 | curNode = n;␊ |
491 | unlink();␉␉␉␉␉// unlink node␊ |
492 | deleteItem( n->data );␉␉␉// deallocate this node␊ |
493 | delete n;␊ |
494 | curNode = firstNode;␊ |
495 | curIndex = curNode ? 0 : -1;␊ |
496 | return TRUE;␊ |
497 | }␊ |
498 | ␊ |
499 | /*!␊ |
500 | \internal␊ |
501 | Removes the item \e d from the list.␉Uses compareItems() to find the item.␊ |
502 | */␊ |
503 | ␊ |
504 | bool QGList::remove( QCollection::Item d )␊ |
505 | {␊ |
506 | if ( d ) {␉␉␉␉␉// find the item␊ |
507 | ␉if ( find(d) == -1 )␊ |
508 | ␉ return FALSE;␊ |
509 | }␊ |
510 | QLNode *n = unlink();␉␉␉// unlink node␊ |
511 | if ( !n )␊ |
512 | ␉return FALSE;␊ |
513 | deleteItem( n->data );␉␉␉// deallocate this node␊ |
514 | delete n;␊ |
515 | return TRUE;␊ |
516 | }␊ |
517 | ␊ |
518 | /*!␊ |
519 | \internal␊ |
520 | Removes the item \e d from the list.␊ |
521 | */␊ |
522 | ␊ |
523 | bool QGList::removeRef( QCollection::Item d )␊ |
524 | {␊ |
525 | if ( d ) {␉␉␉␉␉// find the item␊ |
526 | ␉if ( findRef(d) == -1 )␊ |
527 | ␉ return FALSE;␊ |
528 | }␊ |
529 | QLNode *n = unlink();␉␉␉// unlink node␊ |
530 | if ( !n )␊ |
531 | ␉return FALSE;␊ |
532 | deleteItem( n->data );␉␉␉// deallocate this node␊ |
533 | delete n;␊ |
534 | return TRUE;␊ |
535 | }␊ |
536 | ␊ |
537 | /*!␊ |
538 | \fn bool QGList::removeFirst()␊ |
539 | \internal␊ |
540 | Removes the first item in the list.␊ |
541 | */␊ |
542 | ␊ |
543 | /*!␊ |
544 | \fn bool QGList::removeLast()␊ |
545 | \internal␊ |
546 | Removes the last item in the list.␊ |
547 | */␊ |
548 | ␊ |
549 | /*!␊ |
550 | \internal␊ |
551 | Removes the item at position \e index from the list.␊ |
552 | */␊ |
553 | ␊ |
554 | bool QGList::removeAt( uint index )␊ |
555 | {␊ |
556 | if ( !locate(index) )␊ |
557 | ␉return FALSE;␊ |
558 | QLNode *n = unlink();␉␉␉// unlink node␊ |
559 | if ( !n )␊ |
560 | ␉return FALSE;␊ |
561 | deleteItem( n->data );␉␉␉// deallocate this node␊ |
562 | delete n;␊ |
563 | return TRUE;␊ |
564 | }␊ |
565 | ␊ |
566 | ␊ |
567 | /*!␊ |
568 | \internal␊ |
569 | Takes the node \e n out of the list.␊ |
570 | */␊ |
571 | ␊ |
572 | QCollection::Item QGList::takeNode( QLNode *n )␊ |
573 | {␊ |
574 | #if defined(CHECK_NULL)␊ |
575 | if ( n == 0 || (n->prev && n->prev->next != n) ||␊ |
576 | ␉ (n->next && n->next->prev != n) ) {␊ |
577 | ␉qWarning( "QGList::takeNode: Corrupted node" );␊ |
578 | ␉return 0;␊ |
579 | }␊ |
580 | #endif␊ |
581 | curNode = n;␊ |
582 | unlink();␉␉␉␉␉// unlink node␊ |
583 | Item d = n->data;␊ |
584 | delete n;␉␉␉␉␉// delete the node, not data␊ |
585 | curNode = firstNode;␊ |
586 | curIndex = curNode ? 0 : -1;␊ |
587 | return d;␊ |
588 | }␊ |
589 | ␊ |
590 | /*!␊ |
591 | \internal␊ |
592 | Takes the current item out of the list.␊ |
593 | */␊ |
594 | ␊ |
595 | QCollection::Item QGList::take()␊ |
596 | {␊ |
597 | QLNode *n = unlink();␉␉␉// unlink node␊ |
598 | Item d = n ? n->data : 0;␊ |
599 | delete n;␉␉␉␉␉// delete node, keep contents␊ |
600 | return d;␊ |
601 | }␊ |
602 | ␊ |
603 | /*!␊ |
604 | \internal␊ |
605 | Takes the item at position \e index out of the list.␊ |
606 | */␊ |
607 | ␊ |
608 | QCollection::Item QGList::takeAt( uint index )␊ |
609 | {␊ |
610 | if ( !locate(index) )␊ |
611 | ␉return 0;␊ |
612 | QLNode *n = unlink();␉␉␉// unlink node␊ |
613 | Item d = n ? n->data : 0;␊ |
614 | delete n;␉␉␉␉␉// delete node, keep contents␊ |
615 | return d;␊ |
616 | }␊ |
617 | ␊ |
618 | /*!␊ |
619 | \internal␊ |
620 | Takes the first item out of the list.␊ |
621 | */␊ |
622 | ␊ |
623 | QCollection::Item QGList::takeFirst()␊ |
624 | {␊ |
625 | first();␊ |
626 | QLNode *n = unlink();␉␉␉// unlink node␊ |
627 | Item d = n ? n->data : 0;␊ |
628 | delete n;␊ |
629 | return d;␊ |
630 | }␊ |
631 | ␊ |
632 | /*!␊ |
633 | \internal␊ |
634 | Takes the last item out of the list.␊ |
635 | */␊ |
636 | ␊ |
637 | QCollection::Item QGList::takeLast()␊ |
638 | {␊ |
639 | last();␊ |
640 | QLNode *n = unlink();␉␉␉// unlink node␊ |
641 | Item d = n ? n->data : 0;␊ |
642 | delete n;␊ |
643 | return d;␊ |
644 | }␊ |
645 | ␊ |
646 | ␊ |
647 | /*!␊ |
648 | \internal␊ |
649 | Removes all items from the list.␊ |
650 | */␊ |
651 | ␊ |
652 | void QGList::clear()␊ |
653 | {␊ |
654 | register QLNode *n = firstNode;␊ |
655 | ␊ |
656 | firstNode = lastNode = curNode = 0;␉␉// initialize list␊ |
657 | numNodes = 0;␊ |
658 | curIndex = -1;␊ |
659 | ␊ |
660 | if ( iterators && iterators->count() ) {␊ |
661 | ␉QGListIterator *i = (QGListIterator*)iterators->first();␊ |
662 | ␉while ( i ) {␉␉␉␉// notify all iterators that␊ |
663 | ␉ i->curNode = 0;␉␉␉// this list is empty␊ |
664 | ␉ i = (QGListIterator*)iterators->next();␊ |
665 | ␉}␊ |
666 | }␊ |
667 | ␊ |
668 | QLNode *prevNode;␊ |
669 | while ( n ) {␉␉␉␉// for all nodes ...␊ |
670 | ␉deleteItem( n->data );␉␉␉// deallocate data␊ |
671 | ␉prevNode = n;␊ |
672 | ␉n = n->next;␊ |
673 | ␉delete prevNode;␉␉␉// deallocate node␊ |
674 | }␊ |
675 | }␊ |
676 | ␊ |
677 | ␊ |
678 | /*!␊ |
679 | \internal␊ |
680 | Finds an item in the list.␊ |
681 | */␊ |
682 | ␊ |
683 | int QGList::findRef( QCollection::Item d, bool fromStart )␊ |
684 | {␊ |
685 | register QLNode *n;␊ |
686 | int␉ index;␊ |
687 | if ( fromStart ) {␉␉␉␉// start from first node␊ |
688 | ␉n = firstNode;␊ |
689 | ␉index = 0;␊ |
690 | } else {␉␉␉␉␉// start from current node␊ |
691 | ␉n = curNode;␊ |
692 | ␉index = curIndex;␊ |
693 | }␊ |
694 | while ( n && n->data != d ) {␉␉// find exact match␊ |
695 | ␉n = n->next;␊ |
696 | ␉index++;␊ |
697 | }␊ |
698 | curNode = n;␊ |
699 | curIndex = n ? index : -1;␊ |
700 | return curIndex;␉␉␉␉// return position of item␊ |
701 | }␊ |
702 | ␊ |
703 | /*!␊ |
704 | \internal␊ |
705 | Finds an item in the list. Uses compareItems().␊ |
706 | */␊ |
707 | ␊ |
708 | int QGList::find( QCollection::Item d, bool fromStart )␊ |
709 | {␊ |
710 | register QLNode *n;␊ |
711 | int␉ index;␊ |
712 | if ( fromStart ) {␉␉␉␉// start from first node␊ |
713 | ␉n = firstNode;␊ |
714 | ␉index = 0;␊ |
715 | } else {␉␉␉␉␉// start from current node␊ |
716 | ␉n = curNode;␊ |
717 | ␉index = curIndex;␊ |
718 | }␊ |
719 | while ( n && compareItems(n->data,d) ){␉// find equal match␊ |
720 | ␉n = n->next;␊ |
721 | ␉index++;␊ |
722 | }␊ |
723 | curNode = n;␊ |
724 | curIndex = n ? index : -1;␊ |
725 | return curIndex;␉␉␉␉// return position of item␊ |
726 | }␊ |
727 | ␊ |
728 | ␊ |
729 | /*!␊ |
730 | \internal␊ |
731 | Counts the number an item occurs in the list.␊ |
732 | */␊ |
733 | ␊ |
734 | uint QGList::containsRef( QCollection::Item d ) const␊ |
735 | {␊ |
736 | register QLNode *n = firstNode;␊ |
737 | uint count = 0;␊ |
738 | while ( n ) {␉␉␉␉// for all nodes...␊ |
739 | ␉if ( n->data == d )␉␉␉// count # exact matches␊ |
740 | ␉ count++;␊ |
741 | ␉n = n->next;␊ |
742 | }␊ |
743 | return count;␊ |
744 | }␊ |
745 | ␊ |
746 | /*!␊ |
747 | \internal␊ |
748 | Counts the number an item occurs in the list.␉ Uses compareItems().␊ |
749 | */␊ |
750 | ␊ |
751 | uint QGList::contains( QCollection::Item d ) const␊ |
752 | {␊ |
753 | register QLNode *n = firstNode;␊ |
754 | uint count = 0;␊ |
755 | QGList *that = (QGList*)this;␉␉// mutable for compareItems()␊ |
756 | while ( n ) {␉␉␉␉// for all nodes...␊ |
757 | ␉if ( !that->compareItems(n->data,d) )␉// count # equal matches␊ |
758 | ␉ count++;␊ |
759 | ␉n = n->next;␊ |
760 | }␊ |
761 | return count;␊ |
762 | }␊ |
763 | ␊ |
764 | ␊ |
765 | /*!␊ |
766 | \fn QCollection::Item QGList::at( uint index )␊ |
767 | \internal␊ |
768 | Sets the item at position \e index to the current item.␊ |
769 | */␊ |
770 | ␊ |
771 | /*!␊ |
772 | \fn int QGList::at() const␊ |
773 | \internal␊ |
774 | Returns the current index.␊ |
775 | */␊ |
776 | ␊ |
777 | /*!␊ |
778 | \fn QLNode *QGList::currentNode() const␊ |
779 | \internal␊ |
780 | Returns the current node.␊ |
781 | */␊ |
782 | ␊ |
783 | /*!␊ |
784 | \fn QCollection::Item QGList::get() const␊ |
785 | \internal␊ |
786 | Returns the current item.␊ |
787 | */␊ |
788 | ␊ |
789 | /*!␊ |
790 | \fn QCollection::Item QGList::cfirst() const␊ |
791 | \internal␊ |
792 | Returns the first item in the list.␊ |
793 | */␊ |
794 | ␊ |
795 | /*!␊ |
796 | \fn QCollection::Item QGList::clast() const␊ |
797 | \internal␊ |
798 | Returns the last item in the list.␊ |
799 | */␊ |
800 | ␊ |
801 | ␊ |
802 | /*!␊ |
803 | \internal␊ |
804 | Returns the first list item.␉Sets this to current.␊ |
805 | */␊ |
806 | ␊ |
807 | QCollection::Item QGList::first()␊ |
808 | {␊ |
809 | if ( firstNode ) {␊ |
810 | ␉curIndex = 0;␊ |
811 | ␉return (curNode=firstNode)->data;␊ |
812 | }␊ |
813 | return 0;␊ |
814 | }␊ |
815 | ␊ |
816 | /*!␊ |
817 | \internal␊ |
818 | Returns the last list item. Sets this to current.␊ |
819 | */␊ |
820 | ␊ |
821 | QCollection::Item QGList::last()␊ |
822 | {␊ |
823 | if ( lastNode ) {␊ |
824 | ␉curIndex = numNodes-1;␊ |
825 | ␉return (curNode=lastNode)->data;␊ |
826 | }␊ |
827 | return 0;␊ |
828 | }␊ |
829 | ␊ |
830 | /*!␊ |
831 | \internal␊ |
832 | Returns the next list item (after current). Sets this to current.␊ |
833 | */␊ |
834 | ␊ |
835 | QCollection::Item QGList::next()␊ |
836 | {␊ |
837 | if ( curNode ) {␊ |
838 | ␉if ( curNode->next ) {␊ |
839 | ␉ curIndex++;␊ |
840 | ␉ curNode = curNode->next;␊ |
841 | ␉ return curNode->data;␊ |
842 | ␉}␊ |
843 | ␉curIndex = -1;␊ |
844 | ␉curNode = 0;␊ |
845 | }␊ |
846 | return 0;␊ |
847 | }␊ |
848 | ␊ |
849 | /*!␊ |
850 | \internal␊ |
851 | Returns the previous list item (before current). Sets this to current.␊ |
852 | */␊ |
853 | ␊ |
854 | QCollection::Item QGList::prev()␊ |
855 | {␊ |
856 | if ( curNode ) {␊ |
857 | ␉if ( curNode->prev ) {␊ |
858 | ␉ curIndex--;␊ |
859 | ␉ curNode = curNode->prev;␊ |
860 | ␉ return curNode->data;␊ |
861 | ␉}␊ |
862 | ␉curIndex = -1;␊ |
863 | ␉curNode = 0;␊ |
864 | }␊ |
865 | return 0;␊ |
866 | }␊ |
867 | ␊ |
868 | ␊ |
869 | /*!␊ |
870 | \internal␊ |
871 | Converts the list to a vector.␊ |
872 | */␊ |
873 | ␊ |
874 | void QGList::toVector( QGVector *vector ) const␊ |
875 | {␊ |
876 | vector->clear();␊ |
877 | if ( !vector->resize( count() ) )␊ |
878 | ␉return;␊ |
879 | register QLNode *n = firstNode;␊ |
880 | uint i = 0;␊ |
881 | while ( n ) {␊ |
882 | ␉vector->insert( i, n->data );␊ |
883 | ␉n = n->next;␊ |
884 | ␉i++;␊ |
885 | }␊ |
886 | }␊ |
887 | ␊ |
888 | void QGList::heapSortPushDown( QCollection::Item* heap, int first, int last )␊ |
889 | {␊ |
890 | int r = first;␊ |
891 | while( r <= last/2 ) {␊ |
892 | ␉// Node r has only one child ?␊ |
893 | ␉if ( last == 2*r ) {␊ |
894 | ␉ // Need for swapping ?␊ |
895 | ␉ if ( compareItems( heap[r], heap[ 2*r ] ) > 0 ) {␊ |
896 | ␉␉QCollection::Item tmp = heap[r];␊ |
897 | ␉␉heap[ r ] = heap[ 2*r ];␊ |
898 | ␉␉heap[ 2*r ] = tmp;␊ |
899 | ␉ }␊ |
900 | ␉ // That's it ...␊ |
901 | ␉ r = last;␊ |
902 | ␉} else {␊ |
903 | ␉ // Node has two children␊ |
904 | ␉ if ( compareItems( heap[r], heap[ 2*r ] ) > 0 &&␊ |
905 | ␉␉ compareItems( heap[ 2*r ], heap[ 2*r+1 ] ) <= 0 ) {␊ |
906 | ␉␉// Swap with left child␊ |
907 | ␉␉QCollection::Item tmp = heap[r];␊ |
908 | ␉␉heap[ r ] = heap[ 2*r ];␊ |
909 | ␉␉heap[ 2*r ] = tmp;␊ |
910 | ␉␉r *= 2;␊ |
911 | ␉ } else if ( compareItems( heap[r], heap[ 2*r+1 ] ) > 0 &&␊ |
912 | ␉␉␉compareItems( heap[ 2*r+1 ], heap[ 2*r ] ) < 0 ) {␊ |
913 | ␉␉// Swap with right child␊ |
914 | ␉␉QCollection::Item tmp = heap[r];␊ |
915 | ␉␉heap[ r ] = heap[ 2*r+1 ];␊ |
916 | ␉␉heap[ 2*r+1 ] = tmp;␊ |
917 | ␉␉r = 2*r+1;␊ |
918 | ␉ } else {␊ |
919 | ␉␉// We are done␊ |
920 | ␉␉r = last;␊ |
921 | ␉ }␊ |
922 | ␉}␊ |
923 | }␊ |
924 | }␊ |
925 | ␊ |
926 | ␊ |
927 | /*! Sorts the list by the result of the virtual compareItems() function.␊ |
928 | ␊ |
929 | The Heap-Sort algorithm is used for sorting. It sorts n items with␊ |
930 | O(n*log n) compares. This is the asymptotic optimal solution of the␊ |
931 | sorting problem.␊ |
932 | */␊ |
933 | ␊ |
934 | void QGList::sort()␊ |
935 | {␊ |
936 | uint n = count();␊ |
937 | if ( n < 2 )␊ |
938 | ␉return;␊ |
939 | ␊ |
940 | // Create the heap␊ |
941 | QCollection::Item* realheap = new QCollection::Item[ n ];␊ |
942 | // Wow, what a fake. But I want the heap to be indexed as 1...n␊ |
943 | QCollection::Item* heap = realheap - 1;␊ |
944 | int size = 0;␊ |
945 | QLNode* insert = firstNode;␊ |
946 | for( ; insert != 0; insert = insert->next ) {␊ |
947 | ␉heap[++size] = insert->data;␊ |
948 | ␉int i = size;␊ |
949 | ␉while( i > 1 && compareItems( heap[i], heap[ i / 2 ] ) < 0 ) {␊ |
950 | ␉ QCollection::Item tmp = heap[ i ];␊ |
951 | ␉ heap[ i ] = heap[ i/2 ];␊ |
952 | ␉ heap[ i/2 ] = tmp;␊ |
953 | ␉ i /= 2;␊ |
954 | ␉}␊ |
955 | }␊ |
956 | ␊ |
957 | insert = firstNode;␊ |
958 | // Now do the sorting␊ |
959 | for ( int i = n; i > 0; i-- ) {␊ |
960 | ␉insert->data = heap[1];␊ |
961 | ␉insert = insert->next;␊ |
962 | ␉if ( i > 1 ) {␊ |
963 | ␉ heap[1] = heap[i];␊ |
964 | ␉ heapSortPushDown( heap, 1, i - 1 );␊ |
965 | ␉}␊ |
966 | }␊ |
967 | ␊ |
968 | delete [] realheap;␊ |
969 | }␊ |
970 | ␊ |
971 | ␊ |
972 | /*****************************************************************************␊ |
973 | QGList stream functions␊ |
974 | *****************************************************************************/␊ |
975 | ␊ |
976 | #ifndef QT_NO_DATASTREAM␊ |
977 | QDataStream &operator>>( QDataStream &s, QGList &list )␊ |
978 | {␉␉␉␉␉␉// read list␊ |
979 | return list.read( s );␊ |
980 | }␊ |
981 | ␊ |
982 | QDataStream &operator<<( QDataStream &s, const QGList &list )␊ |
983 | {␉␉␉␉␉␉// write list␊ |
984 | return list.write( s );␊ |
985 | }␊ |
986 | ␊ |
987 | /*!␊ |
988 | \internal␊ |
989 | Reads a list from the stream \e s.␊ |
990 | */␊ |
991 | ␊ |
992 | QDataStream &QGList::read( QDataStream &s )␊ |
993 | {␊ |
994 | uint num;␊ |
995 | s >> num;␉␉␉␉␉// read number of items␊ |
996 | clear();␉␉␉␉␉// clear list␊ |
997 | while ( num-- ) {␉␉␉␉// read all items␊ |
998 | ␉Item d;␊ |
999 | ␉read( s, d );␊ |
1000 | ␉CHECK_PTR( d );␊ |
1001 | ␉if ( !d )␉␉␉␉// no memory␊ |
1002 | ␉ break;␊ |
1003 | ␉QLNode *n = new QLNode( d );␊ |
1004 | ␉CHECK_PTR( n );␊ |
1005 | ␉if ( !n )␉␉␉␉// no memory␊ |
1006 | ␉ break;␊ |
1007 | ␉n->next = 0;␊ |
1008 | ␉if ( (n->prev = lastNode) )␉␉// list is not empty␊ |
1009 | ␉ lastNode->next = n;␊ |
1010 | ␉else␉␉␉␉␉// initialize list␊ |
1011 | ␉ firstNode = n;␊ |
1012 | ␉lastNode = n;␊ |
1013 | ␉numNodes++;␊ |
1014 | }␊ |
1015 | curNode = firstNode;␊ |
1016 | curIndex = curNode ? 0 : -1;␊ |
1017 | return s;␊ |
1018 | }␊ |
1019 | ␊ |
1020 | /*!␊ |
1021 | \internal␊ |
1022 | Writes the list to the stream \e s.␊ |
1023 | */␊ |
1024 | ␊ |
1025 | QDataStream &QGList::write( QDataStream &s ) const␊ |
1026 | {␊ |
1027 | s << count();␉␉␉␉// write number of items␊ |
1028 | QLNode *n = firstNode;␊ |
1029 | while ( n ) {␉␉␉␉// write all items␊ |
1030 | ␉write( s, n->data );␊ |
1031 | ␉n = n->next;␊ |
1032 | }␊ |
1033 | return s;␊ |
1034 | }␊ |
1035 | ␊ |
1036 | #endif // QT_NO_DATASTREAM␊ |
1037 | ␊ |
1038 | /*****************************************************************************␊ |
1039 | QGListIterator member functions␊ |
1040 | *****************************************************************************/␊ |
1041 | ␊ |
1042 | /*!␊ |
1043 | \class QGListIterator qglist.h␊ |
1044 | \brief The QGListIterator class is an internal class for implementing QListIterator.␊ |
1045 | ␊ |
1046 | QGListIterator is a strictly internal class that does the heavy work for␊ |
1047 | QListIterator.␊ |
1048 | */␊ |
1049 | ␊ |
1050 | /*!␊ |
1051 | \internal␊ |
1052 | Constructs an iterator that operates on the list \e l.␊ |
1053 | */␊ |
1054 | ␊ |
1055 | QGListIterator::QGListIterator( const QGList &l )␊ |
1056 | {␊ |
1057 | list = (QGList *)&l;␉␉␉// get reference to list␊ |
1058 | curNode = list->firstNode;␉␉␉// set to first node␊ |
1059 | if ( !list->iterators ) {␊ |
1060 | ␉list->iterators = new QGList;␉␉// create iterator list␊ |
1061 | ␉CHECK_PTR( list->iterators );␊ |
1062 | }␊ |
1063 | list->iterators->append( this );␉␉// attach iterator to list␊ |
1064 | }␊ |
1065 | ␊ |
1066 | /*!␊ |
1067 | \internal␊ |
1068 | Constructs a copy of the iterator \e it.␊ |
1069 | */␊ |
1070 | ␊ |
1071 | QGListIterator::QGListIterator( const QGListIterator &it )␊ |
1072 | {␊ |
1073 | list = it.list;␊ |
1074 | curNode = it.curNode;␊ |
1075 | if ( list )␊ |
1076 | ␉list->iterators->append( this );␉// attach iterator to list␊ |
1077 | }␊ |
1078 | ␊ |
1079 | /*!␊ |
1080 | \internal␊ |
1081 | Assigns a copy of the iterator \e it and returns a reference to this␊ |
1082 | iterator.␊ |
1083 | */␊ |
1084 | ␊ |
1085 | QGListIterator &QGListIterator::operator=( const QGListIterator &it )␊ |
1086 | {␊ |
1087 | if ( list )␉␉␉␉␉// detach from old list␊ |
1088 | ␉list->iterators->removeRef( this );␊ |
1089 | list = it.list;␊ |
1090 | curNode = it.curNode;␊ |
1091 | if ( list )␊ |
1092 | ␉list->iterators->append( this );␉// attach to new list␊ |
1093 | return *this;␊ |
1094 | }␊ |
1095 | ␊ |
1096 | /*!␊ |
1097 | \internal␊ |
1098 | Destroys the iterator.␊ |
1099 | */␊ |
1100 | ␊ |
1101 | QGListIterator::~QGListIterator()␊ |
1102 | {␊ |
1103 | if ( list )␉␉␉␉␉// detach iterator from list␊ |
1104 | ␉list->iterators->removeRef(this);␊ |
1105 | }␊ |
1106 | ␊ |
1107 | ␊ |
1108 | /*!␊ |
1109 | \fn bool QGListIterator::atFirst() const␊ |
1110 | \internal␊ |
1111 | Returns TRUE if the iterator points to the first item, otherwise FALSE.␊ |
1112 | */␊ |
1113 | ␊ |
1114 | /*!␊ |
1115 | \fn bool QGListIterator::atLast() const␊ |
1116 | \internal␊ |
1117 | Returns TRUE if the iterator points to the last item, otherwise FALSE.␊ |
1118 | */␊ |
1119 | ␊ |
1120 | ␊ |
1121 | /*!␊ |
1122 | \internal␊ |
1123 | Sets the list iterator to point to the first item in the list.␊ |
1124 | */␊ |
1125 | ␊ |
1126 | QCollection::Item QGListIterator::toFirst()␊ |
1127 | {␊ |
1128 | if ( !list ) {␊ |
1129 | #if defined(CHECK_NULL)␊ |
1130 | ␉qWarning( "QGListIterator::toFirst: List has been deleted" );␊ |
1131 | #endif␊ |
1132 | ␉return 0;␊ |
1133 | }␊ |
1134 | return list->firstNode ? (curNode = list->firstNode)->getData() : 0;␊ |
1135 | }␊ |
1136 | ␊ |
1137 | /*!␊ |
1138 | \internal␊ |
1139 | Sets the list iterator to point to the last item in the list.␊ |
1140 | */␊ |
1141 | ␊ |
1142 | QCollection::Item QGListIterator::toLast()␊ |
1143 | {␊ |
1144 | if ( !list ) {␊ |
1145 | #if defined(CHECK_NULL)␊ |
1146 | ␉qWarning( "QGListIterator::toLast: List has been deleted" );␊ |
1147 | #endif␊ |
1148 | ␉return 0;␊ |
1149 | }␊ |
1150 | return list->lastNode ? (curNode = list->lastNode)->getData() : 0;␊ |
1151 | }␊ |
1152 | ␊ |
1153 | ␊ |
1154 | /*!␊ |
1155 | \fn QCollection::Item QGListIterator::get() const␊ |
1156 | \internal␊ |
1157 | Returns the iterator item.␊ |
1158 | */␊ |
1159 | ␊ |
1160 | ␊ |
1161 | /*!␊ |
1162 | \internal␊ |
1163 | Moves to the next item (postfix).␊ |
1164 | */␊ |
1165 | ␊ |
1166 | QCollection::Item QGListIterator::operator()()␊ |
1167 | {␊ |
1168 | if ( !curNode )␊ |
1169 | ␉return 0;␊ |
1170 | QCollection::Item d = curNode->getData();␊ |
1171 | curNode = curNode->next;␊ |
1172 | return d;␊ |
1173 | }␊ |
1174 | ␊ |
1175 | /*!␊ |
1176 | \internal␊ |
1177 | Moves to the next item (prefix).␊ |
1178 | */␊ |
1179 | ␊ |
1180 | QCollection::Item QGListIterator::operator++()␊ |
1181 | {␊ |
1182 | if ( !curNode )␊ |
1183 | ␉return 0;␊ |
1184 | curNode = curNode->next;␊ |
1185 | return curNode ? curNode->getData() : 0;␊ |
1186 | }␊ |
1187 | ␊ |
1188 | /*!␊ |
1189 | \internal␊ |
1190 | Moves \e jumps positions forward.␊ |
1191 | */␊ |
1192 | ␊ |
1193 | QCollection::Item QGListIterator::operator+=( uint jumps )␊ |
1194 | {␊ |
1195 | while ( curNode && jumps-- )␊ |
1196 | ␉curNode = curNode->next;␊ |
1197 | return curNode ? curNode->getData() : 0;␊ |
1198 | }␊ |
1199 | ␊ |
1200 | /*!␊ |
1201 | \internal␊ |
1202 | Moves to the previous item (prefix).␊ |
1203 | */␊ |
1204 | ␊ |
1205 | QCollection::Item QGListIterator::operator--()␊ |
1206 | {␊ |
1207 | if ( !curNode )␊ |
1208 | ␉return 0;␊ |
1209 | curNode = curNode->prev;␊ |
1210 | return curNode ? curNode->getData() : 0;␊ |
1211 | }␊ |
1212 | ␊ |
1213 | /*!␊ |
1214 | \internal␊ |
1215 | Moves \e jumps positions backward.␊ |
1216 | */␊ |
1217 | ␊ |
1218 | QCollection::Item QGListIterator::operator-=( uint jumps )␊ |
1219 | {␊ |
1220 | while ( curNode && jumps-- )␊ |
1221 | ␉curNode = curNode->prev;␊ |
1222 | return curNode ? curNode->getData() : 0;␊ |
1223 | }␊ |
1224 |