packet.hpp

RFID reader 语 tag 模拟器

 #ifndef PACKET_H
 #define PACKET_H

 #include <map>
 #include <iostream>
 #include <iomanip>
 using namespace std;
 #include <boost/shared_ptr.hpp>

 #include "utility.hpp"
 #include "sim_time.hpp"
 #include "node.hpp"

 class PacketData {
 public:
    typedef boost::shared_ptr<PacketData> PacketDataPtr;

    virtual ~PacketData() {}

    static inline PacketDataPtr create()
    {
       PacketDataPtr p(new PacketData());
       return p;
    }

    static inline PacketDataPtr create(const PacketData& rhs)
    {
       return rhs.clone();
    }

    virtual inline t_uint getSizeInBytes() const
    {
       return m_DEFAULT_SIZE_IN_BYTES;
    }

    virtual inline ostream& print(ostream& s) const
    {
       return s << "sizeInBytes=" << getSizeInBytes();
    }

 protected:

    PacketData() {}

    PacketData(const PacketData& rhs) {}

    virtual PacketDataPtr clone() const
    {
       PacketDataPtr p(new PacketData(*this));
       return p;
    }

 private:

    static const t_uint m_DEFAULT_SIZE_IN_BYTES = 32;

    PacketData& operator= (const PacketData& rhs);

 };
 typedef boost::shared_ptr<PacketData> PacketDataPtr;

 class Packet {
 friend ostream& operator<< (ostream& s, const Packet& packet);
 public:
    typedef boost::shared_ptr<Packet> PacketPtr;

    enum DataTypes {
       DataTypes_Physical,
       DataTypes_Link,
       DataTypes_Network,
       DataTypes_Transport,
       DataTypes_Application
    };

    typedef map<DataTypes,PacketDataPtr> DataTypeMap;

    virtual ~Packet();

    static inline PacketPtr create();

    static inline PacketPtr create(const Packet& rhs);

    inline t_uint getSizeInBytes() const;

    inline t_uint getSizeInBits() const;

    inline double getDataRate() const;

    inline void setDataRate(double dataRate);

    inline bool getHasError() const;

    inline void setHasError(bool hasError);

    SimTime getDuration() const;

    void addData(DataTypes dataType, const PacketData& data);

    PacketDataPtr getData(DataTypes dataType);

    bool removeData(DataTypes dataTypes);

    bool hasUpperLayerData(DataTypes dataTypes);

    inline void setDestination(const NodeId& destination);

    inline NodeId getDestination() const;

    inline void setTxPower(double txPower);

    inline double getTxPower() const;

    inline void setDoMaxTxPower(bool doMaxTxPower);

    inline bool getDoMaxTxPower() const;

    inline t_ulong getUniqueId() const;

 protected:

    Packet();

    Packet(const Packet& rhs);

    virtual PacketPtr clone() const;

 private:

    static const t_uint m_DEFAULT_SIZE_IN_BYTES;

    static const double m_DEFAULT_DATA_RATE;

    static const t_uint m_DEFAULT_DESTINATION;

    static t_ulong m_nextUniqueId;

    double m_dataRate;

    double m_txPower;

    bool m_doMaxTxPower;

    bool m_hasError;

    DataTypeMap m_data;

    NodeId m_destination;

    t_ulong m_uniqueId;

    Packet& operator= (const Packet& rhs);

 };

 typedef boost::shared_ptr<Packet> PacketPtr;
 typedef boost::shared_ptr<Packet const> ConstPacketPtr;

 // Inline Functions

 inline PacketPtr Packet::create()
 {
    PacketPtr p(new Packet());
    p->m_uniqueId = Packet::m_nextUniqueId++;
    return p;
 }

 inline PacketPtr Packet::create(const Packet& rhs)
 {
    return rhs.clone();
 }

 inline t_uint Packet::getSizeInBytes() const
 {

    t_uint sizeInBytes = m_DEFAULT_SIZE_IN_BYTES;

    // If data has been added to the packet, then
    // we'll sum up the size of all the data rather
    // than using the default size.
    if(m_data.begin() != m_data.end()) {
       sizeInBytes = 0;
       DataTypeMap::const_iterator p;
       for(p = m_data.begin(); p != m_data.end(); ++p) {
          sizeInBytes += p->second->getSizeInBytes();
       }
    }

    return sizeInBytes;
 }

 inline t_uint Packet::getSizeInBits() const
 {
    return (getSizeInBytes() * 8);
 }

 inline double Packet::getDataRate() const
 {
    return m_dataRate;
 }

 inline void Packet::setDataRate(double dataRate)
 {
    assert(dataRate > 0.0);
    m_dataRate = dataRate;
 }

 inline bool Packet::getHasError() const
 {
    return m_hasError;
 }

 inline void Packet::setHasError(bool hasError)
 {
    m_hasError = hasError;
 }

 inline void Packet::setDestination(const NodeId& destination)
 {
    m_destination = destination;
 }

 inline NodeId Packet::getDestination() const
 {
    return m_destination;
 }

 inline void Packet::setTxPower(double txPower)
 {
    assert(txPower >= 0.0);
    m_txPower = txPower;
 }

 inline double Packet::getTxPower() const
 {
    return m_txPower;
 }

 inline void Packet::setDoMaxTxPower(bool doMaxTxPower)
 {
    m_doMaxTxPower = doMaxTxPower;
 }

 inline bool Packet::getDoMaxTxPower() const
 {
    return m_doMaxTxPower;
 }

 inline t_ulong Packet::getUniqueId() const
 {
    return m_uniqueId;
 }

 // Overloaded Operators

 inline ostream& operator<< (ostream& s,
    const Packet::DataTypes& dataType)
 {
    switch(dataType) {
    case Packet::DataTypes_Physical:
       s << "physical";
       break;
    case Packet::DataTypes_Link:
       s << "link";
       break;
    case Packet::DataTypes_Network:
       s << "network";
       break;
    case Packet::DataTypes_Transport:
       s << "transport";
       break;
    case Packet::DataTypes_Application:
       s << "application";
       break;
    }
    s << "LayerData";
    return s;
 }

 inline ostream& operator<< (ostream& s, const PacketData& data)
 {
    return data.print(s);
 }

 inline ostream& operator<< (ostream& s, const Packet& packet)
 {
    ostringstream powerStream;
    if(packet.getDoMaxTxPower()) {
       powerStream << ", doMaxTxPower=" << boolalpha <<
          packet.getDoMaxTxPower();
    } else {
       powerStream << ", txPower=" << packet.getTxPower();
    }

    // cout << "pointer=" << &packet;
    s << "[ packetState " <<
       "uniqueId=" << packet.getUniqueId() <<
       ", sizeInBytes=" << packet.getSizeInBytes() <<
       powerStream.str() <<
       ", dataRate=" << packet.getDataRate() <<
       ", durationInSeconds=" << setprecision(8) <<
       packet.getDuration() <<
       ", hasError=" << boolalpha << packet.getHasError() << " ]";

    typedef map<Packet::DataTypes,PacketDataPtr> DataTypeMap;
    // Put each of the packet headers in the stream
    if(packet.m_data.begin() != packet.m_data.end()) {
       DataTypeMap::const_iterator p;
       for(p = packet.m_data.begin(); p != packet.m_data.end(); ++p) {
          s << " [ " << p->first << " " << *p->second << " ]";
       }
    }
    return s;
 }

 #endif // PACKET_H