error_handler.hpp

Go to the documentation of this file.

#pragma once

 
#include "callable.hpp"
#include <chrono>
#include <exception>
#include <functional>
#include <future>
#include <map>
#include <memory>
#include <mutex>
#include <string>
#include <thread>
#include <type_traits>
#include <vector>
 
namespace threadschedule
{

struct TaskError
{
    std::exception_ptr exception;

    std::string task_description;

    std::thread::id thread_id;

    std::chrono::steady_clock::time_point timestamp;

    static auto capture(std::string description = {}) -> TaskError
    {
        TaskError err;
        err.exception = std::current_exception();
        err.task_description = std::move(description);
        err.thread_id = std::this_thread::get_id();
        err.timestamp = std::chrono::steady_clock::now();
        return err;
    }

    [[nodiscard]] auto what() const -> std::string
    {
        try
        {
            if (exception)
            {
                std::rethrow_exception(exception);
            }
        }
        catch (std::exception const& e)
        {
            return e.what();
        }
        catch (...)
        {
            return "Unknown exception";
        }
        return "No exception";
    }

    void rethrow() const
    {
        if (exception)
        {
            std::rethrow_exception(exception);
        }
    }
};

using ErrorCallback = detail::copyable_callable<void(TaskError const&)>;
 
using ErrorCallbackStorage = ErrorCallback;
using FutureErrorCallback = detail::move_callable<void(std::exception_ptr)>;

class ErrorHandler
{
  public:
    auto add_callback(ErrorCallback callback) -> size_t
    {
        return emplace_callback(ErrorCallbackStorage(std::move(callback)));
    }
 
    template <typename Callback,
              std::enable_if_t<!std::is_same_v<detail::remove_cvref_t<Callback>, ErrorCallback>, int> = 0>
    auto add_callback(Callback&& callback) -> size_t
    {
        static_assert(std::is_invocable_r_v<void, Callback&, TaskError const&>,
                      "Error callback must be invocable with TaskError const&");
        return emplace_callback(detail::make_copyable_callable<void(TaskError 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(TaskError const& error)
    {
        std::vector<ErrorCallbackStorage> 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(ErrorCallbackStorage 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, ErrorCallbackStorage> callbacks_;
    size_t next_callback_id_{0};
    size_t error_count_{0};
};

template <typename Func>
class ErrorHandledTask
{
  public:
    ErrorHandledTask(Func&& func, std::shared_ptr<ErrorHandler> handler, std::string description = "")
        : func_(std::forward<Func>(func)), handler_(std::move(handler)), description_(std::move(description))
    {
    }
 
    void operator()()
    {
        try
        {
            func_();
        }
        catch (...)
        {
            if (handler_)
                handler_->handle_error(TaskError::capture(description_));
        }
    }
 
  private:
    Func func_;
    std::shared_ptr<ErrorHandler> handler_;
    std::string description_;
};

template <typename Func>
auto make_error_handled_task(Func&& func, std::shared_ptr<ErrorHandler> handler, std::string description = "")
{
    return ErrorHandledTask<Func>(std::forward<Func>(func), std::move(handler), std::move(description));
}

template <typename T>
class FutureWithErrorHandler
{
  public:
    explicit FutureWithErrorHandler(std::future<T> future)
        : future_(std::move(future)), error_callback_(nullptr), has_callback_(false)
    {
    }
 
    FutureWithErrorHandler(FutureWithErrorHandler const&) = delete;
    auto operator=(FutureWithErrorHandler const&) -> FutureWithErrorHandler& = delete;
    FutureWithErrorHandler(FutureWithErrorHandler&&) = default;
    auto operator=(FutureWithErrorHandler&&) -> FutureWithErrorHandler& = default;

    auto on_error(std::function<void(std::exception_ptr)> callback) -> FutureWithErrorHandler&
    {
        error_callback_ = FutureErrorCallback(std::move(callback));
        has_callback_ = true;
        return *this;
    }
 
    template <typename Callback,
              std::enable_if_t<!std::is_same_v<detail::remove_cvref_t<Callback>, std::function<void(std::exception_ptr)>>,
                               int> = 0>
    auto on_error(Callback&& callback) -> FutureWithErrorHandler&
    {
        static_assert(std::is_invocable_r_v<void, Callback&, std::exception_ptr>,
                      "Error callback must be invocable with std::exception_ptr");
        error_callback_ = detail::make_move_callable<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 (...)
        {
            if (has_callback_ && error_callback_)
            {
                error_callback_(std::current_exception());
            }
            throw;
        }
    }

    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_;
    FutureErrorCallback error_callback_;
    bool has_callback_{false};
};
 
} // namespace threadschedule