csimulation.h

//==========================================================================
//   CSIMULATION.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_CSIMULATION_H
#define __OMNETPP_CSIMULATION_H

#include "simkerneldefs.h"
#include "simtime_t.h"
#include "ccomponent.h"
#include "cexception.h"

namespace omnetpp {

class cEvent;
class cMessage;
class cGate;
class cComponent;
class cModule;
class cChannel;
class cSimpleModule;
class cSimulation;
class cException;
class cFutureEventSet;
class cScheduler;
class cParsimPartition;
class cNedFileLoader;
class cFingerprintCalculator;
class cModuleType;
class cEnvir;
class cDefaultList;

SIM_API extern cDefaultList defaultList; // also in globals.h


class SIM_API cSimulation : public cNamedObject, noncopyable
{
    friend class cSimpleModule;
  private:
    // global variables
    static cSimulation *activeSimulation;
    static cEnvir *activeEnvir;
    static cEnvir *staticEnvir; // the environment to activate when activeSimulation becomes nullptr

    // variables of the module vector
    int size;                 // size of componentv[]
    int delta;                // if needed, grows by delta
    cComponent **componentv;  // vector of modules/channels, componentv[0] is not used
    int lastComponentId;      // index of last used pos. in componentv[]
#ifdef USE_OMNETPP4x_FINGERPRINTS
    int lastVersion4ModuleId; // last used OMNeT++ V4.x compatible module ID
#endif

    // simulation vars
    cEnvir *envir;            // the environment that belongs to this simulation object
    cModule *systemModule;    // pointer to system (root) module
    cSimpleModule *currentActivityModule; // the module currently executing activity() (nullptr if handleMessage() or in main)
    cComponent *contextComponent;  // component in context (or nullptr)
    int contextType;          // the innermost context type (one of CTX_BUILD, CTX_EVENT, CTX_INITIALIZE, CTX_FINISH)
    cModuleType *networkType; // network type
    cFutureEventSet *fes;     // stores future events
    cScheduler *scheduler;    // event scheduler
    simtime_t warmupPeriod;   // warm-up period

    int simulationStage;      // simulation stage (one of CTX_NONE, CTX_BUILD, CTX_EVENT, CTX_INITIALIZE, CTX_FINISH or CTX_CLEANUP)
    simtime_t currentSimtime; // simulation time (time of current event)
    eventnumber_t currentEventNumber; // sequence number of current event

    cMessage *msgForActivity; // helper variable to pass the received message into activity()
    cException *exception;    // helper variable to get exceptions back from activity()
    bool trapOnNextEvent;  // when set, next handleMessage or activity() will execute debugger interrupt

    cFingerprintCalculator *fingerprint; // used for fingerprint calculation

  private:
    // internal
    void checkActive()  {if (getActiveSimulation()!=this) throw cRuntimeError(this, E_WRONGSIM);}

    // helper for executeEvent()
    void doMessageEvent(cMessage *msg, cSimpleModule *mod);

  public:
    cSimulation(const char *name, cEnvir *env);

    virtual ~cSimulation();

    virtual void forEachChild(cVisitor *v) override;

    virtual std::string getFullPath() const override;

    static cSimulation *getActiveSimulation()  {return activeSimulation;}

    static cEnvir *getActiveEnvir()  {return activeEnvir;}

    static void setActiveSimulation(cSimulation *sim);

    static void setStaticEnvir(cEnvir *env);

    static cEnvir *getStaticEnvir()  {return staticEnvir;}

    cEnvir *getEnvir() const  {return envir;}


    int registerComponent(cComponent *component);

    void deregisterComponent(cComponent *component);

    int getLastComponentId() const    {return lastComponentId;}

    cModule *getModuleByPath(const char *modulePath) const;

    cComponent *getComponent(int id) const  {return id<0 || id>=size ? nullptr : componentv[id];}

    cModule *getModule(int id) const  {return id<0 || id>=size || !componentv[id] ? nullptr : componentv[id]->isModule() ? (cModule *)componentv[id] : nullptr;}

    cChannel *getChannel(int id) const  {return id<0 || id>=size || !componentv[id] ? nullptr : componentv[id]->isChannel() ? (cChannel *)componentv[id] : nullptr;}

    void setSystemModule(cModule *module);

    cModule *getSystemModule() const  {return systemModule;}


    static int loadNedSourceFolder(const char *folderName);

    static void loadNedFile(const char *nedFilename, const char *expectedPackage=nullptr, bool isXML=false);

    static void loadNedText(const char *name, const char *nedText, const char *expectedPackage=nullptr, bool isXML=false);

    static void doneLoadingNedFiles();

    static std::string getNedPackageForFolder(const char *folder);


    void setScheduler(cScheduler *scheduler);

    cScheduler *getScheduler() const  {return scheduler;}

    void setFES(cFutureEventSet *fes);

    cFutureEventSet *getFES() const  {return fes;}

    void setSimulationTimeLimit(simtime_t simTimeLimit);

    void setupNetwork(cModuleType *networkType);

    void callInitialize();

    void callFinish();

    void deleteNetwork();

    int getSimulationStage() const  {return simulationStage;}

    cModuleType *getNetworkType() const  {return networkType;}

    void setSimTime(simtime_t time)  {currentSimtime = time;}

    simtime_t_cref getSimTime() const  {return currentSimtime;}

    eventnumber_t getEventNumber() const  {return currentEventNumber;}

    simtime_t_cref getWarmupPeriod() const  {return warmupPeriod;}

    void setWarmupPeriod(simtime_t t)  {warmupPeriod = t;}

    cEvent *guessNextEvent();

    cSimpleModule *guessNextModule();

    simtime_t guessNextSimtime();

    cEvent *takeNextEvent();

    void putBackEvent(cEvent *event);

    void executeEvent(cEvent *event);

    void transferTo(cSimpleModule *module);

    void transferToMain();

    void insertEvent(cEvent *event);

    void setContext(cComponent *component);

    void setContextType(int type)  {contextType = type;}

    void setGlobalContext()  {contextComponent=nullptr; cOwnedObject::setDefaultOwner(&defaultList);}

    cSimpleModule *getActivityModule() const {return currentActivityModule;}

    cComponent *getContext() const {return contextComponent;}

    int getContextType() const {return contextType;}

    cModule *getContextModule() const;

    cSimpleModule *getContextSimpleModule() const;

    void requestTrapOnNextEvent() {trapOnNextEvent = true;}

    void clearTrapOnNextEvent() {trapOnNextEvent = false;}

    bool isTrapOnNextEventRequested() const {return trapOnNextEvent;}

    unsigned long getUniqueNumber();

    void snapshot(cObject *obj, const char *label);

    cFingerprintCalculator *getFingerprintCalculator() {return fingerprint;}

    void setFingerprintCalculator(cFingerprintCalculator *fingerprint);
};

inline simtime_t simTime() {return cSimulation::getActiveSimulation()->getSimTime();}

inline cSimulation *getSimulation()  {return cSimulation::getActiveSimulation();}

inline cEnvir *getEnvir()  {return cSimulation::getActiveEnvir();}

}  // namespace omnetpp


#endif