result_value_task.h

 
#pragma once
 
#include <system/object.h>
#include <system/nullable.h>
#include <system/iequatable.h>
#include <system/threading/tasks/async.h>
 
namespace System { namespace Runtime { namespace CompilerServices {
template<typename T>
class ResultValueTaskAwaiter;
template<typename T>
class ConfiguredResultValueTaskAwaitable;
}}
 
namespace Threading { namespace Tasks {
 
template<typename T>
class ResultValueTask final : public IEquatable<ResultValueTask<T>>, public System::Details::BoxableObjectBase
{
    using ThisType = ResultValueTask<T>;
    using BaseType = Object;
 
public:
    ResultValueTask()
    {}
    ResultValueTask(const T& result) : m_result(result)
    {}
    ResultValueTask(const RTaskPtr<T>& task) : m_task(task)
    {}
 
    bool get_IsFaulted() const
    {
        return m_task && m_task->get_IsFaulted();
    }
    bool get_IsCompletedSuccessfully() const
    {
        return (m_task && m_task->get_Status() == TaskStatus::RanToCompletion) || m_result.get_HasValue();
    }
    bool get_IsCompleted() const
    {
        return (m_task && m_task->get_IsCompleted()) || m_result.get_HasValue();
    }
    bool get_IsCanceled() const
    {
        return m_task && m_task->get_IsCanceled();
    }
    T get_Result() const
    {
        if (m_task)
        {
            m_result = m_task->get_Result();
            m_task.reset();
        }
 
        return m_result.get_Value();
    }
 
    RTaskPtr<T> AsTask() const
    {
        return m_task ? m_task : MakeObject<ResultTask<T>>(m_result.get_Value());
    }
    Runtime::CompilerServices::ConfiguredResultValueTaskAwaitable<T> ConfigureAwait(bool continueOnCapturedContext) const
    {
        return {*this, continueOnCapturedContext};
    }
    bool Equals(ResultValueTask other) override 
    {
        return *this == other;
    }
    bool Equals(System::SharedPtr<System::Object> obj) override
    {
        return System::ObjectExt::Is<ResultValueTask>(obj) && Equals(System::ExplicitCast<ResultValueTask>(obj));
    }
    Runtime::CompilerServices::ResultValueTaskAwaiter<T> GetAwaiter() const
    {
        return {*this};
    }
 
    bool operator==(const ResultValueTask& other) const
    {
        if (m_result.get_HasValue() || other.m_result.get_HasValue())
        {
            return m_result == other.m_result;
        }
 
        return m_task == other.m_task;
    }
    bool operator!=(const ResultValueTask& other) const {return !(*this == other);}
 
private:
    friend class Runtime::CompilerServices::ResultValueTaskAwaiter<T>;
 
    mutable Nullable<T> m_result;
    mutable RTaskPtr<T> m_task;
};
 
}} // namespace Threading::Tasks
 
namespace Runtime { namespace CompilerServices {
 
template <typename T>
class ResultValueTaskAwaiter
{
public:
    ResultValueTaskAwaiter(Threading::Tasks::ResultValueTask<T> task) : m_task(task)
    {}
 
    bool get_IsCompleted() const
    {
        return m_task.get_IsCompleted();
    }
 
    void OnCompleted(const Action<>& continuation)
    {
        if (m_task.m_task)
        {
            m_task.m_task->AddContinuation(continuation);
        }
    }
 
    T GetResult() const
    {
        return m_task.get_Result();
    }
 
    bool continueOnCapturedContext = false;
 
private:
    Threading::Tasks::ResultValueTask<T> m_task;
};
 
template <typename T>
class ConfiguredResultValueTaskAwaitable
{
public:
    ConfiguredResultValueTaskAwaitable(const Threading::Tasks::ResultValueTask<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:
    Threading::Tasks::ResultValueTask<T> m_task;
    bool m_continueOnCapturedContext;
};
 
}} // namespace Runtime::CompilerServices
 
template <typename T>
Threading::Tasks::ResultValueTask<T> MakeValueAsync(const Details::ResultAsyncFunction<T>& fnc)
{
    return Threading::Tasks::ResultValueTask<T>(MakeAsync<T>(fnc));
}
 
} // namespace System