task.hpp

Go to the documentation of this file.

#pragma once
#include "basic_task.hpp"

namespace xtd {
  namespace threading {
    namespace tasks {
      template<>
      class task<void> : public xtd::threading::tasks::basic_task<> {
      public:
        struct promise_type {
          xtd::runtime::exception_services::exception_dispatch_info exception;
          xtd::ptr<xtd::threading::tasks::task<>> task_;
          std::coroutine_handle<promise_type> self;
 
          auto final_suspend() noexcept {
            struct final_awaiter {
              promise_type& promise;
              
              bool await_ready() noexcept {return false;}
              void await_resume() noexcept {}
              void await_suspend(std::coroutine_handle<promise_type> handle) noexcept {
                promise.task_->start();
                promise.self.destroy();
              }
            };
            return final_awaiter {*this};
          }
          xtd::threading::tasks::task<> get_return_object() {
            task_ = xtd::new_ptr<xtd::threading::tasks::task<>>();
            self = std::coroutine_handle<promise_type>::from_promise(*this);
            return *task_;
          }
          std::suspend_never initial_suspend() {return {};}
          void return_void() {}
          void unhandled_exception() {exception = task_->xtd::threading::tasks::basic_task<>::data_->exception;}
        };
        
        struct awaiter {
          xtd::threading::tasks::task<void>& task_;
          
          bool await_ready() const noexcept {return task_.is_completed();}
          void await_resume() {if (task_.is_faulted()) task_.rethrow_exception();}
          void await_suspend(std::coroutine_handle<> handle) {task_.continue_with([handle] {handle.resume();});}
        };
        
        task() = default;
        task(task&&) = default;
        task(const task&) = default;
        auto operator=(task&&) -> task& = default;
        auto operator=(const task&) -> task& = default;
        
        
        task(const xtd::action<>& action) : basic_task<> {action} {}
        task(const xtd::action<>& action, const xtd::threading::cancellation_token& cancellation_token) : basic_task<> {action, cancellation_token} {}
        task(const xtd::action<const xtd::any_object&>& action, const xtd::any_object& state) : basic_task<> {action, state} {}
        task(const xtd::action<const xtd::any_object&>& action, const xtd::any_object& state, const xtd::threading::cancellation_token& cancellation_token) : basic_task<> {action, state, cancellation_token} {}

        task(const std::function<void()>& action) : basic_task<> {action} {}
        task(const std::function<void()>& action, const xtd::threading::cancellation_token& cancellation_token) : basic_task<> {action, cancellation_token} {}
        task(const std::function<void(const xtd::any_object&)>& action, const xtd::any_object& state) : basic_task<> {action, state} {}
        task(const std::function<void(const xtd::any_object&)>& action, const xtd::any_object& state, const xtd::threading::cancellation_token& cancellation_token) : basic_task<> {action, state, cancellation_token} {}
        
        
        [[nodiscard]] static auto from_result() -> task {
          auto t = task {};
          t.basic_task<>::data_->status = xtd::threading::tasks::task_status::ran_to_completion;
          t.basic_task<>::data_->end_event.set();
          return t;
        }
        
        
        auto operator co_await() noexcept {return awaiter {*this};}
      };
    }
  }
}
 
#include "task_result.hpp"