cchannel.h

//==========================================================================
//   CCHANNEL.H  -  header for
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//
//  Declaration of the following classes:
//    cChannel : channel class
//
//==========================================================================

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

#include "ccomponent.h"
#include "ccomponenttype.h"
#include "cmessage.h"
#include "ctimestampedvalue.h"

NAMESPACE_BEGIN

class cGate;


class SIM_API cChannel : public cComponent //implies noncopyable
{
  protected:
    cGate *srcgatep; // gate the channel is attached to
    int nedConnectionElementId;  // for cChannel::getProperties(); usually the NED connection element's id

  public:
    // internal: called from cGate
    void setSourceGate(cGate *g) {srcgatep=g;}

    // internal: sets/gets nedConnectionElementId
    void setNedConnectionElementId(int id) {nedConnectionElementId = id;}
    int getNedConnectionElementId() {return nedConnectionElementId;}

    // internal: called from callInitialize(). Does one stage for this
    // channel, and returns true if there are more stages to do
    virtual bool initializeChannel(int stage);

    // internal: overridden to perform additional checks
    virtual void finalizeParameters();

  public:
    struct result_t
    {
        result_t() : delay(SIMTIME_ZERO), duration(SIMTIME_ZERO), discard(false) {}
        simtime_t delay;     
        simtime_t duration;  
        bool discard;        
    };

    class MessageSentSignalValue : public cITimestampedValue, public cObject
    {
      public:
        simtime_t timestamp;
        cMessage *msg;
        result_t *result;
      public:
        MessageSentSignalValue(simtime_t_cref t, cMessage *m, result_t *r) {timestamp=t; msg=m; result=r;}

        virtual simtime_t_cref getTimestamp(simsignal_t signalID) const {return timestamp;}

        virtual SimsignalType getValueType(simsignal_t signalID) const {return SIMSIGNAL_OBJECT;}

        virtual cObject *objectValue(simsignal_t signalID) const {return msg;}

        cMessage *getMessage() const {return msg;}

        result_t *getChannelResult() const {return result;}

        virtual bool boolValue(simsignal_t signalID) const {error(); return false;}
        virtual long longValue(simsignal_t signalID) const {error(); return 0;}
        virtual unsigned long unsignedLongValue(simsignal_t signalID) const {error(); return 0;}
        virtual double doubleValue(simsignal_t signalID) const {error(); return 0;}
        virtual SimTime simtimeValue(simsignal_t signalID) const {error(); return timestamp;}
        virtual const char *stringValue(simsignal_t signalID) const {error(); return NULL;}
        void error() const;
    };

  public:
    explicit cChannel(const char *name=NULL);

    virtual ~cChannel();

    virtual std::string info() const;

    virtual void forEachChild(cVisitor *v);

    virtual void parsimPack(cCommBuffer *buffer);

    virtual void parsimUnpack(cCommBuffer *buffer);

    virtual void callInitialize();

    virtual bool callInitialize(int stage);

    virtual void callFinish();

    virtual cModule *getParentModule() const;

    cChannelType *getChannelType() const  {return (cChannelType *)getComponentType();}

    virtual cProperties *getProperties() const;

    cGate *getSourceGate() const  {return srcgatep;}

    virtual bool isTransmissionChannel() const = 0;

    virtual void processMessage(cMessage *msg, simtime_t t, result_t& result) = 0;

    virtual double getNominalDatarate() const = 0;

    virtual simtime_t calculateDuration(cMessage *msg) const = 0;

    virtual simtime_t getTransmissionFinishTime() const = 0;

    virtual bool isBusy() const;

    virtual void forceTransmissionFinishTime(simtime_t t) = 0;
};


class SIM_API cIdealChannel : public cChannel //implies noncopyable
{
  public:
    explicit cIdealChannel(const char *name=NULL) : cChannel(name) {}

    virtual ~cIdealChannel() {}

    static cIdealChannel *create(const char *name);

    virtual void processMessage(cMessage *msg, simtime_t t, result_t& result) {}

    virtual double getNominalDatarate() const {return 0;}

    virtual bool isTransmissionChannel() const {return false;}

    virtual simtime_t calculateDuration(cMessage *msg) const {return SIMTIME_ZERO;}

    virtual simtime_t getTransmissionFinishTime() const {return SIMTIME_ZERO;}

    virtual bool isBusy() const {return false;}

    virtual void forceTransmissionFinishTime(simtime_t t) {}
};

NAMESPACE_END


#endif