The QGList class is an internal class for implementing Qt collection classes. More...

#include <qglist.h>

Inheritance diagram for QGList:

Public Member Functions
uint	count () const

QDataStream &	read (QDataStream &)

QDataStream &	write (QDataStream &) const

Public Member Functions inherited from QCollection
bool	autoDelete () const

void	setAutoDelete (bool enable)

Protected Member Functions
	QGList ()

	QGList (const QGList &)

virtual	~QGList ()

QGList &	operator= (const QGList &)

bool	operator== (const QGList &) const

void	inSort (QCollection::Item)

void	append (QCollection::Item)

bool	insertAt (uint index, QCollection::Item)

void	relinkNode (QLNode *)

bool	removeNode (QLNode *)

bool	remove (QCollection::Item=0)

bool	removeRef (QCollection::Item=0)

bool	removeFirst ()

bool	removeLast ()

bool	removeAt (uint index)

QCollection::Item	takeNode (QLNode *)

QCollection::Item	take ()

QCollection::Item	takeAt (uint index)

QCollection::Item	takeFirst ()

QCollection::Item	takeLast ()

void	sort ()

void	clear ()

int	findRef (QCollection::Item, bool=TRUE)

int	find (QCollection::Item, bool=TRUE)

uint	containsRef (QCollection::Item) const

uint	contains (QCollection::Item) const

QCollection::Item	at (uint index)

int	at () const

QLNode *	currentNode () const

QCollection::Item	get () const

QCollection::Item	cfirst () const

QCollection::Item	clast () const

QCollection::Item	first ()

QCollection::Item	last ()

QCollection::Item	next ()

QCollection::Item	prev ()

void	toVector (QGVector *) const

virtual int	compareItems (QCollection::Item, QCollection::Item)

virtual QDataStream &	read (QDataStream &, QCollection::Item &)

virtual QDataStream &	write (QDataStream &, QCollection::Item) const

Protected Member Functions inherited from QCollection
	QCollection ()

	QCollection (const QCollection &)

virtual	~QCollection ()

virtual Item	newItem (Item)

virtual void	deleteItem (Item)

Private Member Functions
void	prepend (QCollection::Item)

void	heapSortPushDown (QCollection::Item *heap, int first, int last)

QLNode *	locate (uint)

QLNode *	unlink ()

Private Attributes
QLNode *	firstNode

QLNode *	lastNode

QLNode *	curNode

int	curIndex

uint	numNodes

QGList *	iterators

Friends
class	QGListIterator

class	QGVector

Additional Inherited Members
Public Types inherited from QCollection
typedef void *	Item

Protected Attributes inherited from QCollection
bool	del_item

Detailed Description

The QGList class is an internal class for implementing Qt collection classes.

QGList is a strictly internal class that acts as a base class for several collection classes; QList, QQueue and QStack.

QGList has some virtual functions that can be reimplemented to customize the subclasses.

compareItems() compares two collection/list items.
read() reads a collection/list item from a QDataStream.
write() writes a collection/list item to a QDataStream.

Normally, you do not have to reimplement any of these functions. If you still want to reimplement them, see the QStrList class (qstrlist.h), which is a good example.

Definition at line 68 of file qglist.h.

Constructor & Destructor Documentation

QGList::QGList ( )

protected

Definition at line 170 of file qglist.cpp.

 {
     firstNode = lastNode = curNode = 0;         // initialize list
     numNodes  = 0;
     curIndex  = -1;
     iterators = 0;                              // initialize iterator list
 }

QGList::QGList ( const QGList & list )

protected

Definition at line 183 of file qglist.cpp.

     : QCollection( list )
 {
     firstNode = lastNode = curNode = 0;         // initialize list
     numNodes  = 0;
     curIndex  = -1;
     iterators = 0;                              // initialize iterator list
     QLNode *n = list.firstNode;
     while ( n ) {                               // copy all items from list
         append( n->data );
         n = n->next;
     }
 }

QGList::~QGList ( )

protectedvirtual

Definition at line 202 of file qglist.cpp.

 {
     clear();
     if ( !iterators )                           // no iterators for this list
         return;
     QGListIterator *i = (QGListIterator*)iterators->first();
     while ( i ) {                               // notify all iterators that
         i->list = 0;                            // this list is deleted
         i->curNode = 0;
         i = (QGListIterator*)iterators->next();
     }
     delete iterators;
 }

Member Function Documentation

void QGList::append ( QCollection::Item d )

protected

