task_result.hpp

Go to the documentation of this file.

#pragma once
#include "basic_task.hpp"

namespace xtd {
  namespace threading {
    namespace tasks {
      template<typename result_t>
      class task : public xtd::threading::tasks::basic_task<result_t> {
      public:
        struct promise_type {
          xtd::exception_services::exception_dispatch_info exception_;
          sptr<xtd::threading::tasks::task<result_t>> 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 {
                promise.task_->start();
                promise.this_.destroy();
              }
            };
            return final_awaiter {*this};
          }
          xtd::threading::tasks::task<result_t> get_return_object() {
            task_ = xtd::new_ptr<xtd::threading::tasks::task<result_t>>();
            this_ = std::coroutine_handle<promise_type>::from_promise(*this);
            return *task_;
          }
          std::suspend_never initial_suspend() {return {};}
          void return_value(const result_t& result) {task_->template basic_task<result_t>::data_->result = result;}
          void unhandled_exception() {exception_ = task_->template basic_task<result_t>::data_->exception;}
        };
        
        struct awaiter {
          xtd::threading::tasks::task<result_t>& task_;
          
          bool await_ready() const noexcept {return this->task_.is_completed();}
          void await_suspend(std::coroutine_handle<> handle) {task_.continue_with_([handle] {handle.resume();});}
          const result_t& await_resume() {
            task_.on_await_resume();
            if (task_.is_faulted()) task_.rethrow_exception();
            return task_.result();
          }
        };
        
        task();
        task(const std::coroutine_handle<typename task<result_t>::promise_type>& handle) { {*handle_ = handle;}}
        ~task() {if (handle_.is_unique() && *handle_) handle_->destroy();}

        
        
        task(auto func);
        task(auto func, const xtd::threading::cancellation_token& cancellation_token);
        task(auto func, const xtd::any_object& state);
        task(auto func, const xtd::any_object& state, const xtd::threading::cancellation_token& cancellation_token);

        
        [[nodiscard]] auto result() const -> const result_t& {
          if (!basic_task<result_t>::is_completed()) static_cast<basic_task<result_t>&>(const_cast<task&>(*this)).wait();
          return basic_task<result_t>::data_->result;
        }
        
        
        [[nodiscard]] static auto from_result(result_t result) -> task {
          auto t = task {};
          t.data_->result = result;
          t.basic_task<result_t>::data_->status = xtd::threading::tasks::task_status::ran_to_completion;
          t.basic_task<result_t>::data_->end_event.set();
          return t;
        }
        
        
        auto operator co_await() noexcept {return awaiter {*this};}
 
      private:
        xtd::ptr<std::coroutine_handle<promise_type>> handle_ = xtd::new_ptr<std::coroutine_handle<promise_type>>();
      };

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