129 lines
4.6 KiB
C++
129 lines
4.6 KiB
C++
#pragma once
|
|
|
|
// ============================================================================
|
|
// WaitConditions.hpp — waitForSeconds / waitUntil / waitWhile / waitFor.
|
|
//
|
|
// This file is NOT part of the coroutine engine. Everything here is built
|
|
// entirely on top of the public core API (Coroutine's generic "co_yield
|
|
// anything invocable as bool()" support, and CoroutineHandle::isRunning()) --
|
|
// Coroutine.h and CoroutineRunner.h have no idea any of this exists.
|
|
//
|
|
// Each helper below just returns a small callable object with a
|
|
// `bool operator()() const`. co_yield-ing that object works because of
|
|
// Coroutine::promise_type's generic yield_value<F> overload, not because of
|
|
// anything specific to these types. Writing your own wait condition is the
|
|
// same one-line pattern: define a small callable, co_yield it (optionally
|
|
// through a helper function like the ones below, for a readable call site).
|
|
// ============================================================================
|
|
|
|
#include <chrono>
|
|
#include <type_traits>
|
|
#include <utility>
|
|
|
|
#include <acrux/coroutines/CoroutineHandle.h>
|
|
|
|
namespace acrux::coroutines::standard
|
|
{
|
|
namespace detail
|
|
{
|
|
// co_yield waitForSeconds(2.5f) -- resumes once `seconds` of real time
|
|
// has elapsed. The clock starts on this condition's FIRST evaluation
|
|
// (the first time CoroutineRunner::update() checks it after the
|
|
// coroutine suspends), not when waitForSeconds() itself was called.
|
|
class SecondsCondition
|
|
{
|
|
public:
|
|
explicit SecondsCondition(float seconds) noexcept : m_durationSeconds(seconds) {}
|
|
|
|
bool operator()() const
|
|
{
|
|
auto now = std::chrono::steady_clock::now();
|
|
if (!m_started)
|
|
{
|
|
m_startTime = now;
|
|
m_started = true;
|
|
return false;
|
|
}
|
|
std::chrono::duration<float> elapsed = now - m_startTime;
|
|
return elapsed.count() >= m_durationSeconds;
|
|
}
|
|
|
|
private:
|
|
float m_durationSeconds;
|
|
mutable std::chrono::steady_clock::time_point m_startTime{};
|
|
mutable bool m_started = false;
|
|
};
|
|
|
|
// co_yield waitFor(handle) -- resumes once `handle` is no longer
|
|
// running. Implemented purely through CoroutineHandle's public API
|
|
// (isRunning()), so it works the same as co_yield-ing the handle
|
|
// directly (a core feature); this exists only so a call site reading
|
|
// "waitFor" lines up with the other wait* helpers.
|
|
class HandleCondition
|
|
{
|
|
public:
|
|
explicit HandleCondition(CoroutineHandle handle) noexcept : m_handle(handle) {}
|
|
|
|
bool operator()() const { return !m_handle.isRunning(); }
|
|
|
|
private:
|
|
CoroutineHandle m_handle;
|
|
};
|
|
|
|
// co_yield waitWhile(predicate) -- resumes once `predicate()` returns
|
|
// false. A thin wrapper negating whatever predicate was passed in.
|
|
template <typename F>
|
|
class NegatedCondition
|
|
{
|
|
public:
|
|
explicit NegatedCondition(F predicate) : m_predicate(std::move(predicate)) {}
|
|
|
|
bool operator()() const { return !m_predicate(); }
|
|
|
|
private:
|
|
F m_predicate;
|
|
};
|
|
}
|
|
|
|
inline detail::SecondsCondition waitForSeconds(float seconds)
|
|
{
|
|
return detail::SecondsCondition(seconds);
|
|
}
|
|
|
|
// Waits for a coroutine that was started earlier (e.g. via the free
|
|
// function startCoroutine() in CoroutineRunner.h) WITHOUT yielding at
|
|
// that time. Equivalent to `co_yield handle` directly — provided here
|
|
// so waiting on a handle reads the same way as the other wait* helpers:
|
|
//
|
|
// CoroutineHandle bg = startCoroutine(controller.fadeOut(delta)); // fire, don't wait yet
|
|
// ... do other stuff, possibly across several co_yields ...
|
|
// co_yield waitFor(bg); // now block until it's done
|
|
inline detail::HandleCondition waitFor(CoroutineHandle handle)
|
|
{
|
|
return detail::HandleCondition(handle);
|
|
}
|
|
|
|
// Accepts any callable convertible to bool() — including lambdas that
|
|
// capture `this` or a member coroutine's arguments/locals by value or
|
|
// reference. This is what makes waitUntil/waitWhile usable from
|
|
// non-static member coroutines. Returned by value; co_yield can also
|
|
// accept `predicate` directly without this wrapper, since Coroutine's
|
|
// core yield_value already accepts any bool()-invocable object -- this
|
|
// exists purely so the call site reads "waitUntil".
|
|
template <typename F>
|
|
inline std::decay_t<F> waitUntil(F&& predicate)
|
|
{
|
|
static_assert(std::is_invocable_r_v<bool, std::decay_t<F>&>,
|
|
"waitUntil requires a callable convertible to bool().");
|
|
return std::forward<F>(predicate);
|
|
}
|
|
|
|
template <typename F>
|
|
inline detail::NegatedCondition<std::decay_t<F>> waitWhile(F&& predicate)
|
|
{
|
|
static_assert(std::is_invocable_r_v<bool, std::decay_t<F>&>,
|
|
"waitWhile requires a callable convertible to bool().");
|
|
return detail::NegatedCondition<std::decay_t<F>>(std::forward<F>(predicate));
|
|
}
|
|
}
|