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_ISRECEPTIONSTART = 8,
        FL_BITERROR = 16,
    };

    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; // ptr to the encapsulated message
    unsigned short shareCount; // 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

  private:
    void copy(const cPacket& packet);

  public:
    // internal: sets the message duration; called by channel objects and sendDirect
    void setDuration(simtime_t d) {duration = d;}

    // internal: sets the isReceptionStart() flag
    void setReceptionStart(bool b) {setFlag(FL_ISRECEPTIONSTART, b);}

    // internal convenience method: returns the getId() of the innermost encapsulated message,
    // or itself if there is no encapsulated message
    long getEncapsulationId() const;

    // internal convenience method: returns getTreeId() of the innermost encapsulated message,
    // or itself if there is no encapsulated message
    long 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;

    simtime_t_cref getDuration() const {return duration;}

    bool isReceptionStart() const {return flags & FL_ISRECEPTIONSTART;}
};

}  // namespace omnetpp

#endif