HdlcdPacketEndpoint.h

Go to the documentation of this file.

#ifndef HDLCD_PACKET_ENDPOINT_H
#define HDLCD_PACKET_ENDPOINT_H

#include <iostream>
#include <memory>
#include <utility>
#include <boost/asio.hpp>
#include "FrameEndpoint.h"
#include "HdlcdPacketData.h"
#include "HdlcdPacketCtrl.h"
#include <assert.h>

class HdlcdPacketEndpoint: public std::enable_shared_from_this<HdlcdPacketEndpoint> {
public:
    HdlcdPacketEndpoint(boost::asio::io_service& a_IOService, std::shared_ptr<FrameEndpoint> a_FrameEndpoint): m_IOService(a_IOService), m_FrameEndpoint(a_FrameEndpoint), m_KeepAliveTimer(a_IOService) {
        // Checks
        assert(m_FrameEndpoint);

        // Initialize remaining components
        m_bStarted = false;
        m_bStopped = false;
        m_FrameEndpoint->ResetFrameFactories(0xF0); // 0xF0 = type byte filter regarding the HLDCd access protocol specification
        m_FrameEndpoint->RegisterFrameFactory(HDLCD_PACKET_DATA, []()->std::shared_ptr<Frame>{ return HdlcdPacketData::CreateDeserializedPacket(); });
        m_FrameEndpoint->RegisterFrameFactory(HDLCD_PACKET_CTRL, []()->std::shared_ptr<Frame>{ return HdlcdPacketCtrl::CreateDeserializedPacket(); });
        m_FrameEndpoint->SetOnFrameCallback([this](std::shared_ptr<Frame> a_Frame)->bool{ return OnFrame(a_Frame); });
        m_FrameEndpoint->SetOnClosedCallback ([this](){ OnClosed(); });
    }
    
    ~HdlcdPacketEndpoint() {
        m_OnDataCallback   = nullptr;
        m_OnCtrlCallback   = nullptr;
        m_OnClosedCallback = nullptr;
        Close();
    }
            
    // Callback methods
    void SetOnDataCallback(std::function<bool(std::shared_ptr<const HdlcdPacketData> a_PacketData)> a_OnDataCallback) {
        m_OnDataCallback = a_OnDataCallback;
    }
    
    void SetOnCtrlCallback(std::function<void(const HdlcdPacketCtrl& a_PacketCtrl)> a_OnCtrlCallback) {
        m_OnCtrlCallback = a_OnCtrlCallback;
    }
    
    void SetOnClosedCallback(std::function<void()> a_OnClosedCallback) {
        m_OnClosedCallback = a_OnClosedCallback;
    }
    
    bool Send(const Frame& a_Frame, std::function<void()> a_OnSendDoneCallback = nullptr) {
        return (m_FrameEndpoint->SendFrame(a_Frame, a_OnSendDoneCallback));
    }
    
    void Start() {
        assert(m_bStarted == false);
        assert(m_bStopped == false);
        m_bStarted = true;
        auto self(shared_from_this());
        if (m_FrameEndpoint->GetWasStarted()) {
            m_IOService.post([this, self](){ m_FrameEndpoint->TriggerNextFrame(); });
        } else {
            m_IOService.post([this, self](){ m_FrameEndpoint->Start(); });
        } // else

        StartKeepAliveTimer();
    }

    void Shutdown() {
        m_FrameEndpoint->Shutdown();
        m_KeepAliveTimer.cancel();
    }

    void Close() {
        if (m_bStarted && (!m_bStopped)) {
            m_bStopped = true;
            m_KeepAliveTimer.cancel();
            m_FrameEndpoint->Close();
            if (m_OnClosedCallback) {
                m_OnClosedCallback();
            } // if
        } // if
    }
    
    void TriggerNextDataPacket() {
        m_FrameEndpoint->TriggerNextFrame();
    }

private:
    void StartKeepAliveTimer() {
        auto self(shared_from_this());
        m_KeepAliveTimer.expires_from_now(boost::posix_time::minutes(1));
        m_KeepAliveTimer.async_wait([this, self](const boost::system::error_code& a_ErrorCode) {
            if (!a_ErrorCode) {
                // Periodically send keep alive packets
                m_FrameEndpoint->SendFrame(HdlcdPacketCtrl::CreateKeepAliveRequest());
                StartKeepAliveTimer();
            } // if
        }); // async_wait
    }

private:
    // Members
    void OnClosed() {
        Close();
    }
    
    bool OnFrame(std::shared_ptr<Frame> a_Frame) {
        // Reception completed, deliver the packet
        bool l_bReceiving = true;
        auto l_PacketData = std::dynamic_pointer_cast<HdlcdPacketData>(a_Frame);
        if (l_PacketData) {
            if (m_OnDataCallback) {
                // Deliver the data packet but stall the receiver
                l_bReceiving = m_OnDataCallback(l_PacketData);
            } // if
        } else {
            auto l_PacketCtrl = std::dynamic_pointer_cast<HdlcdPacketCtrl>(a_Frame);
            if (l_PacketCtrl) {
                bool l_bDeliver = true;
                if (l_PacketCtrl->GetPacketType() == HdlcdPacketCtrl::CTRL_TYPE_KEEP_ALIVE) {
                    // This is a keep alive packet, simply drop it.
                    l_bDeliver = false;
                } // if
                
                if ((l_bDeliver) && (m_OnCtrlCallback)) {
                    m_OnCtrlCallback(*(l_PacketCtrl.get()));
                } // if
            } else {
                assert(false);
            } // else
        } // else
        
        return l_bReceiving;
    }
    
    boost::asio::io_service& m_IOService;
    std::shared_ptr<FrameEndpoint> m_FrameEndpoint;
    
    
    // All possible callbacks for a user of this class
    std::function<bool(std::shared_ptr<const HdlcdPacketData> a_PacketData)> m_OnDataCallback;
    std::function<void(const HdlcdPacketCtrl& a_PacketCtrl)> m_OnCtrlCallback;
    std::function<void()> m_OnClosedCallback;
    
    bool m_bStarted;
    bool m_bStopped;
    
    // The keep alive timer
    boost::asio::deadline_timer m_KeepAliveTimer;
};

#endif // HDLCD_PACKET_ENDPOINT_H