error_handler.hpp

Go to the documentation of this file.

#pragma once
 
#include "../detail/callable/copyable_function.hpp"
#include "../detail/callable/move_only_function.hpp"
#include "../task_error.hpp"
#include <exception>
#include <functional>
#include <future>
#include <map>
#include <memory>
#include <mutex>
#include <string>
#include <type_traits>
#include <vector>
 
namespace threadschedule::advanced
{
 
namespace error_handler_detail
{
using error_callback_storage = ::threadschedule::detail::copyable_function<void(task_error const&)>;
using future_error_callback = ::threadschedule::detail::move_only_function<void(std::exception_ptr)>;
} // namespace error_handler_detail
 
class error_handler
{
public:
  auto
  add_callback(error_callback callback) -> size_t
  {
    return emplace_callback(error_handler_detail::error_callback_storage(std::move(callback)));
  }
 
  template <typename Callback,
            std::enable_if_t<!std::is_same_v<::threadschedule::detail::remove_cvref_t<Callback>, error_callback>, int>
            = 0>
  auto
  add_callback(Callback&& callback) -> size_t
  {
    static_assert(std::is_invocable_r_v<void, Callback&, task_error const&>,
                  "Error callback must be invocable with task_error const&");
    return emplace_callback(
        ::threadschedule::detail::make_copyable_function<void(task_error const&)>(std::forward<Callback>(callback)));
  }
 
  auto
  remove_callback(size_t id) -> bool
  {
    std::lock_guard<std::mutex> lock(mutex_);
    return callbacks_.erase(id) > 0;
  }
 
  [[nodiscard]] auto
  has_callback(size_t id) const -> bool
  {
    std::lock_guard<std::mutex> lock(mutex_);
    return callbacks_.count(id) > 0;
  }
 
  void
  clear_callbacks()
  {
    std::lock_guard<std::mutex> lock(mutex_);
    callbacks_.clear();
  }
 
  void
  handle_error(task_error const& error)
  {
    std::vector<error_handler_detail::error_callback_storage> snapshot;
    {
      std::lock_guard<std::mutex> lock(mutex_);
      error_count_++;
      snapshot.reserve(callbacks_.size());
      for (auto const& [id, callback] : callbacks_)
        snapshot.push_back(callback);
    }
 
    for (auto& callback : snapshot)
      {
        try
          {
            callback(error);
          }
        catch (...)
          {
          }
      }
  }
 
  [[nodiscard]] auto
  error_count() const -> size_t
  {
    std::lock_guard<std::mutex> lock(mutex_);
    return error_count_;
  }
 
  void
  reset_error_count()
  {
    std::lock_guard<std::mutex> lock(mutex_);
    error_count_ = 0;
  }
 
private:
  auto
  emplace_callback(error_handler_detail::error_callback_storage callback) -> size_t
  {
    std::lock_guard<std::mutex> lock(mutex_);
    size_t const id = next_callback_id_++;
    callbacks_.emplace(id, std::move(callback));
    return id;
  }
 
  mutable std::mutex mutex_;
  std::map<size_t, error_handler_detail::error_callback_storage> callbacks_;
  size_t next_callback_id_{ 0 };
  size_t error_count_{ 0 };
};
 
template <typename Func>
class error_handled_task
{
public:
  error_handled_task(Func func, std::shared_ptr<error_handler> handler, std::string description = "")
      : func_(std::move(func)), handler_(std::move(handler)), description_(std::move(description))
  {
  }
 
  void
  operator()()
  {
    try
      {
        func_();
      }
    catch (...)
      {
        if (handler_)
          handler_->handle_error(task_error::capture(description_));
      }
  }
 
private:
  Func func_;
  std::shared_ptr<error_handler> handler_;
  std::string description_;
};
 
template <typename Func>
auto
make_error_handled_task(Func&& func, std::shared_ptr<error_handler> handler, std::string description = "")
{
  using function_type = std::decay_t<Func>;
  return error_handled_task<function_type>(function_type(std::forward<Func>(func)), std::move(handler),
                                           std::move(description));
}
 
template <typename T>
class future_with_error_handler
{
public:
  explicit future_with_error_handler(std::future<T> future)
      : future_(std::move(future)), error_callback_(nullptr), has_callback_(false)
  {
  }
 
  future_with_error_handler(future_with_error_handler const&) = delete;
  auto operator=(future_with_error_handler const&) -> future_with_error_handler& = delete;
  future_with_error_handler(future_with_error_handler&&) = default;
  auto operator=(future_with_error_handler&&) -> future_with_error_handler& = default;
 
  auto
  on_error(std::function<void(std::exception_ptr)> callback) -> future_with_error_handler&
  {
    error_callback_ = error_handler_detail::future_error_callback(std::move(callback));
    has_callback_ = true;
    return *this;
  }
 
  template <typename Callback, std::enable_if_t<!std::is_same_v<::threadschedule::detail::remove_cvref_t<Callback>,
                                                                std::function<void(std::exception_ptr)>>,
                                                int> = 0>
  auto
  on_error(Callback&& callback) -> future_with_error_handler&
  {
    static_assert(std::is_invocable_r_v<void, Callback&, std::exception_ptr>,
                  "Error callback must be invocable with std::exception_ptr");
    error_callback_
        = ::threadschedule::detail::make_move_only_function<void(std::exception_ptr)>(std::forward<Callback>(callback));
    has_callback_ = true;
    return *this;
  }
 
  auto
  get() -> T
  {
    try
      {
        if constexpr (std::is_void_v<T>)
          future_.get();
        else
          return future_.get();
      }
    catch (...)
      {
        auto const original = std::current_exception();
        if (has_callback_ && error_callback_)
          {
            try
              {
                error_callback_(original);
              }
            catch (...)
              {
              }
          }
        std::rethrow_exception(original);
      }
  }
 
  void
  wait() const
  {
    future_.wait();
  }
 
  template <typename Rep, typename Period>
  auto
  wait_for(std::chrono::duration<Rep, Period> const& timeout_duration) const
  {
    return future_.wait_for(timeout_duration);
  }
 
  template <typename Clock, typename duration>
  auto
  wait_until(std::chrono::time_point<Clock, duration> const& timeout_time) const
  {
    return future_.wait_until(timeout_time);
  }
 
  [[nodiscard]] auto
  valid() const -> bool
  {
    return future_.valid();
  }
 
private:
  std::future<T> future_;
  error_handler_detail::future_error_callback error_callback_;
  bool has_callback_{ false };
};
 
} // namespace threadschedule::advanced