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;}

        _OPPDEPRECATED cObject *operator()() const {return operator*();}

        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;}

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

    _OPPDEPRECATED 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