Definition at line 364 of file qglist.cpp.

 {
     register QLNode *n = new QLNode( newItem(d) );
     CHECK_PTR( n );
     n->next = 0;
     if ( (n->prev = lastNode) )                 // list is not empty
         lastNode->next = n;
     else                                        // initialize list
         firstNode = n;
     lastNode = curNode = n;                     // curNode affected
     curIndex = numNodes;
     numNodes++;
 }

QCollection::Item QGList::at ( uint index )

inlineprotected

Definition at line 172 of file qglist.h.

 {
     QLNode *n = locate( index );
     return n ? n->data : 0;
 }

int QGList::at ( ) const

inlineprotected

Definition at line 167 of file qglist.h.

 {
     return curIndex;
 }

QCollection::Item QGList::cfirst ( ) const

inlineprotected

Definition at line 188 of file qglist.h.

 {
     return firstNode ? firstNode->data : 0;
 }

QCollection::Item QGList::clast ( ) const

inlineprotected

Definition at line 193 of file qglist.h.

 {
     return lastNode ? lastNode->data : 0;
 }

void QGList::clear ( )

protectedvirtual

Removes all objects from the collection. The objects will be deleted if auto-delete has been enabled.

See also: setAutoDelete()

Implements QCollection.

Reimplemented in QList< type >, QList< PyVariableContext::Scope >, QList< PyCallContext::Ctx >, QList< MemberName >, QList< MemberNameInfo >, QList< PageDef >, QList< DocNode >, QList< TagFileInfo >, QList< Grouping >, QList< ListItemInfo >, QList< QCString >, QList< Definition >, QList< MemberDef >, QList< TagPackageInfo >, QList< SectionHandler >, QList< DirRelation >, QList< MemberReference >, QList< DotNode >, QList< HtmlAttrib >, QList< TagPageInfo >, QList< VariableContext::Scope >, QList< IndexIntf >, QList< Entry >, QList< MemberGroup >, QList< DiagramItem >, QList< DotGroupCollaboration::Link >, QList< TagDirInfo >, QList< EntryNav >, QList< IncludeInfo >, QList< QString >, QList< RelatedCompound >, QList< DotFilePatcher >, QList< tcl_scan >, QList< ParameterItemHandler >, QList< VariableListEntryHandler >, QList< TagNamespaceInfo >, QList< NodeHandler >, QList< EntryHandler >, QList< TemplateVariant >, QList< MemberInfo >, QList< TagGroupInfo >, QList< ChildNodeHandler >, QList< DotWorkerThread >, QList< ExprAst >, QList< TemplateNode >, QList< NamespaceDef >, QList< T >, QList< void >, QList< ParamHandler >, QList< OutputGenerator >, QList< QDict< TemplateVariant > >, QList< GroupDef >, QList< IndexField >, QList< ListElem >, QList< DocSets::NodeDef >, QList< CallContext::Ctx >, QList< DotConstString >, QList< RowHandler >, QList< TemplateEngine::Private::IncludeEntry >, QList< DotRunner::CleanupItem >, QList< Formula >, QList< TemplateToken >, QList< GenericsCollection >, QList< DotGroupCollaboration::Edge >, QList< Statistics::stat >, QList< TagIncludeInfo >, QList< ActiveRowSpan >, QList< FilePair >, QList< ClassDef >, QList< Define >, QList< BaseClassDef >, QList< EdgeInfo >, QList< IncludeHandler >, QList< TemplateNodeIf::GuardedNodes >, QList< TagMemberInfo >, QList< TemplateNodeWith::Mapping >, QList< DotRunner >, QList< RefItem >, QList< FileName >, QList< SearchDocEntry >, QList< FlowChart >, QList< SearchDefinitionList >, QList< SectionInfo >, QList< CodeLineHandler >, QList< TemplateNodeIndexEntry::Mapping >, QList< DocPara >, QList< Input * >, QList< EdgeLabelHandler >, QList< LayoutNavEntry >, QList< ConfigOption >, QList< uint >, QList< AlphaIndexTableCell >, QList< UseEntry >, QList< DefineName >, QList< DirEntry >, QList< ParameterHandler >, QList< MemberList >, QList< LayoutDocEntry >, QList< CompoundEntry >, QList< Argument >, QList< TagAnchorInfo >, QList< FileList >, QList< FileDef >, QList< TagClassInfo >, QList< MemberHandler >, QList< DotFilePatcher::Map >, QList< DocImpl >, QList< ArgumentList >, QList< FTVNode >, QList< BaseInfo >, QList< TagEnumValueInfo >, QList< LinkedTextImpl >, QList< SearchIndexList >, QList< DiagramRow >, QList< AlphaIndexTableRows >, QList< NavIndexEntry >, QList< Example >, QList< DirDef >, QInternalList< type >, QInternalList< QGDictIterator >, QInternalList< QWaitConditionEvent >, QInternalList< QCacheItem >, QQueue< type >, QStack< type >, QQueue< DotRunner >, QStack< DocNode >, QStack< PerlModOutputStream >, QStack< LatexDocVisitor::TableState >, QStack< bool >, QStack< DocStyleChange >, and QStack< State >.

