csimul.h

//==========================================================================
//   CSIMUL.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-2005 Andras Varga

  This file is distributed WITHOUT ANY WARRANTY. See the file
  `license' for details on this and other legal matters.
*--------------------------------------------------------------*/

#ifndef __CSIMUL_H
#define __CSIMUL_H

#include "defs.h"

#include "util.h"
#include "errmsg.h"
#include "globals.h"
#include "cmsgheap.h"
#include "ccoroutine.h"
#include "coutvect.h"

//=== classes mentioned:
class  cMessage;
class  cGate;
class  cModulePar;
class  cModule;
class  cSimpleModule;
class  cCompoundModule;
class  cSimulation;
class  cNetworkType;
class  cException;
class  cScheduler;
class  cParsimPartition;


SIM_API extern cSimulation simulation;


class SIM_API cSimulation : public cObject
{
    friend class cSimpleModule;

  private:
    // 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 global vars
    cModule *systemmodp;      // pointer to system module
    cSimpleModule *runningmodp; // the module currently executing activity() (NULL if handleMessage() or in main)
    cModule *contextmodp;     // module in context (or NULL)
    int contexttype;          // CTX_BUILD, CTX_EVENT, CTX_INITIALIZE or CTX_FINISH
    cNetworkType *networktype; // network type
    cScheduler *schedulerp;   // event scheduler

    simtime_t sim_time;       // simulation time (time of current event)
    long event_num;           // sequence number of current event

    int run_number;            // which simulation run
    cSimpleModule *backtomod;  // used in cSimpleModule::wait/sendmsg
    cException *exception;     // helper variable to get exceptions back from activity()
    int exception_type;        // helper variable, also for getting exceptions back from activity()

  public:
    // internal: FES
    cMessageHeap msgQueue;     // future messages (FES)

    // internal: things that cannot be done from the constructor of global object
    void init();

    // internal: complements init().
    void shutdown();

  public:

    cSimulation(const cSimulation& r);

    explicit cSimulation(const char *name);

    virtual ~cSimulation();


    virtual cPolymorphic *dup() const  {return new cSimulation(*this);}

    virtual void forEachChild(cVisitor *v);

    virtual void writeContents(std::ostream& os);

    virtual std::string fullPath() const;

    virtual const char *fullPath(char *buffer, int bufsize) const;

    cSimulation& operator=(const cSimulation&)  {copyNotSupported();return *this;}


    int registerModule(cModule *mod);

    void deregisterModule(cModule *mod);

    int lastModuleId() const    {return last_id;}

    cModule *moduleByPath(const char *modulepath) const;

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

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

    void setSystemModule(cModule *p);

    cModule *systemModule() const  {return systemmodp;}


    void setScheduler(cScheduler *sched);

    cScheduler *scheduler() const  {return schedulerp;}

    void loadNedFile(const char *nedfile);

    void setupNetwork(cNetworkType *net,int run_num);

    void startRun();

    void callFinish();

    void endRun();

    void deleteNetwork();


    cNetworkType *networkType() const     {return networktype;}

    // TBD does run number really belong to the simulation kernel? why not in Envir?
    int  runNumber() const           {return run_number;}

    simtime_t simTime() const       {return sim_time;}

    long eventNumber() const         {return event_num;}


    cSimpleModule *selectNextModule();

    cSimpleModule *guessNextModule();

    void doOneEvent(cSimpleModule *m);

    void transferTo(cSimpleModule *p);

    void transferToMain();

    void setContextModule(cModule *p);

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

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

    cSimpleModule *runningModule() const {return runningmodp;}

    cModule *contextModule() const {return contextmodp;}

    int contextType() const {return contexttype;}

    cSimpleModule *contextSimpleModule() const;

    unsigned long getUniqueNumber();

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

};

#endif

---