read_only_view.h

#pragma once
 
#include <pixie/storage.h>
 
#include <span>
 
namespace pixie {

class ReadOnlyStorageView : public StorageBase<ReadOnlyStorageView> {
 public:
  ReadOnlyStorageView() = default;

  explicit ReadOnlyStorageView(std::span<const std::byte> data) : data_(data) {}

  std::size_t size_bytes_impl() const { return data_.size(); }

  position_type begin_position_impl() const { return 0; }

  position_type end_position_impl() const { return data_.size(); }

  std::span<const std::byte> as_bytes_impl() const { return data_; }

  SplitSpan<const std::byte> segments_impl(std::size_t offset_bytes,
                                           std::size_t count_bytes) const {
    return SplitSpan(data_.subspan(offset_bytes, count_bytes));
  }

  ReadOnlyStorageView view_impl(std::size_t offset_bytes,
                                std::size_t count_bytes) const {
    if (offset_bytes > data_.size() ||
        count_bytes > data_.size() - offset_bytes) {
      throw std::out_of_range("Storage view is outside the backing storage");
    }
    return ReadOnlyStorageView(data_.subspan(offset_bytes, count_bytes));
  }

  static ReadOnlyStorageView deserialize_impl(BinaryReader& reader) {
    const std::size_t size = reader.read_size();
    return ReadOnlyStorageView(reader.read_bytes(size));
  }
 
 private:
  std::span<const std::byte> data_;
};
 
}  // namespace pixie