async.h

 
#pragma once
 
#include <functional>
#include <system/object.h>
#include <system/action.h>
#include <system/threading/tasks/task.h>
#include <system/threading/tasks/task_status.h>
#include <system/threading/tasks/task_scheduler.h>
#include <system/details/dereference.h>
 
namespace System { namespace Details {
 
struct ASPOSECPP_SHARED_CLASS AsyncContext
{
    AsyncContext(Threading::Tasks::Task* task) : m_task(task) {}
 
    void Step(int32_t s) {stage = s;}
    ASPOSECPP_SHARED_API void Return();
    ASPOSECPP_SHARED_API void Continue();
    template<typename T>
    bool Await(const T& awaitee, int32_t step)
    {
        return AwaitImpl(awaitee, step, [](const auto& awaiter) { awaiter.GetResult(); });
    }
    template <typename T, typename V>
    bool Await(const T& awaitee, V& value, int32_t step)
    {
        return AwaitImpl(awaitee, step, [&value](const auto& awaiter) { value = awaiter.GetResult(); });
    }
 
    int32_t stage = 0;
 
protected:
    template <typename AwaiteeT, typename ContinuerT>
    bool AwaitImpl(const AwaiteeT& awaitee, int32_t step, const ContinuerT& continuer)
    {
        stage = step;
 
        auto awaiter = Dereference(awaitee).GetAwaiter();
        if (awaiter.get_IsCompleted())
        {
            continuer(awaiter);
            return false;
        }
 
        m_task->set_Status(Threading::Tasks::TaskStatus::WaitingForChildrenToComplete);
 
        auto continuationContext =
            awaiter.continueOnCapturedContext
                ? Threading::Tasks::TaskScheduler::FromCurrentSynchronizationContext().GetPointer()
                : nullptr;
 
        awaiter.OnCompleted(Action<>([this, awaiter, continuer, continuationContext]
        {
            m_continuer = [awaiter, continuer](){continuer(awaiter);};
            m_task->set_Status(Threading::Tasks::TaskStatus::WaitingForActivation);
            m_task->Activate(continuationContext);
        }));
 
        return true;
    }
 
    Threading::Tasks::Task* m_task;
    std::function<void()>   m_continuer;
};
 
using AsyncFunction = std::function<void(AsyncContext&)>;
 
template<typename T>
struct ResultAsyncContext : AsyncContext
{
    ResultAsyncContext(Threading::Tasks::ResultTask<T>* task) : AsyncContext(task), m_result_task(task) {}
 
    void Return(const T& result)
    {
        m_result_task->set_Result(result);
 
        AsyncContext::Return();
    }
 
protected:
    Threading::Tasks::ResultTask<T>* m_result_task;
};
 
template<typename T>
using ResultAsyncFunction = std::function<void(ResultAsyncContext<T>&)>;
 
} // namespace Details
 
ASPOSECPP_SHARED_API TaskPtr MakeAsync(const Details::AsyncFunction& fnc);
 
template<typename T>
RTaskPtr<T> MakeAsync(const Details::ResultAsyncFunction<T>& fnc)
{
    auto result = System::MakeObject<Threading::Tasks::ResultTask<T>>();
    Details::ResultAsyncContext<T> context(result.GetPointer());
    result->set_Function([fnc, context]() mutable { fnc(context); });
    result->RunSynchronously();
    return result;
}
 
} // namespace System