task.h

 
#pragma once
 
#include <functional>
#include <atomic>
#include <mutex>
#include <system/idisposable.h>
#include <system/threading/tasks/task_status.h>
#include <system/threading/cancellation_token.h>
#include <system/action.h>
#include <system/aggregate_exception.h>
 
namespace System {
template<typename T>
class Nullable;
namespace Threading { namespace Tasks {
class TaskScheduler;
}} // namespace Threading
namespace Runtime { namespace CompilerServices {
class TaskAwaiter;
class ConfiguredTaskAwaitable;
}}
 
namespace Threading { namespace Tasks {
 
class ASPOSECPP_SHARED_CLASS Task : public IDisposable
{
    using ThisType = Task;
 
public:
    ASPOSECPP_SHARED_API Task(const Action<>& action);
    ASPOSECPP_SHARED_API Task(const Action<>& action, const CancellationToken& cancellationToken);
    ASPOSECPP_SHARED_API Task(const Action<SharedPtr<Object>>& action, const SharedPtr<Object>& state);
    ASPOSECPP_SHARED_API Task(const Action<SharedPtr<Object>>& action, const SharedPtr<Object>& state,
                              const CancellationToken& cancellationToken);
    ASPOSECPP_SHARED_API ~Task();
 
    static ASPOSECPP_SHARED_API Nullable<int32_t> get_CurrentId();
    static ASPOSECPP_SHARED_API const TaskPtr& get_CompletedTask();
    ASPOSECPP_SHARED_API bool get_IsCompleted() const;
    bool get_IsCanceled() const {return m_status == TaskStatus::Canceled;}
    TaskStatus get_Status() const {return m_status;}
    ASPOSECPP_SHARED_API AggregateException get_Exception() const;
    int32_t get_Id() const {return m_id;}
    const SharedPtr<Object>& get_AsyncState() const {return m_state;}
    bool get_IsFaulted() const {return m_status == TaskStatus::Faulted;}
 
    ASPOSECPP_SHARED_API TaskPtr ContinueWith(const Action<TaskPtr>& continuationAction);
    template<typename TResult>
    RTaskPtr<TResult> ContinueWith(const Func<TaskPtr, TResult>& continuationFunction);
 
    ASPOSECPP_SHARED_API Runtime::CompilerServices::TaskAwaiter GetAwaiter() const;
    ASPOSECPP_SHARED_API Runtime::CompilerServices::ConfiguredTaskAwaitable ConfigureAwait(bool continueOnCapturedContext) const;
 
    ASPOSECPP_SHARED_API void RunSynchronously();
    ASPOSECPP_SHARED_API void RunSynchronously(const SharedPtr<TaskScheduler>& scheduler);
    ASPOSECPP_SHARED_API void Start();
    ASPOSECPP_SHARED_API void Start(const SharedPtr<TaskScheduler>& scheduler);
    ASPOSECPP_SHARED_API void Wait(const CancellationToken& cancellationToken);
    ASPOSECPP_SHARED_API void Wait();
 
    ASPOSECPP_SHARED_API void Dispose() override;
 
 
    using FunctionT = std::function<void()>;
 
    ASPOSECPP_SHARED_API Task();
    void set_Function(const FunctionT& fnc) {m_function = fnc;}
    ASPOSECPP_SHARED_API void set_Status(TaskStatus status);
    ASPOSECPP_SHARED_API const SharedPtr<TaskScheduler>& get_Scheduler() const {return m_scheduler;}
    ASPOSECPP_SHARED_API void set_Scheduler(const SharedPtr<TaskScheduler>& scheduler) {m_scheduler = scheduler;}
 
    ASPOSECPP_SHARED_API void Activate(const SharedPtr<TaskScheduler>& scheduler = nullptr);
    ASPOSECPP_SHARED_API void Execute();
    ASPOSECPP_SHARED_API void AddCompletionAction(const Action<>& continuation);
    ASPOSECPP_SHARED_API void Complete();
    ASPOSECPP_SHARED_API void Cancel();
 
protected:
    ASPOSECPP_SHARED_API void ContinueWithCore(const TaskPtr& continuationTask);
    ASPOSECPP_SHARED_API void ExecuteContinuations();
 
    ASPOSECPP_SHARED_API virtual void Finish();
 
protected:
    // Task ID
    int32_t             m_id;
    FunctionT           m_function;
    TaskStatus          m_status;
    std::exception_ptr  m_exception;
    CancellationToken   m_cancellation_token;
    SharedPtr<TaskScheduler> m_scheduler;
    SharedPtr<Object>   m_state;
    std::list<Action<>> m_completions;
    std::mutex          m_completions_mutex;
 
    static std::atomic<int32_t> m_next_id;
};
 
}} // namespace Threading::Tasks
 
namespace Runtime { namespace CompilerServices {
 
class ASPOSECPP_SHARED_CLASS TaskAwaiter
{
public:
    TaskAwaiter(const TaskPtr& task) : m_task(task) {}
 
    ASPOSECPP_SHARED_API bool get_IsCompleted() const;
    ASPOSECPP_SHARED_API void OnCompleted(const Action<>& continuation);
    ASPOSECPP_SHARED_API void GetResult() const;
 
    bool continueOnCapturedContext = false;
 
private:
    TaskPtr m_task;
};
 
class ASPOSECPP_SHARED_CLASS ConfiguredTaskAwaitable
{
public:
    ASPOSECPP_SHARED_CLASS ConfiguredTaskAwaitable(const TaskPtr& task, bool continueOnCapturedContext);
    ASPOSECPP_SHARED_API Runtime::CompilerServices::TaskAwaiter GetAwaiter() const;
 
private:
    TaskPtr m_task;
    bool m_continueOnCapturedContext;
};
 
}}} // namespace System::Runtime::CompilerServices
 
#include <system/func.h>
#include <system/threading/tasks/result_task.h>
 
namespace System { namespace Threading { namespace Tasks {
 
template <typename TResult>
RTaskPtr<TResult> Task::ContinueWith(const Func<TaskPtr, TResult>& continuationFunction)
{
    auto result = MakeObject<Threading::Tasks::ResultTask<TResult>>(
        Func<TResult>([continuationFunction, task = MakeSharedPtr(this)] { return continuationFunction(task); }));
    ContinueWithCore(result);
    return result;
}
 
}}} // namespace System::Threading::Tasks