Definition at line 652 of file qglist.cpp.

 {
     register QLNode *n = firstNode;
 
     firstNode = lastNode = curNode = 0;         // initialize list
     numNodes = 0;
     curIndex = -1;
 
     if ( iterators && iterators->count() ) {
         QGListIterator *i = (QGListIterator*)iterators->first();
         while ( i ) {                           // notify all iterators that
             i->curNode = 0;                     // this list is empty
             i = (QGListIterator*)iterators->next();
         }
     }
 
     QLNode *prevNode;
     while ( n ) {                               // for all nodes ...
         deleteItem( n->data );                  // deallocate data
         prevNode = n;
         n = n->next;
         delete prevNode;                        // deallocate node
     }
 }

int QGList::compareItems	(	QCollection::Item	item1,
		QCollection::Item	item2
	)

protectedvirtual

This virtual function compares two list items.

Returns:

0 if item1 == item2
non-zero if item1 != item2

This function returns int rather than bool so that reimplementations can return three values and use it to sort by:

0 if item1 == item2
> 0 (positive integer) if item1 > item2
< 0 (negative integer) if item1 < item2

The QList::inSort() function requires that compareItems() is implemented as described here.

This function should not modify the list because some const functions call compareItems().

The default implementation compares the pointers:

Reimplemented in QList< type >, QList< PyVariableContext::Scope >, QList< PyCallContext::Ctx >, QList< MemberName >, QList< MemberNameInfo >, QList< PageDef >, QList< DocNode >, QList< TagFileInfo >, QList< Grouping >, QList< ListItemInfo >, QList< QCString >, QList< Definition >, QList< MemberDef >, QList< TagPackageInfo >, QList< SectionHandler >, QList< DirRelation >, QList< MemberReference >, QList< DotNode >, QList< HtmlAttrib >, QList< TagPageInfo >, QList< VariableContext::Scope >, QList< IndexIntf >, QList< Entry >, QList< MemberGroup >, QList< DiagramItem >, QList< DotGroupCollaboration::Link >, QList< TagDirInfo >, QList< EntryNav >, QList< IncludeInfo >, QList< QString >, QList< RelatedCompound >, QList< DotFilePatcher >, QList< tcl_scan >, QList< ParameterItemHandler >, QList< VariableListEntryHandler >, QList< TagNamespaceInfo >, QList< NodeHandler >, QList< EntryHandler >, QList< TemplateVariant >, QList< MemberInfo >, QList< TagGroupInfo >, QList< ChildNodeHandler >, QList< DotWorkerThread >, QList< ExprAst >, QList< TemplateNode >, QList< NamespaceDef >, QList< T >, QList< void >, QList< ParamHandler >, QList< OutputGenerator >, QList< QDict< TemplateVariant > >, QList< GroupDef >, QList< IndexField >, QList< ListElem >, QList< DocSets::NodeDef >, QList< CallContext::Ctx >, QList< DotConstString >, QList< RowHandler >, QList< TemplateEngine::Private::IncludeEntry >, QList< DotRunner::CleanupItem >, QList< Formula >, QList< TemplateToken >, QList< GenericsCollection >, QList< DotGroupCollaboration::Edge >, QList< Statistics::stat >, QList< TagIncludeInfo >, QList< ActiveRowSpan >, QList< FilePair >, QList< ClassDef >, QList< Define >, QList< BaseClassDef >, QList< EdgeInfo >, QList< IncludeHandler >, QList< TemplateNodeIf::GuardedNodes >, QList< TagMemberInfo >, QList< TemplateNodeWith::Mapping >, QList< DotRunner >, QList< RefItem >, QList< FileName >, QList< SearchDocEntry >, QList< FlowChart >, QList< SearchDefinitionList >, QList< SectionInfo >, QList< CodeLineHandler >, QList< TemplateNodeIndexEntry::Mapping >, QList< DocPara >, QList< Input * >, QList< EdgeLabelHandler >, QList< LayoutNavEntry >, QList< ConfigOption >, QList< uint >, QList< AlphaIndexTableCell >, QList< UseEntry >, QList< DefineName >, QList< DirEntry >, QList< ParameterHandler >, QList< MemberList >, QList< LayoutDocEntry >, QList< CompoundEntry >, QList< Argument >, QList< TagAnchorInfo >, QList< FileList >, QList< FileDef >, QList< TagClassInfo >, QList< MemberHandler >, QList< DotFilePatcher::Map >, QList< DocImpl >, QList< ArgumentList >, QList< FTVNode >, QList< BaseInfo >, QList< TagEnumValueInfo >, QList< LinkedTextImpl >, QList< SearchIndexList >, QList< DiagramRow >, QList< AlphaIndexTableRows >, QList< NavIndexEntry >, QList< Example >, QList< DirDef >, QStrIList, QStrList, and QSortedList< type >.

