BinaryReader.hpp

#ifndef INTNS_IO_BINARY_READER_HPP
#define INTNS_IO_BINARY_READER_HPP
 
#include <bit>
#include <cstdint>
#include <cstring>
#include <fstream>
#include <span>
#include <stdexcept>
#include <string>
#include <vector>
 
#include "IoTypes.hpp"
 
namespace intns::io {
 
template <Endianness E = Endianness::kLittle>
class MemoryReader {
 public:
  explicit MemoryReader(const std::vector<uint8_t>& buffer, size_t position = 0)
      : data_(buffer.data()), size_(buffer.size()), position_(position) {
    if (position > size_) {
      throw std::out_of_range("Initial position " + std::to_string(position) +
                              " exceeds buffer size " + std::to_string(size_));
    }
  }
 
  explicit MemoryReader(std::span<const uint8_t> buffer, size_t position = 0)
      : data_(buffer.data()), size_(buffer.size()), position_(position) {
    if (position > size_) {
      throw std::out_of_range("Initial position " + std::to_string(position) +
                              " exceeds buffer size " + std::to_string(size_));
    }
  }
 
  [[nodiscard]] size_t size() const noexcept { return size_; }
 
  [[nodiscard]] size_t position() const noexcept { return position_; }
 
  [[nodiscard]] size_t remaining() const noexcept { return size_ - position_; }
 
  void set_position(size_t pos) noexcept {
    if (pos > size_) pos = size_;
    position_ = pos;
  }
 
  void skip(size_t bytes) noexcept {
    position_ = std::min(position_ + bytes, size_);
  }
 
  [[nodiscard]] uint8_t read_u8() {
    if (position_ >= size_) {
      throw std::out_of_range("Cannot read uint8_t: position " +
                              std::to_string(position_) + " >= size " +
                              std::to_string(size_));
    }
    return data_[position_++];
  }
 
  [[nodiscard]] uint16_t read_u16() {
    if (position_ + 2 > size_) {
      throw std::out_of_range("Cannot read uint16_t: need 2 bytes, only " +
                              std::to_string(remaining()) + " available");
    }
    uint16_t value;
    std::memcpy(&value, data_ + position_, 2);
    position_ += 2;
    if constexpr (E != native_endian()) value = bswap_16(value);
    return value;
  }
 
  [[nodiscard]] uint32_t read_u32() {
    if (position_ + 4 > size_) {
      throw std::out_of_range("Cannot read uint32_t: need 4 bytes, only " +
                              std::to_string(remaining()) + " available");
    }
    uint32_t value;
    std::memcpy(&value, data_ + position_, 4);
    position_ += 4;
    if constexpr (E != native_endian()) value = bswap_32(value);
    return value;
  }
 
  [[nodiscard]] uint64_t read_u64() {
    if (position_ + 8 > size_) {
      throw std::out_of_range("Cannot read uint64_t: need 8 bytes, only " +
                              std::to_string(remaining()) + " available");
    }
    uint64_t value;
    std::memcpy(&value, data_ + position_, 8);
    position_ += 8;
    if constexpr (E != native_endian()) value = bswap_64(value);
    return value;
  }
 
  [[nodiscard]] int8_t read_s8() { return static_cast<int8_t>(read_u8()); }
 
  [[nodiscard]] int16_t read_s16() { return static_cast<int16_t>(read_u16()); }
 
  [[nodiscard]] int32_t read_s32() { return static_cast<int32_t>(read_u32()); }
 
  [[nodiscard]] int64_t read_s64() { return static_cast<int64_t>(read_u64()); }
 
  [[nodiscard]] float read_f32() { return std::bit_cast<float>(read_u32()); }
 
  [[nodiscard]] double read_f64() { return std::bit_cast<double>(read_u64()); }
 
  void read_bytes(void* dest, size_t bytes) {
    if (!dest) {
      throw std::invalid_argument("Destination pointer cannot be null");
    }
    if (position_ + bytes > size_) {
      throw std::out_of_range("Cannot read " + std::to_string(bytes) +
                              " bytes: only " + std::to_string(remaining()) +
                              " available");
    }
    std::memcpy(dest, data_ + position_, bytes);
    position_ += bytes;
  }
 
