task_utils.h

 
 
#pragma once
 
#include <functional>
#include <system/object.h>
#include <system/collections/ienumerable.h>
#include <system/linq/enumerable.h>
#include <system/threading/tasks/task.h>
#include <system/threading/tasks/result_task.h>
#include <system/threading/tasks/async.h>
#include <system/array.h>
 
#undef Yield
 
namespace System {
 
namespace Runtime { namespace CompilerServices {
 
class ASPOSECPP_SHARED_CLASS YieldAwaitable
{
public:
    class ASPOSECPP_SHARED_CLASS YieldAwaiter
    {
    public:
        bool get_IsCompleted() const {return false;}
        
        ASPOSECPP_SHARED_API void OnCompleted(const Action<>& continuation);
        
        void GetResult() const {}
 
        static constexpr bool continueOnCapturedContext = false;
    };
 
    YieldAwaiter GetAwaiter() const
    {
        return YieldAwaiter();
    }
};
 
}} // namespace Runtime::CompilerServices
 
namespace Threading {
 
class CancellationToken;
 
namespace Tasks {
 
ASPOSECPP_SHARED_API TaskPtr Delay(int32_t millisecondsDelay);
 
ASPOSECPP_SHARED_API TaskPtr Delay(int32_t millisecondsDelay, const CancellationToken& cancellationToken);
 
ASPOSECPP_SHARED_API TaskPtr FromCanceled(const CancellationToken& cancellationToken);
 
ASPOSECPP_SHARED_API TaskPtr FromException(const Exception& exception);
 
template<typename TResult>
RTaskPtr<TResult> FromException(const Exception& exception)
{
    return MakeAsync<TResult>([=](System::Details::ResultAsyncContext<TResult>& __context) { exception.Throw(); });
}
 
template <typename TResult>
RTaskPtr<TResult> FromResult(TResult result)
{
    return MakeObject<ResultTask<TResult>>(result);
}
 
ASPOSECPP_SHARED_API TaskPtr Run(const Action<>& action);
 
ASPOSECPP_SHARED_API TaskPtr Run(const Action<>& action, const CancellationToken& cancellationToken);
 
ASPOSECPP_SHARED_API TaskPtr Run(const Func<TaskPtr>& function);
 
template <typename TResult>
RTaskPtr<TResult> Run(const Func<TResult>& function)
{
    auto result = MakeObject<ResultTask<TResult>>(function);
    result->Start();
    return result;
}
 
ASPOSECPP_SHARED_API void WaitAll(const ArrayPtr<TaskPtr>& tasks, const CancellationToken& cancellationToken);
 
ASPOSECPP_SHARED_API void WaitAll(const ArrayPtr<TaskPtr>& tasks);
 
ASPOSECPP_SHARED_API int32_t WaitAny(const ArrayPtr<TaskPtr>& tasks, const CancellationToken& cancellationToken);
 
ASPOSECPP_SHARED_API int32_t WaitAny(const ArrayPtr<TaskPtr>& tasks);
 
ASPOSECPP_SHARED_API TaskPtr WhenAll(const ArrayPtr<TaskPtr>& tasks);
 
ASPOSECPP_SHARED_API TaskPtr WhenAll(const SharedPtr<Collections::Generic::IEnumerable<TaskPtr>>& tasks);
 
template <typename TResult>
RTaskPtr<ArrayPtr<TResult>> WhenAll(const SharedPtr<Collections::Generic::IEnumerable<RTaskPtr<TResult>>>& tasks)
{
    return WhenAll(tasks->LINQ_ToArray());
}
 
template <typename TResult>
RTaskPtr<ArrayPtr<TResult>> WhenAll(const ArrayPtr<RTaskPtr<TResult>>& tasks)
{
    auto size = tasks->get_Length();
    if (size == 0)
    {
        return FromResult(MakeArray<TResult>(0));
    }
    else if (size == 1)
    {
        return tasks[0]->ContinueWith(Func<TaskPtr, ArrayPtr<TResult>>([task = tasks[0]](const TaskPtr&) mutable
        {
            auto result = task->get_Result();
            task = nullptr;
            return MakeArray<TResult>({result});
        }));
    }
    else return WhenAll(tasks->template LINQ_Cast<TaskPtr>())->ContinueWith(Func<TaskPtr, ArrayPtr<TResult>>([tasks_copy = tasks, size](const TaskPtr&) mutable
    {
        auto result = MakeArray<TResult>(size);
        for (auto i = 0; i < size; ++i)
        {
            result[i] = tasks_copy[i]->get_Result();
        }
        tasks_copy = nullptr;
        return result;
    }));
}
 
ASPOSECPP_SHARED_API RTaskPtr<TaskPtr> WhenAny(const SharedPtr<Collections::Generic::IEnumerable<TaskPtr>>& tasks);
 
ASPOSECPP_SHARED_API RTaskPtr<TaskPtr> WhenAny(const ArrayPtr<TaskPtr>& tasks);
 
template <typename TResult>
RTaskPtr<RTaskPtr<TResult>> WhenAny(const ArrayPtr<RTaskPtr<TResult>>& tasks)
{
    return WhenAny(tasks->template LINQ_Cast<TaskPtr>())->ContinueWith(Func<RTaskPtr<TaskPtr>, RTaskPtr<TResult>>([](const RTaskPtr<TaskPtr>& task)
    {
        return ExplicitCast<ResultTask<TResult>>(task->get_Result());
    }));
}
 
template <typename TResult>
RTaskPtr<RTaskPtr<TResult>> WhenAny(const SharedPtr<Collections::Generic::IEnumerable<RTaskPtr<TResult>>>& tasks)
{
    return WhenAny(tasks->LINQ_ToArray());
}
 
ASPOSECPP_SHARED_API Runtime::CompilerServices::YieldAwaitable Yield();
 
}}} // namespace System::Threading::Tasks