Definition at line 125 of file qglist.cpp.

 {
     return item1 != item2;                      // compare pointers
 }

uint QGList::contains ( QCollection::Item d ) const

protected

Definition at line 751 of file qglist.cpp.

 {
     register QLNode *n = firstNode;
     uint     count = 0;
     QGList  *that = (QGList*)this;              // mutable for compareItems()
     while ( n ) {                               // for all nodes...
         if ( !that->compareItems(n->data,d) )   // count # equal matches
             count++;
         n = n->next;
     }
     return count;
 }

uint QGList::containsRef ( QCollection::Item d ) const

protected

Definition at line 734 of file qglist.cpp.

 {
     register QLNode *n = firstNode;
     uint     count = 0;
     while ( n ) {                               // for all nodes...
         if ( n->data == d )                     // count # exact matches
             count++;
         n = n->next;
     }
     return count;
 }

uint QGList::count ( ) const

inlinevirtual

Returns the number of objects in the collection.

Implements QCollection.

Reimplemented in QList< type >, QList< PyVariableContext::Scope >, QList< PyCallContext::Ctx >, QList< MemberName >, QList< MemberNameInfo >, QList< PageDef >, QList< DocNode >, QList< TagFileInfo >, QList< Grouping >, QList< ListItemInfo >, QList< QCString >, QList< Definition >, QList< MemberDef >, QList< TagPackageInfo >, QList< SectionHandler >, QList< DirRelation >, QList< MemberReference >, QList< DotNode >, QList< HtmlAttrib >, QList< TagPageInfo >, QList< VariableContext::Scope >, QList< IndexIntf >, QList< Entry >, QList< MemberGroup >, QList< DiagramItem >, QList< DotGroupCollaboration::Link >, QList< TagDirInfo >, QList< EntryNav >, QList< IncludeInfo >, QList< QString >, QList< RelatedCompound >, QList< DotFilePatcher >, QList< tcl_scan >, QList< ParameterItemHandler >, QList< VariableListEntryHandler >, QList< TagNamespaceInfo >, QList< NodeHandler >, QList< EntryHandler >, QList< TemplateVariant >, QList< MemberInfo >, QList< TagGroupInfo >, QList< ChildNodeHandler >, QList< DotWorkerThread >, QList< ExprAst >, QList< TemplateNode >, QList< NamespaceDef >, QList< T >, QList< void >, QList< ParamHandler >, QList< OutputGenerator >, QList< QDict< TemplateVariant > >, QList< GroupDef >, QList< IndexField >, QList< ListElem >, QList< DocSets::NodeDef >, QList< CallContext::Ctx >, QList< DotConstString >, QList< RowHandler >, QList< TemplateEngine::Private::IncludeEntry >, QList< DotRunner::CleanupItem >, QList< Formula >, QList< TemplateToken >, QList< GenericsCollection >, QList< DotGroupCollaboration::Edge >, QList< Statistics::stat >, QList< TagIncludeInfo >, QList< ActiveRowSpan >, QList< FilePair >, QList< ClassDef >, QList< Define >, QList< BaseClassDef >, QList< EdgeInfo >, QList< IncludeHandler >, QList< TemplateNodeIf::GuardedNodes >, QList< TagMemberInfo >, QList< TemplateNodeWith::Mapping >, QList< DotRunner >, QList< RefItem >, QList< FileName >, QList< SearchDocEntry >, QList< FlowChart >, QList< SearchDefinitionList >, QList< SectionInfo >, QList< CodeLineHandler >, QList< TemplateNodeIndexEntry::Mapping >, QList< DocPara >, QList< Input * >, QList< EdgeLabelHandler >, QList< LayoutNavEntry >, QList< ConfigOption >, QList< uint >, QList< AlphaIndexTableCell >, QList< UseEntry >, QList< DefineName >, QList< DirEntry >, QList< ParameterHandler >, QList< MemberList >, QList< LayoutDocEntry >, QList< CompoundEntry >, QList< Argument >, QList< TagAnchorInfo >, QList< FileList >, QList< FileDef >, QList< TagClassInfo >, QList< MemberHandler >, QList< DotFilePatcher::Map >, QList< DocImpl >, QList< ArgumentList >, QList< FTVNode >, QList< BaseInfo >, QList< TagEnumValueInfo >, QList< LinkedTextImpl >, QList< SearchIndexList >, QList< DiagramRow >, QList< AlphaIndexTableRows >, QList< NavIndexEntry >, QList< Example >, QList< DirDef >, QInternalList< type >, QQueue< type >, QStack< type >, QInternalList< QGDictIterator >, QInternalList< QWaitConditionEvent >, QInternalList< QCacheItem >, QQueue< DotRunner >, QStack< DocNode >, QStack< PerlModOutputStream >, QStack< LatexDocVisitor::TableState >, QStack< bool >, QStack< DocStyleChange >, and QStack< State >.

