List.h

Go to the documentation of this file.

/* $Id: List.h,v 1.3 2002/11/05 14:31:15 anonymous Exp $ */

#ifndef __LIST_H
#define __LIST_H

#include <stdlib.h>
#include <stdio.h>

namespace esg {

template <class Type> class List {
protected:
        struct Node {
                Node* pnext;
                Type* pitem;
        };
        
        Node*    _phandler;
        Node*    _pact;
        unsigned _length;
        
public:
        List<Type> () { _pact = (_phandler = NULL); _length = 0; }

        ~List<Type> () {
            Node* n = _phandler; while(n) { Node* t=n; n=n->pnext; delete t; }
        }

        void append (Type* i) { 
            Node* n   = new Node;
            n->pitem  = i;
            n->pnext  = _phandler;
            _phandler = n;
            _length++;
        }

        void append (List<Type>& src) {
            if (_phandler) {
                Node * n = _phandler;
                while (n->pnext) n = n->pnext;
                n->pnext = src._phandler;
            } else
                _phandler = src._phandler;
            _length += src._length;
            src._length = 0;
            src._phandler = (src._pact = NULL);
        }
        
        Type* remove (Type* i) { 
            if (!_phandler || !i) return NULL;
            if (_phandler->pitem == i) {
                Type*   r  = _phandler->pitem;
                Node*   t  = _phandler;
                if (_pact == _phandler) _pact = _phandler->pnext;
                _phandler  = _phandler->pnext;
                delete t;
                _length--;
                return r;
            }
            Node* f = _phandler;
            Node* s = _phandler->pnext;
            while (s && s->pitem != i) { f = s; s = s->pnext; }
            if (s) {
                f->pnext = s->pnext;
                Type* r = s->pitem;
                if (_pact == s) _pact = s->pnext;
                delete s;
                _length--;
                return r;
            }
            return NULL;
        }

        unsigned length () const { return _length; }

        bool empty () const { return ! _length; }

        Type* firstItem () {
            _pact=_phandler;
            return ((_pact) ? _pact->pitem : NULL);
        }

        Type* nextItem () {
            if (_pact && _pact->pnext) {
                _pact=_pact->pnext;
                return _pact->pitem;
            } else
                return NULL;
        }

        Type* actualItem () { return ((_pact) ? _pact->pitem : NULL); }

        Type* iThItem (unsigned i, bool setAct) {
            if (i >= _length) return NULL;
            Node* n = _phandler;
            for (unsigned j = 0; j < i; j++) n = n->pnext;
            if (setAct) _pact = n;
            return n->pitem;
        }

        void dropAll (void) {
            while (remove(firstItem()));
        }

        void deleteAll (void) {
            Type * t = remove(firstItem());
            while (t) { delete t; t = remove(firstItem()); }
        }

        void __debug() { // for Type == BVNode
            if (!_phandler) { fprintf(stderr,"List: No items stored\n"); return; }
            fprintf(stderr,"List: stored items:\n");
        for (Node* n=_phandler;n;n=n->pnext) n->pitem->__debug();
        }
};

}; // namespace

#endif // __LIST_H

---