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::exception_services::exception_dispatch_info exception_;
          xtd::ptr<xtd::threading::tasks::task<>> task_;
          std::coroutine_handle<promise_type> this_;
 
          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 {
                if (!promise.task_->is_completed()) promise.task_->start();
                promise.this_.destroy();
              }
            };
            return final_awaiter {*this};
          }
          xtd::threading::tasks::task<> get_return_object() {
            task_ = xtd::new_ptr<xtd::threading::tasks::task<>>();
            this_ = 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() {
            task_.on_await_resume();
            if (task_.is_faulted()) task_.rethrow_exception();
          }
          void await_suspend(std::coroutine_handle<> handle) {task_.continue_with_([handle] {handle.resume();});}
        };
        
        task();
        
        
        task(auto action);
        task(auto action, const xtd::threading::cancellation_token& cancellation_token);
        task(auto action, const xtd::any_object& state);
        task(auto action, const xtd::any_object& state, const xtd::threading::cancellation_token& 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};}
      };

      inline task<void>::task() {
        lock_(this->static_data_.sync_root) {
          this->static_data_.tasks.add(this->data_->unique_id, new_sptr<task<>>(*this));
        }
      }
      inline task<void>::task(auto action) : basic_task<> {action} {
        lock_(this->static_data_.sync_root) {
          this->static_data_.tasks.add(this->data_->unique_id, new_sptr<task<>>(*this));
        }
      }
      inline task<void>::task(auto action, const xtd::threading::cancellation_token& cancellation_token) : basic_task<> {action, cancellation_token} {
        lock_(this->static_data_.sync_root) {
          this->static_data_.tasks.add(this->data_->unique_id, new_sptr<task<>>(*this));
        }
      }
      inline task<void>::task(auto action, const xtd::any_object& state) : basic_task<> {action, state} {
        lock_(this->static_data_.sync_root) {
          this->static_data_.tasks.add(this->data_->unique_id, new_sptr<task<>>(*this));
        }
      }
      inline task<void>::task(auto action, const xtd::any_object& state, const xtd::threading::cancellation_token& cancellation_token) : basic_task<> {action, state, cancellation_token} {
        lock_(this->static_data_.sync_root) {
          this->static_data_.tasks.add(this->data_->unique_id, new_sptr<task<>>(*this));
        }
      }
    }
  }
}
 
#include "task_result.hpp"