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 cModule;
struct SendOptions;
 
struct SIM_API ChannelResult
{
    bool discard = false;              
    simtime_t delay = SIMTIME_ZERO;    
    simtime_t duration = SIMTIME_ZERO; 
    simtime_t remainingDuration = SIMTIME_ZERO; 
};
 
class SIM_API cChannel : public cComponent //implies noncopyable
{
    friend class cModule; // for setting prevSibling/nextSibling
  protected:
    cGate *srcGate = nullptr; // gate the channel is attached to
    int nedConnectionElementId = -1;  // 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;
 
    // internal: calls preDelete() recursively
    virtual void callPreDelete(cComponent *root) override;
 
  protected:
    virtual cModule *doFindModuleByPath(const char *s) const override;
 
  public:
    typedef ChannelResult Result;
 
    class MessageSentSignalValue : public cITimestampedValue, public cObject
    {
      public:
        simtime_t timestamp;
        cMessage *msg;
        Result *result;
      private:
        void error() const;
      public:
        MessageSentSignalValue(simtime_t_cref t, cMessage *m, Result *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 *getChannelResult() const {return result;}
 
        virtual bool boolValue(simsignal_t signalID) const override {error(); return false;}
        virtual intval_t intValue(simsignal_t signalID) const override {error(); return 0;}
        virtual uintval_t uintValue(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 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 Result processMessage(cMessage *msg, const SendOptions& options, simtime_t t) = 0;
 
    virtual double getNominalDatarate() const = 0;
 
    virtual simtime_t calculateDuration(cMessage *msg) const = 0;
 
    virtual simtime_t getTransmissionFinishTime() const = 0;
 
    virtual bool isBusy() const;
 
    [[deprecated]] virtual void forceTransmissionFinishTime(simtime_t t) {}
 
    virtual bool isDisabled() const  { return false; }
};
 
 
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 Result processMessage(cMessage *msg, const SendOptions& options, simtime_t t) override {return Result();}
 
    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;}
};
 
}  // namespace omnetpp
 
 
#endif