io.hpp

Go to the documentation of this file.

#pragma once
#include <filesystem>
#include <fstream>
#include <type_traits>
#include <vector>
 
#include "NNL/common/exception.hpp"
#include "NNL/common/fixed_type.hpp"
#include "NNL/utility/filesys.hpp"
#include "NNL/utility/math.hpp"
 
namespace nnl {


using Buffer = std::vector<u8>;

class RWBase {
 public:
  virtual void Seek(std::size_t offset) = 0;
  virtual std::size_t Tell() = 0;
  virtual std::size_t Len() = 0;
 
  virtual ~RWBase() = default;
};

class Reader : virtual public RWBase {
 public:
  void ReadBuf(void* dst, std::size_t size) { ReadData(dst, size); }
  template <typename T, typename = std::enable_if_t<std::is_trivially_copyable_v<T>>>
  T ReadLE() {
    T value;
    ReadData(&value, sizeof(T));
    return value;
  }

  template <typename T>
  std::vector<T> ReadArrayLE(std::size_t num_elements) {
    static_assert(std::is_trivially_copyable_v<T>);
    std::vector<T> result;
 
    result.resize(num_elements);
 
    ReadData(result.data(), num_elements * sizeof(T));
 
    return result;
  }
 
  virtual ~Reader() override = default;
 
 protected:
  virtual void ReadData(void* dst, std::size_t size) = 0;
};

class Writer : virtual public RWBase {
 public:
  template <typename T>
  class Offset {
   public:
    auto Get() const { return Ref<T>(*this); }
 
    template <typename M, typename A = T, std::enable_if_t<std::is_class_v<A>, int> = 0>
    auto Get(M A::*member) const {
      return this->Get().Get(member);
    }

    auto operator*() const { return this->Get(); }

    template <typename M, typename A = T, std::enable_if_t<std::is_class_v<A>, int> = 0>
    auto operator->*(M A::*member) const {
      return this->Get(member);
    }

    auto operator[](std::size_t index) const { return *((*this) + index); }

    template <typename Int>
    explicit operator Int() const noexcept {
      static_assert(std::is_integral_v<Int>);
      return static_cast<Int>(offset_);
    }
 
    bool operator==(const Offset& rhs) const = delete;
 
    bool operator!=(const Offset& rhs) const = delete;
 
    Offset& operator++() {
      offset_ += sizeof(T);
      return *this;
    }
 
    Offset operator++(int) {
      Offset prev = *this;
      ++(*this);
      return prev;
    }
 
    Offset& operator+=(std::size_t value) {
      offset_ += sizeof(T) * value;
      return *this;
    }
 
    Offset operator+(std::size_t value) const {
      Offset result = *this;
      result += value;  // Reuse compound assignment
      return result;
    }
 
    Offset& operator--() {
      offset_ -= sizeof(T);
      return *this;
    }
 
    Offset operator--(int) {
      Offset prev = *this;
      --(*this);
      return prev;
    }
 
    Offset& operator-=(std::size_t value) { return *this -= value; }
 
    Offset operator-(std::size_t value) const {
      Offset result = *this;
      result -= value;
      return result;
    }
 
    friend Offset operator+(std::size_t value, const Offset& offset) {
      return Offset{offset.writer_, offset.offset_ + value};
    }
 
    friend Offset operator-(std::size_t value, const Offset& offset) {
      return Offset{offset.writer_, offset.offset_ - value};
    }
 
   private:
    Offset(Writer& writer, std::size_t offset) : writer_(writer), offset_(offset) {}
 
    Writer& writer_;
    std::size_t offset_;
    friend class Writer;
  };  // class Offset

  template <typename T>
  class Ref {
   public:
    template <typename A = T>
    std::enable_if_t<!std::is_array_v<A>, T> Get() const {
      auto prev_offset = off_.writer_.Tell();
      off_.writer_.Seek(off_.offset_);
      auto value = dynamic_cast<Reader&>(off_.writer_).ReadLE<T>();
      off_.writer_.Seek(prev_offset);
      return value;
    }
 
    void Set(const T& value) {
      auto prev_offset = off_.writer_.Tell();
      off_.writer_.Seek(off_.offset_);
      off_.writer_.WriteData(&value, sizeof(T));
      off_.writer_.Seek(prev_offset);
    }
 
