writer_reader.hpp

#pragma once
 
#include <cstdint>
#include <cstring>
#include <string_view>
 
class Writer::CodeReader
{
 public:
  explicit CodeReader(const uint8_t* codes) : pos_(codes), base_(codes)
  {
  }
 
  [[nodiscard]] FormatOp ReadOp() { return static_cast<FormatOp>(*pos_++); }
 
  template <typename T>
  [[nodiscard]] T Read()
  {
    T value{};
    std::memcpy(&value, pos_, sizeof(T));
    pos_ += sizeof(T);
    return value;
  }
 
  [[nodiscard]] FormatType ReadFormatType() { return static_cast<FormatType>(*pos_++); }
 
  [[nodiscard]] Spec ReadSpec()
  {
    return Spec{.flags = *pos_++,
                .fill = static_cast<char>(*pos_++),
                .width = *pos_++,
                .precision = *pos_++};
  }
 
  [[nodiscard]] std::string_view ReadInlineText()
  {
    auto text = reinterpret_cast<const char*>(pos_);
    size_t size = std::strlen(text);
    pos_ += size + 1;
    return std::string_view(text, size);
  }
 
  [[nodiscard]] std::string_view ReadTextRef()
  {
    auto offset = Read<uint16_t>();
    auto size = Read<uint16_t>();
    auto text = reinterpret_cast<const char*>(base_ + offset);
    return std::string_view(text, size);
  }
 
 private:
  const uint8_t* pos_ = nullptr;
  const uint8_t* base_ = nullptr;
};
 
class Writer::ArgumentReader
{
 public:
  explicit ArgumentReader(const uint8_t* data) : pos_(data) {}
 
  template <typename T>
  [[nodiscard]] T Read()
  {
    T value{};
    std::memcpy(&value, pos_, sizeof(T));
    pos_ += sizeof(T);
    return value;
  }
 
 private:
  const uint8_t* pos_ = nullptr;
};