read_only_view.h

#pragma once
 
#include <pixie/storage.h>
 
#include <cstring>
#include <span>
#include <stdexcept>
 
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(); }

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

  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(std::span<const std::byte>& data) {
    if (data.size() < sizeof(std::size_t)) {
      throw std::invalid_argument("Truncated storage size prefix");
    }
    std::size_t size = 0;
    std::memcpy(&size, data.data(), sizeof(size));
    if (size > data.size() - sizeof(size)) {
      throw std::invalid_argument("Truncated storage payload");
    }
    ReadOnlyStorageView result(data.subspan(sizeof(size), size));
    data = data.subspan(sizeof(size) + size);
    return result;
  }
 
 private:
  std::span<const std::byte> data_;
};
 
}  // namespace pixie