Task.h

#pragma once
 
 
 
 
#include <functional>
#include <future>
#include <memory>
#include <string>
 
//--- User configuration header ---//
#include "TasksConfig.h"
 
//--- Debug Macros ---//
#if SQUID_ENABLE_TASK_DEBUG
#define TASK_NAME(...) co_await NAMESPACE_SQUID::SetDebugName(__VA_ARGS__);
#define DEBUG_STR , std::string in_debugStr
#define PASS_DEBUG_STR , in_debugStr
#define MANUAL_DEBUG_STR(debugStr) , debugStr
#define WaitUntilImpl(...) _WaitUntil(__VA_ARGS__, #__VA_ARGS__)
#define WaitWhileImpl(...) _WaitWhile(__VA_ARGS__, #__VA_ARGS__)
#ifndef IN_DOXYGEN
#define WaitUntil(...) WaitUntilImpl(__VA_ARGS__)
#define WaitWhile(...) WaitWhileImpl(__VA_ARGS__)
#endif //IN_DOXYGEN
#else
#define TASK_NAME(...)
#define DEBUG_STR
#define PASS_DEBUG_STR
#define MANUAL_DEBUG_STR(...)
#ifndef IN_DOXYGEN
#define WaitUntil(...) _WaitUntil(__VA_ARGS__)
#define WaitWhile(...) _WaitWhile(__VA_ARGS__)
#endif //IN_DOXYGEN
#endif //SQUID_ENABLE_TASK_DEBUG
 
NAMESPACE_SQUID_BEGIN
 
 
//--- Task Reference Type ---//
enum class eTaskRef 
{
    Strong, 
    Weak, 
};
 
//--- Task Resumable Type ---//
enum class eTaskResumable 
{
    Yes, 
    No, 
};
 
//--- Task Status ---//
enum class eTaskStatus 
{
    Suspended, 
    Done, 
};
 
//--- tTaskCancelFn ---//
using tTaskCancelFn = std::function<bool()>; 
 
// Forward declarations
template <typename tRet, eTaskRef RefType, eTaskResumable Resumable>
class Task; 
template <typename tRet = void>
using TaskHandle = Task<tRet, eTaskRef::Strong, eTaskResumable::No>; 
using WeakTask = Task<void, eTaskRef::Weak, eTaskResumable::Yes>; 
using WeakTaskHandle = Task<void, eTaskRef::Weak, eTaskResumable::No>; 
 
 
 
//--- Suspend Awaiter ---//
struct Suspend : public std::suspend_always
{
};
 
//--- Stop Context ---//
struct StopContext
{
    bool IsStopRequested() const
    {
        return *m_isStoppedPtr;
    }
 
protected:
    friend class TaskInternalBase;
    StopContext(const bool* in_isStoppedPtr)
        : m_isStoppedPtr(in_isStoppedPtr)
    {
    }
 
private:
    const bool* m_isStoppedPtr = nullptr;
};
 
//--- GetStopContext Awaiter ---//
struct GetStopContext
{
};
 
 
//--- Internal Implementation Header ---//
#include "Private/TaskPrivate.h" // Internal use only! Do not move or include elsewhere!
 
 
//--- Task ---//
template <typename tRet = void, eTaskRef RefType = eTaskRef::Strong, eTaskResumable Resumable = eTaskResumable::Yes>
class Task
{
public:
    using tTaskInternal = TaskInternal<tRet>;
    using promise_type = TaskPromise<tRet>;
 
#define NONVOID_ONLY template <typename U = tRet, typename std::enable_if_t<!std::is_void<U>::value>* = nullptr>
 
    // Prohibit illegal task types
    static_assert(RefType == eTaskRef::Strong || std::is_void<tRet>::value, "Illegal task type (cannot combine weak reference type with non-void return type");
 
