Coroutine.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include <exception>
 
#if !defined(__cpp_coroutines) && !defined(__cpp_impl_coroutine)
#error "Generator: Unsupported platform!"
#endif
 
#include <coroutine>
 
namespace CeresEngine {
 
    using std::coroutine_handle;
    using std::coroutine_traits;
    using std::suspend_always;
    using std::suspend_never;
 
    template<typename T = void> using CoroutineHandle = std::coroutine_handle<T>;
 
    template<typename T> using CoroutineTraits = std::coroutine_traits<T>;
 
    using SuspendAlways = std::suspend_always;
 
    using SuspendNever = std::suspend_never;
 
    class VoidCoroutine final {
    public:
        class promise_type final { // NOLINT(readability-identifier-naming)
        public:
            [[nodiscard]] static constexpr auto initial_suspend() noexcept { // NOLINT(readability-identifier-naming)
                return SuspendNever{};
            }
 
            [[nodiscard]] static constexpr auto final_suspend() noexcept { // NOLINT(readability-identifier-naming)
                return SuspendNever{};
            }
 
            static constexpr void return_void() noexcept { // NOLINT(readability-identifier-naming)
                // nothing to do because this is `void` return
            }
 
            static void unhandled_exception() noexcept(false) { // NOLINT(readability-identifier-naming)
                std::terminate();
            }
 
            [[nodiscard]] constexpr VoidCoroutine get_return_object() noexcept { // NOLINT(readability-identifier-naming)
                return VoidCoroutine(this);
            }
 
            [[nodiscard]] static constexpr VoidCoroutine get_return_object_on_allocation_failure() noexcept { // NOLINT(readability-identifier-naming)
                return VoidCoroutine(nullptr);
            }
        };
 
    public:
        explicit constexpr VoidCoroutine(const promise_type*) noexcept {}
    };
 
    class ResumableFunction final {
    public:
        class promise_type;
 
    private:
        CoroutineHandle<void> handle = nullptr;
 
    public:
        ResumableFunction() noexcept = default;
        explicit ResumableFunction(promise_type* ptr) noexcept { handle = CoroutineHandle<promise_type>::from_promise(*ptr); }
 
    public:
        [[nodiscard]] auto get() const noexcept { return handle; }
 
        explicit operator CoroutineHandle<void>() const noexcept { return handle; }
 
        const CoroutineHandle<void>* operator->() const noexcept { return &handle; }
 
        CoroutineHandle<void>* operator->() noexcept { return &handle; }
 
        const CoroutineHandle<void>& operator*() const noexcept { return handle; }
 
        CoroutineHandle<void>& operator*() noexcept { return handle; }
 
    public:
        class promise_type final {
        public:
            auto initial_suspend() noexcept { return suspend_always{}; }
 
            auto final_suspend() noexcept {
                // !!! notice this behavior !!!
                return suspend_always{};
            }
 
            void return_void() noexcept {
                // nothing to do because this is `void` return
            }
 
            void unhandled_exception() noexcept(false) {
                // user can customize this point with std::current_exception ...
                // by default, terminate the program.
                std::terminate();
            }
 
            ResumableFunction get_return_object() noexcept { return ResumableFunction(this); }
        };
    };
} // namespace CeresEngine