Coroutine.h

/*
 * Copyright (C) 2026 by Marc Boris Duerner
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * As a special exception, you may use this file as part of a free
 * software library without restriction. Specifically, if other files
 * instantiate templates or use macros or inline functions from this
 * file, or you compile this file and link it with other files to
 * produce an executable, this file does not by itself cause the
 * resulting executable to be covered by the GNU General Public
 * License. This exception does not however invalidate any other
 * reasons why the executable file might be covered by the GNU Library
 * General Public License.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the:
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301 USA
 */
 
#ifndef PT_COROUTINE_H
#define PT_COROUTINE_H
 
#include <Pt/Api.h>
#include <Pt/Connectable.h>
 
#if __cplusplus >= 202002L
 
#include <coroutine>
#include <exception>
#include <stdexcept>
 
namespace Pt {

class AwaiterBase
{
    public:
        virtual void cancel() = 0;
 
    protected:
        AwaiterBase() = default;

        AwaiterBase(const AwaiterBase&) = delete;

        AwaiterBase& operator=(const AwaiterBase&) = delete;

        virtual ~AwaiterBase() = default;
};

class Awaiter : public AwaiterBase
{
    public:
        bool await_ready() const
        { return false; }

        template<typename P>
        bool await_suspend(std::coroutine_handle<P> h)
        {
            _handle = h;
            onBegin();
            return true;
        }

        void cancel() override
        {
            _handle = nullptr;
            onCancel();
        }
 
    protected:
        Awaiter()
        {}

        void setReady()
        {
            if( _handle )
            {
                std::coroutine_handle<> h = _handle;
                _handle = nullptr;
                h.resume();
            }
        }
 
    protected:
        virtual void onBegin() = 0;

        virtual void onCancel() = 0;
 
    protected:
        std::coroutine_handle<> _handle;
};
 

template<typename R>
class BasicAwaiter : public Awaiter
{
    public:
        R await_resume()
        {
            return onReady();
        }
 
    protected:
        virtual R onReady() = 0;
};
 

template<>
class BasicAwaiter<void> : public Awaiter
{
    public:
        void await_resume()
        { onReady(); }
 
    protected:
        virtual void onReady() = 0;
};
 

class PromiseBase
{
    public:
        void setFinished()
        {
            _pending = nullptr;
        }
 
        void cancel()
        {
            AwaiterBase* pending = _pending;
            _pending = nullptr;
            if(pending)
            {
                pending->cancel();
            }
        }
 
        AwaiterBase*            _pending      = nullptr;
        std::coroutine_handle<> _continuation = nullptr;
        PromiseBase*            _outer        = nullptr;
 
    protected:
        PromiseBase() = default;
        ~PromiseBase() = default;
 
        PromiseBase(const PromiseBase&) = delete;
        PromiseBase& operator=(const PromiseBase&) = delete;
};
 

template<typename T>
class PromiseResult
{
    public:
        void return_value(T v)
        { _result = std::move(v); }
 
        T getResult()
        { return std::move(_result); }
 
        T _result{};
 
    protected:
        PromiseResult() = default;
        ~PromiseResult() = default;
 
        PromiseResult(const PromiseResult&) = delete;
        PromiseResult& operator=(const PromiseResult&) = delete;
};
 

template<typename T>
class PromiseResult<T&>
{
    public:
        void return_value(T& v)
        { _result = &v; }
 
        T& getResult()
        { return *_result; }
 
        T* _result = nullptr;
 
    protected:
        PromiseResult() = default;
        ~PromiseResult() = default;
 
        PromiseResult(const PromiseResult&) = delete;
        PromiseResult& operator=(const PromiseResult&) = delete;
};
 

template<>
class PromiseResult<void>
{
    public:
        void return_void()
        {}
 
        void getResult()
        {}
 
    protected:
        PromiseResult() = default;
        ~PromiseResult() = default;
 