    Task() 
    {
    }
    Task(nullptr_t) 
    {
    }
    Task(std::shared_ptr<tTaskInternal> in_taskInternal) 
        : m_taskInternal(in_taskInternal)
    {
        AddRef();
    }
    Task(std::coroutine_handle<promise_type> in_coroHandle) 
        : m_taskInternal(std::make_shared<tTaskInternal>(in_coroHandle))
    {
        AddRef();
    }
    Task(const Task& in_otherTask) 
        : m_taskInternal(in_otherTask.GetInternalTask())
    {
        static_assert(IsCopyable(), "Cannot copy-construct Task/WeakTask (only TaskHandle/WeakTaskHandle)");
        AddRef();
    }
    Task(Task&& in_otherTask) noexcept 
        : m_taskInternal(std::move(in_otherTask.m_taskInternal))
    {
        // NOTE: No need to alter logical reference here (this is a move)
    }
    Task& operator=(nullptr_t) noexcept 
    {
        RemoveRef(); // Remove logical reference from old internal task
        m_taskInternal = nullptr;
        return *this;
    }
    Task& operator=(const Task& in_otherTask) 
    {
        static_assert(IsCopyable(), "Cannot copy-assign Task/WeakTask (only TaskHandle/WeakTaskHandle)");
        RemoveRef(); // Remove logical reference from our current internal task
        m_taskInternal = in_otherTask.m_taskInternal;
        AddRef();
        return *this;
    }
    Task& operator=(Task&& in_otherTask) noexcept 
    {
        // If the internal task that we're about to move over can never be resumed again, kill it immediately
        KillIfResumable();
        RemoveRef(); // Remove logical reference from old internal task
        // NOTE: No need to add logical reference here (this is a move)
        m_taskInternal = std::move(in_otherTask.m_taskInternal);
        return *this;
    }
    ~Task() 
    {
        RemoveRef(); // Remove logical reference task
 
        // If the internal task can never be resumed again, kill it immediately
        KillIfResumable();
    }
    bool IsValid() const 
    {
        return m_taskInternal.get();
    }
    operator bool() const 
    {
        return IsValid();
    }
    bool IsDone() const 
    {
        return IsValid() ? m_taskInternal->IsDone() : true;
    }
    bool IsStopRequested() const 
    {
        return IsValid() ? m_taskInternal->IsStopRequested() : true;
    }
    void RequestStop() 
    {
        if(IsValid())
        {
            m_taskInternal->RequestStop(); // Tell sub-tasks to stop, as well
        }
    }
    void Kill() 
    {
        // NOTE: Killing a task immediately destroys the coroutine and all of the coroutine's local variables
        if(IsValid())
        {
            m_taskInternal->Kill();
        }
    }
    NONVOID_ONLY std::optional<tRet> TakeReturnValue() 
    {
        SQUID_RUNTIME_CHECK(IsValid(), "Tried to retrieve return value from an invalid handle");
        return GetInternalTask()->TakeReturnValue();
    }
    eTaskStatus Resume() 
    {
        static_assert(IsResumable(), "Cannot call Resume() on a TaskHandle/WeakTaskHandle");
        return IsValid() ? m_taskInternal->Resume() : eTaskStatus::Done;
    }
 
#if SQUID_ENABLE_TASK_DEBUG
    std::string GetDebugName(std::optional<TaskDebugStackFormatter> in_formatter = {}) const 
    {
        const char* defaultRetVal = Resumable == eTaskResumable::Yes ? "[empty task]" : "[empty task handle]";
        auto debugName = IsValid() ? m_taskInternal->GetDebugName() : defaultRetVal;
        return in_formatter ? in_formatter.value().Format(debugName) : debugName;
    }
    std::string GetDebugStack(std::optional<TaskDebugStackFormatter> in_formatter = {}) const 
    {
        if(IsValid())
        {
            return in_formatter ? in_formatter.value().Format(m_taskInternal->GetDebugStack()) : m_taskInternal->GetDebugStack();
        }
        return GetDebugName(in_formatter);
    }
#else
    std::string GetDebugName(std::optional<TaskDebugStackFormatter> in_formatter = {}) const 
    {
        return ""; // Returns an empty string when task debug is disabled
    }
    std::string GetDebugStack(std::optional<TaskDebugStackFormatter> in_formatter = {}) const 
    {
        return ""; // Returns an empty string when task debug is disabled
    }
#endif //SQUID_ENABLE_TASK_DEBUG
 
 
#if SQUID_USE_EXCEPTIONS
    std::exception_ptr GetUnhandledException() const 
    {
        SQUID_RUNTIME_CHECK(IsValid(), "Tried to retrieve unhandled exception from an invalid handle");
        return m_taskInternal->GetUnhandledException();
    }
    void RethrowUnhandledException() const 
    {
        if(auto e = m_taskInternal->GetUnhandledException())
        {
            std::rethrow_exception(e);
        }
    }
#else
    void RethrowUnhandledException() const 
    {
    }
#endif //SQUID_USE_EXCEPTIONS
 
