ceventheap.h

//==========================================================================
//  CEVENTHEAP.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_CEVENTHEAP_H
#define __OMNETPP_CEVENTHEAP_H

#include "cfutureeventset.h"

namespace omnetpp {

class SIM_API cEventHeap : public cFutureEventSet
{
  private:
    // heap data structure
    cEvent **heap;            // heap array  (heap[0] always empty)
    int heapLength;           // number of elements on the heap
    int heapCapacity;         // allocated size of the heap[] array
    eventnumber_t insertCount; // counts insertions; needed because heap's insert is not stable (does not keep order)

    // circular buffer for events scheduled for the current simtime (quite frequent); acts as FIFO
    cEvent **cb;              // size of the circular buffer
    int cbsize;               // always power of 2
    int cbhead, cbtail;       // cbhead is inclusive, cbtail is exclusive
    bool useCb;               // for disabling cb

  private:
    void copy(const cEventHeap& other);

    // internal: restore heap
    void shiftup(int from=1);

    int cblength() const  {return (cbtail-cbhead) & (cbsize-1);}
    cEvent *cbget(int k)  {return cb[(cbhead+k) & (cbsize-1)];}
    void cbgrow();

    void heapInsert(cEvent *event);
    void cbInsert(cEvent *event);
    void flushCb();

  public:
    // internal:
    bool getUseCb() const {return useCb;}
    void setUseCb(bool b) {ASSERT(cbhead==cbtail); useCb = b;}

  public:

    cEventHeap(const cEventHeap& msgq);

    cEventHeap(const char *name=nullptr, int initialCapacity=128);

    virtual ~cEventHeap();

    cEventHeap& operator=(const cEventHeap& other);


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

    virtual std::string str() const override;

    virtual void forEachChild(cVisitor *v) override;

    // no parsimPack() and parsimUnpack()

    virtual void insert(cEvent *event) override;

    virtual cEvent *peekFirst() const override;

    virtual cEvent *removeFirst() override;

    virtual void putBackFirst(cEvent *event) override;

    virtual cEvent *remove(cEvent *event) override;

    virtual bool isEmpty() const override {return cbhead==cbtail && heapLength==0;}

    virtual void clear() override;


    virtual int getLength() const override {return cblength() + heapLength;}

    virtual cEvent *get(int k) override;

    virtual void sort() override;
};

}  // namespace omnetpp


#endif