WirePacket.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <span>
 
namespace corium::wire {
 
inline constexpr uint16_t CORIUM_WIRE_MAGIC = 0xC041;
 
[[nodiscard]] constexpr uint16_t calculateCrc16(std::span<const uint8_t> data) noexcept {
    uint16_t crc = 0xFFFF;
    for (uint8_t byte : data) {
        crc ^= static_cast<uint16_t>(byte) << 8;
        for (int i = 0; i < 8; ++i) {
            if (crc & 0x8000) {
                crc = (crc << 1) ^ 0x1021;
            } else {
                crc = crc << 1;
            }
        }
    }
    return crc;
}
 
template <typename T>
[[nodiscard]] constexpr uint8_t computeTypeSignature() noexcept {
    auto sig = static_cast<uint8_t>(sizeof(T) & 0x0F);
    sig |= static_cast<uint8_t>((alignof(T) & 0x0F) << 4);
    return sig;
}
 
inline constexpr uint8_t CORIUM_WIRE_VERSION = 1;
 
#pragma pack(push, 1)
struct WireHeader {
    uint16_t magic{CORIUM_WIRE_MAGIC};
    uint8_t version{CORIUM_WIRE_VERSION};
    uint8_t typeIndex{0};
    uint8_t flags{0};
    uint8_t reserved{0};
    uint16_t payloadLength{0};
    uint16_t checksum{0};
};
#pragma pack(pop)
 
template <size_t MaxPayloadSize = 64>
struct WirePacket {
    WireHeader header{};
    std::array<uint8_t, MaxPayloadSize> payload{};
 
    constexpr WirePacket() = default;
 
    void finalize(uint8_t typeIdx, uint16_t length, uint8_t flags = 0, uint8_t version = CORIUM_WIRE_VERSION) noexcept {
        header.magic = CORIUM_WIRE_MAGIC;
        header.version = version;
        header.typeIndex = typeIdx;
        header.flags = flags;
        header.reserved = 0;
        header.payloadLength = length > MaxPayloadSize ? static_cast<uint16_t>(MaxPayloadSize) : length;
        header.checksum = calculateCrc16(std::span<const uint8_t>(payload.data(), header.payloadLength));
    }
 
    [[nodiscard]] bool isValid() const noexcept {
        if (header.magic != CORIUM_WIRE_MAGIC) {
            return false;
        }
        if (header.version != CORIUM_WIRE_VERSION) {
            return false;
        }
        if (header.payloadLength > MaxPayloadSize) {
            return false;
        }
        uint16_t expected = calculateCrc16(std::span<const uint8_t>(payload.data(), header.payloadLength));
        return header.checksum == expected;
    }
 
    [[nodiscard]] constexpr size_t totalWireSize() const noexcept {
        return sizeof(WireHeader) + header.payloadLength;
    }
};
 
} // namespace corium::wire