task_utils.h

 
#pragma once
 
#include <functional>
#include <system/object.h>
#include <system/collections/ienumerable.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);
 
//
// Summary:
//     Creates a System.Threading.Tasks.Task that has completed with a specified exception.
//
// Parameters:
//   exception:
//     The exception with which to complete the task.
//
// Returns:
//     The faulted task.
ASPOSECPP_SHARED_API TaskPtr FromException(const Exception& exception);
 
//
// Summary:
//     Creates a System.Threading.Tasks.Task`1 that's completed with a specified exception.
//
// Parameters:
//   exception:
//     The exception with which to complete the task.
//
// Type parameters:
//   TResult:
//     The type of the result returned by the task.
//
// Returns:
//     The faulted task.
template<typename TResult>
RTaskPtr<TResult> FromException(const Exception& exception)
{
    return MakeAsync<TResult>([=](System::Details::ResultAsyncContext<TResult>& __context) { exception.Throw(); });
}
 
//
// Summary:
//     Creates a System.Threading.Tasks.Task`1 that's completed successfully with the
//     specified result.
//
// Parameters:
//   result:
//     The result to store into the completed task.
//
// Type parameters:
//   TResult:
//     The type of the result returned by the task.
//
// Returns:
//     The successfully completed task.
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 TaskPtr WhenAll(const ArrayPtr<TaskPtr>& tasks);
ASPOSECPP_SHARED_API TaskPtr WhenAll(const SharedPtr<Collections::Generic::IEnumerable<TaskPtr>>& tasks);
 
//
// Summary:
//     Creates a task that will complete when all of the System.Threading.Tasks.Task`1
//     objects in an enumerable collection have completed.
//
// Parameters:
//   tasks:
//     The tasks to wait on for completion.
//
// Type parameters:
//   TResult:
//     The type of the completed task.
//
// Returns:
//     A task that represents the completion of all of the supplied tasks.
//
// Exceptions:
//   T:System.ArgumentNullException:
//     The tasks argument was null.
//
//   T:System.ArgumentException:
//     The tasks collection contained a null task.
template <typename T>
RTaskPtr<ArrayPtr<T>> WhenAll(SharedPtr<Collections::Generic::IEnumerable<RTaskPtr<T>>> tasks)
{
    return WhenAll(tasks->LINQ_ToArray());
}
 
//
// Summary:
//     Creates a task that will complete when all of the System.Threading.Tasks.Task`1
//     objects in an array have completed.
//
// Parameters:
//   tasks:
//     The tasks to wait on for completion.
//
// Type parameters:
//   TResult:
//     The type of the completed task.
//
// Returns:
//     A task that represents the completion of all of the supplied tasks.
//
// Exceptions:
//   T:System.ArgumentNullException:
//     The tasks argument was null.
//
//   T:System.ArgumentException:
//     The tasks array contained a null task.
template <typename T>
RTaskPtr<ArrayPtr<T>> WhenAll(ArrayPtr<RTaskPtr<T>> tasks)
{
    //return WhenAll(tasks->LINQ_Cast<TaskPtr>())->ContinueWith<T>
 
    return MakeAsync<ArrayPtr<T>>([=](System::Details::ResultAsyncContext<ArrayPtr<T>>& __context)
    {
        for (auto& task : tasks)
        {
            if (!task->get_IsCompleted())
            {
                return;
            }
        }
 
        auto size = tasks->get_Length();
        auto result = MakeArray<T>(size);
        for (auto i = 0; i < size; ++ i)
        {
            result[i] = tasks[i]->get_Result();
        }
        __context.Return(result);
    });
}
 
ASPOSECPP_SHARED_API Runtime::CompilerServices::YieldAwaitable Yield();
 
}}} // namespace System::Threading::Tasks