storage.h

Go to the documentation of this file.

#pragma once

 
#include <pixie/bit_stream.h>
 
#include <concepts>
#include <cstddef>
#include <cstdint>
#include <span>
#include <stdexcept>
 
namespace pixie {

template <class Impl>
class StorageBase {
 public:
  std::size_t size_bytes() const { return impl().size_bytes_impl(); }

  std::size_t size_bits() const { return size_bytes() * 8; }

  bool empty() const { return size_bytes() == 0; }

  std::span<const std::byte> as_bytes() const { return impl().as_bytes_impl(); }

  std::span<const std::uint16_t> as_words16() const {
    return as_words<std::uint16_t>();
  }

  std::span<const std::uint64_t> as_words64() const {
    return as_words<std::uint64_t>();
  }

  auto view() const { return impl().view_impl(0, size_bytes()); }

  auto view(std::size_t offset_bytes, std::size_t count_bytes) const {
    return impl().view_impl(offset_bytes, count_bytes);
  }

  void serialize(OutputBitStream& stream) const {
    stream << size_bytes();
    for (const std::byte byte : as_bytes()) {
      stream << static_cast<std::uint8_t>(byte);
    }
  }

  void resize(std::size_t size_bits)
    requires requires(Impl& value) { value.resize_impl(size_bits); }
  {
    impl().resize_impl(size_bits);
  }

  auto writable_bytes()
    requires requires(Impl& value) { value.writable_bytes_impl(); }
  {
    return impl().writable_bytes_impl();
  }

  auto writable_words16()
    requires requires(Impl& value) { value.writable_words16_impl(); }
  {
    return impl().writable_words16_impl();
  }

  auto writable_words64()
    requires requires(Impl& value) { value.writable_words64_impl(); }
  {
    return impl().writable_words64_impl();
  }

  std::size_t allocated_bytes() const
    requires requires(const Impl& value) { value.allocated_bytes_impl(); }
  {
    return impl().allocated_bytes_impl();
  }

  void shrink_to_fit()
    requires requires(Impl& value) { value.shrink_to_fit_impl(); }
  {
    impl().shrink_to_fit_impl();
  }
 
 private:
  const Impl& impl() const { return static_cast<const Impl&>(*this); }

  Impl& impl() { return static_cast<Impl&>(*this); }
 
  template <class Word>
  std::span<const Word> as_words() const {
    const auto bytes = as_bytes();
    if (bytes.size() % sizeof(Word) != 0 ||
        reinterpret_cast<std::uintptr_t>(bytes.data()) % alignof(Word) != 0) {
      throw std::invalid_argument("Storage is not aligned to the word type");
    }
    return {reinterpret_cast<const Word*>(bytes.data()),
            bytes.size() / sizeof(Word)};
  }
};

template <class Storage>
concept StorageImplementation =
    std::derived_from<Storage, StorageBase<Storage>>;
 
}  // namespace pixie