cqueue.h

//==========================================================================
//  CQUEUE.H - part of
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//
//  Declaration of the following classes:
//    cQueue : queue of cObject descendants
//
//==========================================================================

/*--------------------------------------------------------------*
  Copyright (C) 1992-2008 Andras Varga
  Copyright (C) 2006-2008 OpenSim Ltd.

  This file is distributed WITHOUT ANY WARRANTY. See the file
  `license' for details on this and other legal matters.
*--------------------------------------------------------------*/

#ifndef __CQUEUE_H
#define __CQUEUE_H

#include "cownedobject.h"

NAMESPACE_BEGIN


typedef int (*CompareFunc)(cObject *a, cObject *b);


class SIM_API cQueue : public cOwnedObject
{
  private:
    struct QElem
    {
        cObject *obj; // the contained object
        QElem *prev;  // element towards the front of the queue
        QElem *next;  // element towards the back of the queue
    };

  public:
    class Iterator
    {
      private:
        QElem *p;

      public:
        Iterator(const cQueue& q, bool reverse=false)
                {p = reverse ? q.backp : q.frontp;}

        void init(const cQueue& q, bool reverse=false)
                {p = reverse ? q.backp : q.frontp;}

        cObject *operator()()  {return p ? p->obj : NULL;}

        bool end() const   {return (bool)(p==NULL);}

        cObject *operator++(int)  {if (!p) return NULL; cObject *r=p->obj; p=p->next; return r;}

        cObject *operator--(int)  {if (!p) return NULL; cObject *r=p->obj; p=p->prev; return r;}
    };

    friend class Iterator;

  private:
    bool tkownership; //FIXME move it info flags
    QElem *frontp, *backp;  // inserting at back(), removal at front()
    int n;  // number of items in the queue
    CompareFunc compare;   // comparison function; NULL for FIFO

  private:
    void copy(const cQueue& other);

  protected:
    // internal functions
    QElem *find_qelem(cObject *obj) const;
    void insbefore_qelem(QElem *p, cObject *obj);
    void insafter_qelem(QElem *p, cObject *obj);
    cObject *remove_qelem(QElem *p);

  public:
    cQueue(const char *name=NULL, CompareFunc cmp=NULL);

    cQueue(const cQueue& queue);

    virtual ~cQueue();

    cQueue& operator=(const cQueue& queue);


    virtual cQueue *dup() const  {return new cQueue(*this);}

    virtual std::string info() const;

    virtual void forEachChild(cVisitor *v);

    virtual void parsimPack(cCommBuffer *buffer);

    virtual void parsimUnpack(cCommBuffer *buffer);

    virtual void setup(CompareFunc cmp);

    virtual void insert(cObject *obj);

    virtual void insertBefore(cObject *where, cObject *obj);

    virtual void insertAfter(cObject *where, cObject *obj);

    virtual cObject *remove(cObject *obj);

    virtual cObject *pop();

    virtual void clear();

    virtual cObject *front() const;

    virtual cObject *back() const;

    virtual int getLength() const;

    bool isEmpty() const {return getLength()==0;}

    int length() const {return getLength();}

    bool empty() const {return isEmpty();}

    cObject *get(int i) const;

    virtual bool contains(cObject *obj) const;


    void setTakeOwnership(bool tk) {tkownership=tk;}

    bool getTakeOwnership() const {return tkownership;}
};

NAMESPACE_END


#endif