HdlcdSessionHeader.h

Go to the documentation of this file.

#ifndef HDLCD_SESSION_HEADER_H
#define HDLCD_SESSION_HEADER_H

#include "Frame.h"
#include <memory>
#include <string>
#include "HdlcdSessionDescriptor.h"

class HdlcdSessionHeader: public Frame {
public:
    static HdlcdSessionHeader Create(HdlcdSessionDescriptor a_HdlcdSessionDescriptor, const std::string& a_SerialPortName) {
        // Called for transmission
        HdlcdSessionHeader l_HdlcdSessionHeader;
        l_HdlcdSessionHeader.m_ServiceAccessPointSpecifier = a_HdlcdSessionDescriptor;
        l_HdlcdSessionHeader.m_SerialPortName = a_SerialPortName;
        return l_HdlcdSessionHeader;
    }

    static std::shared_ptr<HdlcdSessionHeader> CreateDeserializedFrame() {
        // Called on reception
        auto l_HdlcdSessionHeader(std::shared_ptr<HdlcdSessionHeader>(new HdlcdSessionHeader));
        l_HdlcdSessionHeader->m_eDeserialize = DESERIALIZE_HEADER; // Next: read fixed-sized part of the session header
        l_HdlcdSessionHeader->m_BytesRemaining = 3;
        return l_HdlcdSessionHeader;
    }
    
    uint8_t GetServiceAccessPointSpecifier() const {
        assert(m_eDeserialize == DESERIALIZE_FULL);
        return m_ServiceAccessPointSpecifier;
    }

    const std::string& GetSerialPortName() const {
        assert(m_eDeserialize == DESERIALIZE_FULL);
        return m_SerialPortName;
    }

private:
    HdlcdSessionHeader(): m_ServiceAccessPointSpecifier(0x00), m_eDeserialize(DESERIALIZE_FULL) {
    }

    const std::vector<unsigned char> Serialize() const {
        assert(m_eDeserialize == DESERIALIZE_FULL);
        std::vector<unsigned char> l_Buffer;
        l_Buffer.emplace_back(0x00); // Version
        l_Buffer.emplace_back(m_ServiceAccessPointSpecifier);
        l_Buffer.emplace_back(m_SerialPortName.size());
        l_Buffer.insert(l_Buffer.end(), m_SerialPortName.data(), (m_SerialPortName.data() + m_SerialPortName.size()));
        return l_Buffer;
    }

    bool Deserialize() {
        // All requested bytes are available
        switch (m_eDeserialize) {
        case DESERIALIZE_HEADER: {
            // Deserialize the length field
            assert(m_Buffer.size() == 3);

            // Deserialize the version field
            if (m_Buffer[0] != 0) {
                // Wrong version field
                m_eDeserialize = DESERIALIZE_ERROR;
                return false;
            } // if
            
            // Deserialize the service access point identifier and the length field of the serial port name
            m_ServiceAccessPointSpecifier = m_Buffer[1];
            m_BytesRemaining = m_Buffer[2];
            m_Buffer.clear();
            if (m_BytesRemaining) {
                m_eDeserialize = DESERIALIZE_BODY;
            } else {
                // An empty serial port specifier... may happen
                m_eDeserialize = DESERIALIZE_FULL;
            } // else

            break;
        }
        case DESERIALIZE_BODY: {
            // Read of payload completed
            m_SerialPortName.append(m_Buffer.begin(), m_Buffer.end());
            m_eDeserialize = DESERIALIZE_FULL;
            break;
        }
        case DESERIALIZE_ERROR:
        case DESERIALIZE_FULL:
        default:
            assert(false);
        } // switch
        
        // No error
        return true;
    }
    
    // Internal members
    uint8_t m_ServiceAccessPointSpecifier; 
    std::string m_SerialPortName;          
    
    typedef enum {
        DESERIALIZE_ERROR  = 0,            
        DESERIALIZE_HEADER = 1,            
        DESERIALIZE_BODY   = 2,            
        DESERIALIZE_FULL   = 3             
    } E_DESERIALIZE;
    E_DESERIALIZE m_eDeserialize;          
};

#endif // HDLCD_SESSION_HEADER_H