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

#include "cmodule.h"

NAMESPACE_BEGIN

class cQueue;
class cCoroutine;

class SIM_API cSimpleModule : public cModule //implies noncopyable
{
    friend class cModule;
    friend class cSimulation;

  private:
    enum {
        FL_USESACTIVITY = 512,   // uses activity() or handleMessage()
        FL_ISTERMINATED = 1024,  // for both activity and handleMessage modules
        FL_STACKALREADYUNWOUND = 2048, // only for activity modules
    };
    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, cGate *ongate, simtime_t t);

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

  protected:

    virtual void activity();

    virtual void handleMessage(cMessage *msg);

  public:
    cSimpleModule(unsigned stacksize = 0);

    cSimpleModule(const char *dummy1, cModule *dummy2, unsigned stacksize);

    virtual ~cSimpleModule();

    virtual std::string info() const;

    virtual void forEachChild(cVisitor *v);


    virtual void scheduleStart(simtime_t t);

    virtual void deleteModule();


    bool usesActivity() const  {return flags&FL_USESACTIVITY;}

    bool isTerminated() const {return flags&FL_ISTERMINATED;}

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


    int send(cMessage *msg, int gateid)  {return sendDelayed(msg, SIMTIME_ZERO, gateid);}

    int send(cMessage *msg, const char *gatename, int gateindex=-1)  {return sendDelayed(msg, SIMTIME_ZERO, gatename, gateindex);}

    int send(cMessage *msg, cGate *outputgate)  {return sendDelayed(msg, SIMTIME_ZERO, outputgate);}

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

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

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

    int sendDirect(cMessage *msg, cModule *mod, const char *inputGateName, int gateIndex=-1);

    int sendDirect(cMessage *msg, cModule *mod, int inputGateId);

    int sendDirect(cMessage *msg, cGate *inputGate);

    int sendDirect(cMessage *msg, simtime_t propagationDelay, simtime_t duration, cModule *mod, const char *inputGateName, int gateIndex=-1);

    int sendDirect(cMessage *msg, simtime_t propagationDelay, simtime_t duration, cModule *mod, int inputGateId);

    int sendDirect(cMessage *msg, simtime_t propagationDelay, simtime_t duration, cGate *inputGate);


    int scheduleAt(simtime_t t, cMessage *msg);

    cMessage *cancelEvent(cMessage *msg);

    void cancelAndDelete(cMessage *msg);


    cMessage *receive();

    cMessage *receive(simtime_t timeout);


    void wait(simtime_t time);

    void waitAndEnqueue(simtime_t time, cQueue *queue);

    void endSimulation();

    void halt();

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


    virtual bool hasStackOverflow() const;

    virtual unsigned getStackSize() const;

    virtual unsigned getStackUsage() const;
};

NAMESPACE_END


#endif