size_delimited_log_reader.h

Go to the documentation of this file.

// Copyright (c) Space-ng, inc. All rights reserved.
 
#pragma once
 
#include "sol3/core/file_descriptor.h"
#include "sol3/core/shmem_buffer_impl.h"
#include "sol3/cpp/filesystem.h"
 
#include <flatbuffers/flatbuffers.h>
#include <tl/expected.hpp>
 
#include <cstddef>
#include <memory>
#include <optional>
#include <stdexcept>
#include <string>
#include <string_view>
 
namespace sol3::core {
class SizeDelimitedLogReader
    : public std::enable_shared_from_this<SizeDelimitedLogReader> {
 public:
  struct ReadError {
    enum class Code {
      kEndOfFile,
      kNotOpen,
      kTruncatedPrefix,
      kTruncatedBuffer,
      kZeroSizeFrame
    };
 
    Code code;
    size_t offset = 0;
    size_t size = 0;
    std::string path;
  };
 
  class ReadErrorException : public std::runtime_error {
   public:
    ReadErrorException(ReadError err, std::string_view context);
 
    ReadError error;
    std::string context;
  };
 
  class Iterator;
 
  class FrameView {
   public:
    FrameView();
 
    flatbuffers::span<uint8_t const> span() const {
      return flatbuffers::span<uint8_t const>(span_data_, span_size_);
    }
    flatbuffers::span<uint8_t const> spanNoPrefix() const;
    size_t offsetBytes() const { return offset_; }
 
   private:
    friend class SizeDelimitedLogReader;
    friend class Iterator;
    FrameView(
        std::shared_ptr<SizeDelimitedLogReader const> reader,
        flatbuffers::span<uint8_t const> span,
        size_t offset);
 
    std::shared_ptr<SizeDelimitedLogReader const> reader_;
    uint8_t const* span_data_ = nullptr;
    size_t span_size_ = 0;
    size_t offset_ = 0;
  };
 
  class Iterator {
   public:
    using value_type = FrameView;
    using reference = FrameView const&;
    using pointer = FrameView const*;
 
    Iterator();
    explicit Iterator(tl::expected<FrameView, ReadError> current);
    Iterator(Iterator const&) = default;
    Iterator& operator=(Iterator const& other) = default;
    Iterator(Iterator&&) = default;
    Iterator& operator=(Iterator&& other) = default;
    ~Iterator() = default;
 
    reference operator*() const;
    pointer operator->() const;
    Iterator& operator++();
    bool operator==(Iterator const& other) const;
    bool operator!=(Iterator const& other) const;
 
    tl::expected<FrameView, ReadError> const& frameView() const;
 
   private:
    void advance();
    reference frame() const;
 
    tl::expected<FrameView, ReadError> current_;
  };
 
  SizeDelimitedLogReader(SizeDelimitedLogReader const&) = delete;
  SizeDelimitedLogReader& operator=(SizeDelimitedLogReader const&) = delete;
  SizeDelimitedLogReader(SizeDelimitedLogReader&&) = delete;
  SizeDelimitedLogReader& operator=(SizeDelimitedLogReader&&) = delete;
 
  static std::shared_ptr<SizeDelimitedLogReader> open(
      cpp::fs::path const& log_path);
 
  tl::expected<FrameView, ReadError> readAtOffset(size_t offset) const;
 
  Iterator begin() const;
  Iterator const& end() const;
 
  cpp::fs::path const& logPath() const { return log_path_; }
 
 private:
  explicit SizeDelimitedLogReader(cpp::fs::path const& log_path);
  void openFile(cpp::fs::path const& log_path);
  void resetFile();
 
  cpp::fs::path log_path_;
  FileDescriptor fd_;
  impl::Mmap mmap_;
  uint8_t const* data_ = nullptr;
  size_t size_ = 0;
 
  Iterator end_it_;
};
 
char const* readErrorCodeToString(SizeDelimitedLogReader::ReadError::Code code);
std::string formatReadError(
    SizeDelimitedLogReader::ReadError const& err, std::string_view context);
// NOLINTBEGIN(readability-identifier-naming)
std::string format_as(SizeDelimitedLogReader::ReadError::Code code);
std::string format_as(SizeDelimitedLogReader::ReadError const& err);
// NOLINTEND(readability-identifier-naming)
}  // namespace sol3::core