        PromiseResult(const PromiseResult&) = delete;
        PromiseResult& operator=(const PromiseResult&) = delete;
};
 

template<typename A>
class AwaiterProxy
{
    public:
        A&& _awaitable;
        PromiseBase* _promise;
 
        bool await_ready()
        { return _awaitable.await_ready(); }
 
        template<typename P>
        auto await_suspend(std::coroutine_handle<P> h) -> decltype(_awaitable.await_suspend(h))
        { return _awaitable.await_suspend(h); }
 
        auto await_resume() -> decltype(_awaitable.await_resume())
        {
            _promise->setFinished();
            return _awaitable.await_resume();
        }
};
 

class FinalAwaiter
{
    public:
        bool await_ready() const noexcept
        { return false; }
 
        template<typename P>
        std::coroutine_handle<> await_suspend(std::coroutine_handle<P> h) noexcept
        {
            PromiseBase* outer = h.promise()._outer;
 
            if( outer && outer != &h.promise() )
                outer->setFinished();
 
            h.promise()._outer = nullptr;
 
            if( h.promise()._continuation )
                return h.promise()._continuation;
 
            return std::noop_coroutine();
        }
 
        void await_resume() noexcept
        {}
};

template<typename T = void>
class Task : public AwaiterBase
{
    public:
        class Promise : public PromiseResult<T>
                      , public PromiseBase
        {
            public:
                std::exception_ptr _exception;
 
                template<typename A>
                AwaiterProxy<A> await_transform(A&& a)
                {
                    _pending = &a;
                    return AwaiterProxy<A>{ std::forward<A>(a), this };
                }
 
                Task get_return_object()
                {
                    return Task(std::coroutine_handle<promise_type>::from_promise(*this));
                }
 
                std::suspend_always initial_suspend() noexcept
                { return {}; }
 
                FinalAwaiter final_suspend() noexcept
                { return {}; }
 
                void unhandled_exception()
                { _exception = std::current_exception(); }
        };
 
        using promise_type = Promise;
        using handle_type = std::coroutine_handle<promise_type>;
 
    public:
        Task() noexcept
        : _handle(nullptr)
        {}

        explicit Task(handle_type h)
        : _handle(h)
        {}

        Task(Task&& other) noexcept
        : _handle(other._handle)
        {
            other._handle = nullptr;
        }

        Task& operator=(Task&& other) noexcept
        {
            if(this != &other)
            {
                cancel();
                _handle = other._handle;
                other._handle = nullptr;
            }
            return *this;
        }

        ~Task()
        { cancel(); }

        void run()
        {
            if( _handle && ! _handle.done() )
            {
                if (_handle.promise()._outer)
                    throw std::logic_error("task pending");
 
                _handle.promise()._outer = &_handle.promise();
                _handle.resume();
            }
        }

        void cancel() override
        {
            if( _handle )
            {
                _handle.promise().cancel();
                handle_type handle = _handle;
                _handle = nullptr;
                handle.destroy();
            }
        }

        bool done() const
        { return _handle && _handle.done(); }

        explicit operator bool() const
        { return _handle != nullptr; }

        T result()
        {
            if( _handle.promise()._exception )
                std::rethrow_exception(_handle.promise()._exception);
 
            return _handle.promise().getResult();
        }

        bool await_ready() const noexcept
        { return done(); }

        template<typename P>
        std::coroutine_handle<> await_suspend(std::coroutine_handle<P> outer)
        {
            if(_handle.promise()._outer)
            {
                throw std::logic_error("task pending");
            }
 
            _handle.promise()._continuation = outer;
            _handle.promise()._outer = &outer.promise();
            return _handle;
        }

        T await_resume()
        {
            if( _handle.promise()._exception )
                std::rethrow_exception(_handle.promise()._exception);
 
            return _handle.promise().getResult();
        }
 
    private:
        Task(const Task&) = delete;
        Task& operator=(const Task&) = delete;
 
        handle_type _handle;
 
};
 
} // namespace Pt
 
#endif // __cplusplus >= 202002L
 
#endif // PT_COROUTINE_H