    template <typename M, typename A = T, std::enable_if_t<std::is_class_v<A>, int> = 0>
    Ref<M> Get(M A::*member) const {
      std::size_t member_offset = reinterpret_cast<std::size_t>(&(((T*)nullptr)->*member));
      return Ref<M>({off_.writer_, off_.offset_ + member_offset});
    }
 
    template <typename A = T, typename M = std::remove_all_extents_t<A>,
              std::enable_if_t<std::is_array_v<A> && std::rank_v<A> == 1, int> = 0>
    Ref<M> Get(std::size_t index) const {
      return Ref<M>({off_.writer_, off_.offset_ + sizeof(M) * index});
    }
 
    template <typename A = T, typename M = std::remove_extent_t<A>,
              std::enable_if_t<std::is_array_v<A> && std::rank_v<A> != 1, int> = 0>
    Ref<M> Get(std::size_t index) const {
      return Ref<M>({off_.writer_, off_.offset_ + sizeof(M) * index});
    }

    template <typename M, typename A = T, std::enable_if_t<std::is_class_v<A>, int> = 0>
    Ref<M> operator->*(M A::*member) const {
      return Get(member);
    }

    template <typename A = T, typename M = std::remove_all_extents_t<A>,
              std::enable_if_t<std::is_array_v<A> && std::rank_v<A> == 1, int> = 0>
    Ref<M> operator[](std::size_t index) const {
      return Get(index);
    }

    template <typename A = T, typename M = std::remove_extent_t<A>,
              std::enable_if_t<std::is_array_v<A> && std::rank_v<A> != 1, int> = 0>
    Ref<M> operator[](std::size_t index) const {
      return Get(index);
    }

    template <typename A = T, std::enable_if_t<!std::is_array_v<A>, int> = 0>
    operator A() const {
      static_assert(std::is_convertible_v<T, A>);
 
      return Get();
    }

    void operator=(const T& value) { Set(value); }
 
    bool operator==(const Ref& other) const { return this->Get() == other.Get(); }
 
    bool operator!=(const Ref& other) const { return !(*this == other); }
 
    bool operator==(const T& other) const { return this->Get() == other; }
 
    bool operator!=(const T& other) const { return !(*this == other); }
 
   private:
    Ref(Offset<T> offset) : off_(offset) {}
 
    Offset<T> off_;
 
    friend class Writer;
  };  // class Ref

  template <typename T, typename = std::enable_if_t<std::is_trivially_copyable_v<T>>>
  Offset<T> MakeOffsetLE() {
    return Offset<T>(*this, Tell());
  }

  Offset<u8> WriteBuf(const void* src, std::size_t size) {
    auto pos = Tell();
    WriteData(src, size);
    return Offset<u8>(*this, pos);
  }

  template <typename T, std::enable_if_t<std::is_trivially_copyable_v<T>, int> = 0>
  Offset<T> WriteLE(const T& value) {
    auto pos = Tell();
 
    WriteData(&value, sizeof(T));
 
    return Offset<T>(*this, pos);
  }

  template <typename T>
  Offset<T> WriteArrayLE(const std::vector<T>& container) {
    static_assert(std::is_trivially_copyable_v<T>);
 
    auto prev_position = Tell();
 
    WriteData(container.data(), container.size() * sizeof(T));
 
    return Offset<T>(*this, prev_position);
  }

  void AlignData(std::size_t multiple, unsigned char value = 0) {
    auto cur_pos = Tell();
    auto num_bytes = utl::math::RoundNum(cur_pos, multiple) - cur_pos;
    for (std::size_t i = 0; i < num_bytes; i++) WriteLE(value);
  }
 
  virtual ~Writer() override = default;
 
 protected:
  virtual void WriteData(const void* src, std::size_t size) = 0;
};

class FileReader final : public Reader {
 public:
  FileReader(const std::filesystem::path& path) : path_(path) {
    file_stream_.open(path, std::ios::ate | std::ios::in | std::ios::binary);
 
    if (!file_stream_.is_open()) {
      NNL_THROW(nnl::IOError(NNL_SRCTAG(std::strerror(errno)), utl::filesys::u8string(path)));
    }
 
    size_ = file_stream_.tellg();
    file_stream_.seekg(0);
  }
  void Seek(std::size_t offset) override { file_stream_.seekg(offset, std::ios::beg); }
 