    // Task conversion methods
    template <typename tOtherRet>
    operator Task<tOtherRet>() const & 
    {
        constexpr bool isLegalReturnTypeConversion = std::is_void<tOtherRet>::value || std::is_same<tRet, tOtherRet>::value;
        constexpr bool isLegalTypeConversion = IsStrong() && IsResumable();
        static_assert(isLegalTypeConversion, "Cannot promote WeakTask/TaskHandle/WeakTaskHandle to Task");
        static_assert(!isLegalTypeConversion || isLegalReturnTypeConversion, "Mismatched return type (invalid return type conversion)");
        static_assert(!isLegalTypeConversion || !isLegalReturnTypeConversion, "Cannot copy Task -> Task because it is non-copyable (try std::move(task))");
        return {};
    }
    template <typename tOtherRet>
    operator Task<tOtherRet>() && 
    {
        constexpr bool isLegalReturnTypeConversion = std::is_void<tOtherRet>::value || std::is_same<tRet, tOtherRet>::value;
        constexpr bool isLegalTypeConversion = IsStrong() && IsResumable();
        static_assert(isLegalTypeConversion, "Cannot promote WeakTask/TaskHandle/WeakTaskHandle to Task");
        static_assert(!isLegalTypeConversion || isLegalReturnTypeConversion, "Cannot convert tasks to non-void return type (invalid return type conversion)");
        
        // Move-to-void conversion (applies to all types)
        return MoveToTask<tOtherRet, RefType, Resumable>();
    }
    operator WeakTask() const & 
    {
        static_assert(IsResumable(), "Cannot convert TaskHandle -> WeakTask (invalid resumability conversion");
        static_assert(!IsResumable(), "Cannot copy Task -> WeakTask because it is non-copyable (try std::move(task))");
        return {};
    }
    operator WeakTask() && 
    {
        static_assert(IsResumable(), "Cannot convert TaskHandle -> WeakTask (invalid resumability conversion)");
        return MoveToTask<void, eTaskRef::Weak, eTaskResumable::Yes>();
    }
    operator TaskHandle<tRet>() const 
    {
        static_assert(IsStrong(), "Cannot convert WeakTask/WeakTaskHandle -> TaskHandle (invalid reference-strength conversion)");
        return CopyToTask<tRet, eTaskRef::Strong, eTaskResumable::No>();
    }
    template <typename tOtherRet>
    operator TaskHandle<tOtherRet>() const 
    {
        constexpr bool isLegalReturnTypeConversion = std::is_void<tOtherRet>::value || std::is_same<tRet, tOtherRet>::value;
        static_assert(IsStrong(), "Cannot convert WeakTask/WeakTaskHandle -> TaskHandle (invalid reference-strength conversion)");
        static_assert(!IsStrong() || isLegalReturnTypeConversion, "Mismatched return type (invalid return type conversion)");
        return CopyToTask<tOtherRet, eTaskRef::Strong, eTaskResumable::No>();
    }
    operator WeakTaskHandle() const 
    {
        // Convert anything to a weak task handle
        return CopyToTask<void, eTaskRef::Weak, eTaskResumable::No>();
    }
 
    // Cancel-If Methods
    auto CancelIf(tTaskCancelFn in_cancelFn) &&
    {
        return CancelTaskIf(std::move(*this), in_cancelFn);
    }
    auto CancelIfStopRequested() && 
    {
        return std::move(*this).CancelIf([this] { return IsStopRequested(); });
    }
    auto CancelIf(tTaskCancelFn in_cancelFn) & 
    {
        static_assert(static_false<tRet>::value, "Cannot call CancelIf() on an lvalue (try std::move(task).CancelIf())");
        return CancelTaskIf(std::move(*this), in_cancelFn);
    }
    auto CancelIfStopRequested() & 
    {
        static_assert(static_false<tRet>::value, "Cannot call CancelIfStopRequested() on an lvalue (try std::move(task).CancelIfStopRequested())");
        return std::move(*this).CancelIf([this] { return IsStopRequested(); });
    }
 
