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;
        
        
        [[nodiscard]] auto continue_when_all(xtd::iterable auto&& tasks, auto&& action) const -> xtd::threading::tasks::task<xtd::raw_type<decltype(std::declval<decltype(action)>()())>> {
          task<>::when_all(tasks).wait();;
          auto t = xtd::threading::tasks::task<xtd::raw_type<decltype(std::declval<decltype(action)>()())>> {action};
          t.start();
          return t;
        }
        [[nodiscard]] auto continue_when_all(xtd::iterable auto&& tasks, auto&& action, const xtd::threading::cancellation_token& cancellation_token) const -> xtd::threading::tasks::task<xtd::raw_type<decltype(std::declval<decltype(action)>()())>> {
          task<>::when_all(tasks).wait();;
          auto t = xtd::threading::tasks::task<xtd::raw_type<decltype(std::declval<decltype(action)>()())>> {action, cancellation_token};
          t.start();
          return t;
        }
        [[nodiscard]] auto continue_when_all(xtd::iterable auto&& tasks, auto&& action, const xtd::any_object& state) const -> xtd::threading::tasks::task<xtd::raw_type<decltype(std::declval<decltype(action)>()(std::declval<const xtd::any_object&>()))>> {
          task<>::when_all(tasks).wait();;
          auto t = xtd::threading::tasks::task<xtd::raw_type<decltype(std::declval<decltype(action)>()(std::declval<const xtd::any_object&>()))>> {action, state};
          t.start();
          return t;
        }
        template<typename result_t>
        [[nodiscard]] auto continue_when_all(xtd::iterable auto&& tasks, auto&& action, const xtd::any_object& state, const xtd::threading::cancellation_token& cancellation_token) const -> xtd::threading::tasks::task<xtd::raw_type<decltype(action(std::declval<const xtd::any_object&>()))>> {
          task<>::when_all(tasks).wait();;
          auto t = xtd::threading::tasks::task<xtd::raw_type<decltype(std::declval<decltype(action)>()(std::declval<const xtd::any_object&>()))>> {action, state, cancellation_token};
          t.start();
          return t;
        }
 
        [[nodiscard]] auto continue_when_any(xtd::iterable auto&& tasks, auto&& action) const -> xtd::threading::tasks::task<xtd::raw_type<decltype(std::declval<decltype(action)>()())>> {
          task<>::when_any(tasks).wait();;
          auto t = xtd::threading::tasks::task<xtd::raw_type<decltype(std::declval<decltype(action)>()())>> {action};
          t.start();
          return t;
        }
        [[nodiscard]] auto continue_when_any(xtd::iterable auto&& tasks, auto&& action, const xtd::threading::cancellation_token& cancellation_token) const -> xtd::threading::tasks::task<xtd::raw_type<decltype(std::declval<decltype(action)>()())>> {
          task<>::when_any(tasks).wait();;
          auto t = xtd::threading::tasks::task<xtd::raw_type<decltype(std::declval<decltype(action)>()())>> {action, cancellation_token};
          t.start();
          return t;
        }
        [[nodiscard]] auto continue_when_any(xtd::iterable auto&& tasks, auto&& action, const xtd::any_object& state) const -> xtd::threading::tasks::task<xtd::raw_type<decltype(std::declval<decltype(action)>()(std::declval<const xtd::any_object&>()))>> {
          task<>::when_any(tasks).wait();;
          auto t = xtd::threading::tasks::task<xtd::raw_type<decltype(std::declval<decltype(action)>()(std::declval<const xtd::any_object&>()))>> {action, state};
          t.start();
          return t;
        }
        template<typename result_t>
        [[nodiscard]] auto continue_when_any(xtd::iterable auto&& tasks, auto&& action, const xtd::any_object& state, const xtd::threading::cancellation_token& cancellation_token) const -> xtd::threading::tasks::task<xtd::raw_type<decltype(action(std::declval<const xtd::any_object&>()))>> {
          task<>::when_any(tasks).wait();;
          auto t = xtd::threading::tasks::task<xtd::raw_type<decltype(std::declval<decltype(action)>()(std::declval<const xtd::any_object&>()))>> {action, state, cancellation_token};
          t.start();
          return t;
        }
        
        [[nodiscard]] auto start_new(auto&& action) const -> xtd::threading::tasks::task<xtd::raw_type<decltype(std::declval<decltype(action)>()())>> {
          auto t = xtd::threading::tasks::task<xtd::raw_type<decltype(std::declval<decltype(action)>()())>> {action};
          t.start();
          return t;
        }

        [[nodiscard]] auto start_new(auto&& action, const xtd::threading::cancellation_token& cancellation_token) const -> xtd::threading::tasks::task<xtd::raw_type<decltype(std::declval<decltype(action)>()())>> {
          auto t = xtd::threading::tasks::task<xtd::raw_type<decltype(std::declval<decltype(action)>()())>> {action, cancellation_token};
          t.start();
          return t;
        }

        [[nodiscard]] auto start_new(auto&& action, const xtd::any_object& state) const -> xtd::threading::tasks::task<xtd::raw_type<decltype(std::declval<decltype(action)>()(std::declval<const xtd::any_object&>()))>> {
          auto t = xtd::threading::tasks::task<xtd::raw_type<decltype(std::declval<decltype(action)>()(std::declval<const xtd::any_object&>()))>> {action, state};
          t.start();
          return t;
        }

        template<typename result_t>
        [[nodiscard]] auto start_new(auto&& action, const xtd::any_object& state, const xtd::threading::cancellation_token& cancellation_token) const -> xtd::threading::tasks::task<xtd::raw_type<decltype(action(std::declval<const xtd::any_object&>()))>> {
          auto t = xtd::threading::tasks::task<xtd::raw_type<decltype(std::declval<decltype(action)>()(std::declval<const xtd::any_object&>()))>> {action, state, cancellation_token};
          t.start();
          return t;
        }

      };
      
      template<typename 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<typename 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<typename result_t>
      auto basic_task<result_t>::continue_with(xtd::action<>&& continuation) -> xtd::threading::tasks::task<> {
        auto call_now = false;
        
        lock_(data_->sync_root) {
          data_->continuation = xtd::new_sptr<xtd::threading::tasks::task<>>(continuation);
          if (is_completed()) call_now = true;
        }
        
        if (call_now) run_continuation(data_->continuation_async);
        return *data_->continuation;
      }
      
      template<typename result_t>
      auto basic_task<result_t>::continue_with(xtd::func<xtd::threading::tasks::task<>>&& continuation_async) -> xtd::threading::tasks::task<xtd::threading::tasks::task<>> {
        auto call_now = false;
        
        lock_(data_->sync_root) {
          data_->continuation_async = xtd::new_sptr<xtd::threading::tasks::task<xtd::threading::tasks::task<>>>(continuation_async);
          if (is_completed()) call_now = true;
        }
        
        if (call_now) run_continuation(data_->continuation_async);
        return *data_->continuation_async;
      }
 
      template<typename 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<typename 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<typename 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<typename 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<typename 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<typename 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<typename result_t>
      template<typename 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::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<typename 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<typename 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<typename 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<typename 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<typename result_t>
      template<typename ...items_t>
      auto xtd::threading::tasks::basic_task<result_t>::when_all(items_t&&... items) -> task<> {
        return task_factory {}.start_new([&items...]() mutable {
          task<>::wait_all(std::forward<items_t>(items)...);
        });
      }
      
      template<typename result_t>
      template<typename ...items_t>
      auto xtd::threading::tasks::basic_task<result_t>::when_any(items_t&&... items) -> task<xtd::usize> {
        return task_factory {}.start_new([&items...]() mutable {
          return task<>::wait_any(std::forward<items_t>(items)...);
        });
      }
 
      template<typename result_t>
      auto xtd::threading::tasks::basic_task<result_t>::yield() -> task<result_t> {
        co_await yield_awaiter {};
      }
 
      template<typename result_t>
      auto xtd::threading::tasks::basic_task<result_t>::run_continuation(auto continuation) -> void {
        continuation->start();
        continuation->wait();
      }
 
      template<typename result1_t, typename result2_t>
      inline auto operator &&(const task<result1_t>& t1, const task<result2_t>& t2) -> task<> {
        return task_factory {}.start_new([t1, t2]() mutable {task<>::wait_all(t1, t2);});
      }
      
      template<typename result1_t, typename result2_t>
      inline auto operator ||(const task<result1_t>& t1, const task<result2_t>& t2) -> task<> {
        return task_factory {}.start_new([t1, t2]() mutable {task<>::wait_any(t1, t2);});
      }
    }
  }
}