  void read_u16_array(uint16_t* array, size_t count) {
    if (!array) {
      throw std::invalid_argument("Array pointer cannot be null");
    }
    read_bytes(array, count * 2);
    if constexpr (E != native_endian()) {
      for (size_t i = 0; i < count; ++i) {
        array[i] = bswap_16(array[i]);
      }
    }
  }
 
  void read_u32_array(uint32_t* array, size_t count) {
    if (!array) {
      throw std::invalid_argument("Array pointer cannot be null");
    }
    read_bytes(array, count * 4);
    if constexpr (E != native_endian()) {
      for (size_t i = 0; i < count; ++i) {
        array[i] = bswap_32(array[i]);
      }
    }
  }
 
  [[nodiscard]] std::string read_string(size_t length) {
    if (position_ + length > size_) {
      throw std::out_of_range("Cannot read string of length " +
                              std::to_string(length) + ": only " +
                              std::to_string(remaining()) + " bytes available");
    }
    std::string result(reinterpret_cast<const char*>(data_ + position_),
                       length);
    position_ += length;
    return result;
  }
 
  [[nodiscard]] std::string read_cstring() {
    const uint8_t* start = data_ + position_;
    const uint8_t* end =
        static_cast<const uint8_t*>(std::memchr(start, 0, remaining()));
 
    if (!end) {
      // No null terminator - read to end
      end = data_ + size_;
    }
 
    size_t length = end - start;
    std::string result(reinterpret_cast<const char*>(start), length);
    position_ += length + (end < data_ + size_ ? 1 : 0);
    return result;
  }
 
  [[nodiscard]] uint8_t peek_u8() const {
    if (position_ >= size_) {
      throw std::out_of_range("Cannot peek uint8_t: position " +
                              std::to_string(position_) + " >= size " +
                              std::to_string(size_));
    }
    return data_[position_];
  }
 
  [[nodiscard]] uint16_t peek_u16() const {
    if (position_ + 2 > size_) {
      throw std::out_of_range("Cannot peek uint16_t: need 2 bytes, only " +
                              std::to_string(size_ - position_) + " available");
    }
    uint16_t value;
    std::memcpy(&value, data_ + position_, 2);
    if constexpr (E != native_endian()) value = bswap_16(value);
    return value;
  }
 
 private:
  static constexpr Endianness native_endian() noexcept {
    return std::endian::native == std::endian::little ? Endianness::kLittle
                                                      : Endianness::kBig;
  }
 
  const uint8_t* data_;  
  size_t size_;          
  size_t position_;      
};
 
template <Endianness E = Endianness::kLittle>
class FileReader {
 public:
  explicit FileReader(const std::string& filename, size_t buffer_size = 8192)
      : buffer_(buffer_size) {
    if (buffer_size == 0) {
      throw std::invalid_argument("Buffer size cannot be zero");
    }
 
    file_.open(filename, std::ios::binary);
    if (!file_) {
      throw std::runtime_error("Failed to open file: " + filename);
    }
 
    file_.seekg(0, std::ios::end);
    file_size_ = file_.tellg();
    file_.seekg(0);
 
    fill_buffer();
  }
 
  [[nodiscard]] size_t size() const noexcept { return file_size_; }
 
  [[nodiscard]] size_t position() const noexcept {
    return file_pos_ - buffer_remaining();
  }
 
  [[nodiscard]] size_t remaining() const noexcept {
    return file_size_ - position();
  }
 
  void set_position(size_t pos) {
    if (pos > file_size_) pos = file_size_;
    file_.seekg(pos);
    if (!file_) {
      throw std::runtime_error("Failed to seek to position " +
                               std::to_string(pos));
    }
    file_pos_ = pos;
    fill_buffer();
  }
 
  void skip(size_t bytes) { set_position(position() + bytes); }
 
  [[nodiscard]] uint8_t read_u8() {
    ensure_available(1);
    return buffer_[buffer_pos_++];
  }
 
  [[nodiscard]] uint16_t read_u16() {
    ensure_available(2);
    uint16_t value;
    std::memcpy(&value, &buffer_[buffer_pos_], 2);
    buffer_pos_ += 2;
    if constexpr (E != native_endian()) value = bswap_16(value);
    return value;
  }
 
