cmessageheap.h

//==========================================================================
//  CMESSAGEHEAP.H - part of
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//
//  Declaration of the following classes:
//    cMessageHeap : future event set, implemented as heap
//
//==========================================================================

/*--------------------------------------------------------------*
  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 __CMESSAGEHEAP_H
#define __CMESSAGEHEAP_H

#include "cownedobject.h"

NAMESPACE_BEGIN

class cMessage;


class SIM_API cMessageHeap : public cOwnedObject
{
  public:
    class Iterator
    {
      private:
        cMessageHeap *q;
        int pos;

      public:
        Iterator(const cMessageHeap& mh)  {q=const_cast<cMessageHeap*>(&mh);pos=0;}

        void init(const cMessageHeap& mh) {q=const_cast<cMessageHeap*>(&mh);pos=0;}

        cMessage *operator()()  {return q->peek(pos);}

        cMessage *operator++(int)  {return end() ? NULL : q->peek(pos++);}

        bool end() const  {return pos>=q->getLength();}
    };

    friend class Iterator;

  private:
    // heap data structure
    cMessage **h;             // pointer to the 'heap'  (h[0] always empty)
    int n;                    // number of elements in the heap
    int size;                 // size of allocated h array
    unsigned long insertcntr; // counts insertions

    // circular buffer for events scheduled for the current simtime (quite frequent)
    cMessage **cb;            // size of the circular buffer
    int cbsize;               // always power of 2
    int cbhead, cbtail;       // cbhead is inclusive, cbtail is exclusive

  private:
    void copy(const cMessageHeap& other);

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

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

  public:

    cMessageHeap(const cMessageHeap& msgq);

    cMessageHeap(const char *name=NULL, int size=128);

    virtual ~cMessageHeap();

    cMessageHeap& operator=(const cMessageHeap& msgqueue);


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

    virtual std::string info() const;

    virtual void forEachChild(cVisitor *v);

    // no parsimPack() and parsimUnpack()


    void insert(cMessage *event);

    cMessage *peekFirst() const;

    cMessage *peek(int m);

    cMessage *removeFirst();

    cMessage *remove(cMessage *event);

    void sort();

    void clear();

    int getLength() const {return cblength() + n;}

    bool isEmpty() const {return cbhead==cbtail && n==0;}

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

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

NAMESPACE_END


#endif