task_factory.hpp

Go to the documentation of this file.

#pragma once
#include "task.hpp"

namespace xtd {
  namespace threading {
    namespace tasks {
      class task_factory : public xtd::object {
      public:
        task_factory() = default;
        task_factory(task_factory&&) = default;
        auto operator=(task_factory&&) -> task_factory& = default;
        task_factory(const task_factory&) = default;
        auto operator=(const task_factory&) -> task_factory& = default;
        
        
        template<class result_t>
        auto start_new(const xtd::func<result_t>& action) const -> xtd::threading::tasks::task<result_t> {
          auto t = xtd::threading::tasks::task<result_t> {action};
          t.start();
          return t;
        }

        template<class result_t>
        auto start_new(const xtd::func<result_t>& action, const xtd::threading::cancellation_token& cancellation_token) const -> xtd::threading::tasks::task<result_t> {
          auto t = xtd::threading::tasks::task<result_t> {action, cancellation_token};
          t.start();
          return t;
        }

        template<class result_t>
        auto start_new(const xtd::func<result_t, const xtd::any_object&>& action, const xtd::any_object& state) const -> xtd::threading::tasks::task<result_t> {
          auto t = xtd::threading::tasks::task<result_t> {action, state};
          t.start();
          return t;
        }

        template<class result_t>
        auto start_new(const xtd::func<result_t, const xtd::any_object&>& action, const xtd::any_object& state, const xtd::threading::cancellation_token& cancellation_token) const -> xtd::threading::tasks::task<result_t> {
          auto t = xtd::threading::tasks::task<result_t> {action, state, cancellation_token};
          t.start();
          return t;
        }


        auto start_new(const std::function<void()>& action) const -> xtd::threading::tasks::task<> {
          auto t = xtd::threading::tasks::task<> {action};
          t.start();
          return t;
        }
        auto start_new(const std::function<void()>& action, const xtd::threading::cancellation_token& cancellation_token) const -> xtd::threading::tasks::task<> {
          auto t = xtd::threading::tasks::task<> {action, cancellation_token};
          t.start();
          return t;
        }
        auto start_new(const std::function<void(const xtd::any_object&)>& action, const xtd::any_object& state) const -> xtd::threading::tasks::task<> {
          auto t = xtd::threading::tasks::task<> {action, state};
          t.start();
          return t;
        }
        auto start_new(const std::function<void(const xtd::any_object&)>& action, const xtd::any_object& state, const xtd::threading::cancellation_token& cancellation_token) const -> xtd::threading::tasks::task<> {
          auto t = xtd::threading::tasks::task<> {action, state, cancellation_token};
          t.start();
          return t;
        }
 
        template<class result_t>
        auto start_new(const std::function<result_t()>& action) const -> xtd::threading::tasks::task<result_t> {
          auto t = xtd::threading::tasks::task<result_t> {action};
          t.start();
          return t;
        }
        template<class result_t>
        auto start_new(const std::function<result_t()>& action, const xtd::threading::cancellation_token& cancellation_token) const -> xtd::threading::tasks::task<result_t> {
          auto t = xtd::threading::tasks::task<result_t> {action, cancellation_token};
          t.start();
          return t;
        }
        template<class result_t>
        auto start_new(const std::function<result_t(const xtd::any_object&)>& action, const xtd::any_object& state) const -> xtd::threading::tasks::task<result_t> {
          auto t = xtd::threading::tasks::task<result_t> {action, state};
          t.start();
          return t;
        }
        template<class result_t>
        auto start_new(const std::function<result_t(const xtd::any_object&)>& action, const xtd::any_object& state, const xtd::threading::cancellation_token& cancellation_token) const -> xtd::threading::tasks::task<result_t> {
          auto t = xtd::threading::tasks::task<result_t> {action, state, cancellation_token};
          t.start();
          return t;
        }
      };
      
      template<class result_t>
      struct xtd::threading::tasks::basic_task<result_t>::yield_awaiter {
        xtd::threading::tasks::task<result_t> task_;
        