Definition at line 150 of file qglist.h.

 {
     return numNodes;
 }

QLNode * QGList::currentNode ( ) const

inlineprotected

Definition at line 178 of file qglist.h.

 {
     return curNode;
 }

int QGList::find	(	QCollection::Item	d,
		bool	fromStart = `TRUE`
	)

protected

Definition at line 708 of file qglist.cpp.

 {
     register QLNode *n;
     int      index;
     if ( fromStart ) {                          // start from first node
         n = firstNode;
         index = 0;
     } else {                                    // start from current node
         n = curNode;
         index = curIndex;
     }
     while ( n && compareItems(n->data,d) ){     // find equal match
         n = n->next;
         index++;
     }
     curNode = n;
     curIndex = n ? index : -1;
     return curIndex;                            // return position of item
 }

int QGList::findRef	(	QCollection::Item	d,
		bool	fromStart = `TRUE`
	)

protected

Definition at line 683 of file qglist.cpp.

 {
     register QLNode *n;
     int      index;
     if ( fromStart ) {                          // start from first node
         n = firstNode;
         index = 0;
     } else {                                    // start from current node
         n = curNode;
         index = curIndex;
     }
     while ( n && n->data != d ) {               // find exact match
         n = n->next;
         index++;
     }
     curNode = n;
     curIndex = n ? index : -1;
     return curIndex;                            // return position of item
 }

QCollection::Item QGList::first ( )

protected

Definition at line 807 of file qglist.cpp.

 {
     if ( firstNode ) {
         curIndex = 0;
         return (curNode=firstNode)->data;
     }
     return 0;
 }

QCollection::Item QGList::get ( ) const

inlineprotected

Definition at line 183 of file qglist.h.

 {
     return curNode ? curNode->data : 0;
 }

void QGList::heapSortPushDown	(	QCollection::Item *	heap,
		int	first,
		int	last
	)

private

Definition at line 888 of file qglist.cpp.

 {
     int r = first;
     while( r <= last/2 ) {
         // Node r has only one child ?
         if ( last == 2*r ) {
             // Need for swapping ?
             if ( compareItems( heap[r], heap[ 2*r ] ) > 0 ) {
                 QCollection::Item tmp = heap[r];
                 heap[ r ] = heap[ 2*r ];
                 heap[ 2*r ] = tmp;
             }
             // That's it ...
             r = last;
         } else {
             // Node has two children
             if ( compareItems( heap[r], heap[ 2*r ] ) > 0 &&
                  compareItems( heap[ 2*r ], heap[ 2*r+1 ] ) <= 0 ) {
                 // Swap with left child
                 QCollection::Item tmp = heap[r];
                 heap[ r ] = heap[ 2*r ];
                 heap[ 2*r ] = tmp;
                 r *= 2;
             } else if ( compareItems( heap[r], heap[ 2*r+1 ] ) > 0 &&
                         compareItems( heap[ 2*r+1 ], heap[ 2*r ] ) < 0 ) {
                 // Swap with right child
                 QCollection::Item tmp = heap[r];
                 heap[ r ] = heap[ 2*r+1 ];
                 heap[ 2*r+1 ] = tmp;
                 r = 2*r+1;
             } else {
                 // We are done
                 r = last;
             }
         }
     }
 }

bool QGList::insertAt	(	uint	index,
		QCollection::Item	d
	)

protected

Definition at line 384 of file qglist.cpp.

 {
     if ( index == 0 ) {                         // insert at head of list
         prepend( d );
         return TRUE;
     } else if ( index == numNodes ) {           // append at tail of list
         append( d );
         return TRUE;
     }
     QLNode *nextNode = locate( index );
     if ( !nextNode )                            // illegal position
         return FALSE;
     QLNode *prevNode = nextNode->prev;
     register QLNode *n = new QLNode( newItem(d) );
     CHECK_PTR( n );
     nextNode->prev = n;
     prevNode->next = n;
     n->prev = prevNode;                         // link new node into list
     n->next = nextNode;
     curNode = n;                                // curIndex set by locate()
     numNodes++;
     return TRUE;
 }

