tsDLList< T > Class Template Reference

#include "tsDLList.h"

Public Member Functions
	tsDLList ()
unsigned	count () const
void	add (T &item)
void	add (tsDLList< T > &addList)
void	push (T &item)
void	push (tsDLList< T > &pushList)
void	remove (T &item)
void	removeAll (tsDLList< T > &destination)
T *	get ()
T *	pop ()
void	insertAfter (T &item, T &itemBefore)
void	insertBefore (T &item, T &itemAfter)
int	find (const T &item) const
T *	first (void) const
T *	last (void) const
tsDLIterConst< T >	firstIter () const
tsDLIter< T >	firstIter ()
tsDLIterConst< T >	lastIter () const
tsDLIter< T >	lastIter ()

Static Public Member Functions
static tsDLIterConst< T >	invalidConstIter ()
static tsDLIter< T >	invalidIter ()

Detailed Description

template<class T>
class tsDLList< T >

Definition at line 21 of file tsDLList.h.

Constructor & Destructor Documentation

template<class T >

tsDLList< T >::tsDLList ( )

inline

Definition at line 170 of file tsDLList.h.

{
    this->clear ();
}

Member Function Documentation

template<class T>

void tsDLList< T >::add ( T &  item )

inline

Definition at line 313 of file tsDLList.h.

{
    tsDLNode<T> &theNode = item;

    theNode.pNext = 0;
    theNode.pPrev = this->pLast;

    if ( this->itemCount ) {
        tsDLNode<T> &lastNode = *this->pLast;
        lastNode.pNext = &item;
    }
    else {
        this->pFirst = &item;
    }

    this->pLast = &item;

    this->itemCount++;
}

template<class T>

void tsDLList< T >::add ( tsDLList< T > &  addList )

inline

Definition at line 289 of file tsDLList.h.

{
    if ( addList.itemCount != 0u ) {
        if ( this->itemCount == 0u ) {
            this->pFirst = addList.pFirst;
        }
        else {
            tsDLNode<T> *pLastNode = this->pLast;
            tsDLNode<T> *pAddListFirstNode = addList.pFirst;
            pLastNode->pNext = addList.pFirst;
            pAddListFirstNode->pPrev = addList.pLast;
        }
        this->pLast = addList.pLast;
        this->itemCount += addList.itemCount;
        addList.clear();
    }
}

template<class T >

unsigned tsDLList< T >::count ( ) const

inline

Definition at line 181 of file tsDLList.h.

{
    return this->itemCount;
}

template<class T>

int tsDLList< T >::find

(

const T &

item

)

const

Definition at line 442 of file tsDLList.h.

{
    tsDLIterConst < T > thisItem ( &item );
    tsDLIterConst < T > iter ( this->first () );
    int itemNo = 0;

    while ( iter.valid () ) {
        if ( iter == thisItem ) {
            return itemNo;
        }
        itemNo++;
        iter++;
    }
    return -1;
}

template<class T >

T * tsDLList< T >::first ( void  ) const

inline

Definition at line 190 of file tsDLList.h.

{
    return this->pFirst;
}

template<class T >

tsDLIterConst< T > tsDLList< T >::firstIter ( ) const

inline

Definition at line 459 of file tsDLList.h.

{
    return tsDLIterConst < T > ( this->pFirst );
}

template<class T >

tsDLIter< T > tsDLList< T >::firstIter ( )

inline

Definition at line 465 of file tsDLList.h.

{
    return tsDLIter < T > ( this->pFirst );
}

template<class T >

T * tsDLList< T >::get ( )

inline

Definition at line 261 of file tsDLList.h.

{
    T *pItem = this->pFirst;

    if ( pItem ) {
        this->remove ( *pItem );
    }

    return pItem;
}

template<class T>

void tsDLList< T >::insertAfter ( T &  item, T &  itemBefore  )

inline

Definition at line 339 of file tsDLList.h.

{
    tsDLNode<T> &nodeItem = item;
    tsDLNode<T> &nodeBefore = itemBefore;

    nodeItem.pPrev = &itemBefore;
    nodeItem.pNext = nodeBefore.pNext;
    nodeBefore.pNext = &item;

    if (nodeItem.pNext) {
        tsDLNode<T> *pNextNode = nodeItem.pNext;
        pNextNode->pPrev = &item;
    }
    else {
        this->pLast = &item;
    }

    this->itemCount++;
}

