csimulation.h

//==========================================================================
//   CSIMULATION.H  -  header for
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//
//  Declaration of the following classes:
//    cSimulation  : simulation management class; only one instance
//
//==========================================================================

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

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

NAMESPACE_BEGIN

//=== classes mentioned:
class  cMessage;
class  cGate;
class  cModule;
class  cSimpleModule;
class  cCompoundModule;
class  cSimulation;
class  cException;
class  cScheduler;
class  cParsimPartition;
class  cNEDFileLoader;
class  cHasher;
class  cModuleType;
class  cEnvir;
class  cDefaultList;

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

#define simulation  (*cSimulation::getActiveSimulation())


class SIM_API cSimulation : public cNamedObject, noncopyable
{
    friend class cSimpleModule;
  private:
    // global variables
    static cSimulation *simPtr; // the active cSimulation instance
    static cEnvir *evPtr;       // the active cEnvir instance
    static cEnvir *staticEvPtr; // the environment to activate when simPtr becomes NULL

    // variables of the module vector
    int size;                 // size of vector
    int delta;                // if needed, grows by delta
    cModule **vect;           // vector of modules, vect[0] is not used
    int last_id;              // index of last used pos. in vect[]

    // simulation vars
    cEnvir *ownEvPtr;         // the environment that belongs to this simulation object
    cModule *systemmodp;      // pointer to system (root) module
    cSimpleModule *activitymodp; // the module currently executing activity() (NULL if handleMessage() or in main)
    cComponent *contextmodp;  // component in context (or NULL)
    int contexttype;          // the innermost context type (one of CTX_BUILD, CTX_EVENT, CTX_INITIALIZE, CTX_FINISH)
    cModuleType *networktype; // network type
    cScheduler *schedulerp;   // event scheduler
    simtime_t warmup_period;  // warm-up period

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

    cMessage *msg_for_activity; // helper variable to pass the received message into activity()
    cException *exception;    // helper variable to get exceptions back from activity()

    cHasher *hasherp;         // used for fingerprint calculation

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

  public:
    // internal: FES
    cMessageHeap msgQueue;    // future messages (FES)
    cMessageHeap& getMessageQueue() {return msgQueue;}  // accessor for sim_std.msg

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

    virtual ~cSimulation();

    virtual void forEachChild(cVisitor *v);

    virtual std::string getFullPath() const;

    static cSimulation *getActiveSimulation()  {return simPtr;}

    static cEnvir *getActiveEnvir()  {return evPtr;}

    static void setActiveSimulation(cSimulation *sim);

    static void setStaticEnvir(cEnvir *env);

    static cEnvir *getStaticEnvir()  {return staticEvPtr;}

    cEnvir *getEnvir() const  {return ownEvPtr;}


    int registerModule(cModule *mod);

    void deregisterModule(cModule *mod);

    int getLastModuleId() const    {return last_id;}

    cModule *getModuleByPath(const char *modulepath) const;

    cModule *getModule(int id) const  {return id>=0 && id<size ? vect[id] : NULL;}

    _OPPDEPRECATED cModule& operator[](int id) const  {return id>=0 && id<size ? *vect[id] : *(cModule *)NULL;}

    void setSystemModule(cModule *p);

    cModule *getSystemModule() const  {return systemmodp;}


    static int loadNedSourceFolder(const char *foldername);

    static void loadNedFile(const char *nedfname, const char *expectedPackage=NULL, bool isXML=false);

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

    static void doneLoadingNedFiles();

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

    static void clearLoadedNedFiles();


    void setScheduler(cScheduler *scheduler);

    cScheduler *getScheduler() const  {return schedulerp;}

    void setupNetwork(cModuleType *networkType);

    void startRun();

    void callFinish();

    void endRun();

    void deleteNetwork();

    int getSimulationStage() const  {return simulationstage;}

    cModuleType *getNetworkType() const  {return networktype;}

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

    simtime_t_cref getSimTime() const  {return sim_time;}

    eventnumber_t getEventNumber() const  {return event_num;}

    simtime_t_cref getWarmupPeriod() const  {return warmup_period;}

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


    cSimpleModule *selectNextModule();

    cMessage *guessNextEvent();

    cSimpleModule *guessNextModule();

    simtime_t guessNextSimtime();

    void doOneEvent(cSimpleModule *m);

    void transferTo(cSimpleModule *p);

    void transferToMain();

    void insertMsg(cMessage *msg);

    void setContext(cComponent *p);

    void setContextType(int ctxtype)  {contexttype = ctxtype;}

    void setGlobalContext()  {contextmodp=NULL; cOwnedObject::setDefaultOwner(&defaultList);}

    cSimpleModule *getActivityModule() const {return activitymodp;}

    cComponent *getContext() const {return contextmodp;}

    int getContextType() const {return contexttype;}

    cModule *getContextModule() const;

    cSimpleModule *getContextSimpleModule() const;

    unsigned long getUniqueNumber();

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

    cHasher *getHasher() {return hasherp;}

    void setHasher(cHasher *hasher);
};

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


NAMESPACE_END


#endif

---