AnyOperation.hpp

#pragma once
 
#include "util/async/Error.hpp"
#include "util/async/impl/ErasedOperation.hpp"
 
#include <fmt/format.h>
#include <fmt/std.h>
 
#include <any>
#include <expected>
#include <thread>
#include <type_traits>
#include <utility>
 
// TODO: In the future, perhaps cancel and requestStop should be combined into one.
// Users of the library should not care whether the operation is cancellable or stoppable - users
// just want to cancel it whatever that means internally.
 
namespace util::async {

template <typename RetType>
class AnyOperation {
public:
    /* implicit */ AnyOperation(impl::ErasedOperation&& operation)
        : operation_{std::move(operation)}
    {
    }
 
    ~AnyOperation() = default;
 
    AnyOperation(AnyOperation const&) = delete;
    AnyOperation(AnyOperation&&) = default;
    AnyOperation&
    operator=(AnyOperation const&) = delete;
    AnyOperation&
    operator=(AnyOperation&&) = default;

    void
    wait() noexcept
    {
        operation_.wait();
    }

    void
    abort()
    {
        operation_.abort();
    }

    [[nodiscard]] std::expected<RetType, ExecutionError>
    get()
    {
        try {
            auto data = operation_.get();
            if (not data)
                return std::unexpected(std::move(data).error());
 
            if constexpr (std::is_void_v<RetType>) {
                return {};
            } else {
                return std::any_cast<RetType>(std::move(data).value());
            }
 
        } catch (std::bad_any_cast const& e) {
            return std::unexpected{
                ExecutionError(fmt::format("{}", std::this_thread::get_id()), "Bad any cast")
            };
        }
    }

    void
    invoke()
    {
        operation_.invoke();
    }
 
private:
    impl::ErasedOperation operation_;
};
 
}  // namespace util::async