xtd 1.0.0
Loading...
Searching...
No Matches
basic_task.hpp
Go to the documentation of this file.
1
4#pragma once
5#include "itask.hpp"
6#include "task_canceled_exception.hpp"
7#include "task_creation_options.hpp"
8#include "task_object.hpp"
9#include "task_status.hpp"
10#include "../auto_reset_event.hpp"
11#include "../lock.hpp"
12#include "../thread_pool.hpp"
13#include "../../collections/generic/dictionary.hpp"
14#include "../../diagnostics/stopwatch.hpp"
15#include "../../exception_services/exception_dispatch_info.hpp"
16#include "../../helpers/throw_helper.hpp"
17#include "../../action.hpp"
18#include "../../aggregate_exception.hpp"
19#include "../../func.hpp"
20#include "../../iasync_result.hpp"
21#include "../../new_sptr.hpp"
22#include "../../optional.hpp"
23#include "../../ref.hpp"
24#include "../../scope_exit.hpp"
25#include "../../sptr.hpp"
26#include <coroutine>
27
29namespace xtd {
31 namespace threading {
33 namespace tasks {
35 template<typename result_t = void>
36 class task;
37
38 template<typename result_t>
39 struct task_awaiter;
40
41 class task_factory;
43
59 template<typename result_t>
60 class basic_task : public xtd::threading::tasks::task_object, public xtd::threading::tasks::itask, public xtd::iasync_result {
61 public:
62 struct yield_awaiter;
63
65
69 static constexpr xtd::usize wait_timeout = xtd::usize_object::max_value;
72
76 basic_task(const xtd::func<result_t>& func) {
77 data_->func = func;
78 }
79 basic_task(const xtd::func<result_t>& func, const xtd::threading::cancellation_token& cancellation_token) {
80 data_->func = func;
81 data_->cancellation_token = cancellation_token;
82 }
83 basic_task(const xtd::func<result_t, const xtd::any_object&>& func, const xtd::any_object& state) {
84 data_->parameterized_func = func;
85 data_->state = &state;
86 }
87 basic_task(const xtd::func<result_t>& func, const xtd::any_object& state, const xtd::threading::cancellation_token& cancellation_token) {
88 data_->func = func;
89 data_->state = &state;
90 data_->cancellation_token = cancellation_token;
91 }
93
95 template<typename create_result_t>
96 basic_task(const xtd::func<create_result_t>& func) {
97 data_->func = func;
98 }
99 template<typename create_result_t>
100 basic_task(const xtd::func<create_result_t>& func, const xtd::threading::cancellation_token& cancellation_token) {
101 data_->func = func;
102 data_->cancellation_token = cancellation_token;
103 }
104 template<typename create_result_t>
105 basic_task(const xtd::func<create_result_t, const xtd::any_object&>& func, const xtd::any_object& state) {
106 data_->parameterized_func = func;
107 data_->state = &state;
108 }
109 template<typename create_result_t>
110 basic_task(const xtd::func<create_result_t, const xtd::any_object&>& func, const xtd::any_object& state, const xtd::threading::cancellation_token& cancellation_token) {
111 data_->parameterized_func = func;
112 data_->state = &state;
113 data_->cancellation_token = cancellation_token;
114 }
116
117
119
121 [[nodiscard]] auto async_state() const noexcept -> xtd::any_object override {return data_->async_state;}
122 [[nodiscard]] auto creation_options() const noexcept -> xtd::threading::tasks::task_creation_options {return data_->creation_options;}
123 [[nodiscard]] auto exception() const noexcept -> xtd::ref<xtd::exception> {return data_->exception.exception_captured() ? xtd::ref<xtd::exception> {*data_->exception.source_exception()} : xtd::ref<xtd::exception> {xtd::null};}
128 [[nodiscard]] auto id() const noexcept -> xtd::usize override {return data_->id;}
129 [[nodiscard]] auto is_canceled() const noexcept -> bool {return data_->status == xtd::threading::tasks::task_status::canceled;}
130 [[nodiscard]] auto is_completed() const noexcept -> bool override {return is_faulted() || is_canceled() || data_->status == xtd::threading::tasks::task_status::ran_to_completion;}
131 [[nodiscard]] auto is_empty() const noexcept -> bool {return data_->func.is_empty();}
132 [[nodiscard]] auto is_faulted() const noexcept -> bool {return data_->status == xtd::threading::tasks::task_status::faulted;}
133 [[nodiscard]] auto status() const noexcept -> xtd::threading::tasks::task_status {return data_->status;}
135
137
139 [[nodiscard]] static auto completed_task() -> task<result_t>;
140 [[nodiscard]] static auto current_id() noexcept -> xtd::usize {return current_id_;}
141 [[nodiscard]] static auto factory() noexcept -> const xtd::threading::tasks::task_factory&;
143
145
147 auto continue_with(xtd::action<>&& continuation) -> xtd::threading::tasks::task<>;
148 auto continue_with(xtd::func<xtd::threading::tasks::task<>>&& continuation_async) -> xtd::threading::tasks::task<xtd::threading::tasks::task<>>;
149
150 [[noreturn]] auto rethrow_exception() -> void {
151 if (is_faulted () && data_->exception) throw *data_->exception.source_exception();
152 xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation, "This task is not faulted.");
153 }
154
155 auto run_synchronously() -> void {
156 if (is_completed()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation, "Start may not be called on a task that has completed.");
157 data_->status = xtd::threading::tasks::task_status::waiting_to_run;
158 data_->task_proc(data_->state, false);
159 }
160
162 auto start() -> void override {
163 if (is_completed()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation, "Start may not be called on a task that has completed.");
164 data_->status = xtd::threading::tasks::task_status::waiting_for_activation;
165 data_->caller_thread = &xtd::threading::thread::current_thread();
166 data_->caller_id = &current_id_;
167 thread_pool::register_wait_for_single_object(data_->start_event, data_->task_proc, *data_->state, xtd::threading::timeout::infinite, true);
168 data_->status = xtd::threading::tasks::task_status::waiting_to_run;
169 data_->start_event.set();
170 }
171
173 auto wait() -> void override {wait(xtd::threading::timeout::infinite);}
177 auto wait(xtd::int32 milliseconds_timeout) -> bool override {
178 auto cancellation_token = xtd::threading::cancellation_token {};
179 return wait(milliseconds_timeout, data_->cancellation_token ? *data_->cancellation_token : cancellation_token);
180 }
184 auto wait(xtd::int32 milliseconds_timeout, xtd::threading::cancellation_token& cancellation_token) -> bool override {
185 auto& cancellation_token_wait_handle = cancellation_token.wait_handle();
186 auto result = xtd::threading::wait_handle::wait_any(milliseconds_timeout, &cancellation_token_wait_handle, &data_->end_event);
187 if (result == 0) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::task_canceled);
188 if (data_->status == xtd::threading::tasks::task_status::faulted) rethrow_exception();
189 return result == 1;
190 }
194 auto wait(const xtd::time_span& timeout) -> bool override {return wait(xtd::as<xtd::int32>(timeout.total_milliseconds_duration().count()));}
198 auto wait(const xtd::time_span& timeout, xtd::threading::cancellation_token& cancellation_token) -> bool override {return wait(xtd::as<xtd::int32>(timeout.total_milliseconds_duration().count()), cancellation_token);}
200
202
204 operator bool() const noexcept {return !is_empty();}
206
208
210 [[nodiscard]] static auto from_cancelation(const xtd::threading::cancellation_token& cancellation_token) -> task<result_t>;
211
212 template<typename from_exception_t>
213 [[nodiscard]] static auto from_exception(from_exception_t exception) -> task<result_t>;
214
215 [[nodiscard]] static auto delay(const xtd::time_span& delay) -> task<>;
216 [[nodiscard]] static auto delay(const xtd::time_span& delay, const xtd::threading::cancellation_token& cancellation_token) -> task<>;
217 [[nodiscard]] static auto delay(xtd::int32 milliseconds_delay) -> task<>;
218 [[nodiscard]] static auto delay(xtd::int32 milliseconds_delay, const xtd::threading::cancellation_token& cancellation_token) -> task<>;
219
220 [[nodiscard]] static auto run(const xtd::func<result_t>& func) -> task<result_t>;
221 [[nodiscard]] static auto run(const xtd::func<result_t>& func, const xtd::threading::cancellation_token& cancellation_token) -> task<result_t>;
222 [[nodiscard]] static auto run(const xtd::func<result_t, const xtd::any_object&>& func, const xtd::any_object& state) -> task<result_t>;
223 [[nodiscard]] static auto run(const xtd::func<result_t, const xtd::any_object&>& func, const xtd::any_object& state, const xtd::threading::cancellation_token& cancellation_token) -> task<result_t>;
224
225 template<typename collection_t>
226 static auto wait_all(const collection_t& tasks) -> bool {return wait_all(tasks, xtd::threading::timeout::infinite);}
227
228 template<typename collection_t>
229 static auto wait_all(const collection_t& tasks, xtd::int32 milliseconds_timeout) -> bool {
230 auto task_pointers = std::vector<itask*> {};
231 for (auto& task : tasks)
232 task_pointers.push_back(const_cast<decltype(&task)>(&task));
233 return wait_all(array<itask*> {task_pointers}, milliseconds_timeout);
234 }
235
236 template<typename collection_t>
237 static auto wait_all(const collection_t& tasks, const xtd::time_span& timeout) -> bool {return wait_all(tasks, xtd::as<xtd::int32>(timeout.total_milliseconds_duration().count()));}
238
239 template<typename collection_t>
240 static xtd::usize wait_any(const collection_t& tasks) {return wait_any(tasks, timeout::infinite);}
241
242 template<typename collection_t>
243 static xtd::usize wait_any(const collection_t& tasks, int32 milliseconds_timeout) {
244 auto task_pointers = std::vector<itask*> {};
245 for (auto& task : tasks)
246 task_pointers.push_back(const_cast<decltype(&task)>(&task));
247 return wait_any(xtd::array<itask*> {task_pointers}, milliseconds_timeout);
248 }
249
250 template<typename collection_t>
251 static xtd::usize wait_any(const collection_t& tasks, const time_span& timeout) {return wait_any(tasks, as<int32>(timeout.total_milliseconds_duration().count()));}
252
253 template<typename ...items_t>
254 static auto when_all(items_t&&... items) -> task<>;
255
256 template<typename ...items_t>
257 static auto when_any(items_t&&... items) -> task<xtd::usize>;
259
261 template<typename ...items_t>
262 static auto wait_all(items_t... items) -> bool {return wait_all(xtd::threading::timeout::infinite, items...);}
263 template<typename ...items_t>
264 static auto wait_all(const xtd::time_span& timeout, items_t... items) -> bool {return wait_all(xtd::as<xtd::int32>(timeout.total_milliseconds()), items...);}
265 template<typename ...items_t>
266 static auto wait_all(xtd::int32 milliseconds_timeout, items_t... items) -> bool {
267 auto task_pointers = std::vector<itask*> {};
268 fill_task_pointers(task_pointers, items...);
269 return wait_all(xtd::array<itask*> {task_pointers}, milliseconds_timeout);
270 }
271 template<typename item_t>
272 static auto wait_all(const std::initializer_list<item_t>& tasks) -> bool {return wait_all(tasks, timeout::infinite);}
273 template<typename item_t>
274 static auto wait_all(const std::initializer_list<item_t>& tasks, xtd::int32 milliseconds_timeout) -> bool {
275 auto task_pointers = std::vector<itask*> {};
276 for (auto& task : tasks)
277 task_pointers.push_back(const_cast<item_t*>(&task));
278 return wait_all(xtd::array<itask*> {task_pointers}, milliseconds_timeout);
279 }
280 template<typename item_t>
281 static auto wait_all(const std::initializer_list<item_t>& tasks, const xtd::time_span& timeout) -> bool {return wait_all(tasks, as<int32>(timeout.total_milliseconds_duration().count()));}
282 static auto wait_all(const std::initializer_list<xtd::sptr<itask>>& tasks) -> bool {return wait_all(tasks, xtd::threading::timeout::infinite);}
283 static auto wait_all(const std::initializer_list<xtd::sptr<itask>>& tasks, xtd::int32 milliseconds_timeout) -> bool {
284 auto task_pointers = std::vector<itask*> {};
285 for (auto& task : tasks)
286 task_pointers.push_back(task.get());
287 return wait_all(xtd::array<itask*> {task_pointers}, milliseconds_timeout);
288 }
289 static auto wait_all(const std::initializer_list<xtd::sptr<itask>>& tasks, const xtd::time_span& timeout) -> bool {return wait_all(tasks, xtd::as<xtd::int32>(timeout.total_milliseconds_duration().count()));}
290 static auto wait_all(const std::initializer_list<xtd::uptr<itask>>& tasks) -> bool {return wait_all(tasks, xtd::threading::timeout::infinite);}
291 static auto wait_all(const std::initializer_list<xtd::uptr<itask>>& tasks, xtd::int32 milliseconds_timeout) -> bool {
292 auto task_pointers = std::vector<itask*> {};
293 for (auto& task : tasks)
294 task_pointers.push_back(task.get());
295 return wait_all(xtd::array<itask*> {task_pointers}, milliseconds_timeout);
296 }
297 static auto wait_all(const std::initializer_list<xtd::uptr<itask>>& tasks, const xtd::time_span& timeout) -> bool {return wait_all(tasks, xtd::as<xtd::int32>(timeout.total_milliseconds_duration().count()));}
298 static auto wait_all(const xtd::array<xtd::sptr<itask>>& tasks) -> bool {return wait_all(tasks, timeout::infinite);}
299 static auto wait_all(const xtd::array<xtd::sptr<itask>>& tasks, xtd::int32 milliseconds_timeout) -> bool {
300 auto task_pointers = std::vector<itask*> {};
301 for (auto& task : tasks)
302 task_pointers.push_back(task.get());
303 return wait_all(xtd::array<itask*> {task_pointers}, milliseconds_timeout);
304 }
305 static auto wait_all(const xtd::array<xtd::sptr<itask>>& tasks, const xtd::time_span& timeout) -> bool {return wait_all(tasks, xtd::as<xtd::int32>(timeout.total_milliseconds_duration().count()));}
306 static auto wait_all(const xtd::array<xtd::uptr<itask>>& tasks) -> bool {return wait_all(tasks, timeout::infinite);}
307 static auto wait_all(const xtd::array<xtd::uptr<itask>>& tasks, xtd::int32 milliseconds_timeout) -> bool {
308 auto task_pointers = std::vector<itask*> {};
309 for (auto& task : tasks)
310 task_pointers.push_back(task.get());
311 return wait_all(xtd::array<itask*> {task_pointers}, milliseconds_timeout);
312 }
313 static auto wait_all(const xtd::array<xtd::uptr<itask>>& tasks, const xtd::time_span& timeout) -> bool {return wait_all(tasks, xtd::as<xtd::int32>(timeout.total_milliseconds_duration().count()));}
314 static auto wait_all(const xtd::array<itask*>& tasks, xtd::int32 milliseconds_timeout) -> bool {
315 if (milliseconds_timeout < timeout::infinite) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);
316
317 if (milliseconds_timeout == timeout::infinite) {
318 for (auto task : tasks)
319 task->wait();
320 return true;
321 }
322
323 auto sw = xtd::diagnostics::stopwatch::start_new();
324 for (auto& task : tasks)
325 if (sw.elapsed_milliseconds() > milliseconds_timeout || task->wait(milliseconds_timeout - xtd::as<xtd::int32>(sw.elapsed_milliseconds()))) return false;
326 return true;
327 }
328
329 template<typename ...items_t>
330 static auto wait_any(items_t... items) -> xtd::usize {return wait_any(xtd::threading::timeout::infinite, items...);}
331 template<typename ...items_t>
332 static auto wait_any(const xtd::time_span& timeout, items_t... items) -> xtd::usize {return wait_any(xtd::as<xtd::int32>(timeout.total_milliseconds()), items...);}
333 template<typename ...items_t>
334 static auto wait_any(xtd::int32 milliseconds_timeout, items_t... items) -> xtd::usize {
335 auto task_pointers = std::vector<itask*> {};
336 fill_task_pointers(task_pointers, items...);
337 return wait_any(xtd::array<itask*> {task_pointers}, milliseconds_timeout);
338 }
339 template<typename item_t>
340 static auto wait_any(const std::initializer_list<item_t>& tasks) -> xtd::usize {return wait_any(tasks, timeout::infinite);}
341 template<typename item_t>
342 static auto wait_any(const std::initializer_list<item_t>& tasks, xtd::int32 milliseconds_timeout) -> xtd::usize {
343 auto task_pointers = std::vector<itask*> {};
344 for (auto& task : tasks)
345 task_pointers.push_back(const_cast<item_t*>(&task));
346 return wait_any(xtd::array<itask*> {task_pointers}, milliseconds_timeout);
347 }
348 template<typename item_t>
349 static auto wait_any(const std::initializer_list<item_t>& tasks, const xtd::time_span& timeout) -> xtd::usize {return wait_any(tasks, as<int32>(timeout.total_milliseconds_duration().count()));}
350 static auto wait_any(const std::initializer_list<xtd::sptr<itask>>& tasks) -> xtd::usize {return wait_any(tasks, xtd::threading::timeout::infinite);}
351 static auto wait_any(const std::initializer_list<xtd::sptr<itask>>& tasks, xtd::int32 milliseconds_timeout) -> xtd::usize {
352 auto task_pointers = std::vector<itask*> {};
353 for (auto& task : tasks)
354 task_pointers.push_back(task.get());
355 return wait_any(xtd::array<itask*> {task_pointers}, milliseconds_timeout);
356 }
357 static auto wait_any(const std::initializer_list<xtd::sptr<itask>>& tasks, const xtd::time_span& timeout) -> xtd::usize {return wait_any(tasks, xtd::as<xtd::int32>(timeout.total_milliseconds_duration().count()));}
358 static auto wait_any(const std::initializer_list<xtd::uptr<itask>>& tasks) -> xtd::usize {return wait_any(tasks, xtd::threading::timeout::infinite);}
359 static auto wait_any(const std::initializer_list<xtd::uptr<itask>>& tasks, xtd::int32 milliseconds_timeout) -> xtd::usize {
360 auto task_pointers = std::vector<itask*> {};
361 for (auto& task : tasks)
362 task_pointers.push_back(task.get());
363 return wait_any(xtd::array<itask*> {task_pointers}, milliseconds_timeout);
364 }
365 static auto wait_any(const std::initializer_list<xtd::uptr<itask>>& tasks, const xtd::time_span& timeout) -> xtd::usize {return wait_any(tasks, xtd::as<xtd::int32>(timeout.total_milliseconds_duration().count()));}
366 static auto wait_any(const xtd::array<xtd::sptr<itask>>& tasks) -> xtd::usize {return wait_any(tasks, timeout::infinite);}
367 static auto wait_any(const xtd::array<xtd::sptr<itask>>& tasks, xtd::int32 milliseconds_timeout) -> xtd::usize {
368 auto task_pointers = std::vector<itask*> {};
369 for (auto& task : tasks)
370 task_pointers.push_back(task.get());
371 return wait_any(xtd::array<itask*> {task_pointers}, milliseconds_timeout);
372 }
373 static auto wait_any(const xtd::array<xtd::sptr<itask>>& tasks, const xtd::time_span& timeout) -> xtd::usize {return wait_any(tasks, xtd::as<xtd::int32>(timeout.total_milliseconds_duration().count()));}
374 static auto wait_any(const xtd::array<xtd::uptr<itask>>& tasks) -> xtd::usize {return wait_any(tasks, timeout::infinite);}
375 static auto wait_any(const xtd::array<xtd::uptr<itask>>& tasks, xtd::int32 milliseconds_timeout) -> xtd::usize {
376 auto task_pointers = std::vector<itask*> {};
377 for (auto& task : tasks)
378 task_pointers.push_back(task.get());
379 return wait_any(xtd::array<itask*> {task_pointers}, milliseconds_timeout);
380 }
381 static auto wait_any(const xtd::array<xtd::uptr<itask>>& tasks, const xtd::time_span& timeout) -> xtd::usize {return wait_any(tasks, xtd::as<xtd::int32>(timeout.total_milliseconds_duration().count()));}
382 static auto wait_any(const xtd::array<itask*>& tasks, xtd::int32 milliseconds_timeout) -> xtd::usize {
383 if (milliseconds_timeout < xtd::threading::timeout::infinite) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);
384
385 auto sleep_duration = 1;
386 const auto max_sleep = 10;
387 auto sw = xtd::diagnostics::stopwatch::start_new();
388
389 while (milliseconds_timeout == xtd::threading::timeout::infinite || sw.elapsed_milliseconds() <= milliseconds_timeout) {
390 for (auto index = xtd::usize {0}; index < tasks.length(); ++index)
391 if (tasks[index]->wait(0)) return index;
392
393 xtd::threading::thread::sleep(sleep_duration);
394 sleep_duration = std::min(sleep_duration + 1, max_sleep);
395 }
396
397 return wait_timeout;
398 }
399
400 static auto yield() -> task<result_t>;
402
403 protected:
405 auto continue_with_(xtd::action<>&& continuation) -> void {
406 auto call_now = false;
407
408 lock_(data_->sync_root) {
409 if (is_completed()) call_now = true;
410 else data_->internal_continuation = continuation;
411 }
412
413 if (call_now) continuation();
414 }
416
417 private:
418 template<typename task_result_t>
419 friend class task;
420 template<typename batic_task_result_t>
421 friend class batic_task;
422
423 basic_task() = default;
424 basic_task(basic_task&&) = default;
425 basic_task(const basic_task&) = default;
426 auto operator=(basic_task&&) -> basic_task& = default;
427 auto operator=(const basic_task&) -> basic_task& = default;
428
429 [[nodiscard]] auto async_wait_handle() noexcept -> xtd::threading::wait_handle& override {return data_->async_event;}
430 [[nodiscard]] auto completed_synchronously() const noexcept -> bool override {return false;}
431
432 template<typename item_t, typename ...items_t>
433 static auto fill_task_pointers(std::vector<itask*>& itask_pointer, item_t& first, items_t& ... rest) -> void {
434 itask_pointer.push_back(&first);
435 fill_task_pointers(itask_pointer, rest...);
436 }
437 template<typename item_t>
438 static auto fill_task_pointers(std::vector<itask*>& itask_pointer, item_t& item) -> void {
439 itask_pointer.push_back(&item);
440 }
441
442 auto on_await_resume() -> void {
443 if (data_->caller_thread->is_main_thread()) thread::set_main_managed_thread_id(xtd::threading::thread::current_thread().get_managed_thread_id());
444 // a bad idea that seems like a good one
445 // std::swap(data_->caller_thread->get_managed_thread_id(), xtd::threading::thread::current_thread().get_managed_thread_id());
446 //std::swap(*data_->caller_id, current_id_);
447 }
448
449 static auto run_continuation(auto continuation) -> void;
450
451 struct data {
452 using result_type = std::conditional_t<std::is_same_v<result_t, void>, std::uint8_t, result_t>;
453
454 xtd::async_callback async_callback;
455 xtd::threading::manual_reset_event async_event;
456 xtd::any_object async_state;
457 xtd::optional<xtd::threading::cancellation_token> cancellation_token;
458 xtd::action<> internal_continuation;
459 xtd::sptr<xtd::threading::tasks::task<>> continuation;
460 xtd::sptr<xtd::threading::tasks::task<xtd::threading::tasks::task<>>> continuation_async;
461 xtd::threading::tasks::task_creation_options creation_options = xtd::threading::tasks::task_creation_options::none;
462 const xtd::any_object empty_state;
463 xtd::threading::auto_reset_event end_event;
464 xtd::exception_services::exception_dispatch_info exception;
465 xtd::func<result_t> func;
466 xtd::usize id = generate_id();
467 xtd::usize previous_current_id;
468 xtd::func<result_t, const xtd::any_object&> parameterized_func;
469 result_type result;
470 const xtd::any_object* state = &empty_state;
471 xtd::threading::auto_reset_event start_event;
472 xtd::threading::tasks::task_status status = xtd::threading::tasks::task_status::created;
473 xtd::object sync_root;
474 xtd::usize unique_id = generate_unique_id();
475 xtd::threading::thread* caller_thread = null;
476 xtd::usize* caller_id = null;
477
478 xtd::threading::wait_or_timer_callback task_proc {delegate_(const xtd::any_object& state, bool timed_out) {
479 previous_current_id = current_id_;
480 current_id_ = id;
481
482 scope_exit_ {
483 end_event.set();
484 if (!internal_continuation.is_empty()) internal_continuation();
485 if (continuation) basic_task<result_t>::run_continuation(continuation);
486 else if (continuation_async) basic_task<result_t>::run_continuation(continuation_async);
487 current_id_ = previous_current_id;
488 lock_(static_data_.sync_root) {
489 if (static_data_.tasks.contains_key(unique_id)) static_data_.tasks.remove(unique_id);
490 }
491 };
492
493 status = xtd::threading::tasks::task_status::running;
494 try {
495 if (cancellation_token && cancellation_token->wait_handle().wait_one(0)) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::task_canceled);
496 if constexpr(std::is_same_v<result_t, void>) {
497 if (!func.is_empty()) func();
498 else if (!parameterized_func.is_empty()) parameterized_func(state);
499 } else {
500 if (!func.is_empty()) result = func();
501 else if (!parameterized_func.is_empty()) result = parameterized_func(state);
502 }
503 if (cancellation_token && cancellation_token->wait_handle().wait_one(0)) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::task_canceled);
504 status = xtd::threading::tasks::task_status::ran_to_completion;
505 } catch (const xtd::threading::tasks::task_canceled_exception& e) {
506 exception = xtd::exception_services::exception_dispatch_info::capture(e);
507 status = xtd::threading::tasks::task_status::canceled;
508 } catch (const xtd::exception& e) {
509 exception = xtd::exception_services::exception_dispatch_info::capture(e);
510 status = xtd::threading::tasks::task_status::faulted;
511 } catch (const std::exception& e) {
512 exception = xtd::exception_services::exception_dispatch_info::capture(xtd::exception {e.what()});
513 status = xtd::threading::tasks::task_status::faulted;
514 } catch (...) {
515 exception = xtd::exception_services::exception_dispatch_info::capture(xtd::exception {"Unknown exception"});
516 status = xtd::threading::tasks::task_status::faulted;
517 }
518 }};
519 };
520
521 struct static_data {
522 xtd::object sync_root;
523 xtd::collections::generic::dictionary<xtd::usize, sptr<basic_task>> tasks;
524 };
525
526 xtd::sptr<data> data_ = xtd::new_sptr<data>();
527 inline static static_data static_data_;
528 };
529 }
530 }
531}
action.hpp
Contains xtd::action delegate.
aggregate_exception.hpp
Contains xtd::aggregate_exception exception.
auto_reset_event.hpp
Contains xtd::threading::auto_reset_event exception.
xtd::box_integer< xtd::usize >::max_value
static constexpr xtd::usize max_value
Definition box_integer.hpp:71
xtd::diagnostics::stopwatch::start_new
static auto start_new() noexcept -> xtd::diagnostics::stopwatch
Initializes a new xtd::diagnostics::stopwatch instance, sets the xtd::diagnostics::stopwatch::elapsed...
xtd::exception_services::exception_dispatch_info::capture
static auto capture() -> exception_dispatch_info
Creates an xtd::exception_services::exception_dispatch_info object that represents the specified exce...
Definition exception_dispatch_info.hpp:65
xtd::exception::exception
exception(const xtd::diagnostics::stack_frame &stack_frame=xtd::diagnostics::stack_frame::current())
Create a new instance of class exception.
xtd::helpers::throw_helper::throws
static auto throws(xtd::helpers::exception_case exception_case, const source_location &location=source_location::current()) -> void
Throws an exption with specified exception case.
xtd::threading::event_wait_handle::set
auto set() -> bool
Sets the state of the event to signaled, allowing one or more waiting threads to proceed.
xtd::threading::tasks::task_factory
Provides support for creating and scheduling Task objects.
Definition task_factory.hpp:22
xtd::threading::tasks::task
Represents an asynchronous operation.
Definition task_result.hpp:20
xtd::threading::thread_pool::register_wait_for_single_object
static auto register_wait_for_single_object(wait_handle &wait_object, const wait_or_timer_callback &callback, const xtd::any_object &state, int32 milliseconds_timeout_interval, bool execute_only_once) -> registered_wait_handle
Registers a delegate to wait for a xtd::threading::wait_handle, specifying a 32-bit signed integer fo...
xtd::threading::thread::sleep
static auto sleep(int32 milliseconds_timeout) -> void
Suspends the current thread for a specified time.
xtd::threading::thread::current_thread
static auto current_thread() noexcept -> thread &
Gets the currently running thread.
xtd::threading::timeout::infinite
static constexpr int32 infinite
A constant used to specify an infinite waiting period. This field is constant.
Definition timeout.hpp:41
xtd::threading::wait_handle::wait_any
static auto wait_any(const collection_t &wait_handles) -> xtd::usize
Waits for any of the elements in the specified collection to receive a signal.
Definition wait_handle.hpp:198
dictionary.hpp
Contains xtd::collections::generic::dictionary <key_t, value_t> class.
exception_dispatch_info.hpp
Contains xtd::exception_services::exception_dispatch_info class.
func.hpp
Contains xtd::func delegate.
xtd::func
xtd::delegate< result_t(arguments_t... arguments)> func
Represents a delegate that has variables parameters and returns a value of the type specified by the ...
Definition func.hpp:27
xtd::threading::wait_or_timer_callback
xtd::delegate< void(const xtd::any_object &state, bool timed_out)> wait_or_timer_callback
Represents a method to be called when a xtd::threading::wait_handle is signaled or times out.
Definition wait_or_timer_callback.hpp:30
xtd::async_callback
xtd::delegate< void(xtd::async_result ar)> async_callback
References a method to be called when a corresponding asynchronous operation completes.
Definition delegate.hpp:39
xtd::helpers::exception_case::argument
@ argument
The argument is not valid.
Definition exception_case.hpp:31
xtd::helpers::exception_case::task_canceled
@ task_canceled
The task is canceled.
Definition exception_case.hpp:103
xtd::helpers::exception_case::invalid_operation
@ invalid_operation
The operation is not valid.
Definition exception_case.hpp:65
scope_exit_
#define scope_exit_
Nowadays, every C++ developer is familiar with the Resource Acquisition Is Initialization (RAII) tech...
Definition scope_exit.hpp:134
delegate_
#define delegate_
The declaration of a delegate type is similar to a method signature. It has a return value and any nu...
Definition delegate.hpp:1018
lock_
#define lock_(object)
The lock_ keyword marks a statement block as a critical section by obtaining the mutual-exclusion loc...
Definition lock.hpp:68
xtd::threading::tasks::task_status
task_status
Represents the current stage in the lifecycle of a xtd::threading::tasks::task.
Definition task_status.hpp:23
xtd::threading::tasks::task_creation_options
task_creation_options
Specifies flags that control optional behavior for the creation and execution of tasks....
Definition task_creation_options.hpp:23
xtd::threading::tasks::task_status::waiting_to_run
@ waiting_to_run
The task has been scheduled for execution but has not yet begun executing.
Definition task_status.hpp:29
xtd::threading::tasks::task_status::running
@ running
The task is running but has not yet completed.
Definition task_status.hpp:31
xtd::threading::tasks::task_status::ran_to_completion
@ ran_to_completion
The task completed execution successfully.
Definition task_status.hpp:35
xtd::threading::tasks::task_status::waiting_for_activation
@ waiting_for_activation
The task is waiting to be activated and scheduled internally by the Switch infrastructure.
Definition task_status.hpp:27
xtd::threading::tasks::task_status::faulted
@ faulted
The task completed due to an unhandled exception.
Definition task_status.hpp:39
xtd::threading::tasks::task_status::canceled
@ canceled
The task acknowledged cancellation by throwing an OperationCanceledException with its own Cancellatio...
Definition task_status.hpp:37
xtd::threading::tasks::task_status::created
@ created
The task has been initialized but has not yet been scheduled.
Definition task_status.hpp:25
xtd::threading::tasks::task_creation_options::none
@ none
Specifies that the default behavior should be used.
Definition task_creation_options.hpp:25
xtd::threading::this_thread::yield
auto yield() noexcept -> bool
Suggests that the implementation reschedule execution of threads.
xtd::sptr
xtd::shared_ptr_object< type_t > sptr
The xtd::sptr object is a shared pointer.
Definition sptr.hpp:25
xtd::null
null_ptr null
Represents a null pointer value.
xtd::uptr
xtd::unique_ptr_object< type_t > uptr
The xtd::uptr object is a unique pointer.
Definition uptr.hpp:25
xtd::int32
std::int32_t int32
Represents a 32-bit signed integer.
Definition int32.hpp:25
xtd::ref
xtd::reference_wrapper_object< type_t > ref
The xtd::ref object is a reference wrapper.
Definition ref.hpp:25
xtd::optional
std::optional< type_t > optional
Represents the optional alias on std::optional.
Definition optional.hpp:26
xtd::usize
std::size_t usize
Represents an unsigned size of any object in bytes.
Definition usize.hpp:22
xtd::as
auto as(any_object &o) -> type_t
Casts a type into another type.
Definition __as_any_object.hpp:60
xtd::as< xtd::int32 >
auto as< xtd::int32 >(xtd::any value) -> xtd::int32
Casts a type into another type.
Definition __as_int32.hpp:36
xtd::new_sptr
auto new_sptr(args_t &&... args) -> xtd::sptr< type_t >
xtd::new_sptr operator creates a xtd::sptr object.
Definition new_sptr.hpp:24
xtd::diagnostics::trace_event_type::start
@ start
Starting of a logical operation.
Definition trace_event_type.hpp:37
xtd::console_key::e
@ e
The E key.
Definition console_key.hpp:96
iasync_result.hpp
Contains xtd::iasync_result interface.
itask.hpp
Contains xtd::threading::tasks::itask interface.
xtd::threading::tasks
The xtd::threading::tasks namespace provides types that simplify the work of writing concurrent and a...
Definition itask.hpp:14
xtd::threading
The xtd::threading namespace provides classes and interfaces that enable multithreaded programming....
Definition abandoned_mutex_exception.hpp:10
xtd
The xtd namespace contains all fundamental classes to access Hardware, Os, System,...
Definition abstract_object.hpp:8
xtd::first
auto first() const -> read_only_span< type_t, count >
Obtains a subspan consisting of the first count elements of the sequence.
Definition read_only_span.hpp:245
xtd::data
constexpr auto data() const noexcept -> const_pointer
Gets direct access to the underlying contiguous storage.
Definition read_only_span.hpp:197
xtd::is_empty
constexpr auto is_empty() const noexcept -> bool
Returns a value that indicates whether the current xtd::read_only_span <type_t> is empty.
Definition read_only_span.hpp:205
new_sptr.hpp
Contains xtd::new_sptr method.
optional.hpp
Contains xtd::optional type.
ref.hpp
Contains xtd::ref type.
scope_exit.hpp
Contains scope_exit_ keyword.
sptr.hpp
Contains xtd::sptr type.
stopwatch.hpp
Contains xtd::diagnostics::stopwatch class.
task_canceled_exception.hpp
Contains xtd::threading::tasks::task_canceled_exception exception.
task_creation_options.hpp
Contains xtd::threading::tasks::task_creation_options enum class.
task_object.hpp
Contains xtd::threading::tasks::task_object class.
task_status.hpp
Contains xtd::threading::tasks::task_status enum class.
thread_pool.hpp
Contains xtd::threading::thread_pool class.
lock.hpp
Contains xtd::threading::lock class.
throw_helper.hpp
Contains xtd::helpers::throw_helper class.
Generated on for xtd by Gammasoft. All rights reserved.