        yield_awaiter() {task_.start();};
        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();});}
      };
 
      template<class result_t>
      auto basic_task<result_t>::completed_task() -> xtd::threading::tasks::task<result_t> {
        auto task = xtd::threading::tasks::task<result_t> {};
        task.basic_task<result_t>::data_->status = xtd::threading::tasks::task_status::ran_to_completion;
        task.basic_task<result_t>::data_->end_event.set();
        return task;
      }
 
      template<class result_t>
      auto basic_task<result_t>::factory() noexcept -> const xtd::threading::tasks::task_factory& {
        static auto factory = xtd::threading::tasks::task_factory {};
        return factory;
      }
 
      template<class result_t>
      auto basic_task<result_t>::delay(const xtd::time_span& delay) -> xtd::threading::tasks::task<> {return basic_task<result_t>::delay(xtd::as<xtd::int32>(delay.total_milliseconds()));}
      
      template<class result_t>
      auto basic_task<result_t>::delay(const xtd::time_span& delay, const xtd::threading::cancellation_token& cancellation_token) -> task<> {return basic_task<result_t>::delay(xtd::as<xtd::int32>(delay.total_milliseconds()), cancellation_token);}
      
      template<class result_t>
      auto basic_task<result_t>::delay(xtd::int32 milliseconds_delay) -> xtd::threading::tasks::task<> {return xtd::threading::tasks::task<>::run([milliseconds_delay]{xtd::threading::cancellation_token {}.wait_handle().wait_one(milliseconds_delay);});}
      
      template<class result_t>
      auto basic_task<result_t>::delay(xtd::int32 milliseconds_delay, const xtd::threading::cancellation_token& cancellation_token) -> task<> {
        return xtd::threading::tasks::task<>::run([cancellation_token, milliseconds_delay]{xtd::threading::cancellation_token {cancellation_token}.wait_handle().wait_one(milliseconds_delay);}, cancellation_token);
      }
      
      template<class result_t>
      auto basic_task<result_t>::from_cancelation(const xtd::threading::cancellation_token& cancellation_token) -> task<result_t> {
        if (!cancellation_token.is_cancellation_requested()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
        auto task = xtd::threading::tasks::task<result_t> {};
        task.basic_task<>::data_->cancellation_token = cancellation_token;
        task.basic_task<>::data_->status = xtd::threading::tasks::task_status::canceled;
        task.basic_task<>::data_->end_event.set();
        return task;
      }
      
      template<class result_t>
      template<class from_exception_t>
      auto basic_task<result_t>::from_exception(from_exception_t exception) -> xtd::threading::tasks::task<result_t> {
        auto task = xtd::threading::tasks::task<result_t> {};
        task.basic_task<>::data_->exception = xtd::runtime::exception_services::exception_dispatch_info::capture(exception);
        task.basic_task<>::data_->status = xtd::threading::tasks::task_status::faulted;
        task.basic_task<>::data_->end_event.set();
        return task;
      }
      
      template<class result_t>
      auto xtd::threading::tasks::basic_task<result_t>::run(const xtd::func<result_t>& func) -> xtd::threading::tasks::task<result_t> {return factory().start_new(func);}
      template<class result_t>
      auto xtd::threading::tasks::basic_task<result_t>::run(const xtd::func<result_t>& func, const xtd::threading::cancellation_token& cancellation_token) -> xtd::threading::tasks::task<result_t> {return factory().start_new(func, cancellation_token);}
      template<class result_t>
      auto xtd::threading::tasks::basic_task<result_t>::run(const xtd::func<result_t, const xtd::any_object&>& func, const xtd::any_object& state) -> xtd::threading::tasks::task<result_t> {return factory().start_new(func, state);}
      template<class result_t>
      auto xtd::threading::tasks::basic_task<result_t>::run(const xtd::func<result_t, const xtd::any_object&>& func, const xtd::any_object& state, const xtd::threading::cancellation_token& cancellation_token) -> xtd::threading::tasks::task<result_t> {return factory().start_new(func, state, cancellation_token);}
      template<class result_t>
      auto xtd::threading::tasks::basic_task<result_t>::run(const std::function<result_t()>& func) -> xtd::threading::tasks::task<result_t> {return factory().start_new(func);}
      template<class result_t>
      auto xtd::threading::tasks::basic_task<result_t>::run(const std::function<result_t()>& func, const xtd::threading::cancellation_token& cancellation_token) -> xtd::threading::tasks::task<result_t> {return factory().start_new(func, cancellation_token);}
      template<class result_t>
      auto xtd::threading::tasks::basic_task<result_t>::run(const std::function<result_t(const xtd::any_object&)>& func, const xtd::any_object& state) -> xtd::threading::tasks::task<result_t> {return factory().start_new(func, state);}
      template<class result_t>
      auto xtd::threading::tasks::basic_task<result_t>::run(const std::function<result_t(const xtd::any_object&)>& func, const xtd::any_object& state, const xtd::threading::cancellation_token& cancellation_token) -> xtd::threading::tasks::task<result_t> {return factory().start_new(func, state, cancellation_token);}
      
      template<class result_t>
      auto xtd::threading::tasks::basic_task<result_t>::yield() -> task<result_t> {
        co_await yield_awaiter {};
      }
    }
  }
}