  [[nodiscard]] uint32_t read_u32() {
    ensure_available(4);
    uint32_t value;
    std::memcpy(&value, &buffer_[buffer_pos_], 4);
    buffer_pos_ += 4;
    if constexpr (E != native_endian()) value = bswap_32(value);
    return value;
  }
 
  [[nodiscard]] uint64_t read_u64() {
    ensure_available(8);
    uint64_t value;
    std::memcpy(&value, &buffer_[buffer_pos_], 8);
    buffer_pos_ += 8;
    if constexpr (E != native_endian()) value = bswap_64(value);
    return value;
  }
 
  [[nodiscard]] int8_t read_s8() { return static_cast<int8_t>(read_u8()); }
 
  [[nodiscard]] int16_t read_s16() { return static_cast<int16_t>(read_u16()); }
 
  [[nodiscard]] int32_t read_s32() { return static_cast<int32_t>(read_u32()); }
 
  [[nodiscard]] int64_t read_s64() { return static_cast<int64_t>(read_u64()); }
 
  [[nodiscard]] float read_f32() { return std::bit_cast<float>(read_u32()); }
 
  [[nodiscard]] double read_f64() { return std::bit_cast<double>(read_u64()); }
 
  void read_bytes(void* dest, size_t bytes) {
    if (!dest) {
      throw std::invalid_argument("Destination pointer cannot be null");
    }
 
    uint8_t* out = static_cast<uint8_t*>(dest);
    while (bytes > 0) {
      ensure_available(1);
      size_t chunk = std::min(bytes, buffer_remaining());
      std::memcpy(out, &buffer_[buffer_pos_], chunk);
      buffer_pos_ += chunk;
      out += chunk;
      bytes -= chunk;
    }
  }
 
  [[nodiscard]] std::string read_string(size_t length) {
    std::string result(length, '\0');
    read_bytes(result.data(), length);
    return result;
  }
 
  [[nodiscard]] std::string read_cstring() {
    std::string result;
    uint8_t ch;
    while ((ch = read_u8()) != 0) {
      result.push_back(static_cast<char>(ch));
    }
    return result;
  }
 
 private:
  [[nodiscard]] size_t buffer_remaining() const noexcept {
    return buffer_end_ - buffer_pos_;
  }
 
  void fill_buffer() {
    file_.read(reinterpret_cast<char*>(buffer_.data()), buffer_.size());
    buffer_end_ = file_.gcount();
    buffer_pos_ = 0;
    file_pos_ = file_.tellg();
 
    if (file_.bad()) {
      throw std::runtime_error("Failed to read from file");
    }
  }
 
  void ensure_available(size_t bytes) {
    if (buffer_remaining() < bytes) {
      // Move remaining bytes to start of buffer
      if (buffer_remaining() > 0) {
        std::memmove(buffer_.data(), &buffer_[buffer_pos_], buffer_remaining());
      }
      buffer_end_ = buffer_remaining();
      buffer_pos_ = 0;
 
      // Fill rest of buffer
      file_.read(reinterpret_cast<char*>(&buffer_[buffer_end_]),
                 buffer_.size() - buffer_end_);
      buffer_end_ += file_.gcount();
      file_pos_ = file_.tellg();
 
      if (file_.bad()) {
        throw std::runtime_error("Failed to read from file");
      }
    }
 
    if (buffer_remaining() < bytes) {
      throw std::out_of_range("Cannot read " + std::to_string(bytes) +
                              " bytes: reached end of file");
    }
  }
 
  static constexpr Endianness native_endian() noexcept {
    return std::endian::native == std::endian::little ? Endianness::kLittle
                                                      : Endianness::kBig;
  }
 
  std::ifstream file_;           
  std::vector<uint8_t> buffer_;  
  size_t file_size_ = 0;         
  size_t file_pos_ = 0;          
  size_t buffer_pos_ = 0;        
  size_t buffer_end_ = 0;        
};
 
using LEMemoryReader = MemoryReader<Endianness::kLittle>;
 
using BEMemoryReader = MemoryReader<Endianness::kBig>;
 
using LEFileReader = FileReader<Endianness::kLittle>;
 
using BEFileReader = FileReader<Endianness::kBig>;
 
}  // namespace intns::io
 
#endif  // INTNS_IO_BINARY_READER_HPP