serialization.ccm

Go to the documentation of this file.

// SPDX-FileType: Source
// SPDX-FileCopyrightText: 2026 Edward Kmett <ekmett@gmail.com>
// SPDX-License-Identifier: BSD-2-Clause OR Apache-2.0

module;
#include <array>
#include <concepts>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <span>
#include <type_traits>
#include <utility>
#include <variant>
#include <vector>
 
export module auth.serialization;
export import auth.error;
 
namespace auth {

export using bytes = std::vector<std::uint8_t>;
 
template<class... Ts>
using variant_tag = std::conditional_t<(sizeof...(Ts) <= 256), std::uint8_t, std::uint32_t>;

export struct writer {
  static constexpr bool reading = false; 
  bytes data; 

  template<std::unsigned_integral T>
  void field(T value) {
    if constexpr (std::same_as<T, bool>) {
      data.push_back(value ? 1 : 0);
    } else {
      for (std::size_t i = 0; i < sizeof(T); ++i)
        data.push_back(static_cast<std::uint8_t>(value >> (i * 8)));
    }
  }

  template<class T, std::size_t N>
  void field(const std::array<T, N>& value) {
    for (const auto& x : value) field(x);
  }

  template<class... Ts>
  void field(const std::variant<Ts...>& value) {
    if (value.valueless_by_exception()) throw auth_error("valueless variant");
    field(static_cast<variant_tag<Ts...>>(value.index()));
    std::visit([this](const auto& x) { this->field(x); }, value);
  }

  template<class T>
  void field(const std::unique_ptr<T>& value) {
    if (!value) throw auth_error("null boxed value");
    field(*value);
  }

  template<class T> requires requires(const T& v, writer& s) { v.serialize(s); }
  void field(const T& value) { value.serialize(*this); }

  template<class... Ts>
  void operator()(const Ts&... values) { (field(values), ...); }
};

export struct reader {
  static constexpr bool reading = true; 
  std::span<const std::uint8_t> data; 
  std::size_t position = 0; 

  template<std::unsigned_integral T>
  void field(T& value) {
    constexpr auto width = std::same_as<T, bool> ? 1 : sizeof(T);
    if (data.size() - position < width) throw auth_error("truncated value");
    if constexpr (std::same_as<T, bool>) {
      const auto byte = data[position++];
      if (byte > 1) throw auth_error("invalid boolean");
      value = byte != 0;
    } else {
      value = 0;
      for (std::size_t i = 0; i < sizeof(T); ++i)
        value |= static_cast<T>(data[position++]) << (i * 8);
    }
  }

  template<class T, std::size_t N>
  void field(std::array<T, N>& value) {
    for (auto& x : value) field(x);
  }

  template<class... Ts>
  void field(std::variant<Ts...>& value) {
    variant_tag<Ts...> tag;
    field(tag);
    if (tag >= sizeof...(Ts)) throw auth_error("invalid variant index");
    alternative(value, tag);
  }

  template<class T>
  void field(std::unique_ptr<T>& value) {
    auto decoded = std::make_unique<T>();
    field(*decoded);
    value = std::move(decoded);
  }

  template<class T> requires requires(T& v, reader& s) { v.serialize(s); }
  void field(T& value) { value.serialize(*this); }

  template<class... Ts>
  void operator()(Ts&... values) { (field(values), ...); }
 
private:
  template<std::size_t I = 0, class... Ts>
  void alternative(std::variant<Ts...>& value, std::size_t tag) {
    if (tag == I) field(value.template emplace<I>());
    else if constexpr (I + 1 < sizeof...(Ts)) alternative<I + 1>(value, tag);
  }
};

export template<class T>
bytes encode(const T& value) {
  writer stream;
  stream(value);
  return std::move(stream.data);
}

export template<class T>
std::pair<T, const std::uint8_t*> decode(std::span<const std::uint8_t> data) {
  T value{};
  reader stream{data};
  stream(value);
  return {std::move(value), data.subspan(stream.position).data()};
}
 
} // namespace auth