    // Stop-If Methods
    auto StopIf(tTaskCancelFn in_cancelFn) && 
    {
        return StopTaskIf(std::move(*this), in_cancelFn);
    }
    auto StopIf(tTaskCancelFn in_cancelFn) & 
    {
        static_assert(static_false<tRet>::value, "Cannot call StopIf() on an lvalue (try std::move(task).StopIf())");
        return StopTaskIf(std::move(*this), in_cancelFn);
    }
#if SQUID_ENABLE_GLOBAL_TIME
    auto StopIf(tTaskCancelFn in_cancelFn, tTaskTime in_timeout) &&
    {
        // Cannot be called unless SQUID_ENABLE_GLOBAL_TIME has been set in TasksConfig.h.
        return StopTaskIf(std::move(*this), in_cancelFn, in_timeout);
    }
    auto StopIf(tTaskCancelFn in_cancelFn, tTaskTime in_timeout) & 
    {
        static_assert(static_false<tRet>::value, "Cannot call StopIf() on an lvalue (try std::move(task).StopIf())");
        return StopTaskIf(std::move(*this), in_cancelFn, in_timeout);
    }
#else
    auto StopIf(tTaskCancelFn in_cancelFn, tTaskTime in_timeout) && 
    {
        static_assert(static_false<tRet>::value, "Global task time not enabled (see SQUID_ENABLE_GLOBAL_TIME in TasksConfig.h)");
        return StopTaskIf(std::move(*this), in_cancelFn);
    }
    auto StopIf(tTaskCancelFn in_cancelFn, tTaskTime in_timeout) & 
    {
        static_assert(static_false<tRet>::value, "Global task time not enabled (see TasksConfig.h)");
        return StopTaskIf(std::move(*this), in_cancelFn);
    }
#endif //SQUID_ENABLE_GLOBAL_TIME
    template <typename tTimeFn>
    auto StopIf(tTaskCancelFn in_cancelFn, tTaskTime in_timeout, tTimeFn in_timeFn) &&
    {
        return StopTaskIf(std::move(*this), in_cancelFn, in_timeout, in_timeFn);
    }
    template <typename tTimeFn>
    auto StopIf(tTaskCancelFn in_cancelFn, tTaskTime in_timeout, tTimeFn in_timeFn) & 
    {
        static_assert(static_false<tRet>::value, "Cannot call StopIf() on an lvalue (try std::move(task).StopIf())");
        return StopTaskIf(std::move(*this), in_cancelFn, in_timeout, in_timeFn);
    }
 
private:
    template <typename, eTaskRef, eTaskResumable, typename> friend struct TaskAwaiterBase;
    template <typename, eTaskRef, eTaskResumable> friend class Task;
    friend class TaskInternalBase;
 
    // Task Internal Storage
    std::shared_ptr<TaskInternalBase> m_taskInternal;
 
    // Casts the internal task storage pointer to a concrete (non-TaskInternalBase) pointer
    std::shared_ptr<tTaskInternal> GetInternalTask() const
    {
        // We can safely downcast from TaskInternalBase to TaskInternal<void>
        return std::static_pointer_cast<tTaskInternal>(m_taskInternal);
    }
 
    // Copy/Move Implementations
    template <typename tNewRet, eTaskRef NewRefType, eTaskResumable NewResumable>
    Task<tNewRet, NewRefType, NewResumable> CopyToTask() const
    {
        Task<tNewRet, NewRefType, NewResumable> ret;
        ret.m_taskInternal = m_taskInternal;
        ret.AddRef();
        return ret;
    }
 
    template <typename tNewRet, eTaskRef NewRefType, eTaskResumable NewResumable>
    Task<tNewRet, NewRefType, NewResumable> MoveToTask()
    {
        Task<tNewRet, NewRefType, NewResumable> ret;
        ret.m_taskInternal = m_taskInternal;
        ret.AddRef();
        RemoveRef();
        m_taskInternal = nullptr;
        return ret;
    }
 