  std::size_t Tell() override { return file_stream_.tellg(); }
 
  std::size_t Len() override { return size_; }
  void ClearState() { file_stream_.clear(); }
  void Close() {
    file_stream_.close();
    size_ = 0;
  }
 
 protected:
  void ReadData(void* dst, std::size_t size) override {
    file_stream_.read(static_cast<char*>(dst), size);
    if (!file_stream_) {
      NNL_THROW(nnl::IOError(NNL_SRCTAG("failed to read data"), utl::filesys::u8string(path_)));
    }
  }
 
 private:
  std::filesystem::path path_;
  std::ifstream file_stream_;
  std::size_t size_ = 0;
};

class FileRW final : public Writer, public Reader {
 public:
  FileRW(const std::filesystem::path& path, bool truncate) : path_(path) {
    auto open_mode = std::ios::binary | std::ios::out | std::ios::in;
 
    if (truncate) {
      open_mode |= std::ios::trunc;
    }
 
    file_stream_.open(path, open_mode);
 
    if (!file_stream_.is_open()) {
      NNL_THROW(nnl::IOError(NNL_SRCTAG(std::strerror(errno)), utl::filesys::u8string(path)));
    }
  }
  void Seek(std::size_t offset) override { file_stream_.seekp(offset, std::ios::beg); }
 
  std::size_t Tell() override { return file_stream_.tellp(); }
 
  std::size_t Len() override {
    auto cur_pos = file_stream_.tellp();
    file_stream_.seekp(0, std::ios::end);
    std::size_t size = file_stream_.tellp();
    file_stream_.seekp(cur_pos);
    return size;
  }

  void ClearState() { file_stream_.clear(); }
  void Close() { file_stream_.close(); }
 
 protected:
  void WriteData(const void* src, std::size_t size) override {
    file_stream_.write(static_cast<const char*>(src), size);
    if (!file_stream_) {
      NNL_THROW(nnl::IOError(NNL_SRCTAG("failed to write data"), utl::filesys::u8string(path_)));
    }
  }
 
  void ReadData(void* dst, std::size_t size) override {
    file_stream_.read(static_cast<char*>(dst), size);
    if (!file_stream_) {
      NNL_THROW(nnl::IOError(NNL_SRCTAG("failed to read data"), utl::filesys::u8string(path_)));
    }
  }
 
 private:
  std::filesystem::path path_;
  std::fstream file_stream_;
};

class BufferView final : public Reader {
 public:
  using value_type = u8;
  using iterator = const value_type*;
  using const_iterator = const value_type*;
  using reverse_iterator = std::reverse_iterator<iterator>;
  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
  BufferView() noexcept {}

  BufferView(const void* buffer, std::size_t size) noexcept
      : buffer_ptr_(reinterpret_cast<const u8*>(buffer)), buffer_size_(size) {
    NNL_EXPECTS_DBG(buffer != nullptr || size == 0);
  }

  template <typename TContainer,
            typename = std::enable_if_t<std::is_trivially_copyable_v<typename TContainer::value_type>>>
  BufferView(const TContainer& buffer) noexcept
      : buffer_ptr_(reinterpret_cast<const u8*>(buffer.data())),
        buffer_size_(buffer.size() * sizeof(typename TContainer::value_type)) {}
 
  void Seek(std::size_t offset) override { position_ = offset; }
 
  std::size_t Tell() override { return position_; }
 
  std::size_t Len() override { return buffer_size_; }

  [[nodiscard]] BufferView SubView(std::size_t offset, std::size_t size) const {
    NNL_EXPECTS(offset + size <= buffer_size_);
    return BufferView(buffer_ptr_ + offset, size);
  }
 
  Buffer CopyBuf() const {
    std::vector<u8> copied_buf(buffer_size_);
 
    if (buffer_ptr_ != nullptr && buffer_size_ != 0) std::memcpy(copied_buf.data(), buffer_ptr_, buffer_size_);
 
    return copied_buf;
  }
 
  const u8& operator[](std::size_t index) const {
    NNL_EXPECTS_DBG(index < size());
    return buffer_ptr_[index];
  }
 