void QGList::inSort ( QCollection::Item d )

protected

Definition at line 327 of file qglist.cpp.

 {
     int index = 0;
     register QLNode *n = firstNode;
     while ( n && compareItems(n->data,d) < 0 ){ // find position in list
         n = n->next;
         index++;
     }
     insertAt( index, d );
 }

QCollection::Item QGList::last ( )

protected

Definition at line 821 of file qglist.cpp.

 {
     if ( lastNode ) {
         curIndex = numNodes-1;
         return (curNode=lastNode)->data;
     }
     return 0;
 }

QLNode * QGList::locate ( uint index )

private

Definition at line 275 of file qglist.cpp.

 {
     if ( index == (uint)curIndex )              // current node ?
         return curNode;
     if ( !curNode && firstNode ) {              // set current node
         curNode  = firstNode;
         curIndex = 0;
     }
     register QLNode *node;
     int  distance = index - curIndex;           // node distance to cur node
     bool forward;                               // direction to traverse
 
     if ( index >= numNodes ) {
 #if defined(CHECK_RANGE)
         qWarning( "QGList::locate: Index %d out of range", index );
 #endif
         return 0;
     }
 
     if ( distance < 0 )
         distance = -distance;
     if ( (uint)distance < index && (uint)distance < numNodes - index ) {
         node =  curNode;                        // start from current node
         forward = index > (uint)curIndex;
     } else if ( index < numNodes - index ) {    // start from first node
         node = firstNode;
         distance = index;
         forward = TRUE;
     } else {                                    // start from last node
         node = lastNode;
         distance = numNodes - index - 1;
         if ( distance < 0 )
             distance = 0;
         forward = FALSE;
     }
     if ( forward ) {                            // now run through nodes
         while ( distance-- )
             node = node->next;
     } else {
         while ( distance-- )
             node = node->prev;
     }
     curIndex = index;                           // must update index
     return curNode = node;
 }

QCollection::Item QGList::next ( )

protected

Definition at line 835 of file qglist.cpp.

 {
     if ( curNode ) {
         if ( curNode->next ) {
             curIndex++;
             curNode = curNode->next;
             return curNode->data;
         }
         curIndex = -1;
         curNode = 0;
     }
     return 0;
 }

QGList & QGList::operator= ( const QGList & list )

protected

Definition at line 222 of file qglist.cpp.

 {
     clear();
     if ( list.count() > 0 ) {
         QLNode *n = list.firstNode;
         while ( n ) {                           // copy all items from list
             append( n->data );
             n = n->next;
         }
         curNode  = firstNode;
         curIndex = 0;
     }
     return *this;
 }

bool QGList::operator== ( const QGList & list ) const

protected

Compares this list with list. Retruns TRUE if the lists contain the same data, else FALSE.

Definition at line 242 of file qglist.cpp.

 {
     if ( count() != list.count() )
         return FALSE;
     
     if ( count() == 0 )
         return TRUE;
     
     QLNode *n1 = firstNode;
     QLNode *n2 = list.firstNode;
     while ( n1 && n2 ) {
         // should be mutable
         if ( ( (QGList*)this )->compareItems( n1->data, n2->data ) != 0 )
             return FALSE;
         n1 = n1->next;
         n2 = n2->next;
     }
     
     return TRUE;
 }

void QGList::prepend ( QCollection::Item d )

private

Definition at line 344 of file qglist.cpp.

 {
     register QLNode *n = new QLNode( newItem(d) );
     CHECK_PTR( n );
     n->prev = 0;
     if ( (n->next = firstNode) )                // list is not empty
         firstNode->prev = n;
     else                                        // initialize list
         lastNode = n;
     firstNode = curNode = n;                    // curNode affected
     numNodes++;
     curIndex = 0;
 }

QCollection::Item QGList::prev ( )

protected

Definition at line 854 of file qglist.cpp.

 {
     if ( curNode ) {
         if ( curNode->prev ) {
             curIndex--;
             curNode = curNode->prev;
             return curNode->data;
         }
         curIndex = -1;
         curNode = 0;
     }
     return 0;
 }

QDataStream & QGList::read ( QDataStream & s )

Definition at line 992 of file qglist.cpp.

 {
     uint num;
     s >> num;                                   // read number of items
     clear();                                    // clear list
     while ( num-- ) {                           // read all items
         Item d;
         read( s, d );
         CHECK_PTR( d );
         if ( !d )                               // no memory
             break;
         QLNode *n = new QLNode( d );
         CHECK_PTR( n );
         if ( !n )                               // no memory
             break;
         n->next = 0;
         if ( (n->prev = lastNode) )             // list is not empty
             lastNode->next = n;
         else                                    // initialize list
             firstNode = n;
         lastNode = n;
         numNodes++;
     }
     curNode  = firstNode;
     curIndex = curNode ? 0 : -1;
     return s;
 }