    // Logical reference management
    void AddRef()
    {
        if(m_taskInternal)
        {
            if(RefType == eTaskRef::Strong)
            {
                m_taskInternal->AddLogicalRef();
            }
        }
    }
    void RemoveRef()
    {
        if(m_taskInternal)
        {
            if(RefType == eTaskRef::Strong)
            {
                m_taskInternal->RemoveLogicalRef();
            }
        }
    }
    void KillIfResumable()
    {
        if (IsResumable() && IsValid())
        {
            Kill();
        }
    }
 
    // Constexpr Helpers
    static constexpr bool IsResumable()
    {
        return Resumable == eTaskResumable::Yes;
    }
    static constexpr bool IsStrong()
    {
        return RefType == eTaskRef::Strong;
    }
    static constexpr bool IsCopyable()
    {
        return !IsResumable();
    }
 
    #undef NONVOID_ONLY
};
 
 
 
template <typename tTimeFn>
tTaskTime GetTimeSince(tTaskTime in_t, tTimeFn in_timeFn)
{
    return in_timeFn() - in_t;
}
 
#if SQUID_ENABLE_GLOBAL_TIME
 
tTaskTime GetGlobalTime();
 
inline auto GlobalTime()
{
    return &GetGlobalTime;
}
 
inline tTaskTime GetTimeSince(tTaskTime in_t)
{
    return GetTimeSince(in_t, GlobalTime());
}
#else
template <typename T = void>
tTaskTime GetTimeSince(tTaskTime in_t)
{
    static_assert(static_false<T>::value, "Global task time not enabled (see SQUID_ENABLE_GLOBAL_TIME in TasksConfig.h)");
    return tTaskTime(0);
}
#endif //SQUID_ENABLE_GLOBAL_TIME
 
 
 
//--- All/Any/Select Tasks ---//
struct TaskWrapper
{
public:
    TaskWrapper(Task<> in_task) : task(std::move(in_task)) {}
    ~TaskWrapper() {}
    Task<> task;
 
    template <typename tRet>
    static std::shared_ptr<TaskWrapper> Wrap(Task<tRet> in_task)
    {
        return std::make_shared<TaskWrapper>(std::move(in_task));
    }
    template <typename tReadyFn>
    static std::shared_ptr<TaskWrapper> Wrap(tReadyFn in_readyFn)
    {
        auto task = [](tReadyFn in_readyFn) -> Task<> { co_await in_readyFn; }(in_readyFn);
        return std::make_shared<TaskWrapper>(std::move(task));
    }
};
 
struct TaskSingleEntry
{
    template <typename tRet>
    TaskSingleEntry(Task<tRet> in_task)
        : taskWrapper(TaskWrapper::Wrap(std::move(in_task)))
    {
    }
    template <typename tReadyFn>
    TaskSingleEntry(tReadyFn in_readyFn)
        : taskWrapper(TaskWrapper::Wrap(in_readyFn))
    {
    }
    auto Resume()
    {
        return taskWrapper->task.Resume();
    }
    std::shared_ptr<TaskWrapper> taskWrapper;
};
 
template <typename tValue>
struct TaskSelectEntry
{
    template <typename tRet>
    TaskSelectEntry(tValue in_value, Task<tRet> in_task)
        : value(in_value)
        , taskWrapper(TaskWrapper::Wrap(std::move(in_task)))
    {
    }
    template <typename tReadyFn>
    TaskSelectEntry(tValue in_value, tReadyFn in_readyFn)
        : value(in_value)
        , taskWrapper(TaskWrapper::Wrap(in_readyFn))
    {
    }
    auto Resume()
    {
        return taskWrapper->task.Resume();
    }
    auto GetValue()
    {
        return value;
    }
    tValue value;
    std::shared_ptr<TaskWrapper> taskWrapper;
};
 
#define TASK_NAME_ENTRIES(name, entries) \
    TASK_NAME(name, [entries]() { \
        std::string debugStr; \
        for(auto entry : entries) \
        { \
            debugStr += debugStr.size() ? "\n" : "\n`"; \
            debugStr += entry.taskWrapper->task.GetDebugStack(); \
        } \
        debugStr += "`\n"; \
        return debugStr; \
    });
 