  friend bool operator==(const BufferView& lhs, const BufferView& rhs) {
    return (lhs.buffer_size_ == 0 && rhs.buffer_size_ == 0) ||
           (lhs.buffer_size_ == rhs.buffer_size_ &&
            std::memcmp(lhs.buffer_ptr_, rhs.buffer_ptr_, lhs.buffer_size_) == 0);
  }
 
  friend bool operator!=(const BufferView& lhs, const BufferView& rhs) { return !(lhs == rhs); }
 
  std::size_t size() const noexcept { return buffer_size_; }
 
  [[nodiscard]] std::size_t empty() const noexcept { return buffer_size_ == 0; }

  const u8* data() const noexcept { return buffer_ptr_; }
 
  const u8& at(std::size_t index) const {
    NNL_EXPECTS(index < buffer_size_);
    return buffer_ptr_[index];
  }
 
  const u8& front() const {
    NNL_EXPECTS_DBG(buffer_size_ > 0);
    return *begin();
  }
 
  const u8& back() const {
    NNL_EXPECTS_DBG(buffer_size_ > 0);
    return *rbegin();
  }
 
  const_iterator begin() const noexcept { return buffer_ptr_; }
 
  const_iterator end() const noexcept { return buffer_ptr_ + buffer_size_; }
 
  const_reverse_iterator rbegin() const noexcept { return std::make_reverse_iterator(end()); }
 
  const_reverse_iterator rend() const noexcept { return std::make_reverse_iterator(begin()); }
 
 protected:
  void ReadData(void* dst, std::size_t size) override {
    if (position_ + size > this->buffer_size_) {
      NNL_THROW(nnl::IOError(NNL_SRCTAG("Read exceeds buffer size")));
    }
    std::memcpy(dst, buffer_ptr_ + position_, size);
    position_ += size;
  }
 
 private:
  const u8* buffer_ptr_ = nullptr;
  std::size_t buffer_size_ = 0;
  std::size_t position_ = 0;
};

class BufferSpan final : public Reader, public Writer {
 public:
  using value_type = u8;
  using iterator = value_type*;
  using reverse_iterator = std::reverse_iterator<iterator>;
 
  BufferSpan() noexcept {}
  BufferSpan(void* buffer, std::size_t size) noexcept : buffer_ptr_(reinterpret_cast<u8*>(buffer)), buffer_size_(size) {
    NNL_EXPECTS_DBG(buffer != nullptr || size == 0);
  }

  template <typename TContainer,
            typename = std::enable_if_t<std::is_trivially_copyable_v<typename TContainer::value_type>>>
  BufferSpan(TContainer& buffer) noexcept
      : buffer_ptr_(reinterpret_cast<u8*>(buffer.data())),
        buffer_size_(buffer.size() * sizeof(typename TContainer::value_type)) {}
 
  void Seek(std::size_t offset) override { position_ = offset; }
 
  std::size_t Tell() override { return position_; }
 
  std::size_t Len() override { return buffer_size_; }

  void Clear(u8 val = 0) {
    if (buffer_ptr_ != nullptr) std::memset(buffer_ptr_, val, buffer_size_);
  }

  [[nodiscard]] BufferView SubView(std::size_t offset, std::size_t size) const {
    NNL_EXPECTS(offset + size <= buffer_size_);
 
    return BufferView(buffer_ptr_ + offset, size);
  }

  [[nodiscard]] BufferSpan SubSpan(std::size_t offset, std::size_t size) {
    NNL_EXPECTS(offset + size <= buffer_size_);
 
    return BufferSpan(buffer_ptr_ + offset, size);
  }
 
  Buffer CopyBuf() const {
    std::vector<u8> copy(buffer_size_);
    if (buffer_ptr_ != nullptr && buffer_size_ != 0) std::memcpy(copy.data(), buffer_ptr_, buffer_size_);
    return copy;
  }

  operator BufferView() const noexcept { return BufferView(buffer_ptr_, buffer_size_); }
 
  u8& operator[](std::size_t index) {
    NNL_EXPECTS_DBG(index < Len());
    return buffer_ptr_[index];
  }
 