QDataStream & QGList::read	(	QDataStream &	s,
		QCollection::Item &	item
	)

protectedvirtual

Reads a collection/list item from the stream s and returns a reference to the stream.

The default implementation sets item to 0.

See also: write()

Reimplemented in QStrList.

Definition at line 140 of file qglist.cpp.

 {
     item = 0;
     return s;
 }

void QGList::relinkNode ( QLNode * n )

protected

Definition at line 414 of file qglist.cpp.

 {
     if ( n == firstNode )                       // already first
         return;
     curNode = n;
     unlink();
     n->prev = 0;
     if ( (n->next = firstNode) )                // list is not empty
         firstNode->prev = n;
     else                                        // initialize list
         lastNode = n;
     firstNode = curNode = n;                    // curNode affected
     numNodes++;
     curIndex = 0;
 }

bool QGList::remove ( QCollection::Item d = 0 )

protected

Definition at line 504 of file qglist.cpp.

 {
     if ( d ) {                                  // find the item
         if ( find(d) == -1 )
             return FALSE;
     }
     QLNode *n = unlink();                       // unlink node
     if ( !n )
         return FALSE;
     deleteItem( n->data );                      // deallocate this node
     delete n;
     return TRUE;
 }

bool QGList::removeAt ( uint index )

protected

Definition at line 554 of file qglist.cpp.

 {
     if ( !locate(index) )
         return FALSE;
     QLNode *n = unlink();                       // unlink node
     if ( !n )
         return FALSE;
     deleteItem( n->data );                      // deallocate this node
     delete n;
     return TRUE;
 }

bool QGList::removeFirst ( )

inlineprotected

Definition at line 155 of file qglist.h.

 {
     first();
     return remove();
 }

bool QGList::removeLast ( )

inlineprotected

Definition at line 161 of file qglist.h.

 {
     last();
     return remove();
 }

bool QGList::removeNode ( QLNode * n )

protected

Definition at line 481 of file qglist.cpp.

 {
 #if defined(CHECK_NULL)
     if ( n == 0 || (n->prev && n->prev->next != n) ||
          (n->next && n->next->prev != n) ) {
         qWarning( "QGList::removeNode: Corrupted node" );
         return FALSE;
     }
 #endif
     curNode = n;
     unlink();                                   // unlink node
     deleteItem( n->data );                      // deallocate this node
     delete n;
     curNode  = firstNode;
     curIndex = curNode ? 0 : -1;
     return TRUE;
 }

bool QGList::removeRef ( QCollection::Item d = 0 )

protected

Definition at line 523 of file qglist.cpp.

 {
     if ( d ) {                                  // find the item
         if ( findRef(d) == -1 )
             return FALSE;
     }
     QLNode *n = unlink();                       // unlink node
     if ( !n )
         return FALSE;
     deleteItem( n->data );                      // deallocate this node
     delete n;
     return TRUE;
 }

void QGList::sort ( )

protected

Sorts the list by the result of the virtual compareItems() function.

The Heap-Sort algorithm is used for sorting. It sorts n items with O(n*log n) compares. This is the asymptotic optimal solution of the sorting problem.

Definition at line 934 of file qglist.cpp.

 {
     uint n = count();
     if ( n < 2 )
         return;
 
     // Create the heap
     QCollection::Item* realheap = new QCollection::Item[ n ];
     // Wow, what a fake. But I want the heap to be indexed as 1...n
     QCollection::Item* heap = realheap - 1;
     int size = 0;
     QLNode* insert = firstNode;
     for( ; insert != 0; insert = insert->next ) {
         heap[++size] = insert->data;
         int i = size;
         while( i > 1 && compareItems( heap[i], heap[ i / 2 ] ) < 0 ) {
             QCollection::Item tmp = heap[ i ];
             heap[ i ] = heap[ i/2 ];
             heap[ i/2 ] = tmp;
             i /= 2;
         }
     }
 
     insert = firstNode;
     // Now do the sorting
     for ( int i = n; i > 0; i-- ) {
         insert->data = heap[1];
         insert = insert->next;
         if ( i > 1 ) {
             heap[1] = heap[i];
             heapSortPushDown( heap, 1, i - 1 );
         }
     }
 
     delete [] realheap;
 }

QCollection::Item QGList::take ( )

protected

