cqueue.h

//==========================================================================
//  CQUEUE.H - part of
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//==========================================================================
 
/*--------------------------------------------------------------*
  Copyright (C) 1992-2017 Andras Varga
  Copyright (C) 2006-2017 OpenSim Ltd.
 
  This file is distributed WITHOUT ANY WARRANTY. See the file
  `license' for details on this and other legal matters.
*--------------------------------------------------------------*/
 
#ifndef __OMNETPP_CQUEUE_H
#define __OMNETPP_CQUEUE_H
 
#include "cownedobject.h"
 
namespace omnetpp {
 
 
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 SIM_API Comparator
    {
      public:
        virtual ~Comparator() {}
        virtual Comparator *dup() const = 0;
        virtual bool less(cObject *a, cObject *b) = 0;
    };
 
    typedef int (*CompareFunc)(cObject *a, cObject *b);
 
    class SIM_API Iterator
    {
      private:
        QElem *p;
 
      public:
        Iterator(const cQueue& q, bool reverse=false) { init(q, reverse);}
 
        void init(const cQueue& q, bool reverse=false) {p = reverse ? q.backp : q.frontp;}
 
        cObject *operator*() const {return p ? p->obj : nullptr;}
 
        bool end() const {return p == nullptr;}
 
        Iterator& operator++() {if (!end()) p = p->next; return *this;}
 
        Iterator operator++(int) {Iterator tmp(*this); if (!end()) p = p->next; return tmp;}
 
        Iterator& operator--() {if (!end()) p = p->prev; return *this;}
 
        Iterator operator--(int) {Iterator tmp(*this); if (!end()) p = p->prev; return tmp;}
    };
 
    friend class Iterator;
 
  private:
    bool takeOwnership = true;
    QElem *frontp = nullptr, *backp = nullptr;  // front and back pointers
    int len = 0;  // number of items in the queue
    Comparator *comparator = nullptr; // comparison functor; nullptr 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=nullptr, Comparator *cmp=nullptr);
 
    cQueue(const char *name, CompareFunc cmp);
 
    cQueue(const cQueue& queue);
 
    virtual ~cQueue();
 
    cQueue& operator=(const cQueue& queue);
 
 
    virtual cQueue *dup() const override  {return new cQueue(*this);}
 
    virtual std::string str() const override;
 
    virtual void forEachChild(cVisitor *v) override;
 
    virtual void parsimPack(cCommBuffer *buffer) const override;
 
    virtual void parsimUnpack(cCommBuffer *buffer) override;
 
    virtual void setup(Comparator *cmp);
 
    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;}
 
    [[deprecated("use getLength() instead")]] int length() const {return getLength();}
 
    [[deprecated("use isEmpty() instead")]] bool empty() const {return isEmpty();}
 
    virtual cObject *get(int i) const;
 
    virtual bool contains(cObject *obj) const;
 
 
    void setTakeOwnership(bool tk) {takeOwnership=tk;}
 
    bool getTakeOwnership() const {return takeOwnership;}
};
 
// for backward compatibility
typedef cQueue::CompareFunc CompareFunc;
 
}  // namespace omnetpp
 
 
#endif