packet.hpp

#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

---