stream.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstddef>
#include <cstdint>
#include <span>
#include <string>
#include <type_traits>
#include <vector>
 
#include <rex/assert.h>
#include <rex/memory/endian.h>
#include <rex/platform.h>
#include <rex/types.h>
 
namespace rex::memory {

class REX_API BitStream {
 public:
  BitStream(u8* buffer, size_t size_in_bits);
  ~BitStream() = default;
 
  const u8* GetBuffer() const { return buffer_; }
 
  u8* GetBuffer() { return buffer_; }
 
  size_t GetOffsetBits() const { return offset_bits_; }
 
  size_t GetSizeBits() const { return size_bits_; }
 
  void Advance(size_t num_bits);

  void SetOffset(size_t offset_bits);
 
  size_t GetBitsRemaining() const;

  u64 Peek(size_t num_bits);

  u64 Read(size_t num_bits);

  bool Write(u64 val, size_t num_bits);

  size_t Copy(u8* dest_buffer, size_t num_bits);
 
 private:
  u8* buffer_ = nullptr;
  size_t offset_bits_ = 0;
  size_t size_bits_ = 0;
};

class REX_API ByteStream {
 public:
  ByteStream(u8* data, size_t data_length, size_t offset = 0);
  ~ByteStream() = default;
 
  void Advance(size_t num_bytes);

  void Read(std::span<u8> buf);

  void Write(std::span<const u8> buf);

  void Read(void* buf, size_t len) { return Read(std::span<u8>(reinterpret_cast<u8*>(buf), len)); }

  void Write(const void* buf, size_t len) {
    return Write(std::span<const u8>(reinterpret_cast<const u8*>(buf), len));
  }
 
  const u8* GetData() const { return data_; }
 
  u8* GetData() { return data_; }
 
  size_t GetSize() const { return data_length_; }
 
  size_t GetOffset() const { return offset_; }
 
  void SetOffset(size_t offset) { offset_ = offset; }

  template <typename T>
  T Read() {
    T data;
    Read(std::span<u8>(reinterpret_cast<u8*>(&data), sizeof(T)));
    return data;
  }

  template <typename T>
  void Write(T data) {
    Write(std::span<const u8>(reinterpret_cast<const u8*>(&data), sizeof(T)));
  }

  void Write(const std::string_view str) {
    Write(static_cast<u32>(str.length()));
    Write(str.data(), str.length() * sizeof(char));
  }

  void Write(const std::u16string_view str) {
    Write(static_cast<u32>(str.length()));
    Write(str.data(), str.length() * sizeof(char16_t));
  }
 
 private:
  u8* data_ = nullptr;
  size_t data_length_ = 0;
  size_t offset_ = 0;
};

template <>
REX_API std::string ByteStream::Read();

template <>
REX_API std::u16string ByteStream::Read();
 
using RingSizeT = u32;

class REX_API RingBuffer {
 public:
  RingBuffer(u8* buffer, size_t capacity);
 
  u8* GetBuffer() const { return buffer_; }
 
  RingSizeT GetCapacity() const { return capacity_; }

  bool IsEmpty() const { return read_offset_ == write_offset_; }
 
  RingSizeT GetReadOffset() const { return read_offset_; }

  uintptr_t GetReadPtr() const {
    return reinterpret_cast<uintptr_t>(buffer_) + static_cast<uintptr_t>(read_offset_);
  }

  void SetReadOffset(size_t offset) { read_offset_ = static_cast<RingSizeT>(offset) % capacity_; }

  RingSizeT GetReadCount() const {
    RingSizeT read_offs = read_offset_;
    RingSizeT write_offs = write_offset_;
    RingSizeT cap = capacity_;
    if (read_offs <= write_offs) {
      return write_offs - read_offs;
    } else {
      return (cap - read_offs) + write_offs;
    }
  }
 
  RingSizeT GetWriteOffset() const { return write_offset_; }

  uintptr_t GetWritePtr() const {
    return reinterpret_cast<uintptr_t>(buffer_) + static_cast<uintptr_t>(write_offset_);
  }

  void SetWriteOffset(size_t offset) { write_offset_ = static_cast<RingSizeT>(offset) % capacity_; }

  RingSizeT GetWriteCount() const {
    RingSizeT read_offs = read_offset_;
    RingSizeT write_offs = write_offset_;
    RingSizeT cap = capacity_;
    if (read_offs == write_offs) {
      return cap;
    } else if (write_offs < read_offs) {
      return read_offs - write_offs;
    } else {
      return (cap - write_offs) + read_offs;
    }
  }

  void AdvanceRead(size_t count);

  void AdvanceWrite(size_t count);

  struct ReadRange {
    const u8* __restrict first;  
    const u8* __restrict second; 
    RingSizeT first_length;
    RingSizeT second_length;
  };

  ReadRange BeginRead(size_t count);

  void EndRead(ReadRange read_range);

  size_t Read(u8* buffer, size_t count);

  template <typename T>
  size_t Read(T* buffer, size_t count) {
    return Read(reinterpret_cast<u8*>(buffer), count);
  }

  template <typename T>
  T Read() {
    static_assert(std::is_fundamental<T>::value, "Immediate read only supports basic types!");
 
    T imm;
    size_t read = Read(reinterpret_cast<u8*>(&imm), sizeof(T));
    REX_ASSERT(read == sizeof(T));
    return imm;
  }

  template <typename T>
  T ReadAndSwap() {
    static_assert(std::is_fundamental<T>::value, "Immediate read only supports basic types!");
 
    T imm;
    size_t read = Read(reinterpret_cast<u8*>(&imm), sizeof(T));
    REX_ASSERT(read == sizeof(T));
    imm = rex::byte_swap(imm);
    return imm;
  }

  size_t Write(const u8* buffer, size_t count);

  template <typename T>
  size_t Write(const T* buffer, size_t count) {
    return Write(reinterpret_cast<const u8*>(buffer), count);
  }

  template <typename T>
  size_t Write(T& data) {
    return Write(reinterpret_cast<const u8*>(&data), sizeof(T));
  }
 
 private:
  u8* __restrict buffer_ = nullptr;
  RingSizeT capacity_ = 0;
  RingSizeT read_offset_ = 0;
  RingSizeT write_offset_ = 0;
};

template <>
inline u32 RingBuffer::ReadAndSwap<u32>() {
  REX_ASSERT(capacity_ >= 4);
  RingSizeT read_offs = read_offset_;
  RingSizeT next_read_offs = read_offs + 4;
  if (next_read_offs == capacity_) [[unlikely]] {
    next_read_offs = 0;
  }
  read_offset_ = next_read_offs;
  return memory::load<be_u32>(buffer_ + read_offs);
}
 
}  // namespace rex::memory