  friend bool operator==(const BufferSpan& lhs, const BufferSpan& rhs) {
    return (lhs.buffer_size_ == 0 && rhs.buffer_size_ == 0) ||
           (lhs.buffer_size_ == rhs.buffer_size_ &&
            std::memcmp(lhs.buffer_ptr_, rhs.buffer_ptr_, lhs.buffer_size_) == 0);
  }
 
  friend bool operator!=(const BufferSpan& lhs, const BufferSpan& rhs) { return !(lhs == rhs); }
 
  std::size_t size() const noexcept { return buffer_size_; }
 
  [[nodiscard]] std::size_t empty() const noexcept { return buffer_size_ == 0; }
  u8* data() noexcept { return buffer_ptr_; }
 
  u8& at(std::size_t index) {
    NNL_EXPECTS(index < buffer_size_);
    return buffer_ptr_[index];
  }
 
  u8& front() {
    NNL_EXPECTS_DBG(buffer_size_ > 0);
    return *begin();
  }
 
  u8& back() {
    NNL_EXPECTS_DBG(buffer_size_ > 0);
    return *rbegin();
  }
 
  iterator begin() noexcept { return buffer_ptr_; }
 
  iterator end() noexcept { return buffer_ptr_ + buffer_size_; }
 
  reverse_iterator rbegin() noexcept { return std::make_reverse_iterator(end()); }
 
  reverse_iterator rend() noexcept { return std::make_reverse_iterator(begin()); }
 
 protected:
  void ReadData(void* dst, std::size_t size) override {
    if (position_ + size > this->buffer_size_) {
      NNL_THROW(nnl::IOError(NNL_SRCTAG("Read exceeds buffer size")));
    }
    std::memcpy(dst, buffer_ptr_ + position_, size);
    position_ += size;
  }
 
  void WriteData(const void* src, std::size_t size) override {
    if (position_ + size > this->buffer_size_) {
      NNL_THROW(nnl::IOError(NNL_SRCTAG("Write exceeds buffer size")));
    }
    std::memcpy(buffer_ptr_ + position_, src, size);
    position_ += size;
  }
 
 private:
  u8* buffer_ptr_ = nullptr;
  std::size_t buffer_size_ = 0;
  std::size_t position_ = 0;
};

class BufferRW final : public Writer, public Reader {
 public:
  BufferRW() {}
 
  BufferRW(const BufferRW& buf) : buffer_(buf.buffer_), position_(buf.position_) {}
 
  BufferRW(BufferRW&& buf) noexcept : buffer_(std::move(buf.buffer_)), position_(buf.position_) { buf.position_ = 0; }
 
  BufferRW(const Buffer& buf) : buffer_(buf) {}
 
  BufferRW(Buffer&& buf) noexcept : buffer_(std::move(buf)) {}
 
  BufferRW& operator=(const BufferRW& buf) {
    if (this != &buf) {
      buffer_ = buf.buffer_;
      position_ = buf.position_;
    }
    return *this;
  }
 
  BufferRW& operator=(BufferRW&& buf) noexcept {
    if (this != &buf) {
      buffer_ = std::move(buf.buffer_);
      position_ = buf.position_;
      buf.position_ = 0;
    }
    return *this;
  }
 
  void Seek(std::size_t offset) override { position_ = offset; }
 
  std::size_t Tell() override { return position_; }
 
  std::size_t Len() override { return buffer_.size(); }
  Buffer CopyBuf() const { return buffer_; }

  [[nodiscard]] Buffer ReleaseBuf() noexcept {
    position_ = 0;
    return std::move(buffer_);
  }
 
  operator Buffer() const { return buffer_; }

  operator Buffer&&() && noexcept {
    position_ = 0;
    return std::move(buffer_);
  }
 
 protected:
  void WriteData(const void* src, std::size_t size) override {
    if (position_ + size > buffer_.size()) buffer_.resize(position_ + size);
 
    std::memcpy(buffer_.data() + position_, src, size);
    position_ += size;
  }
 
  void ReadData(void* dst, std::size_t size) override {
    if (position_ + size > this->buffer_.size()) {
      NNL_THROW(nnl::IOError(NNL_SRCTAG("Read exceeds buffer size")));
    }
    std::memcpy(dst, buffer_.data() + position_, size);
    position_ += size;
  }
 
 private:
  Buffer buffer_;
  std::size_t position_ = 0;
};

 
}  // namespace nnl