cancellable_future.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <kcenon/thread/core/cancellation_token.h>
#include <kcenon/thread/core/error_handling.h>
 
#include <chrono>
#include <future>
#include <optional>
 
namespace kcenon::thread {
 
template<typename R>
class cancellable_future {
public:
    using value_type = R;
 
    cancellable_future(std::future<R> future, cancellation_token token)
        : future_(std::move(future))
        , token_(std::move(token))
    {}
 
    // Destructor
    ~cancellable_future() = default;
 
    // Delete copy operations
    cancellable_future(const cancellable_future&) = delete;
    cancellable_future& operator=(const cancellable_future&) = delete;
 
    // Allow move operations
    cancellable_future(cancellable_future&&) noexcept = default;
    cancellable_future& operator=(cancellable_future&&) noexcept = default;
 
    [[nodiscard]] auto get() -> common::Result<R> {
        if (token_.is_cancelled()) {
            return make_error_result<R>(error_code::operation_canceled);
        }
        try {
            return common::Result<R>::ok(future_.get());
        } catch (const std::exception& e) {
            return make_error_result<R>(error_code::job_execution_failed, e.what());
        } catch (...) {
            return make_error_result<R>(error_code::unknown_error, "Unknown exception in future");
        }
    }
 
    [[nodiscard]] auto get_for(std::chrono::milliseconds timeout)
        -> common::Result<std::optional<R>>
    {
        if (token_.is_cancelled()) {
            return make_error_result<std::optional<R>>(error_code::operation_canceled);
        }
 
        auto status = future_.wait_for(timeout);
        if (status == std::future_status::ready) {
            try {
                return common::Result<std::optional<R>>::ok(future_.get());
            } catch (const std::exception& e) {
                return make_error_result<std::optional<R>>(
                    error_code::job_execution_failed, e.what());
            } catch (...) {
                return make_error_result<std::optional<R>>(
                    error_code::unknown_error, "Unknown exception in future");
            }
        }
        return common::Result<std::optional<R>>::ok(std::nullopt);
    }
 
    [[nodiscard]] auto is_ready() const -> bool {
        return future_.wait_for(std::chrono::seconds(0)) ==
               std::future_status::ready;
    }
 
    [[nodiscard]] auto is_cancelled() const -> bool {
        return token_.is_cancelled();
    }
 
    void cancel() {
        token_.cancel();
    }
 
    [[nodiscard]] auto valid() const -> bool {
        return future_.valid();
    }
 
    void wait() const {
        future_.wait();
    }
 
    template<typename Rep, typename Period>
    [[nodiscard]] auto wait_for(const std::chrono::duration<Rep, Period>& timeout) const
        -> std::future_status
    {
        return future_.wait_for(timeout);
    }
 
    [[nodiscard]] auto get_token() const -> cancellation_token {
        return token_;
    }
 
private:
    mutable std::future<R> future_;
    cancellation_token token_;
};
 
template<>
class cancellable_future<void> {
public:
    using value_type = void;
 
    cancellable_future(std::future<void> future, cancellation_token token)
        : future_(std::move(future))
        , token_(std::move(token))
    {}
 
    ~cancellable_future() = default;
 
    cancellable_future(const cancellable_future&) = delete;
    cancellable_future& operator=(const cancellable_future&) = delete;
    cancellable_future(cancellable_future&&) noexcept = default;
    cancellable_future& operator=(cancellable_future&&) noexcept = default;
 
    [[nodiscard]] auto get() -> common::VoidResult {
        if (token_.is_cancelled()) {
            return make_error_result(error_code::operation_canceled);
        }
        try {
            future_.get();
            return common::ok();
        } catch (const std::exception& e) {
            return make_error_result(error_code::job_execution_failed, e.what());
        } catch (...) {
            return make_error_result(error_code::unknown_error, "Unknown exception in future");
        }
    }
 
    [[nodiscard]] auto get_for(std::chrono::milliseconds timeout) -> common::Result<bool> {
        if (token_.is_cancelled()) {
            return make_error_result<bool>(error_code::operation_canceled);
        }
 
        auto status = future_.wait_for(timeout);
        if (status == std::future_status::ready) {
            try {
                future_.get();
                return common::Result<bool>::ok(true);
            } catch (const std::exception& e) {
                return make_error_result<bool>(error_code::job_execution_failed, e.what());
            } catch (...) {
                return make_error_result<bool>(error_code::unknown_error, "Unknown exception in future");
            }
        }
        return common::Result<bool>::ok(false);
    }
 
    [[nodiscard]] auto is_ready() const -> bool {
        return future_.wait_for(std::chrono::seconds(0)) ==
               std::future_status::ready;
    }
 
    [[nodiscard]] auto is_cancelled() const -> bool {
        return token_.is_cancelled();
    }
 
    void cancel() {
        token_.cancel();
    }
 
    [[nodiscard]] auto valid() const -> bool {
        return future_.valid();
    }
 
    void wait() const {
        future_.wait();
    }
 
    template<typename Rep, typename Period>
    [[nodiscard]] auto wait_for(const std::chrono::duration<Rep, Period>& timeout) const
        -> std::future_status
    {
        return future_.wait_for(timeout);
    }
 
    [[nodiscard]] auto get_token() const -> cancellation_token {
        return token_;
    }
 
private:
    mutable std::future<void> future_;
    cancellation_token token_;
};
 
} // namespace kcenon::thread