result_task.h

 
#pragma once
 
#include <functional>
#include <system/object.h>
#include <system/func.h>
#include <system/threading/tasks/task.h>
 
namespace System { namespace Runtime { namespace CompilerServices {
template<typename T>
class ResultTaskAwaiter;
template<typename T>
class ConfiguredResultTaskAwaitable;
}}
 
namespace Threading { namespace Tasks {
 
template<typename T>
class ResultTask final : public Task
{
    using ThisType = ResultTask<T>;
    using BaseType = Task;
 
public:
    ResultTask(const Func<T>& function) : Task(MakeFunction(function))
    {
    }
 
    T get_Result()
    {
        Wait();
        return m_result;
    }
 
    Runtime::CompilerServices::ConfiguredResultTaskAwaitable<T> ConfigureAwait(bool continueOnCapturedContext) const
    {
        return {MakeSharedPtr(this), continueOnCapturedContext};
    }
 
    using Task::ContinueWith;
 
    TaskPtr ContinueWith(const Action<RTaskPtr<T>>& continuationAction)
    {
        auto result = MakeObject<Task>(
            std::function<void()>([continuationAction, task = MakeSharedPtr(this)] { continuationAction(task); }));
        ContinueWithCore(result);
        return result;
    }
 
    template<typename TNewResult>
    RTaskPtr<TNewResult> ContinueWith(const Func<RTaskPtr<T>, TNewResult>& continuationFunction)
    {
        auto result = MakeObject<ResultTask<TNewResult>>(std::function<TNewResult()>(
            [continuationFunction, task = MakeSharedPtr(this)] { return continuationFunction(task); }));
        ContinueWithCore(result);
        return result;
    }
 
    Runtime::CompilerServices::ResultTaskAwaiter<T> GetAwaiter() const
    {
        return {MakeSharedPtr(this)};
    }
 
 
    ResultTask()
    {
    }
 
    ResultTask(const T& result) : m_result(result)
    {
        set_Status(TaskStatus::RanToCompletion);
    }
 
    void set_Result(const T& result)
    {
        m_result = result;
    }
 
    void Complete(const T& result)
    {
        set_Result(result);
        BaseType::Complete();
    }
 
private:
    FunctionT MakeFunction(const Func<T>& func)
    {
        return [func, this]
        {
            set_Result(func());
        };
    }
 
    T m_result;
};
 
}} // namespace Threading::Tasks
 
namespace Runtime { namespace CompilerServices {
 
template <typename T>
class ResultTaskAwaiter
{
public:
    ResultTaskAwaiter(const RTaskPtr<T>& task) : m_task(task)
    {}
 
    bool get_IsCompleted() const
    {
        return m_task->get_IsCompleted();
    }
 
    void OnCompleted(const Action<>& continuation)
    {
        m_task->AddCompletionAction(continuation);
    }
 
    T GetResult() const
    {
        return m_task->get_Result();
    }
 
    bool continueOnCapturedContext = false;
 
private:
    RTaskPtr<T> m_task;
};
 
template <typename T>
class ConfiguredResultTaskAwaitable
{
public:
    ConfiguredResultTaskAwaitable(const RTaskPtr<T>& task, bool continueOnCapturedContext)
        : m_task(task), m_continueOnCapturedContext(continueOnCapturedContext)
    {}
 
    Runtime::CompilerServices::ResultTaskAwaiter<T> GetAwaiter() const
    {
        auto result = m_task->GetAwaiter();
        result.continueOnCapturedContext = m_continueOnCapturedContext;
        return result;
    }
 
private:
    RTaskPtr<T> m_task;
    bool m_continueOnCapturedContext;
};
 
}} // namespace Runtime::CompilerServices
 
} // namespace System