cevent.h

//==========================================================================
//   CEVENT.H  -  header for
//                     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_CEVENT_H
#define __OMNETPP_CEVENT_H
 
#include "cownedobject.h"
 
namespace omnetpp {
 
class cMessage;
class cPacket;
class cEventHeap;
 
class SIM_API cEvent : public cOwnedObject
{
    friend class cMessage;     // getArrivalTime()
    friend class cEventHeap;   // heapIndex
 
  private:
    simtime_t arrivalTime;  // time of delivery -- set internally
    short priority = 0;     // priority -- used for scheduling events with equal arrival times
    int heapIndex = -1;     // used by cEventHeap (-1 if not on heap; all other values, including negative ones, means "on the heap")
    eventnumber_t insertOrder = -1; // used by the FES to keep order of events with equal time and priority
    eventnumber_t previousEventNumber = -1; // most recent event number when envir was notified about this event object (e.g. creating/cloning/sending/scheduling/deleting of this event object)
 
  public:
    // internal: returns the event number which scheduled this event object, or the event
    // number in which this event object was last executed (e.g. delivered to a module);
    // stored for recording into the event log file.
    eventnumber_t getPreviousEventNumber() const {return previousEventNumber;}
 
    // internal: sets previousEventNumber.
    void setPreviousEventNumber(eventnumber_t num) {previousEventNumber = num;}
 
    // internal: used by cEventHeap.
    eventnumber_t getInsertOrder() const {return insertOrder;}
 
    // internal: called by the simulation kernel to set the value returned
    // by the getArrivalTime() method; must not be called while the event is
    // in the FES, because it would break ordering.
    void setArrivalTime(simtime_t t) {ASSERT(!isScheduled()); arrivalTime = t;}
 
    // internal: used by the parallel simulation kernel.
    virtual int getSrcProcId() const {return -1;}
 
    // internal: utility function
    static int compareBySchedulingOrder(const cEvent *a, const cEvent *b);
 
  public:
 
    cEvent(const cEvent& event) : cOwnedObject(event) {operator=(event);}
 
    explicit cEvent(const char *name) : cOwnedObject(name, false) {}  // note: name pooling is off by default, as unique message names are quite common
 
    virtual ~cEvent() {}
 
    cEvent& operator=(const cEvent& event);
 
    virtual cEvent *dup() const override = 0;
 
    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;
 
 
    void setSchedulingPriority(short p);
 
    short getSchedulingPriority() const  {return priority;}
 
 
    bool isScheduled() const  {return heapIndex!=-1;}
 
    simtime_t_cref getArrivalTime() const  {return arrivalTime;}
 
    virtual cObject *getTargetObject() const = 0;
 
    virtual bool isMessage() const {return false;}
 
    virtual bool isPacket() const {return false;}
 
    virtual bool isStale() {return false;}
 
    bool shouldPrecede(const cEvent *event) const;
 
    virtual void execute() = 0;
};
 
}  // namespace omnetpp
 
#endif