storage.h

Go to the documentation of this file.

#pragma once

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

template <class Impl>
class StorageBase : public SerializationBase<Impl> {
 public:
  using position_type = std::uint64_t;

  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; }

  position_type begin_position() const { return impl().begin_position_impl(); }

  position_type end_position() const { return impl().end_position_impl(); }

  bool contains(position_type position, std::size_t count_bytes) const {
    const position_type begin = begin_position();
    const position_type end = end_position();
    return position >= begin && position <= end &&
           count_bytes <= end - position;
  }

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

  SplitSpan<std::byte> segments()
    requires requires(Impl& value) {
      {
        value.segments_impl(position_type{}, std::size_t{})
      } -> std::same_as<SplitSpan<std::byte>>;
    }
  {
    return segments(begin_position(), size_bytes());
  }

  SplitSpan<const std::byte> segments() const {
    return segments(begin_position(), size_bytes());
  }

  SplitSpan<std::byte> segments(position_type position, std::size_t count_bytes)
    requires requires(Impl& value) {
      {
        value.segments_impl(position_type{}, std::size_t{})
      } -> std::same_as<SplitSpan<std::byte>>;
    }
  {
    if constexpr (requires(Impl& value) {
                    value.prepare_segments_impl(position_type{}, std::size_t{});
                  }) {
      impl().prepare_segments_impl(position, count_bytes);
    }
    validate_range(position, count_bytes);
    return impl().segments_impl(position, count_bytes);
  }

  SplitSpan<const std::byte> segments(position_type position,
                                      std::size_t count_bytes) const {
    validate_range(position, count_bytes);
    return impl().segments_impl(position, count_bytes);
  }

  std::span<const std::uint16_t> as_words16() const
    requires requires(const Impl& value) { value.as_bytes_impl(); }
  {
    return as_words<std::uint16_t>();
  }

  std::span<const std::uint64_t> as_words64() const
    requires requires(const Impl& value) { value.as_bytes_impl(); }
  {
    return as_words<std::uint64_t>();
  }

  auto view() const
    requires requires(const Impl& value) {
      value.view_impl(std::size_t{}, std::size_t{});
    }
  {
    return impl().view_impl(0, size_bytes());
  }

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

  void serialize_impl(BinaryWriter& writer) const {
    writer.write_size(size_bytes());
    for (const std::span<const std::byte> segment : segments()) {
      writer.write_bytes(segment);
    }
  }

  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:
  void validate_range(position_type position, std::size_t count_bytes) const {
    if (!contains(position, count_bytes)) {
      throw std::out_of_range("Storage range is outside the working window");
    }
  }

  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