---

queue.h

Go to the documentation of this file.

/***************************************************************************
    queue.h  -  Definition of Queue template class.
                             -------------------
    begin                : October 14 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 QUEUE_H
#define QUEUE_H

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


template<class T_> struct QueueLinkedList
{
  struct QueueLinkedList<T_> *next_;
  
  T_ *data_;

}; //QueueLinkedList


template<class T_> class Queue : public Collection<T_>
{
public:
  Queue(void) : Collection<T_>() { initQueue(); }

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



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


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



  virtual void enqueue(T_ *item)
  {
    QueueLinkedList<T_> *pom;

    NEW(pom, QueueLinkedList<T_>);

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

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

    lastNode_ = pom;

    cnt_++;
  }



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

        firstNode_ = firstNode_->next_;

        if (!firstNode_)
          lastNode_ = 0;

        cnt_--;

        DELETE(pom);

        return data;
      }
  }



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

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

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

        DELETE(pom);
      }

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


  

protected:
  struct QueueLinkedList<T_> *firstNode_;

  struct QueueLinkedList<T_> *lastNode_;

  virtual void initQueue(void)
  {
    firstNode_ = 0;
    lastNode_ = 0;
  }

}; //Queue


#endif //QUEUE_H

---