mac_protocol.hpp

RFID reader 语 tag 模拟器

 #ifndef MAC_PROTOCOL_H
 #define MAC_PROTOCOL_H

 #include <boost/shared_ptr.hpp>

 #include "timer.hpp"
 #include "simulation_end_listener.hpp"

 class LinkLayer;
 typedef boost::shared_ptr<LinkLayer> LinkLayerPtr;

 class MacProtocol : public SimulationEndListener {
 friend class SendToLinkLayerEvent;
 public:
    typedef boost::shared_ptr<MacProtocol> MacProtocolPtr;
    typedef boost::shared_ptr<SimulationEndListener>
       SimulationEndListenerPtr;

    virtual ~MacProtocol();

    virtual MacProtocolPtr thisMacProtocol() = 0;

    virtual SimulationEndListenerPtr thisSimulationEndListener() = 0;

    bool startSendTimer(
       CommunicationLayer::Directions direction, PacketPtr packet,
       const SimTime& delay);

    virtual bool recvFromLinkLayer(
       CommunicationLayer::Directions direction, PacketPtr packet,
       t_uint sendingLayerIdx);

    virtual bool handleRecvdMacPacket(PacketPtr packet,
       t_uint sendingLayerIdx) = 0;

    virtual bool handleRecvdUpperLayerPacket(PacketPtr packet,
       t_uint sendingLayerIdx) = 0;

    virtual void handleChannelBusy(PacketPtr packet) = 0;

    virtual void handlePacketSent(PacketPtr packet) = 0;

    void setLinkLayer(LinkLayerPtr linkLayer);

    inline NodePtr getNode() const
    {
       return m_node;
    }

 protected:

    MacProtocol(NodePtr node);

    bool sendToLinkLayer(
       CommunicationLayer::Directions direction, PacketPtr packet);

    void blockUpperQueues();

    void unblockUpperQueues();

    bool getQueueIsBlocked() const;

    TimerPtr m_sendTimer;

    boost::weak_ptr<LinkLayer> m_linkLayer;

 private:

    NodePtr m_node;

 };
 typedef boost::shared_ptr<MacProtocol> MacProtocolPtr;

 // SlottedMac Class

 class SlottedMac : public MacProtocol {
 friend class SlottedMacSlotEvent;
 public:
    typedef boost::shared_ptr<SlottedMac> SlottedMacPtr;

    virtual ~SlottedMac() {};

 protected:

    static const double m_DEFAULT_SLOT_TIME;

    TimerPtr m_slotTimer;

    t_uint m_currentSlotNumber;

    t_uint m_txSlotNumber;

    t_uint m_numberOfSlots;

    PacketPtr m_packetToTransmit;

    SlottedMac(NodePtr node)
       : MacProtocol(node), m_currentSlotNumber(0),
       m_txSlotNumber(0), m_numberOfSlots(0)
    { }

    virtual void beginSlotEvent() = 0;

    inline void setSlotTime(const SimTime& slotTime)
    {
       m_slotTime = slotTime;
    }

    inline SimTime getSlotTime() const
    {
       return m_slotTime;
    }

    inline bool inContentionCycle() const
    {
       return (m_currentSlotNumber < m_numberOfSlots);
    }

    inline void stopContentionCycle()
    {
       m_currentSlotNumber = 0;
       m_numberOfSlots = 0;
    }

 private:

    SimTime m_slotTime;

 };
 typedef boost::shared_ptr<SlottedMac> SlottedMacPtr;

 // Event Subclasses

 class SlottedMacSlotEvent : public Event {
 public:
    typedef boost::shared_ptr<SlottedMacSlotEvent> SlottedMacSlotEventPtr;

    static inline SlottedMacSlotEventPtr create(
       SlottedMacPtr slottedMac)
    {
       SlottedMacSlotEventPtr p(new SlottedMacSlotEvent(slottedMac));
       return p;
    }

    void execute()
    {
       m_slottedMac->beginSlotEvent();
    }

 protected:

    SlottedMacSlotEvent(SlottedMacPtr slottedMac)
       : Event()
    {
       m_slottedMac = slottedMac;
    }
 private:
    SlottedMacPtr m_slottedMac;
 };
 typedef boost::shared_ptr<SlottedMacSlotEvent> SlottedMacSlotEventPtr;

 class SendToLinkLayerEvent : public Event {
 public:
    typedef boost::shared_ptr<SendToLinkLayerEvent>
       SendToLinkLayerEventPtr;

    static inline SendToLinkLayerEventPtr create(
       MacProtocolPtr macProtocol,
       CommunicationLayer::Directions direction, PacketPtr packet)
    {
       SendToLinkLayerEventPtr p(new SendToLinkLayerEvent(
          macProtocol, direction, packet));
       return p;
    }

    void execute()
    {
       m_macProtocol->sendToLinkLayer(m_direction, m_packet);
    }

 protected:
    SendToLinkLayerEvent(MacProtocolPtr macProtocol,
       CommunicationLayer::Directions direction, PacketPtr packet)
       : Event(), m_macProtocol(macProtocol), m_direction(direction),
       m_packet(packet)
    {

    }
 private:
    MacProtocolPtr m_macProtocol;
    CommunicationLayer::Directions m_direction;
    PacketPtr m_packet;
 };
 typedef boost::shared_ptr<SendToLinkLayerEvent> SendToLinkLayerEventPtr;

 #endif // MAC_PROTOCOL_H