csimplemodule.h

//==========================================================================
//   CSIMPLEMODULE.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_CSIMPLEMODULE_H
#define __OMNETPP_CSIMPLEMODULE_H
 
#include "cmodule.h"
 
namespace omnetpp {
 
class cQueue;
class cCoroutine;
 
struct SIM_API SendOptions {
    simtime_t sendDelay = SIMTIME_ZERO; // for after()
    simtime_t propagationDelay_ = SIMTIME_ZERO; // for sendDirect()
    simtime_t duration_ = DURATION_UNSPEC; // for packets not using channel datarate
    bool isUpdate = false;
    txid_t transmissionId_ = -1; // if not -1, specifies the transmission id
    simtime_t remainingDuration = DURATION_UNSPEC; // when updating an earlier transmission
 
    static const simtime_t DURATION_UNSPEC;
    static const SendOptions DEFAULT;
 
    SendOptions() {}
 
    SendOptions& after(simtime_t delay) {this->sendDelay = delay; return *this;}
 
    SendOptions& propagationDelay(simtime_t delay) {this->propagationDelay_ = delay; return *this;}
 
    SendOptions& duration(simtime_t duration) {this->duration_ = duration; return *this;}
 
    SendOptions& transmissionId(txid_t transmissionId) {this->transmissionId_ = transmissionId; return *this;}
 
    SendOptions& finishTx(txid_t transmissionId) {this->isUpdate = true; this->transmissionId_ = transmissionId; remainingDuration = SIMTIME_ZERO; return *this;}
 
    SendOptions& updateTx(txid_t transmissionId) {this->isUpdate = true; this->transmissionId_ = transmissionId; remainingDuration = DURATION_UNSPEC; return *this;}
 
    SendOptions& updateTx(txid_t transmissionId, simtime_t remainingDuration) {this->isUpdate = true; this->transmissionId_ = transmissionId; this->remainingDuration = remainingDuration; return *this;}
 
    std::string str() const;
};
 
class SIM_API cSimpleModule : public cModule //implies noncopyable
{
    friend class cModule;
    friend class cSimulation;
    friend class cMessage;
 
  private:
    enum {
        FL_USESACTIVITY        = 1 << 13, // uses activity() or handleMessage()
        FL_ISTERMINATED        = 1 << 14, // for both activity and handleMessage modules
        FL_STACKALREADYUNWOUND = 1 << 15, // only for activity modules
        FL_SUPPORTSTXUPDATES   = 1 << 16, // whether module is prepared to receive tx updates (see SendOptions)
    };
 
    cMessage *timeoutMessage;   // msg used in wait() and receive() with timeout
    cCoroutine *coroutine;
 
    static cMessage *msgForActivity; // helper variable to pass the received message into activity()
    static bool stackCleanupRequested; // 'true' value asks activity() to throw a cStackCleanupException
    static cSimpleModule *afterCleanupTransferTo; // transfer back to this module (or to main)
 
  private:
    // internal use
    static void activate(void *p);
 
    // internal utility methods
    cGate *resolveSendDirectGate(cModule *mod, int gateId);
    cGate *resolveSendDirectGate(cModule *mod, const char *gateName, int gateIndex);
    static SendOptions resolveSendDirectOptions(simtime_t propagationDelay, simtime_t duration);
    void deleteObsoletedTransmissionFromFES(txid_t transmissionId, cPacket *updatePkt);
    void throwNotOwnerOfMessage(const char *sendOp, cMessage *msg);
 
  protected:
    // internal: handle a message event, basically dispatch to handleMessage() or activity(); not supposed to be overridden by models
    virtual void doMessageEvent(cMessage *msg);
 
  protected:
 
    virtual void activity();
 
    virtual void handleMessage(cMessage *msg);
 
  public:
    cSimpleModule(unsigned stacksize = 0);
 
    virtual ~cSimpleModule();
 
    virtual std::string str() const override;
 
    virtual bool isSimple() const override;
 
    virtual void forEachChild(cVisitor *v) override;
 
 
    virtual void scheduleStart(simtime_t t) override;
 
    virtual void arrived(cMessage *msg, cGate *ongate, const SendOptions& options, simtime_t t) override;
 
 
    bool usesActivity() const  {return flags&FL_USESACTIVITY;}
 
    void setTxUpdateSupport(bool b) {setFlag(FL_SUPPORTSTXUPDATES, b);}
 
    bool supportsTxUpdates() const  {return flags&FL_SUPPORTSTXUPDATES;}
 
