cchannel.h

//==========================================================================
//   CCHANNEL.H  -  header for
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//==========================================================================

/*--------------------------------------------------------------*
  Copyright (C) 1992-2017 Andras Varga
  Copyright (C) 2006-2017 OpenSim Ltd.

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

#ifndef __OMNETPP_CCHANNEL_H
#define __OMNETPP_CCHANNEL_H

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

namespace omnetpp {

class cGate;


class SIM_API cChannel : public cComponent //implies noncopyable
{
  protected:
    cGate *srcGate; // 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) {srcGate=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() override;

    // internal: calls refreshDisplay() recursively
    virtual void callRefreshDisplay() override;

  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;
      private:
        void error() const;
      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 override {return timestamp;}

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

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

        cMessage *getMessage() const {return msg;}

        result_t *getChannelResult() const {return result;}

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

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

    virtual ~cChannel();

    virtual std::string str() const override;

    virtual void parsimPack(cCommBuffer *buffer) const override;

    virtual void parsimUnpack(cCommBuffer *buffer) override;

    virtual void callInitialize() override;

    virtual bool callInitialize(int stage) override;

    virtual void callFinish() override;

    virtual ComponentKind getComponentKind() const override  {return KIND_CHANNEL;}

    virtual cModule *getParentModule() const override;

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

    virtual cProperties *getProperties() const override;

    virtual cGate *getSourceGate() const  {return srcGate;}

    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=nullptr) : cChannel(name) {}

    virtual ~cIdealChannel() {}

    static cIdealChannel *create(const char *name);

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

    virtual double getNominalDatarate() const override {return 0;}

    virtual bool isTransmissionChannel() const override {return false;}

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

    virtual simtime_t getTransmissionFinishTime() const override {return SIMTIME_ZERO;}

    virtual bool isBusy() const override {return false;}

    virtual void forceTransmissionFinishTime(simtime_t t) override {}
};

}  // namespace omnetpp


#endif