crunch_types.hpp

#pragma once
 
#include <cstdint>
#include <string_view>
 
namespace Crunch {
 
using FieldId = int32_t;
 
static constexpr FieldId MaxFieldId = (1 << 29) - 1;
 
using MessageId = int32_t;
 
enum class Format : uint8_t {
    Packed = 0x01,    
    Aligned4 = 0x02,  
    Aligned8 = 0x03,  
    TLV = 0x04,       
};
 
using CrunchVersionId = uint8_t;
 
static constexpr std::size_t StandardHeaderSize =
    sizeof(CrunchVersionId) + sizeof(Format) + sizeof(MessageId);
 
static constexpr CrunchVersionId CrunchVersion = 0x03;
 
enum class ErrorCode : uint8_t {
    UNKNOWN = 0,           
    IntegrityCheckFailed,  
    DeserializationError,  
    ValidationFailed,      
    InvalidMessageId,      
    InvalidFormat,         
    CapacityExceeded,      
};
 
struct Error {
    ErrorCode code;  
    // cppcheck-suppress unusedStructMember
    FieldId field_id{0};  
    // cppcheck-suppress unusedStructMember
    std::string_view message{};  
 
    [[nodiscard]] static constexpr Error integrity() noexcept {
        return {ErrorCode::IntegrityCheckFailed, 0, "integrity check failed"};
    }
 
    template <size_t N>
    [[nodiscard]] static constexpr Error validation(
        FieldId id, const char (&msg)[N]) noexcept {
        return {ErrorCode::ValidationFailed, id, std::string_view{msg, N - 1}};
    }
 
    [[nodiscard]] static constexpr Error deserialization(
        std::string_view msg = "deserialization error") noexcept {
        return {ErrorCode::DeserializationError, 0, msg};
    }
 
    [[nodiscard]] static constexpr Error invalid_message_id() noexcept {
        return {ErrorCode::InvalidMessageId, 0, "invalid message id"};
    }
 
    [[nodiscard]] static constexpr Error invalid_format() noexcept {
        return {ErrorCode::InvalidFormat, 0, "invalid serialization format"};
    }
 
    template <size_t N>
    [[nodiscard]] static constexpr Error capacity_exceeded(
        FieldId id, const char (&msg)[N]) noexcept {
        return {ErrorCode::CapacityExceeded, id, std::string_view{msg, N - 1}};
    }
 
    [[nodiscard]] constexpr bool operator==(const Error& other) const noexcept =
        default;
 
    [[nodiscard]] constexpr bool operator==(ErrorCode c) const noexcept {
        return code == c;
    }
};
 
}  // namespace Crunch