#define TASK_NAME_ENTRIES_ALL(name, entries) \
    TASK_NAME(name, [entries]() { \
        std::string debugStr; \
        for(auto entry : entries) \
        { \
            debugStr += debugStr.size() ? "\n" : "\n`"; \
            debugStr += entry.taskWrapper->task.GetDebugStack() + (entry.taskWrapper->task.IsDone() ? " [DONE]" : " [RUNNING]"); \
        } \
        debugStr += "`\n"; \
        return debugStr; \
    });
 
inline Task<> WaitForAny(std::vector<TaskSingleEntry> in_entries)
{
    TASK_NAME_ENTRIES(__FUNCTION__, in_entries);
 
    for(auto& entry : in_entries)
    {
        co_await AddStopTask(entry.taskWrapper->task); // Setup stop-request propagation
    }
 
    while(true)
    {
        for(auto& entry : in_entries)
        {
            if(entry.Resume() == eTaskStatus::Done)
            {
                co_return;
            }
        }
        co_await Suspend();
    }
}
 
inline Task<> WaitForAll(std::vector<TaskSingleEntry> in_entries)
{
    TASK_NAME_ENTRIES_ALL(__FUNCTION__, in_entries);
 
    for(auto& entry : in_entries)
    {
        co_await AddStopTask(entry.taskWrapper->task); // Setup stop-request propagation
    }
 
    while(true)
    {
        bool allDone = true;
        for(auto& entry : in_entries)
        {
            if(entry.Resume() != eTaskStatus::Done)
            {
                allDone = false;
            }
        }
        if(allDone)
        {
            co_return; // Done!
        }
        co_await Suspend();
    }
}
 
template<class tValue>
Task<tValue> Select(std::vector<TaskSelectEntry<tValue>> in_entries)
{
    TASK_NAME_ENTRIES(__FUNCTION__, in_entries);
 
    for(auto& entry : in_entries)
    {
        co_await AddStopTask(entry.taskWrapper->task); // Setup stop-request propagation
    }
 
    while(true)
    {
        for(size_t i = 0; i < in_entries.size(); ++i)
        {
            if(in_entries[i].Resume() == eTaskStatus::Done)
            {
                co_return in_entries[i].GetValue();
            }
        }
        co_await Suspend();
    }
    co_return tValue{};
}
 
#ifdef IN_DOXYGEN
inline Task<> WaitUntil(tTaskReadyFn in_readyFn) {}
 
inline Task<> WaitWhile(tTaskReadyFn in_readyFn) {}
#endif // IN_DOXYGEN
 
inline Task<> _WaitUntil(tTaskReadyFn in_readyFn DEBUG_STR) 
{
    TASK_NAME("WaitUntil", [debugStr = FormatDebugString(in_debugStr)]{ return debugStr; });
 
    co_await in_readyFn; // Wait until the ready functor returns true
}
inline Task<> _WaitWhile(tTaskReadyFn in_readyFn DEBUG_STR) 
{
    TASK_NAME("WaitWhile", [debugStr = FormatDebugString(in_debugStr)]{ return debugStr; });
 
    co_await[&in_readyFn]{ return !in_readyFn(); }; // Wait until the ready function returns false
}
 
inline Task<> WaitForever()
{
    return _WaitUntil([]() { return false; } MANUAL_DEBUG_STR("WaitForever"));
}
 
template <typename tTimeFn>
Task<tTaskTime> WaitSeconds(tTaskTime in_seconds, tTimeFn in_timeFn)
{
    auto startTime = in_timeFn();
    TASK_NAME(__FUNCTION__, [in_timeFn, startTime, in_seconds] { return std::to_string(GetTimeSince(startTime, in_timeFn)) + "/" + std::to_string(in_seconds); });
 
    auto IsTimerUp = [in_timeFn, startTime, in_seconds] {
        return GetTimeSince(startTime, in_timeFn) >= in_seconds;
    };
    co_await IsTimerUp; // Wait until the timer is up
    co_return in_timeFn() - startTime - in_seconds;
}
 
