csimplemodule.h

//==========================================================================
//   CSIMPLEMODULE.H  -  header for
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//
//  Declaration of the following classes:
//    cSimpleModule  : base for simple module objects
//
//==========================================================================

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

#include "cmodule.h"


class SIM_API cSimpleModule : public cModule
{
    friend class cModule;
    friend class cSimulation;
    friend class TSimpleModInspector;

  private:
    bool usesactivity;      // uses activity() or handleMessage()
    int state;              // ended/ready/waiting for msg
    opp_string phasestr;    // a 'phase' string
    cMessage *timeoutmsg;   // msg used in wait() and receive() with timeout
    cCoroutine *coroutine;

    static bool stack_cleanup_requested; // 'true' value asks activity() to throw a cStackCleanupException
    static cSimpleModule *after_cleanup_transfer_to; // transfer back to this module (or to main)

  private:
    // internal use
    static void activate(void *p);

  protected:
    // internal use
    virtual void arrived(cMessage *msg,int n,simtime_t t);

    // internal: sets the module id.
    virtual void setId(int n);

  protected:

    virtual void activity();

    virtual void handleMessage(cMessage *msg);

  public:

    cSimpleModule(const cSimpleModule& mod);

    cSimpleModule(const char *name, cModule *parentmod, unsigned stk);

    virtual ~cSimpleModule();

    cSimpleModule& operator=(const cSimpleModule& mod);


    virtual cObject *dup() const  {return new cSimpleModule(*this);}

    virtual std::string info() const;

    virtual void forEachChild(cVisitor *v);


    virtual void scheduleStart(simtime_t t);

    virtual void deleteModule();


    bool usesActivity() const  {return usesactivity;}


    simtime_t simTime() const;   // cannot make inline because of declaration order!


    void setPhase(const char *phase)  {phasestr=phase;}

    const char *phase() const  {return phasestr.c_str();}

    bool snapshot(cObject *obj=&simulation, const char *label=NULL); // write snapshot file

    void breakpoint(const char *label);     // user breakpoint

    void pause(const char *phase=NULL);


    int send(cMessage *msg, int gateid);   // send a message thru gate id

    int send(cMessage *msg, const char *gatename, int sn=-1); // s:gate name, sn:index

    int send(cMessage *msg, cGate *outputgate);

    int sendDelayed(cMessage *msg, double delay, int gateid);

    int sendDelayed(cMessage *msg, double delay, const char *gatename, int sn=-1);

    int sendDelayed(cMessage *msg, double delay, cGate *outputgate);

    int sendDirect(cMessage *msg, double delay, cModule *mod, int inputgateid);

    int sendDirect(cMessage *msg, double delay, cModule *mod, const char *inputgatename, int sn=-1);

    int sendDirect(cMessage *msg, double delay, cGate *inputgate);


    int scheduleAt(simtime_t t, cMessage *msg);

    cMessage *cancelEvent(cMessage *msg);


    cMessage *receive();

    cMessage *receive(simtime_t timeout);


    void wait(simtime_t time);

    void waitAndEnqueue(simtime_t time, cQueue *queue);


    void end();

    void endSimulation();

    void error(const char *fmt,...) const;


    void recordScalar(const char *name, double value);


    virtual bool stackOverflow() const;

    virtual unsigned stackSize() const;

    virtual unsigned stackUsage() const;

    int moduleState() const {return state;}
};

#endif

---