meshFrame.h

Go to the documentation of this file.

 
#ifndef MESH_FRAME_H
#define MESH_FRAME_H
 
#include "meshPacketFlags.h"
#include "meshVariableArray.h"
 
struct MeshFrame;
 
struct MeshFrameHeader {
    MeshFrameHeader() = default;
 
    MeshFrameHeader(const uint8_t* data, uint8_t dataSize);
    
    MeshFrameControl FrameControl;
 
    MeshMAC BSSID;
 
    uint8_t ID = 0;
 
    inline uint16_t GetUniquePacketID() const {
        return (uint16_t)ID << 8 | Source;
    }
 
    uint8_t Source = INVALID_MESH_ADDRESS;
 
    uint8_t CarriageCount = 0;
 
    inline bool HasError() const {
        return !IS_VALID_MESH_SRC_ADDRESS(Source) || (FrameControl.IsCarriageHeader() && CarriageCount == 0);
    }
 
    void Clear();
 
    inline bool IsSamePacket(const MeshFrameHeader& frameHeader) const {
        return BSSID == frameHeader.BSSID && ID == frameHeader.ID && Source == frameHeader.Source;
    }
 
    inline bool IsSamePacket(const MeshFrame& frame) const;
 
    inline uint8_t GetRawLength() const {
        return 7 + FrameControl.IsCarriageFrame();
    }
 
    inline static uint8_t GetRawLength(bool includeCarriageCount) {
        return 7 + includeCarriageCount;
    }
 
    bool FromRaw(const uint8_t* data, uint8_t dataSize);
 
    bool ToRaw(uint8_t* data, uint8_t& dataSize) const;
};
 
struct MeshFrame {
 
    MeshFrame();
 
    MeshFrame(const uint8_t* data, uint8_t dataSize);
 
    MeshFrame(const MeshFrame& mf);
 
    MeshFrame(MeshFrame&& mf) noexcept;
 
    ~MeshFrame();
 
    MeshFrame& operator=(const MeshFrame& mf);
 
    MeshFrame& operator=(MeshFrame&& mf) noexcept;
 
    MeshFrameHeader FrameHeader;
 
    inline uint8_t Length() const {
        return DataSize;
    }
 
    uint8_t operator [](uint8_t i) const {
        return Data[i];
    }
 
    uint8_t& operator [](uint8_t i) {
        return Data[i];
    }
 
    inline bool HasError() const {
        return FrameHeader.HasError();
    }
 
    inline uint8_t GetRawLength() const {
        return DataSize + FrameHeader.GetRawLength();
    }
 
    bool FromRaw(const uint8_t* data, uint8_t dataSize);
 
    bool ToRaw(uint8_t* data, uint8_t& dataSize) const;
 
    uint8_t GetDataByteAt(uint8_t index) const;
 
    bool SetDataByteAt(uint8_t index, uint8_t value);
 
    bool SetData(const uint8_t* data, const uint8_t dataLength);
 
    void GetData(uint8_t* data, uint8_t& dataLength) const;
 
    bool ResizeData(uint8_t size, bool doNotCopy = false);
 
    void ClearData();
 
    void Clear();
 
    bool copyFrom(const MeshFrame& another);
 
    void moveFrom(MeshFrame& another);
 
    inline const uint8_t* d_ptr() const {
        return Data;
    }
 
    //Operators, that allows setting and reading frame header
    void operator=(const MeshFrameHeader& val) {
        FrameHeader = val;
    }
 
    operator MeshFrameHeader() const { return FrameHeader; }
    operator MeshFrameHeader() { return FrameHeader; }
 
    inline bool IsSamePacket(const MeshFrameHeader& frameHeader) const{
        return FrameHeader.BSSID == frameHeader.BSSID && FrameHeader.ID == frameHeader.ID && FrameHeader.Source == frameHeader.Source;
    }
 
    inline bool IsSamePacket(const MeshFrame& frame) const {
        return IsSamePacket(frame.FrameHeader);
    }
 
protected:
    uint8_t DataSize = 0;
 
    uint8_t* Data = NULL;
};
 
#endif // !MESH_FRAME_H