cpacket.h

//==========================================================================
//   CPACKET.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_CPACKET_H
#define __OMNETPP_CPACKET_H
 
#include "cmessage.h"
 
namespace omnetpp {
 
 
class SIM_API cPacket : public cMessage
{
  private:
    enum {
        FL_BITERROR = 8, // has bit errors
        FL_TXCHANNELSEEN = 16, // encountered a transmission channel during its last send
        FL_ISUPDATE = 32, // if true, this packet is a transmission update
    };
 
    int64_t bitLength;    // length of the packet in bits -- used for bit error and transmission delay modeling
    simtime_t duration;   // transmission duration on last channel with datarate
    cPacket *encapsulatedPacket = nullptr; // ptr to the encapsulated message
    unsigned short shareCount = 0; // num of messages MINUS ONE that have this message encapsulated.
                                   // 0: not shared (not encapsulated or encapsulated in one message);
                                   // 1: shared once (shared among two messages);
                                   // 2: shared twice (shared among three messages); etc.
                                   // on reaching max sharecount a new packet gets created
    txid_t transmissionId = -1;  // for pairing transmission updates with the original transmission
    simtime_t remainingDuration; // if transmission update: remaining duration (otherwise it must be equal to the duration)
 
  private:
    void copy(const cPacket& packet);
 
  public:
    // internal: setters used from within send()/sendDirect() and channel code
    void setDuration(simtime_t d) {duration = d;}
    void setRemainingDuration(simtime_t d) {remainingDuration = d;}
    void setTransmissionId(txid_t id) {transmissionId = id;}
    void setIsUpdate(bool b) {setFlag(FL_ISUPDATE, b);}
    void setTxChannelEncountered(bool b) {setFlag(FL_TXCHANNELSEEN, b);}
    void clearTxChannelEncountered() {flags &= ~FL_TXCHANNELSEEN;}
    void setTxChannelEncountered() {flags |= FL_TXCHANNELSEEN;}
 
    // internal (for now)
    bool getTxChannelEncountered() const {return flags&FL_TXCHANNELSEEN;}
 
    // internal convenience method: returns the getId() of the innermost encapsulated message,
    // or itself if there is no encapsulated message
    msgid_t getEncapsulationId() const;
 
    // internal convenience method: returns getTreeId() of the innermost encapsulated message,
    // or itself if there is no encapsulated message
    msgid_t getEncapsulationTreeId() const;
 
    cPacket *_getEncapMsg() { return encapsulatedPacket; }
 
    // internal: if encapmsg is shared (sharecount>0), creates a private copy for this packet,
    // and in any case it sets encapmsg's owner to be this object. This method
    // has to be called before any operation on encapmsg, to prevent trouble
    // that may arise from accessing shared message instances. E.g. without calling
    // _detachEncapMsg(), encapmsg's ownerp is unpredictable (may be any previous owner,
    // possibly not even existing any more) which makes even a call to its getFullPath()
    // method dangerous.
    void _detachEncapMsg();
 
    // internal: delete encapmsg, paying attention to its sharecount (assumes encapmsg!=nullptr)
    void _deleteEncapMsg();
 
    // internal: only to be used by test cases
    int getShareCount() const {return shareCount;}
 
  public:
    cPacket(const cPacket& packet);
 
    explicit cPacket(const char *name=nullptr, short kind=0, int64_t bitLength=0);
 
    virtual ~cPacket();
 
    cPacket& operator=(const cPacket& packet);
 
 
    virtual cPacket *dup() const override  {return new cPacket(*this);}
 
    virtual std::string str() const override;
 
    virtual void forEachChild(cVisitor *v) override;
 
    virtual void parsimPack(cCommBuffer *buffer) const override;
 
    virtual void parsimUnpack(cCommBuffer *buffer) override;
 
    virtual bool isPacket() const override {return true;}
 
    virtual const char *getDisplayString() const override;
 
    virtual void setBitLength(int64_t l);
 
    void setByteLength(int64_t l)  {setBitLength(l<<3);}
 
    virtual void addBitLength(int64_t delta);
 
    void addByteLength(int64_t delta)  {addBitLength(delta<<3);}
 
    virtual int64_t getBitLength() const  {return bitLength;}
 
    int64_t getByteLength() const  {return (getBitLength()+7)>>3;}
 
    virtual void setBitError(bool e) {setFlag(FL_BITERROR,e);}
 
    virtual bool hasBitError() const {return flags&FL_BITERROR;}
 
 
    virtual void encapsulate(cPacket *packet);
 
    virtual cPacket *decapsulate();
 
    virtual cPacket *getEncapsulatedPacket() const;
 
    virtual bool hasEncapsulatedPacket() const;
 
    bool isUpdate() const {return flags&FL_ISUPDATE;}
 
    txid_t getTransmissionId() const {return transmissionId;}
 
    simtime_t_cref getDuration() const {return duration;}
 
    simtime_t_cref getRemainingDuration() const {return remainingDuration;}
 
    bool isReceptionStart() const {return duration == remainingDuration;}
 
    bool isReceptionEnd() const {return remainingDuration.isZero();}
};
 
}  // namespace omnetpp
 
#endif