template<class T>

void tsDLList< T >::insertBefore ( T &  item, T &  itemAfter  )

inline

Definition at line 365 of file tsDLList.h.

{
    tsDLNode<T> &node = item;
    tsDLNode<T> &nodeAfter = itemAfter;

    node.pNext = &itemAfter;
    node.pPrev = nodeAfter.pPrev;
    nodeAfter.pPrev = &item;

    if (node.pPrev) {
        tsDLNode<T> &prevNode = *node.pPrev;
        prevNode.pNext = &item;
    }
    else {
        this->pFirst = &item;
    }

    this->itemCount++;
}

template<class T >

tsDLIterConst< T > tsDLList< T >::invalidConstIter ( )

inlinestatic

Definition at line 483 of file tsDLList.h.

{
    return tsDLIterConst < T > ( 0 );
}

template<class T >

tsDLIter< T > tsDLList< T >::invalidIter ( )

inlinestatic

Definition at line 489 of file tsDLList.h.

{
    return tsDLIter < T > ( 0 );
}

template<class T >

T * tsDLList< T >::last ( void  ) const

inline

Definition at line 199 of file tsDLList.h.

{
    return this->pLast;
}

template<class T >

tsDLIterConst< T > tsDLList< T >::lastIter ( ) const

inline

Definition at line 471 of file tsDLList.h.

{
    return tsDLIterConst < T > ( this->pLast );
}

template<class T >

tsDLIter< T > tsDLList< T >::lastIter ( )

inline

Definition at line 477 of file tsDLList.h.

{
    return tsDLIter < T > ( this->pLast );
}

template<class T >

T * tsDLList< T >::pop ( )

inline

Definition at line 277 of file tsDLList.h.

{
    return this->get ();
}

template<class T>

void tsDLList< T >::push ( T &  item )

inline

Definition at line 416 of file tsDLList.h.

{
    tsDLNode<T> &theNode = item;
    theNode.pPrev = 0;
    theNode.pNext = this->pFirst;

    if ( this->itemCount ) {
        tsDLNode<T> *pFirstNode = this->pFirst;
        pFirstNode->pPrev = & item;
    }
    else {
        this->pLast = & item;
    }

    this->pFirst = &item;

    this->itemCount++;
}

template<class T>

void tsDLList< T >::push ( tsDLList< T > &  pushList )

inline

Definition at line 392 of file tsDLList.h.

{
    if ( pushList.itemCount != 0u ) {
        if ( this->itemCount ) {
            tsDLNode<T> * pFirstNode = this->pFirst;
            tsDLNode<T> * pAddListLastNode = pushList.pLast;
            pFirstNode->pPrev = pushList.pLast;
            pAddListLastNode->pNext = this->pFirst;
        }
        else {
            this->pLast = pushList.pLast;
        }
        this->pFirst = pushList.pFirst;
        this->itemCount += pushList.itemCount;
        pushList.clear();
    }
}

template<class T>

void tsDLList< T >::remove ( T &  item )

inline

Definition at line 219 of file tsDLList.h.

{
    tsDLNode<T> &theNode = item;

    if ( this->pLast == &item ) {
        this->pLast = theNode.pPrev;
    }
    else {
        tsDLNode<T> &nextNode = *theNode.pNext;
        nextNode.pPrev = theNode.pPrev;
    }

    if ( this->pFirst == &item ) {
        this->pFirst = theNode.pNext;
    }
    else {
        tsDLNode<T> &prevNode = *theNode.pPrev;
        prevNode.pNext = theNode.pNext;
    }

    this->itemCount--;
}

template<class T>

void tsDLList< T >::removeAll ( tsDLList< T > &  destination )

inline

Definition at line 246 of file tsDLList.h.

{
    destination.pFirst = this->pFirst;
    destination.pLast = this->pLast;
    destination.itemCount = this->itemCount;
    this->pFirst = 0;
    this->pLast = 0;
    this->itemCount = 0;
}

---

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

• modules/libcom/src/cxxTemplates/tsDLList.h