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 "ccontextswitcher.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 cSoftOwner;
 
SIM_API extern cSoftOwner globalOwningContext; // 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 = 0;                       // size of componentv[]
    int delta = 32;                     // if needed, grows by delta
    cComponent **componentv = nullptr;  // vector of modules/channels, componentv[0] is not used for historical reasons
    int lastComponentId = 0;            // index of last used pos. in componentv[]
 
    // simulation vars
    cEnvir *envir = nullptr;            // the environment that belongs to this simulation object
    cModule *systemModule = nullptr;    // pointer to system (root) module
    cSimpleModule *currentActivityModule = nullptr; // the module currently executing activity() (nullptr if handleMessage() or in main)
    cComponent *contextComponent = nullptr;  // component in context (or nullptr)
    ContextType contextType;            // the innermost context type
    cModuleType *networkType = nullptr; // network type
    cFutureEventSet *fes = nullptr;     // stores future events
    cScheduler *scheduler = nullptr;    // event scheduler
    simtime_t warmupPeriod;             // warm-up period
 
    ContextType simulationStage;        // simulation stage
    simtime_t currentSimtime;           // simulation time (time of current event)
    eventnumber_t currentEventNumber = 0; // sequence number of current event
 
    cException *exception;    // helper variable to get exceptions back from activity()
    bool trapOnNextEvent = false;  // when set, next handleMessage or activity() will execute debugger interrupt
 
    bool parameterMutabilityCheck = true;  // when disabled, module parameters can be set without them being declared @mutable
 
    cFingerprintCalculator *fingerprint = nullptr; // used for fingerprint calculation
 
  private:
    // internal
    void checkActive()  {if (getActiveSimulation()!=this) throw cRuntimeError(this, E_WRONGSIM);}
 
  public:
    // internal
    void setParameterMutabilityCheck(bool b) {parameterMutabilityCheck = b;}
    bool getParameterMutabilityCheck() const {return parameterMutabilityCheck;}
 
  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;
 
    cModule *findModuleByPath(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, const char *excludedPackages="");
 
    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 callRefreshDisplay();
 
    void transferTo(cSimpleModule *module);
 
    void transferToMain();
 
    void insertEvent(cEvent *event);
 
    void setContext(cComponent *component);
 
    void setContextType(ContextType type)  {contextType = type;}
 
    void setGlobalContext()  {contextComponent=nullptr; cOwnedObject::setOwningContext(&globalOwningContext);}
 
    cSimpleModule *getActivityModule() const {return currentActivityModule;}
 
    cComponent *getContext() const {return contextComponent;}
 
    ContextType 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