template <typename tRet, typename tTimeFn>
auto Timeout(Task<tRet>&& in_task, tTaskTime in_seconds, tTimeFn in_timeFn)
{
    auto IsTimerUp = [in_timeFn, startTime = in_timeFn(), in_seconds]{
        return GetTimeSince(startTime, in_timeFn) >= in_seconds;
    };
    return CancelTaskIf(std::move(in_task), IsTimerUp);
}
 
template <typename tFn, typename tTimeFn>
Task<> DelayCall(tTaskTime in_delaySeconds, tFn in_fn, tTimeFn in_timeFn)
{
    TASK_NAME(__FUNCTION__);
 
    // Call function after N seconds
    co_await WaitSeconds(in_delaySeconds, in_timeFn);
    in_fn();
}
 
#if SQUID_ENABLE_GLOBAL_TIME
inline Task<tTaskTime> WaitSeconds(tTaskTime in_seconds)
{
    return WaitSeconds(in_seconds, GlobalTime());
}
 
template <typename tRet>
auto Timeout(Task<tRet>&& in_task, tTaskTime in_seconds)
{
    return Timeout(std::move(in_task), in_seconds, GlobalTime());
}
 
template <typename tFn>
Task<> DelayCall(tTaskTime in_delaySeconds, tFn in_fn)
{
    return DelayCall(in_delaySeconds, in_fn, GlobalTime());
}
#else
template <typename T = void>
Task<tTaskTime> WaitSeconds(tTaskTime in_seconds) 
{
    static_assert(static_false<T>::value, "Global task time not enabled (see SQUID_ENABLE_GLOBAL_TIME in TasksConfig.h)");
    return Task<tTaskTime>{};
}
template <typename tRet, typename T = void>
auto Timeout(Task<tRet>&& in_task, tTaskTime in_seconds) 
{
    static_assert(static_false<T>::value, "Global task time not enabled (see SQUID_ENABLE_GLOBAL_TIME in TasksConfig.h)");
    return Task<>{};
}
template <typename tFn, typename T = void>
static Task<> DelayCall(tTaskTime in_delaySeconds, tFn in_fn) 
{
    static_assert(static_false<T>::value, "Global task time not enabled (see SQUID_ENABLE_GLOBAL_TIME in TasksConfig.h)");
    return Task<>{};
}
#endif //SQUID_ENABLE_GLOBAL_TIME
 
//--- Cancel-If Implementation ---//
template <typename tRet>
Task<std::optional<tRet>> CancelIfImpl(Task<tRet> in_task, tTaskCancelFn in_cancelFn) 
{
    TASK_NAME("CancelIf", [taskHandle = TaskHandle<tRet>(in_task)]{ return taskHandle.GetDebugStack(); });
 
    co_await AddStopTask(in_task); // Setup stop-request propagation
 
    while(true)
    {
        if(in_cancelFn && in_cancelFn())
        {
            co_return{};
        }
        auto taskStatus = in_task.Resume();
        if(taskStatus == eTaskStatus::Done)
        {
            co_return in_task.TakeReturnValue();
        }
        co_await Suspend();
    }
    co_return{};
}
inline Task<bool> CancelIfImpl(Task<> in_task, tTaskCancelFn in_cancelFn) 
{
    TASK_NAME("CancelIf", [taskHandle = TaskHandle<>(in_task)]{ return taskHandle.GetDebugStack(); });
 
    co_await AddStopTask(in_task); // Setup stop-request propagation
 
    while(true)
    {
        if(in_cancelFn && in_cancelFn())
        {
            co_return false;
        }
        auto taskStatus = in_task.Resume();
        if(taskStatus == eTaskStatus::Done)
        {
            co_return true;
        }
        co_await Suspend();
    }
    co_return false;
}
template <typename tRet, eTaskRef RefType, eTaskResumable Resumable>
auto CancelTaskIf(Task<tRet, RefType, Resumable>&& in_task, tTaskCancelFn in_cancelFn) 
{
    static_assert(RefType == eTaskRef::Strong && Resumable == eTaskResumable::Yes, "Cannot call CancelIf() on WeakTask, TaskHandle or WeakTaskHandle");
    return CancelIfImpl(std::move(in_task), in_cancelFn);
}
 
