---

list.h

Go to the documentation of this file.

// OMICRON ENGINE HEADER FILE
//
// --------------------------------------------------------------------------
// Copyright (C) 2001-2002 by Bjoern Paetzel <kolrabi@gmx.de>
//
// This file is part of the Omicron Engine.
//
// The Omicron Engine is free software; you can redistribute it and/or modify
// it under the terms of the  GNU General Public License  as published by the
// Free Software Foundation;  either version  2  of the License,  or (at your
// option) any later version.
//
// The Omicron Engine  is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
// or  FITNESS FOR A PARTICULAR PURPOSE.  See the  GNU General Public License
// for more details.
//
// You should have  received a copy of the  GNU General Public License  along
// with The Omicron Engine;  if not,  write to the  Free Software Foundation,
// Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
//
// --------------------------------------------------------------------------
// Last modified:       $Date: 2002/12/13 12:29:26 $
// By           :       $Author: kolrabi $
// $Id: list.h,v 1.2 2002/12/13 12:29:26 kolrabi Exp $ 

/*

  $Log: list.h,v $
  Revision 1.2  2002/12/13 12:29:26  kolrabi
  fixed some bugs

  Revision 1.1.1.1  2002/12/07 19:02:17  kolrabi
  initial release


*/

/**************************************************************************** 
 **************************************************************************** 
 * TYPES ******************************************************************** 
 **************************************************************************** 
 ****************************************************************************/ 
 
template <class T>
class list_c
{ 
protected: 

#if !defined(__GNUG__)
    template <class T>
#endif
    struct entry_t
    { 
        entry_t<T>  *next, *prev;       
        T           *data;              
    };

    entry_t<T>      *first;             
    entry_t<T>      *last;              
    entry_t<T>      *current;           
 
    long            count;              
 
public: 
 
    list_c<T>()
    {
        count = 0; 
        first = last = current = NULL; 
    }

    virtual
    ~list_c<T>()
    { 
        AssertThis;

        current = first; 
        while(current) 
        { 
            entry_t<T> *next; 
         
            next = current->next; 
            SafeDelete(current); 
            current = next; 
        } 
    } 

    void
    add_first(T* data)
    { 
        AssertThis;

        count++; 
 
        current = new entry_t<T>; 
 
        current->data = data; 
 
        if (!first) 
        { 
            last = first = current; 
            first->next = first->prev = NULL; 
            return; 
        } 
 
        current->data   = data; 
        current->next   = first; 
        current->prev   = NULL; 
 
        first->prev     = current; 
        first           = current; 
    } 

    void
    append(T* data)
    { 
        AssertThis;

        count++; 
 
        current = new entry_t<T>; 
 
        current->data = data; 
 
        if (!last) 
        { 
            last = first = current; 
            last->next = last->prev = NULL; 
            return; 
        } 
 
        current->data   = data; 
        current->next   = NULL; 
        current->prev   = last; 
 
        last->next      = current; 
        last            = current; 
    } 
 
    void
    add_aftercurrent(T* data)
    { 
        AssertThis;

        count++; 
 
        if (current == last || !current) 
        { 
            append(data); 
            return; 
        }
        
        entry_t<T> *p,*n; 
 
        p = current; 
        n = current->next; 
 
        current = new entry_t<T>;
 
        current->data   = data; 
        current->next   = n; 
        current->prev   = p; 
 
        p->next         = current; 
        n->prev         = current; 
    } 

    void
    add_beforecurrent(T* data)
    { 
        AssertThis;

        count++; 
 
        if (current == first || !current) 
        { 
            add_first(data); 
            return; 
        } 
 
        entry_t<T> *p,*n; 
 
        p = current->prev; 
        n = current; 
 
        current = new entry_t<T>;
 
        current->data   = data; 
        current->next   = n; 
        current->prev   = p; 
 
        p->next         = current; 
        n->prev         = current; 
    } 

 
    long
    get_count()
    { 
        AssertThisValue(INVALID_INDEX);
        return count; 
    }; 
 
    T *
    get_first()
    { 
        AssertThisV;
        return first  ?(current=first)->data  :NULL; 
    }; 

    T *
    get_last()
    { 
        AssertThisV;
        return last   ?(current=last)->data   :NULL; 
    }; 

    T *
    get_current()
    {
        AssertThisV;
        return current?current->data          :NULL; 
    };
 
    T *
    get_next()
    { 
        AssertThisV;
        return (current&&current->next)?(current=current->next)->data: NULL; 
    };

    T *
    get_prev()
    { 
        AssertThisV;
        return (current&&current->prev)?(current=current->prev)->data: NULL; 
    }; 
 
    void
    set_current(T* ptr)
    { 
        AssertThis;

        T *e; 
 
        e = get_first(); 
        while(e) 
        { 
            if (e==ptr) 
                return; 
 
            e = get_next(); 
        } 
 
        current = NULL; 
    } 

    void
    set_current_num(ulong n)
    { 
        AssertThis;

        T       *e; 
        ulong   i = 0; 
 
        e = get_first(); 
        while(e) 
        { 
            if (i==n) 
                return; 
 
            i++; 
            e = get_next(); 
        } 
 
        current = last; 
    }

    void
    remove(T* ptr)
    { 
        AssertThis;

        set_current(ptr); 
 
        if (!current)  
            return; 
 
        if (current == first) 
            first = first->next; 
     
        if (current == last) 
            last = last->prev; 
 
        count --; 
     
        entry_t<T> *prev, *next; 
 
        prev = current->prev; 
        next = current->next; 
 
        if (next) 
            next->prev = prev; 
 
        if (prev) 
            prev->next = next; 
 
        SafeDelete(current);
    }
};

---