MessageFrame.h

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <cstring>
#include <vector>
 
#include "Network/Schema/generated/ember_protocol_generated.h"
 
namespace Ember {
namespace Network {
 
constexpr size_t FRAME_HEADER_SIZE = 5;
 
struct MessageFrame {
    uint32_t payloadLength = 0;
    Protocol::MessageType messageType = Protocol::MessageType_Error;
    std::vector<uint8_t> payload;
 
    MessageFrame() = default;
 
    MessageFrame(Protocol::MessageType type, const uint8_t *data, size_t size)
        : payloadLength(static_cast<uint32_t>(size)), messageType(type), payload(data, data + size) {}
 
    MessageFrame(Protocol::MessageType type, std::vector<uint8_t> &&data)
        : payloadLength(static_cast<uint32_t>(data.size())), messageType(type), payload(std::move(data)) {}
 
    std::vector<uint8_t> ToBytes() const {
        std::vector<uint8_t> result;
        result.reserve(FRAME_HEADER_SIZE + payload.size());
 
        result.push_back(static_cast<uint8_t>(payloadLength & 0xFF));
        result.push_back(static_cast<uint8_t>((payloadLength >> 8) & 0xFF));
        result.push_back(static_cast<uint8_t>((payloadLength >> 16) & 0xFF));
        result.push_back(static_cast<uint8_t>((payloadLength >> 24) & 0xFF));
 
        result.push_back(static_cast<uint8_t>(messageType));
 
        result.insert(result.end(), payload.begin(), payload.end());
 
        return result;
    }
 
    static bool ParseHeader(const uint8_t *data, size_t dataSize, uint32_t &outLength, Protocol::MessageType &outType) {
        if (dataSize < FRAME_HEADER_SIZE) {
            return false;
        }
 
        outLength = static_cast<uint32_t>(data[0]) | (static_cast<uint32_t>(data[1]) << 8) |
                    (static_cast<uint32_t>(data[2]) << 16) | (static_cast<uint32_t>(data[3]) << 24);
 
        outType = static_cast<Protocol::MessageType>(data[4]);
 
        return true;
    }
 
    static MessageFrame FromBytes(const uint8_t *data, size_t dataSize) {
        MessageFrame frame;
 
        if (!ParseHeader(data, dataSize, frame.payloadLength, frame.messageType)) {
            return frame;
        }
 
        if (dataSize >= FRAME_HEADER_SIZE + frame.payloadLength) {
            frame.payload.assign(data + FRAME_HEADER_SIZE, data + FRAME_HEADER_SIZE + frame.payloadLength);
        }
 
        return frame;
    }
 
    bool IsValid() const { return payloadLength > 0 && payloadLength == payload.size(); }
 
    size_t TotalSize() const { return FRAME_HEADER_SIZE + payloadLength; }
};
 
} // namespace Network
} // namespace Ember