//--- Stop-If Implementation ---//
template <typename tRet, typename tTimeFn>
Task<std::optional<tRet>> StopIfImpl(Task<tRet> in_task, tTaskCancelFn in_cancelFn, std::optional<tTaskTime> in_timeout, tTimeFn in_timeFn) 
{
    TASK_NAME("StopIf", [taskHandle = TaskHandle<tRet>(in_task), in_timeout]{
        return std::string("timeout = ") + (in_timeout ? std::to_string(in_timeout.value()) : "none") + ", task = " + taskHandle.GetDebugStack();
        });
 
    co_await AddStopTask(in_task); // Setup stop-request propagation
 
    while(true)
    {
        if(!in_task.IsStopRequested() && in_cancelFn && in_cancelFn())
        {
            in_task.RequestStop();
            if(in_timeout.has_value())
            {
                co_return co_await Timeout(std::move(in_task), in_timeout.value(), in_timeFn);
            }
        }
        auto taskStatus = in_task.Resume();
        if(taskStatus == eTaskStatus::Done)
        {
            co_return in_task.TakeReturnValue();
        }
        co_await Suspend();
    }
}
template <typename tTimeFn>
Task<bool> StopIfImpl(Task<> in_task, tTaskCancelFn in_cancelFn, std::optional<tTaskTime> in_timeout, tTimeFn in_timeFn) 
{
    TASK_NAME("StopIf", [taskHandle = TaskHandle<>(in_task), in_timeout]{
        return std::string("timeout = ") + (in_timeout ? std::to_string(in_timeout.value()) : "none") + ", task = " + taskHandle.GetDebugStack();
        });
 
    co_await AddStopTask(in_task); // Setup stop-request propagation
 
    while(true)
    {
        if(!in_task.IsStopRequested() && in_cancelFn && in_cancelFn())
        {
            in_task.RequestStop();
            if(in_timeout)
            {
                co_return co_await Timeout(std::move(in_task), in_timeout.value(), in_timeFn);
            }
        }
        auto taskStatus = in_task.Resume();
        if(taskStatus == eTaskStatus::Done)
        {
            co_return true;
        }
        co_await Suspend();
    }
    co_return false;
}
template <typename tRet, eTaskRef RefType, eTaskResumable Resumable>
auto StopTaskIf(Task<tRet, RefType, Resumable>&& in_task, tTaskCancelFn in_cancelFn) 
{
    return StopIfImpl(std::move(in_task), in_cancelFn, {}, (float(*)())nullptr);
}
 
#if SQUID_ENABLE_GLOBAL_TIME
template <typename tRet, eTaskRef RefType, eTaskResumable Resumable>
auto StopTaskIf(Task<tRet, RefType, Resumable>&& in_task, tTaskCancelFn in_cancelFn, tTaskTime in_timeout) 
{
    return StopIfImpl(std::move(in_task), in_cancelFn, in_timeout, GlobalTime()); // Default time function to global-time
}
#else
template <typename tRet, eTaskRef RefType, eTaskResumable Resumable>
auto StopTaskIf(Task<tRet, RefType, Resumable>&& in_task, tTaskCancelFn in_cancelFn, tTaskTime in_timeout) 
{
    static_assert(static_false<tRet>::value, "Global task time not enabled (see SQUID_ENABLE_GLOBAL_TIME in TasksConfig.h)");
    return StopIfImpl(std::move(in_task), in_cancelFn, in_timeout, nullptr); // Default time function to global-time
}
#endif //SQUID_ENABLE_GLOBAL_TIME
 
template <typename tRet, eTaskRef RefType, eTaskResumable Resumable, typename tTimeFn>
auto StopTaskIf(Task<tRet, RefType, Resumable>&& in_task, tTaskCancelFn in_cancelFn, tTaskTime in_timeout, tTimeFn in_timeFn) 
{
    // See forward-declaration for default arguments
    static_assert(RefType == eTaskRef::Strong && Resumable == eTaskResumable::Yes, "Cannot call StopIf() on WeakTask, TaskHandle or WeakTaskHandle");
    return StopIfImpl(std::move(in_task), in_cancelFn, in_timeout, in_timeFn);
}
 
 
NAMESPACE_SQUID_END