ManualBackendWorker.h

#pragma once

#include "quill/backend/BackendOptions.h"
#include "quill/backend/BackendWorker.h"
#include <chrono>
#include <limits>

QUILL_BEGIN_NAMESPACE

QUILL_BEGIN_EXPORT

class ManualBackendWorker
{
public:
  explicit ManualBackendWorker(detail::BackendWorker* backend_worker)
    : _backend_worker(backend_worker)
  {
  }

  ManualBackendWorker(ManualBackendWorker const&) = delete;
  ManualBackendWorker& operator=(ManualBackendWorker const&) = delete;
  ManualBackendWorker(ManualBackendWorker&&) = delete;
  ManualBackendWorker& operator=(ManualBackendWorker&&) = delete;

  ~ManualBackendWorker()
  {
    // Preserve legacy behavior for callers that forgot explicit shutdown().
    shutdown();
  }

  void init(BackendOptions options)
  {
    QUILL_ASSERT(!_started, "ManualBackendWorker::init() must not be called more than once");

    options.sleep_duration = std::chrono::nanoseconds{0};
    options.enable_yield_when_idle = false;
    _backend_worker->_init(options);
    _started = true;
  }

  void shutdown()
  {
    if (!_started)
    {
      return;
    }

    QUILL_ASSERT(_backend_worker->_worker_thread_id.load() == detail::get_thread_id(),
                 "ManualBackendWorker::shutdown() must be called from the same thread that "
                 "called init()");

    _backend_worker->_exit();
    _backend_worker->_worker_thread_id.store(0);
    _started = false;
  }

  void poll_one()
  {
    QUILL_ASSERT(
      _backend_worker->_options.sleep_duration.count() == 0,
      "ManualBackendWorker::poll_one() requires init() to be called first with sleep_duration = 0");
    QUILL_ASSERT(_backend_worker->_options.enable_yield_when_idle == false,
                 "ManualBackendWorker::poll_one() requires init() to be called first with "
                 "enable_yield_when_idle = false");
    QUILL_ASSERT(_backend_worker->_worker_thread_id.load() != 0,
                 "ManualBackendWorker::poll_one() requires init() to be called first");
    QUILL_ASSERT(_backend_worker->_worker_thread_id.load() == detail::get_thread_id(),
                 "ManualBackendWorker::poll_one() must always be called from the same thread");

    QUILL_TRY { _backend_worker->_poll(); }
#if !defined(QUILL_NO_EXCEPTIONS)
    QUILL_CATCH(std::exception const& e)
    {
      detail::BackendWorker::_notify_error(_backend_worker->_options.error_notifier, e.what());
    }
    QUILL_CATCH_ALL()
    {
      detail::BackendWorker::_notify_error(_backend_worker->_options.error_notifier,
                                           std::string{"Caught unhandled exception."});
    }
#endif
  }

  void poll()
  {
    while (!_backend_worker->_check_frontend_queues_and_cached_transit_events_empty())
    {
      poll_one();
    }
  }

  void poll(std::chrono::microseconds timeout)
  {
    auto const start = std::chrono::steady_clock::now();
    while (!_backend_worker->_check_frontend_queues_and_cached_transit_events_empty())
    {
      poll_one();

      auto const now = std::chrono::steady_clock::now();

      if ((now - start) > timeout)
      {
        break;
      }
    }
  }

private:
  detail::BackendWorker* _backend_worker;
  bool _started{false};
};

QUILL_END_EXPORT

QUILL_END_NAMESPACE