    bool isTerminated() const {return flags&FL_ISTERMINATED;}
 
    virtual void snapshot(cObject *obj=nullptr, const char *label=nullptr);
 
 
    virtual void send(cMessage *msg, int gateid)  {send(msg, gate(gateid));}
 
    virtual void send(cMessage *msg, const char *gatename, int gateindex=-1)  {send(msg, gate(gatename, gateindex));}
 
    virtual void send(cMessage *msg, cGate *outputgate)  {send(msg, SendOptions::DEFAULT, outputgate);}
 
    virtual void send(cMessage *msg, const SendOptions& options, int gateid)  {send(msg, options, gate(gateid));}
 
    virtual void send(cMessage *msg, const SendOptions& options, const char *gatename, int gateindex=-1)  {send(msg, options, gate(gatename, gateindex));}
 
    virtual void send(cMessage *msg, const SendOptions& options, cGate *outputgate);
 
    virtual void sendDelayed(cMessage *msg, simtime_t delay, int gateid)  {send(msg, SendOptions().after(delay), gate(gateid));}
 
    virtual void sendDelayed(cMessage *msg, simtime_t delay, const char *gatename, int gateindex=-1)  {send(msg, SendOptions().after(delay), gate(gatename, gateindex));}
 
    virtual void sendDelayed(cMessage *msg, simtime_t delay, cGate *outputgate)  {send(msg, SendOptions().after(delay), outputgate);}
 
    virtual void sendDirect(cMessage *msg, cModule *mod, const char *inputGateName, int gateIndex=-1)  {sendDirect(msg, SendOptions::DEFAULT, resolveSendDirectGate(mod, inputGateName, gateIndex));}
 
    virtual void sendDirect(cMessage *msg, cModule *mod, int inputGateId) {sendDirect(msg, SendOptions::DEFAULT, resolveSendDirectGate(mod, inputGateId));}
 
    virtual void sendDirect(cMessage *msg, cGate *inputGate) {sendDirect(msg, SendOptions::DEFAULT, inputGate);}
 
    virtual void sendDirect(cMessage *msg, const SendOptions& options, cModule *mod, const char *inputGateName, int gateIndex=-1) {sendDirect(msg, options, resolveSendDirectGate(mod, inputGateName, gateIndex));}
 
    virtual void sendDirect(cMessage *msg, const SendOptions& options, cModule *mod, int inputGateId) {sendDirect(msg, options, resolveSendDirectGate(mod, inputGateId));}
 
    virtual void sendDirect(cMessage *msg, const SendOptions& options, cGate *inputGate);
 
    virtual void sendDirect(cMessage *msg, simtime_t propagationDelay, simtime_t duration, cModule *mod, const char *inputGateName, int gateIndex=-1) {sendDirect(msg, resolveSendDirectOptions(propagationDelay, duration), resolveSendDirectGate(mod, inputGateName, gateIndex));}
 
    virtual void sendDirect(cMessage *msg, simtime_t propagationDelay, simtime_t duration, cModule *mod, int inputGateId) {sendDirect(msg, resolveSendDirectOptions(propagationDelay, duration), resolveSendDirectGate(mod, inputGateId));}
 
    virtual void sendDirect(cMessage *msg, simtime_t propagationDelay, simtime_t duration, cGate *inputGate) {sendDirect(msg, resolveSendDirectOptions(propagationDelay, duration), inputGate);}
 
 
    virtual void scheduleAt(simtime_t t, cMessage *msg);
 
    virtual void scheduleAfter(simtime_t delay, cMessage *msg);
 
    virtual void rescheduleAt(simtime_t t, cMessage *msg);
 
    virtual void rescheduleAfter(simtime_t delay, cMessage *msg);
 
    virtual cMessage *cancelEvent(cMessage *msg);
 
    virtual void cancelAndDelete(cMessage *msg);
 
 
    virtual cMessage *receive();
 
    virtual cMessage *receive(simtime_t timeout);
 
 
    virtual void wait(simtime_t time);
 
    virtual void waitAndEnqueue(simtime_t time, cQueue *queue);
 
    virtual void endSimulation();
 
    virtual void halt();
 
    _OPP_GNU_ATTRIBUTE(format(printf, 2, 3))
    virtual void error(const char *format,...) const;
 
 
    virtual bool hasStackOverflow() const;
 
    virtual unsigned getStackSize() const;
 
    virtual unsigned getStackUsage() const;
};
 
}  // namespace omnetpp
 
 
#endif