---

list.h

Go to the documentation of this file.

/***************************************************************************
    list.h  -  Definition of List template class.
                             -------------------
    begin                : June 21 2002
    copyright            : (C) 2003 by Vojtìch Toman
    email                : vtoman@lit.cz
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program 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.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef LIST_H
#define LIST_H

#include "defs.h"
#include "collection.h"
#include "debug.h"



template<class T_> struct ListLinkedList
{
  struct ListLinkedList<T_> *prev_;
  
  struct ListLinkedList<T_> *next_;
  
  T_ *data_;

}; //SLListLinkedList



template<class T_> class List : public Collection<T_>
{
public:
  List(void) : Collection<T_>() { initList(); }

  virtual ~List(void) { clear(); }


  virtual T_ *first(void)
  { 
    if (!firstNode_)
      return 0;
    else
      {
        currentNode_ = firstNode_;
        return firstNode_->data_;
      }
  }


  virtual T_ *last(void)
  { 
    if (!lastNode_)
      return 0;
    else
      {
        currentNode_ = lastNode_;
        return lastNode_->data_;
      }
  }


  virtual T_ *current(void)
  { 
    if (!currentNode_)
      return 0;
    else
      {
        return currentNode_->data_;
      }
  }


  virtual T_ *next(void)
  {
    if (!currentNode_)
      return 0;
    else
      if (!currentNode_->next_)
        {
          currentNode_ = 0;
          return 0;
        }
      else
        {
          currentNode_ = currentNode_->next_;
          return currentNode_->data_;
        }
  }


  virtual T_ *prev(void)
  {
    if (!currentNode_)
      return 0;
    else
      if (!currentNode_->prev_)
        {
          currentNode_ = 0;
          return 0;
        }
      else
        {
          currentNode_ = currentNode_->prev_;
          return currentNode_->data_;
        }
  }


  virtual void insert(T_ *item)
  {
    ListLinkedList<T_> *pom;

    NEW(pom, ListLinkedList<T_>);

    pom->data_ = item;


    if (!firstNode_)
      {
        pom->prev_ = 0;
        pom->next_ = 0;
        firstNode_ = pom;
        lastNode_ = pom;
      }
    else
      {
        if (!currentNode_)
          {
            pom->prev_ = 0;
            pom->next_ = firstNode_;
            firstNode_->prev_ = pom;
          }
        else
          {
            pom->prev_ = currentNode_;
            pom->next_ = currentNode_->next_;
            currentNode_->next_ = pom;
            
            if (!pom->next_)
              lastNode_ = pom;
            else
              pom->next_->prev_ = pom;
          }
      }

    currentNode_ = pom;

    cnt_++;
  }


  virtual void append(T_ *item)
  {
    ListLinkedList<T_> *pom;

    NEW(pom, ListLinkedList<T_>);

    pom->next_ = 0;
    pom->prev_ = lastNode_;
    pom->data_ = item;

    if (!firstNode_)
      firstNode_ = pom;
    else
      lastNode_->next_ = pom;

    lastNode_ = pom;
    currentNode_ = pom;

    cnt_++;
  }


  virtual void prepend(T_ *item)
  {
    ListLinkedList<T_> *pom;

    NEW(pom, ListLinkedList<T_>);

    pom->prev_ = 0;
    pom->next_ = firstNode_;
    pom->data_ = item;


    !lastNode_ ? lastNode_ = pom : firstNode_->prev_ = pom;

    firstNode_ = pom;

    currentNode_ = pom;

    cnt_++;
  }


  virtual T_ *getFirst(void)
  {
    if (!firstNode_)
      return 0;
    else
      {
        ListLinkedList<T_> *pom;
        T_ *data;
        
        pom = firstNode_;
        data = firstNode_->data_;


        firstNode_ = firstNode_->next_;
        currentNode_ = firstNode_;


        if (firstNode_)
          {
            firstNode_->prev_ = 0;
          }

        cnt_--;

        DELETE(pom);
        return data;
      }
  }


  virtual bool remove(void)
  {
    if (!currentNode_)
      return false;
    else
      {
        ListLinkedList<T_> *pom1, *pom2;
        
        pom1 = currentNode_->prev_;
        pom2 = currentNode_->next_;


        if (pom1)
          pom1->next_ = pom2;
        else
          firstNode_ = pom2;

        if (pom2)
          pom2->prev_ = pom1;
        else
          lastNode_ = pom1;

        if (autoDelete_)
          {
            DELETE(currentNode_->data_);
          }


        DELETE(currentNode_);
        cnt_--;

        currentNode_ = pom2;


        return true;
      }
  }



  virtual bool remove(T_ *item)
  {
    ListLinkedList<T_> *pom;

    pom = firstNode_;

    while (pom)
      {
        if (pom->data_ == item)
          {
            currentNode_ = pom;
            return remove();
          }
        else
          pom = pom->next_;
      }
    
    return false;
  }



  virtual bool contains(T_ *item)
  {
    ListLinkedList<T_> *pom;

    pom = firstNode_;

    while (pom)
      {
        if (pom->data_ == item)
          return true;
        else
          pom = pom->next_;
      }
    
    return false;
  }


  virtual void clear(void)
  {
    ListLinkedList<T_> *pom;

    while (firstNode_)
      {
        pom = firstNode_;
        firstNode_ = firstNode_->next_;

        if (autoDelete_)
          DELETE(pom->data_);

        DELETE(pom);
      }

    firstNode_ = 0;
    lastNode_ = 0;
    currentNode_ = 0;
    cnt_ = 0;
  }


protected:
  struct ListLinkedList<T_> *firstNode_;

  struct ListLinkedList<T_> *lastNode_;

  struct ListLinkedList<T_> *currentNode_;


  virtual void initList(void)
  {
    firstNode_ = 0;
    lastNode_ = 0;
    currentNode_ = 0;
  }

}; //List


#endif //LIST_H

---