future.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright 2026 Chris Leishman
 
#pragma once
 
#include <idfxx/error.hpp>
 
#include <chrono>
#include <functional>
#include <memory>
#include <optional>
#include <type_traits>
#include <utility>
 
namespace idfxx {
 
template<typename T>
class future {
public:
    future() = default;
 
    template<typename W>
        requires std::is_invocable_r_v<result<T>, W&, std::optional<std::chrono::milliseconds>>
    explicit future(W waiter)
        : _state(std::make_shared<state>(std::move(waiter))) {}
 
    template<typename W, typename D>
        requires std::is_invocable_r_v<result<T>, W&, std::optional<std::chrono::milliseconds>> &&
        std::is_nothrow_invocable_r_v<bool, const D&>
    future(W waiter, D done_check)
        : _state(std::make_shared<state>(std::move(waiter), std::move(done_check))) {}
 
    [[nodiscard]] bool valid() const noexcept { return _state != nullptr; }
 
    [[nodiscard]] bool done() const noexcept;
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    T wait() const { return unwrap(try_wait()); }
 
    template<typename Rep, typename Period>
    T wait_for(const std::chrono::duration<Rep, Period>& timeout) const {
        return unwrap(try_wait_for(timeout));
    }
#endif
 
    [[nodiscard]] result<T> try_wait() const;
 
    template<typename Rep, typename Period>
    [[nodiscard]] result<T> try_wait_for(const std::chrono::duration<Rep, Period>& timeout) const;
 
private:
    struct state {
        std::move_only_function<result<T>(std::optional<std::chrono::milliseconds>)> waiter;
        std::move_only_function<bool() const noexcept> done_check;
 
        template<typename W>
        explicit state(W&& w)
            : waiter(std::forward<W>(w)) {}
 
        template<typename W, typename D>
        state(W&& w, D&& d)
            : waiter(std::forward<W>(w))
            , done_check(std::forward<D>(d)) {}
    };
    std::shared_ptr<state> _state;
};
 
template<typename T>
bool future<T>::done() const noexcept {
    if (!_state) {
        return true;
    }
    if (_state->done_check) {
        return _state->done_check();
    }
    auto r = _state->waiter(std::optional<std::chrono::milliseconds>{std::chrono::milliseconds{0}});
    return r.has_value();
}
 
template<typename T>
result<T> future<T>::try_wait() const {
    if (!_state) {
        if constexpr (std::is_void_v<T>) {
            return {};
        } else {
            return T{};
        }
    }
    return _state->waiter(std::nullopt);
}
 
template<typename T>
template<typename Rep, typename Period>
result<T> future<T>::try_wait_for(const std::chrono::duration<Rep, Period>& timeout) const {
    if (!_state) {
        if constexpr (std::is_void_v<T>) {
            return {};
        } else {
            return T{};
        }
    }
    return _state->waiter(
        std::optional<std::chrono::milliseconds>{std::chrono::ceil<std::chrono::milliseconds>(timeout)}
    );
}
 
} // namespace idfxx