AsyncReader.h

#pragma once

#include <functional>
#include <memory>

#include "logdevice/include/Record.h"
#include "logdevice/include/types.h"

namespace facebook { namespace logdevice {

struct ReadStreamAttributes;

enum class HealthChangeType {
  LOG_HEALTHY = 0,
  LOG_UNHEALTHY = 1,
};

class AsyncReader {
 public:
  virtual void
  setRecordCallback(std::function<bool(std::unique_ptr<DataRecord>&)>) = 0;

  virtual void setGapCallback(std::function<bool(const GapRecord&)>) = 0;

  virtual void setDoneCallback(std::function<void(logid_t)>) = 0;

  virtual void
  setHealthChangeCallback(std::function<void(logid_t, HealthChangeType)>) = 0;

  virtual int startReading(logid_t log_id,
                           lsn_t from,
                           lsn_t until = LSN_MAX,
                           const ReadStreamAttributes* attrs = nullptr) = 0;

  virtual int stopReading(logid_t log_id,
                          std::function<void()> callback = nullptr) = 0;

  virtual int resumeReading(logid_t log_id) = 0;

  virtual void addMonitoringTag(std::string tag) = 0;

  virtual void withoutPayload() = 0;

  virtual void forceNoSingleCopyDelivery() = 0;

  virtual void includeByteOffset() = 0;

  virtual void doNotSkipPartiallyTrimmedSections() = 0;

  virtual int isConnectionHealthy(logid_t) const = 0;

  virtual void doNotDecodeBufferedWrites() = 0;

  static lsn_t nextFromLsnWhenStuck(lsn_t stuck_lsn = LSN_INVALID,
                                    lsn_t tail_lsn = LSN_INVALID);

  virtual void getBytesBuffered(std::function<void(size_t)> callback) = 0;

  virtual void setReaderName(const std::string& reader_name) = 0;

  virtual ~AsyncReader() {}
};

}} // namespace facebook::logdevice