abstract-reader.hpp

#ifndef OPENEV_READERS_ABSTRACT_READER_HPP
#define OPENEV_READERS_ABSTRACT_READER_HPP
 
#include "openev/containers/queue.hpp"
#include "openev/containers/vector.hpp"
#include "openev/core/types.hpp"
#include <atomic>
#include <cstddef>
#include <limits>
#include <mutex>
#include <thread>
 
namespace ev {

class AbstractReader_ {
public:
  static constexpr std::size_t NO_BUFFER = 0;
  static constexpr std::size_t INF_BUFFER = std::numeric_limits<std::size_t>::max();

  virtual ~AbstractReader_();
  AbstractReader_(const AbstractReader_ &) = delete;
  AbstractReader_(AbstractReader_ &&) noexcept = delete;
  AbstractReader_ &operator=(const AbstractReader_ &) = delete;
  AbstractReader_ &operator=(AbstractReader_ &&) noexcept = delete;

  AbstractReader_(const std::size_t buffer_size, const bool use_threading);

  bool read(Event &e);

  bool read(Vector &vector, const int n);

  bool read(Queue &queue, const int n, const bool keep_size = false);

  bool read_t(Vector &vector, const double t);

  bool read_t(Queue &queue, const double t, const bool keep_size = false);

  bool skip(int n);

  bool skip_t(const double t);

  void reset();

  [[nodiscard]] virtual std::size_t count() = 0;
 
protected:
  const std::size_t bufferSize_;
  std::thread thread_;
  Queue buffer_;
  std::mutex bufferMutex_;
  std::atomic<bool> threadRunning_{};
 
  virtual bool read_(Event &e) = 0;
  virtual void reset_() = 0;
 
private:
  void threadFunction();
  bool loadBuffer();
};
 
} // namespace ev
 
#endif // OPENEV_READERS_ABSTRACT_READER_HPP