parallel.hpp

Go to the documentation of this file.

#pragma once
#include "task_factory.hpp"
#include "../../collections/generic/list.hpp"
#include "../../action_callable.hpp"
#include "../../array.hpp"
#include "../../integer.hpp"
#include "../../static.hpp"

namespace xtd {
  namespace threading {
    namespace tasks {
      class parallel static_ {
      public:
        template<xtd::integer integer_t>
        static auto for_(integer_t from_inclusive, integer_t to_exclusive, auto&& body) -> void {
          for_each(xtd::linq::enumerable::range(from_inclusive, to_exclusive - from_inclusive), body);
        }
        
        template<xtd::integer integer_t>
        static auto for_(integer_t from_inclusive, integer_t to_exclusive, auto&& body, const xtd::threading::cancellation_token& cancellation_token) -> void {
          for_each(xtd::linq::enumerable::range(from_inclusive, to_exclusive - from_inclusive), body, cancellation_token).wait();
        }
 
        template<xtd::integer integer_t>
        static auto for_async(integer_t from_inclusive, integer_t to_exclusive, auto&& body) -> xtd::threading::tasks::task<> {
          return for_each_async(xtd::linq::enumerable::range(from_inclusive, to_exclusive - from_inclusive), body);
        }
        
        template<xtd::integer integer_t>
        static auto for_async(integer_t from_inclusive, integer_t to_exclusive, auto&& body, const xtd::threading::cancellation_token& cancellation_token) -> xtd::threading::tasks::task<> {
          return for_each_async(xtd::linq::enumerable::range(from_inclusive, to_exclusive - from_inclusive), body, cancellation_token);
        }
        
        template<xtd::iterable source_t>
        static auto for_each(source_t&& source, auto&& body) -> void {
          for_each_async(std::forward<source_t>(source), body).wait();
        }
        
        template<xtd::iterable source_t>
        static auto for_each(source_t&& source, auto&& body, const xtd::threading::cancellation_token& cancellation_token) -> void {
          for_each_async(std::forward<source_t>(source), body, cancellation_token).wait();
        }

        template<xtd::iterable source_t>
        static auto for_each_async(source_t&& source, auto&& body) -> xtd::threading::tasks::task<> {
          using result_t = xtd::raw_type<decltype(body(std::declval<const xtd::iterable_value_type<source_t>&>()))>;
          xtd::collections::generic::list<xtd::threading::tasks::task<result_t>> tasks;
          
          for(const auto& item : source)
            tasks.add(xtd::threading::tasks::task<>::factory().start_new([body](auto state) -> result_t {return body(as<xtd::iterable_value_type<source_t>>(state));}, xtd::any_object(item)));
          
          co_await xtd::threading::tasks::task<result_t>::when_all(tasks);
        }
        
        template<xtd::iterable source_t>
        static auto for_each_async(source_t&& source, auto&& body, const xtd::threading::cancellation_token& cancellation_token) -> xtd::threading::tasks::task<> {
          using result_t = xtd::raw_type<decltype(body(std::declval<const xtd::iterable_value_type<source_t>&>()))>;
          xtd::collections::generic::list<xtd::threading::tasks::task<result_t>> tasks;
          
          for(const auto& item : source)
            tasks.add(xtd::threading::tasks::task<>::factory().start_new([body](auto state) -> result_t {return body(as<xtd::iterable_value_type<source_t>>(state));}, xtd::any_object(item), cancellation_token));
          
          co_await xtd::threading::tasks::task<result_t>::when_all(tasks);
        }
        
        template<typename type_t>
        static auto for_each(std::initializer_list<type_t>&& source, auto&& body) -> void {
          for_each(xtd::collections::generic::list<type_t>(source), body);
        }
        
        template<typename type_t>
        static auto for_each(std::initializer_list<type_t>&& source, auto&& body, const xtd::threading::cancellation_token& cancellation_token) -> void {
          for_each(xtd::collections::generic::list<type_t>(source), body, cancellation_token);
        }
        
        template<typename type_t>
        static auto for_each_async(std::initializer_list<type_t>&& source, auto&& body) -> xtd::threading::tasks::task<> {
          return for_each_async(xtd::collections::generic::list<type_t>(source), body);
        }
        
        template<typename type_t>
        static auto for_each_async(std::initializer_list<type_t>&& source, auto&& body, const xtd::threading::cancellation_token& cancellation_token) -> xtd::threading::tasks::task<> {
          return for_each_async(xtd::collections::generic::list<type_t>(source), body, cancellation_token);
        }

        static auto invoke(xtd::array<xtd::action<>>&& actions) -> void {
          task<>::wait_all(invoke_async(actions));
        }

        template<typename collection_t>
        static auto invoke(collection_t&& actions) -> void {
          task<>::wait_all(invoke_async(actions));
        }

        template<typename ...args_t>
        static auto invoke(args_t&&... args) -> void {invoke(xtd::array<xtd::action<>> {xtd::action<> {std::forward<args_t>(args)}...});}
 
        static auto invoke_async(xtd::array<xtd::action<>>&& actions) -> xtd::array<xtd::threading::tasks::task<>> {
          xtd::collections::generic::list<xtd::threading::tasks::task<>> tasks;
          for (const auto& action : actions)
            tasks.add(xtd::threading::tasks::task<>::factory().start_new(action));
          return tasks.to_array();
        }
        
        template<typename collection_t>
        static auto invoke_async(collection_t&& actions) -> xtd::array<xtd::threading::tasks::task<>> {
          xtd::collections::generic::list<xtd::threading::tasks::task<>> tasks;
          for (const auto& action : actions)
            tasks.add(xtd::threading::tasks::task<>::factory().start_new(action));
          return tasks.to_array();
        }
        
        template<typename ...args_t>
        static auto invoke_async(args_t&&... args) -> xtd::array<xtd::threading::tasks::task<>> {return invoke_async(xtd::array<xtd::action<>> {xtd::action<> {std::forward<args_t>(args)}...});}
      };
    }
  }
}