cmessage.h

//==========================================================================
//   CMESSAGE.H  -  header for
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//
//  Declaration of the following classes:
//    cMessage : message and event object
//
//==========================================================================

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

#include <time.h>
#include "cobject.h"
#include "carray.h"
#include "cpar.h"
#include "csimul.h"

//=== classes mentioned:
class cPar;
class cGate;
class cChannel;
class cModule;
class cSimpleModule;
class cCompoundModule;
class cSimulation;
class cMessageHeap;


enum eMessageKind
{
  MK_STARTER = -1,  
  MK_TIMEOUT = -2,  
  MK_PACKET  = -3,  
  MK_INFO    = -4,  

  MK_PARSIM_BEGIN = -1000  
};

//==========================================================================

class SIM_API cMessage : public cObject
{
    friend class cMessageHeap;

  private:
    int msgkind;               // message kind -- <0 reserved, 0>= user-defined meaning
    int prior;                 // priority -- used for scheduling msgs with equal times
    long len;                  // length of message -- used for bit errors and transm.delay
    bool error : 1;            // bit error occurred during transmission
    unsigned char refcount : 7;// reference count for encapsulated message (0: not encapsulated, max 127)
    unsigned char srcprocid;   // reserved for use by parallel execution: id of source partition
    cArray *parlistp;          // ptr to list of parameters
    cMessage *encapmsg;        // ptr to encapsulated msg
    cPolymorphic *ctrlp;       // ptr to "control info"
    void *contextptr;          // a stored pointer -- user-defined meaning, used with self-messages

    int frommod,fromgate;      // source module and gate IDs -- set internally
    int tomod,togate;          // dest. module and gate IDs -- set internally
    simtime_t created;         // creation time -- set be constructor
    simtime_t sent,delivd;     // time of sending & delivery -- set internally
    simtime_t tstamp;          // time stamp -- user-defined meaning

    int heapindex;             // used by cMessageHeap (-1 if not on heap)
    unsigned long insertordr;  // used by cMessageHeap

    // helper function
    void _createparlist();

    // global variables for statistics
    static long total_msgs;
    static long live_msgs;

  public:

    cMessage(const cMessage& msg);

    explicit cMessage(const char *name=NULL, int k=0, long len=0, int pri=0, bool err=false);

    virtual ~cMessage();

    cMessage& operator=(const cMessage& msg);


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

    virtual std::string info() const;

    virtual void forEachChild(cVisitor *v);

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

    virtual void netPack(cCommBuffer *buffer);

    virtual void netUnpack(cCommBuffer *buffer);


    void setKind(int k)     {msgkind=k;}

    void setPriority(int p) {prior=p;}

    void setLength(long l);

    void addLength(long delta);

    void setBitError(bool err) {error=err;}

    void setTimestamp() {tstamp=simulation.simTime();}

    void setTimestamp(simtime_t t) {tstamp=t;}

    void setContextPointer(void *p) {contextptr=p;}

    void setControlInfo(cPolymorphic *p);

    cPolymorphic *removeControlInfo();

    int  kind() const     {return msgkind;}

    int  priority() const {return prior;}

    long length() const   {return len;}

    bool hasBitError() const {return error;}

    simtime_t timestamp() const {return tstamp;}

    unsigned long insertOrder() const {return insertordr;}

    void *contextPointer() const {return contextptr;}

    cPolymorphic *controlInfo() const {return ctrlp;}


    cArray& parList()
        {if (!parlistp) _createparlist(); return *parlistp;}

    cPar& addPar(const char *s)  {cPar *p=new cPar(s);parList().add(p);return *p;}

    cPar& addPar(cPar *p)  {parList().add(p); return *p;}

    cPar& addPar(cPar& p)  {parList().add(&p); return p;}

    cPar& par(int n);

    cPar& par(const char *s);

    int findPar(const char *s) const;

    bool hasPar(const char *s) const {return findPar(s)>=0;}

    cObject *addObject(cObject *p)  {parList().add(p); return p;}

    cObject *getObject(const char *s)  {return parList().get(s);}

    bool hasObject(const char *s)  {return !parlistp ? false : parlistp->find(s)>=0;}

    cObject *removeObject(const char *s)  {return parList().remove(s);}

    cObject *removeObject(cObject *p)  {return parList().remove(p);}


    void encapsulate(cMessage *msg);

    cMessage *decapsulate();

    cMessage *encapsulatedMsg() const {return encapmsg;}


    bool isSelfMessage() const {return togate==-1;}

    bool isScheduled() const {return heapindex!=-1;}

    cGate *senderGate() const;

    cGate *arrivalGate() const;

    int senderModuleId() const {return frommod;}

    int senderGateId() const   {return fromgate;}

    int arrivalModuleId() const {return tomod;}

    int arrivalGateId() const  {return togate;}

    simtime_t creationTime() const {return created;}

    simtime_t sendingTime()  const {return sent;}

    simtime_t arrivalTime()  const {return delivd;}

    bool arrivedOn(int g) const {return g==togate;}

    bool arrivedOn(const char *s, int g=0);


    virtual void setSentFrom(cModule *module, int gate, simtime_t t);

    virtual void setArrival(cModule *module, int gate);

    virtual void setArrival(cModule *module, int gate, simtime_t t);

    virtual void setArrivalTime(simtime_t t);

    void setSrcProcId(unsigned char procId) {srcprocid=procId;}

    unsigned char srcProcId() {return srcprocid;}


    virtual const char *displayString() const;

    static int cmpbydelivtime(cObject *one, cObject *other);

    static int cmpbypriority(cObject *one, cObject *other);

    static long totalMessageCount() {return total_msgs;}

    static long liveMessageCount() {return live_msgs;}

    static void resetMessageCounters()  {total_msgs=live_msgs=0;}
};

#endif

---