Definition at line 595 of file qglist.cpp.

 {
     QLNode *n = unlink();                       // unlink node
     Item d = n ? n->data : 0;
     delete n;                                   // delete node, keep contents
     return d;
 }

QCollection::Item QGList::takeAt ( uint index )

protected

Definition at line 608 of file qglist.cpp.

 {
     if ( !locate(index) )
         return 0;
     QLNode *n = unlink();                       // unlink node
     Item d = n ? n->data : 0;
     delete n;                                   // delete node, keep contents
     return d;
 }

QCollection::Item QGList::takeFirst ( )

protected

Definition at line 623 of file qglist.cpp.

 {
     first();
     QLNode *n = unlink();                       // unlink node
     Item d = n ? n->data : 0;
     delete n;
     return d;
 }

QCollection::Item QGList::takeLast ( )

protected

Definition at line 637 of file qglist.cpp.

 {
     last();
     QLNode *n = unlink();                       // unlink node
     Item d = n ? n->data : 0;
     delete n;
     return d;
 }

QCollection::Item QGList::takeNode ( QLNode * n )

protected

Definition at line 572 of file qglist.cpp.

 {
 #if defined(CHECK_NULL)
     if ( n == 0 || (n->prev && n->prev->next != n) ||
          (n->next && n->next->prev != n) ) {
         qWarning( "QGList::takeNode: Corrupted node" );
         return 0;
     }
 #endif
     curNode = n;
     unlink();                                   // unlink node
     Item d = n->data;
     delete n;                                   // delete the node, not data
     curNode  = firstNode;
     curIndex = curNode ? 0 : -1;
     return d;
 }

void QGList::toVector ( QGVector * vector ) const

protected

Definition at line 874 of file qglist.cpp.

 {
     vector->clear();
     if ( !vector->resize( count() ) )
         return;
     register QLNode *n = firstNode;
     uint i = 0;
     while ( n ) {
         vector->insert( i, n->data );
         n = n->next;
         i++;
     }
 }

QLNode * QGList::unlink ( )

private

Definition at line 436 of file qglist.cpp.

 {
     if ( curNode == 0 )                         // null current node
         return 0;
     register QLNode *n = curNode;               // unlink this node
     if ( n == firstNode ) {                     // removing first node ?
         if ( (firstNode = n->next) ) {
             firstNode->prev = 0;
         } else {
             lastNode = curNode = 0;             // list becomes empty
             curIndex = -1;
         }
     } else {
         if ( n == lastNode ) {                  // removing last node ?
             lastNode = n->prev;
             lastNode->next = 0;
         } else {                                // neither last nor first node
             n->prev->next = n->next;
             n->next->prev = n->prev;
         }
     }
     if ( n->next ) {                            // change current node
         curNode = n->next;
     } else if ( n->prev ) {
         curNode = n->prev;
         curIndex--;
     }
     if ( iterators && iterators->count() ) {    // update iterators
         QGListIterator *i = (QGListIterator*)iterators->first();
         while ( i ) {                           // fix all iterators that
             if ( i->curNode == n )              // refers to pending node
                 i->curNode = curNode;
             i = (QGListIterator*)iterators->next();
         }
     }
     numNodes--;
     return n;
 }

QDataStream & QGList::write ( QDataStream & s ) const

Definition at line 1025 of file qglist.cpp.

 {
     s << count();                               // write number of items
     QLNode *n = firstNode;
     while ( n ) {                               // write all items
         write( s, n->data );
         n = n->next;
     }
     return s;
 }

QDataStream & QGList::write	(	QDataStream &	s,
		QCollection::Item
	)		const

protectedvirtual

Writes a collection/list item to the stream s and returns a reference to the stream.

The default implementation does nothing.

See also: read()

Reimplemented in QStrList.

Definition at line 155 of file qglist.cpp.

 {
     return s;
 }

Friends And Related Function Documentation

friend class QGListIterator

friend

Definition at line 70 of file qglist.h.

friend class QGVector

friend

Definition at line 71 of file qglist.h.

Member Data Documentation

int QGList::curIndex

private

Definition at line 141 of file qglist.h.

QLNode* QGList::curNode

private

Definition at line 140 of file qglist.h.

QLNode* QGList::firstNode

private

Definition at line 138 of file qglist.h.

QGList* QGList::iterators

private

Definition at line 143 of file qglist.h.

QLNode* QGList::lastNode

private

Definition at line 139 of file qglist.h.

uint QGList::numNodes

private

Definition at line 142 of file qglist.h.

The documentation for this class was generated from the following files:

doxygen-1.8.11/qtools/qglist.h
doxygen-1.8.11/qtools/qglist.cpp

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation