crunch.hpp

#pragma once
 
#include <array>
#include <concepts>
#include <crunch/crunch_detail.hpp>
#include <crunch/fields/crunch_enum.hpp>
#include <crunch/fields/crunch_string.hpp>
#include <crunch/integrity/crunch_integrity.hpp>
#include <crunch/messages/crunch_messages.hpp>
#include <crunch/serdes/crunch_serdes.hpp>
#include <crunch/serdes/crunch_static_layout.hpp>
#include <cstddef>
#include <cstdint>
#include <expected>
#include <optional>
#include <span>
 
namespace Crunch {
 
// Expose Buffer, IsBuffer, and Decoder from detail namespace
using detail::Buffer;
using detail::Decoder;
using detail::IsBuffer;
 
template <messages::CrunchMessage Message, typename Integrity, typename Serdes>
    requires IntegrityPolicy<Integrity> && SerdesPolicy<Serdes, Message>
// cppcheck-suppress unusedFunction
[[nodiscard]] constexpr auto GetBuffer() noexcept {
    constexpr std::size_t N =
        detail::GetBufferSize<Message, Integrity, Serdes>();
    return Buffer<Message, Integrity, Serdes, N>{};
}
 
template <messages::CrunchMessage Message>
[[nodiscard]] constexpr auto Validate(const Message& message) noexcept
    -> std::optional<Error> {
    return detail::Validate(message);
}
 
template <typename BufferType, typename Message>
    requires IsBuffer<BufferType> && messages::CrunchMessage<Message> &&
             std::same_as<typename BufferType::MessageType, Message>
[[nodiscard]] constexpr auto Serialize(BufferType& buffer,
                                       const Message& message) noexcept
    -> std::optional<Error> {
    using Serdes = typename BufferType::SerdesType;
    using Integrity = typename BufferType::IntegrityType;
    auto res = detail::Serialize<Integrity, Serdes>(buffer.data, message);
    if (!res) {
        return res.error();
    }
    buffer.used_bytes = *res;
    return std::nullopt;
}
 
template <typename BufferType, typename Message>
    requires IsBuffer<BufferType> && messages::CrunchMessage<Message> &&
             std::same_as<typename BufferType::MessageType, Message>
constexpr void SerializeWithoutValidation(BufferType& buffer,
                                          const Message& message) noexcept {
    using Serdes = typename BufferType::SerdesType;
    using Integrity = typename BufferType::IntegrityType;
    buffer.used_bytes = detail::SerializeWithoutValidation<Integrity, Serdes>(
        buffer.data, message);
}
 
template <typename BufferType, typename Message>
    requires IsBuffer<BufferType> && messages::CrunchMessage<Message> &&
             std::same_as<typename BufferType::MessageType, Message>
[[nodiscard]] constexpr auto Deserialize(const BufferType& buffer,
                                         Message& out_message)
    -> std::optional<Error> {
    using Serdes = typename BufferType::SerdesType;
    using Integrity = typename BufferType::IntegrityType;
    return detail::Deserialize<Integrity, Serdes>(
        buffer.serialized_message_span(), out_message);
}
 
}  // namespace Crunch