coroutine.hpp

Go to the documentation of this file.

#pragma once

#include <chrono>
#include <coroutine>
#include <functional>
#include <unordered_map>

#include "Mountain/core.hpp"
#include "Mountain/utils/guid.hpp"


namespace Mountain
{
    // Everything named using the snake_case convention in this file is required by C++20 coroutines: https://en.cppreference.com/w/cpp/language/coroutines

    class Coroutine
    {
        struct Awaitable;

    public:
        using AwaitType = std::chrono::duration<double_t>;

        struct promise_type
        {
            AwaitType awaitValue = AwaitType::zero();

            MOUNTAIN_API Coroutine get_return_object();

            MOUNTAIN_API std::suspend_always initial_suspend();

            MOUNTAIN_API std::suspend_always final_suspend() noexcept;

            [[noreturn]]
            MOUNTAIN_API void unhandled_exception();

            MOUNTAIN_API void return_void();

            MOUNTAIN_API Awaitable await_transform(const AwaitType& duration);

            MOUNTAIN_API Awaitable await_transform(float_t duration);

            MOUNTAIN_API std::suspend_always yield_value(nullptr_t);
        };

    private:
        struct Awaitable
        {
            MOUNTAIN_API bool_t await_ready();

            MOUNTAIN_API void await_suspend(std::coroutine_handle<promise_type>);

            MOUNTAIN_API void await_resume();
        };

        MOUNTAIN_API static inline std::unordered_map<Guid, Coroutine> m_RunningRoutines;

    public:
        using HandleType = std::coroutine_handle<promise_type>;

        MOUNTAIN_API static Guid Start(Coroutine&& coroutine);

        MOUNTAIN_API static void Start(Coroutine&& coroutine, Guid* coroutineId);

        MOUNTAIN_API static void UpdateAll();

        MOUNTAIN_API static void Stop(const Guid& coroutineId);

        MOUNTAIN_API static void StopAll();

        [[nodiscard]]
        MOUNTAIN_API static bool_t IsRunning(const Guid& coroutineId);

        [[nodiscard]]
        MOUNTAIN_API static bool_t IsRunningAndNotEmpty(const Guid& coroutineId);

        [[nodiscard]]
        MOUNTAIN_API static size_t GetRunningCount();

        MOUNTAIN_API Coroutine() = default;

        // ReSharper disable once CppNonExplicitConvertingConstructor
        [[nodiscard]]
        MOUNTAIN_API Coroutine(HandleType handle);

        MOUNTAIN_API Coroutine& operator=(HandleType handle) noexcept;

        MOUNTAIN_API ~Coroutine();

        // Delete copy operations
        Coroutine(const Coroutine&) = delete;
        Coroutine& operator=(const Coroutine&) = delete;

        // Define move operations
        [[nodiscard]]
        MOUNTAIN_API Coroutine(Coroutine&& other) noexcept;
        MOUNTAIN_API Coroutine& operator=(Coroutine&& other) noexcept;

        MOUNTAIN_API void Resume() const;

        MOUNTAIN_API void ResumeSafe() const;

        [[nodiscard]]
        MOUNTAIN_API bool_t Finished() const;

        [[nodiscard]]
        MOUNTAIN_API bool_t FinishedSafe() const;

        MOUNTAIN_API void Destroy();

        MOUNTAIN_API void DestroySafe();

        [[nodiscard]]
        MOUNTAIN_API bool_t Valid() const;

        MOUNTAIN_API void Reset();

        [[nodiscard]]
        MOUNTAIN_API Guid GetId() const;

    private:
        HandleType m_Handle;

        Guid m_Id;

        Coroutine(const Guid& guid, HandleType handle);
    };

    template <typename... Args>
    using CoroutineFunction = std::function<Coroutine(Args...)>;
}