rfid_tag_mac.hpp

#ifndef RFID_TAG_MAC_H
#define RFID_TAG_MAC_H

#include <boost/shared_ptr.hpp>

#include "simulator.hpp"
#include "mac_protocol.hpp"
#include "packet.hpp"

class RfidReaderMacData;
typedef boost::shared_ptr<RfidReaderMacData> RfidReaderMacDataPtr;
class RfidTagApp;
typedef boost::shared_ptr<RfidTagApp> RfidTagAppPtr;

// PacketData Subclass

class RfidTagMacData : public PacketData {
public:
   typedef boost::shared_ptr<RfidTagMacData> RfidTagMacDataPtr;

   enum Types {
      Types_Generic, 
      Types_Reply 
   };

   static inline RfidTagMacDataPtr create();

   static inline RfidTagMacDataPtr create(
      const RfidTagMacData& rhs);

   virtual inline t_uint getSizeInBytes() const;

   void setSenderId(const NodeId& nodeId);

   NodeId getSenderId() const;

   void setReceiverId(const NodeId& nodeId);

   NodeId getReceiverId() const;

   inline void setType(Types type);

   inline Types getType() const;

   inline ostream& print(ostream& s) const;

protected:

   RfidTagMacData();

   RfidTagMacData(const RfidTagMacData& rhs);

   virtual PacketDataPtr clone() const;

private:

   static const t_uint m_senderIdBytes = 12;

   static const t_uint m_receiverIdBytes = 4;

   static const t_uint m_typeBytes = 1;

   t_uchar m_senderId[m_senderIdBytes];

   t_uchar m_receiverId[m_receiverIdBytes];

   Types m_type;

};
typedef boost::shared_ptr<RfidTagMacData> RfidTagMacDataPtr;

// RfidTagMac Class

class RfidTagMac : public SlottedMac {
public:
   typedef boost::shared_ptr<RfidTagMac> RfidTagMacPtr;

   virtual ~RfidTagMac();

   static inline RfidTagMacPtr create(NodePtr node, 
      RfidTagAppPtr tagApp);

   virtual inline RfidTagMacPtr thisRfidTagMac();

   virtual inline SlottedMacPtr thisSlottedMac();

   virtual inline MacProtocolPtr thisMacProtocol();

   virtual inline SimulationEndListenerPtr thisSimulationEndListener();

   virtual void simulationEndHandler();

   bool handleRecvdMacPacket(PacketPtr packet, 
      t_uint sendingLayerIdx);

   bool handleRecvdUpperLayerPacket(PacketPtr packet, 
      t_uint sendingLayerIdx);

   virtual void handleChannelBusy(PacketPtr packet);

   virtual void handlePacketSent(PacketPtr packet);

protected:

   static const double m_TAG_GENERIC_IFS;

   static const double m_TAG_REPLY_IFS;

   RfidTagAppPtr m_tagApp;

   RfidTagMac(NodePtr node, RfidTagAppPtr tagApp);

   virtual void beginSlotEvent();

   bool handleRequestPacket(RfidReaderMacDataPtr macData, 
      t_uint sendingLayerIdx);

   PacketPtr createReplyPacket(NodeId receiverId) const;

   void addGenericHeader(PacketPtr packet, NodeId receiverId) const;

   bool packetIsForMe(RfidReaderMacDataPtr macData) const;

   bool isPacketType(PacketPtr packet, 
      RfidTagMacData::Types type) const;

private:

   static const bool m_DEBUG = true;

   boost::weak_ptr<RfidTagMac> m_weakThis;

};
typedef boost::shared_ptr<RfidTagMac> RfidTagMacPtr;

// Inline Functions

inline RfidTagMacPtr RfidTagMac::create(NodePtr node, 
   RfidTagAppPtr tagApp)
{
   RfidTagMacPtr p(new RfidTagMac(node, tagApp));
   // weakThis *must* be set before the this* functions are called.
   p->m_weakThis = p;

   SlottedMacSlotEventPtr slotEvent = 
      SlottedMacSlotEvent::create(p->thisSlottedMac());
   p->m_slotTimer = Timer::create(p->getNode(), slotEvent);
   p->m_slotTimer->start(SimTime(0.0));

   Simulator::instance()->addSimulationEndListener(
      p->thisSimulationEndListener());

   return p;
}

inline RfidTagMacPtr RfidTagMac::thisRfidTagMac()
{
   RfidTagMacPtr p(m_weakThis);
   return p;
}

inline SlottedMacPtr RfidTagMac::thisSlottedMac()
{
   SlottedMacPtr p(m_weakThis);
   return p;
}

inline MacProtocolPtr RfidTagMac::thisMacProtocol()
{
   MacProtocolPtr p(m_weakThis);
   return p;
}

inline SimulationEndListenerPtr RfidTagMac::thisSimulationEndListener()
{
   SimulationEndListenerPtr p(m_weakThis);
   return p;
}

// Overloaded Operators

// RfidTagMacData Inline Functions

inline RfidTagMacDataPtr RfidTagMacData::create()
{
   RfidTagMacDataPtr p(new RfidTagMacData());
   return p;
}

inline RfidTagMacDataPtr RfidTagMacData::create(const RfidTagMacData& rhs)
{
   RfidTagMacDataPtr p = 
      boost::dynamic_pointer_cast<RfidTagMacData>(rhs.clone());
   // If the shared_ptr is empty, then the cast failed.
   assert(p.get() != 0);
   return p;
}

inline void RfidTagMacData::setType(RfidTagMacData::Types type)
{
   m_type = type;
}

inline RfidTagMacData::Types RfidTagMacData::getType() const
{
   return m_type;
}


inline t_uint RfidTagMacData::getSizeInBytes() const
{
   return (m_senderIdBytes + m_receiverIdBytes + m_typeBytes);
}

// Overloaded Operators

inline ostream& operator<< (ostream& s, 
      const RfidTagMacData::Types& dataType)
{
   switch(dataType) {
   case RfidTagMacData::Types_Generic:
      s << "GENERIC";
      break;
   case RfidTagMacData::Types_Reply:
      s << "REPLY";
      break;
   }
   return s;
}

inline ostream& RfidTagMacData::print(ostream& s) const
{
   s << "type=" << m_type << ", " <<
      "senderId=" << 
      NodeId(m_senderId, m_senderIdBytes) << ", " <<
      "receiverId=" << 
      NodeId(m_receiverId, m_receiverIdBytes);
   return s;
}


#endif // RFID_TAG_MAC_H

---