xtd 0.2.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_status.hpp"
9#include "../auto_reset_event.hpp"
10#include "../lock.hpp"
11#include "../thread_pool.hpp"
12#include "../../diagnostics/stopwatch.hpp"
13#include "../../helpers/throw_helper.hpp"
14#include "../../exception_services/exception_dispatch_info.hpp"
15#include "../../action.hpp"
16#include "../../aggregate_exception.hpp"
17#include "../../func.hpp"
18#include "../../iasync_result.hpp"
19#include "../../new_sptr.hpp"
20#include "../../optional.hpp"
21#include "../../ref.hpp"
22#include "../../scope_exit.hpp"
23#include "../../sptr.hpp"
24#include "../../usize.hpp"
25#include <coroutine>
26
28namespace xtd {
30 namespace threading {
32 namespace tasks {
34 template<typename result_t = void>
35 class task;
36
37 template<typename result_t>
38 struct task_awaiter;
39
40 class task_factory;
42
49 template<typename result_t = void>
50 class basic_task : public itask, public xtd::iasync_result {
51 public:
52 struct yield_awaiter;
53
55
59 static constexpr xtd::usize wait_timeout = xtd::usize_object::max_value;
62
64 basic_task(const xtd::func<result_t>& func) {
65 data_->func = func;
66 }
67 basic_task(const xtd::func<result_t>& func, const xtd::threading::cancellation_token& cancellation_token) {
68 data_->func = func;
69 data_->cancellation_token = cancellation_token;
70 }
71 basic_task(const xtd::func<result_t, const xtd::any_object&>& func, const xtd::any_object& state) {
72 data_->parameterized_func = func;
73 data_->state = &state;
74 }
75 basic_task(const xtd::func<result_t>& func, const xtd::any_object& state, const xtd::threading::cancellation_token& cancellation_token) {
76 data_->func = func;
77 data_->state = &state;
78 data_->cancellation_token = cancellation_token;
79 }
81
83 template<typename create_result_t>
84 basic_task(const xtd::func<create_result_t>& func) {
85 data_->func = func;
86 }
87 template<typename create_result_t>
88 basic_task(const xtd::func<create_result_t>& func, const xtd::threading::cancellation_token& cancellation_token) {
89 data_->func = func;
90 data_->cancellation_token = cancellation_token;
91 }
92 template<typename create_result_t>
93 basic_task(const xtd::func<create_result_t, const xtd::any_object&>& func, const xtd::any_object& state) {
94 data_->parameterized_func = func;
95 data_->state = &state;
96 }
97 template<typename create_result_t>
98 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) {
99 data_->parameterized_func = func;
100 data_->state = &state;
101 data_->cancellation_token = cancellation_token;
102 }
104
105
107
109 [[nodiscard]] auto async_state() const noexcept -> xtd::any_object override {return data_->async_state;}
110 [[nodiscard]] auto creation_options() const noexcept -> xtd::threading::tasks::task_creation_options {return data_->creation_options;}
111 [[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};}
116 [[nodiscard]] auto id() const noexcept -> xtd::usize override {return data_->id;}
117 [[nodiscard]] auto is_canceled() const noexcept -> bool {return data_->status == xtd::threading::tasks::task_status::canceled;}
118 [[nodiscard]] auto is_completed() const noexcept -> bool override {return is_faulted() || is_canceled() || data_->status == xtd::threading::tasks::task_status::ran_to_completion;}
119 [[nodiscard]] auto is_faulted() const noexcept -> bool {return data_->status == xtd::threading::tasks::task_status::faulted;}
120 [[nodiscard]] auto status() const noexcept -> xtd::threading::tasks::task_status {return data_->status;}
122
124
126 [[nodiscard]] static auto completed_task() -> task<result_t>;
127 [[nodiscard]] static auto current_id() noexcept -> xtd::usize {return current_id_;}
128 [[nodiscard]] static auto factory() noexcept -> const xtd::threading::tasks::task_factory&;
130
132
134 auto continue_with(xtd::action<> continuation) -> void {
135 auto call_now = false;
136
137 lock_(data_->sync_root) {
138 if (is_completed()) call_now = true;
139 else data_->continuation = continuation;
140 }
141
142 if (call_now) continuation();
143 }
144
145 [[noreturn]] auto rethrow_exception() -> void {
146 if (is_faulted () && data_->exception) throw *data_->exception.source_exception();
147 xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation, "This task is not faulted.");
148 }
149
150 auto run_synchronously() -> void {
151 data_->status = xtd::threading::tasks::task_status::waiting_for_activation;
152 data_->task_proc(data_->state, false);
153 data_->status = xtd::threading::tasks::task_status::waiting_to_run;
154 }
155
157 auto start() -> void override {
158 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.");
159 data_->status = xtd::threading::tasks::task_status::waiting_for_activation;
160 thread_pool::register_wait_for_single_object(data_->start_event, data_->task_proc, *data_->state, xtd::threading::timeout::infinite, true);
161 data_->status = xtd::threading::tasks::task_status::waiting_to_run;
162 data_->start_event.set();
163 }
164
166 auto wait() -> void override {wait(xtd::threading::timeout::infinite);}
170 auto wait(xtd::int32 milliseconds_timeout) -> bool override {
171 auto cancellation_token = xtd::threading::cancellation_token {};
172 return wait(milliseconds_timeout, cancellation_token);
173 }
177 auto wait(xtd::int32 milliseconds_timeout, xtd::threading::cancellation_token& cancellation_token) -> bool override {
178 auto& cancellation_token_wait_handle = cancellation_token.wait_handle();
179 auto result = xtd::threading::wait_handle::wait_any(milliseconds_timeout, &data_->end_event, &cancellation_token_wait_handle);
180 if (data_->status == xtd::threading::tasks::task_status::faulted) rethrow_exception();
181 return result;
182 }
186 auto wait(const xtd::time_span& timeout) -> bool override {return wait(xtd::as<xtd::int32>(timeout.total_milliseconds_duration().count()));}
190 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);}
192
194
196 [[nodiscard]] static auto from_cancelation(const xtd::threading::cancellation_token& cancellation_token) -> task<result_t>;
197
198 template<typename from_exception_t>
199 [[nodiscard]] static auto from_exception(from_exception_t exception) -> task<result_t>;
200
201 [[nodiscard]] static auto delay(const xtd::time_span& delay) -> task<>;
202 [[nodiscard]] static auto delay(const xtd::time_span& delay, const xtd::threading::cancellation_token& cancellation_token) -> task<>;
203 [[nodiscard]] static auto delay(xtd::int32 milliseconds_delay) -> task<>;
204 [[nodiscard]] static auto delay(xtd::int32 milliseconds_delay, const xtd::threading::cancellation_token& cancellation_token) -> task<>;
205
206 [[nodiscard]] static auto run(const xtd::func<result_t>& func) -> task<result_t>;
207 [[nodiscard]] static auto run(const xtd::func<result_t>& func, const xtd::threading::cancellation_token& cancellation_token) -> task<result_t>;
208 [[nodiscard]] static auto run(const xtd::func<result_t, const xtd::any_object&>& func, const xtd::any_object& state) -> task<result_t>;
209 [[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>;
210
211 template<typename collection_t>
212 static auto wait_all(const collection_t& tasks) -> bool {return wait_all(tasks, xtd::threading::timeout::infinite);}
213
214 template<typename collection_t>
215 static auto wait_all(const collection_t& tasks, xtd::int32 milliseconds_timeout) -> bool {
216 auto task_pointers = std::vector<itask*> {};
217 for (auto& task : tasks)
218 task_pointers.push_back(const_cast<decltype(&task)>(&task));
219 return wait_all(array<itask*> {task_pointers}, milliseconds_timeout);
220 }
221
222 template<typename collection_t>
223 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()));}
224
225 template<typename collection_t>
226 static xtd::usize wait_any(const collection_t& tasks) {return wait_any(tasks, timeout::infinite);}
227
228 template<typename collection_t>
229 static xtd::usize wait_any(const collection_t& tasks, int32 milliseconds_timeout) {
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_any(xtd::array<itask*> {task_pointers}, milliseconds_timeout);
234 }
235
236 template<typename collection_t>
237 static xtd::usize wait_any(const collection_t& tasks, const time_span& timeout) {return wait_any(tasks, as<int32>(timeout.total_milliseconds_duration().count()));}
239
241 template<typename ...items_t>
242 static auto wait_all(items_t... items) -> bool {return wait_all(xtd::threading::timeout::infinite, items...);}
243 template<typename ...items_t>
244 static auto wait_all(const xtd::time_span& timeout, items_t... items) -> bool {return wait_all(xtd::as<xtd::int32>(timeout.total_milliseconds()), items...);}
245 template<typename ...items_t>
246 static auto wait_all(xtd::int32 milliseconds_timeout, items_t... items) -> bool {
247 auto task_pointers = std::vector<itask*> {};
248 fill_task_pointers(task_pointers, items...);
249 return wait_all(xtd::array<itask*> {task_pointers}, milliseconds_timeout);
250 }
251 template<typename item_t>
252 static auto wait_all(const std::initializer_list<item_t>& tasks) -> bool {return wait_all(tasks, timeout::infinite);}
253 template<typename item_t>
254 static auto wait_all(const std::initializer_list<item_t>& tasks, xtd::int32 milliseconds_timeout) -> bool {
255 auto task_pointers = std::vector<itask*> {};
256 for (auto& task : tasks)
257 task_pointers.push_back(const_cast<item_t*>(&task));
258 return wait_all(xtd::array<itask*> {task_pointers}, milliseconds_timeout);
259 }
260 template<typename item_t>
261 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()));}
262 static auto wait_all(const std::initializer_list<xtd::sptr<itask>>& tasks) -> bool {return wait_all(tasks, xtd::threading::timeout::infinite);}
263 static auto wait_all(const std::initializer_list<xtd::sptr<itask>>& tasks, xtd::int32 milliseconds_timeout) -> bool {
264 auto task_pointers = std::vector<itask*> {};
265 for (auto& task : tasks)
266 task_pointers.push_back(task.get());
267 return wait_all(xtd::array<itask*> {task_pointers}, milliseconds_timeout);
268 }
269 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()));}
270 static auto wait_all(const std::initializer_list<xtd::uptr<itask>>& tasks) -> bool {return wait_all(tasks, xtd::threading::timeout::infinite);}
271 static auto wait_all(const std::initializer_list<xtd::uptr<itask>>& tasks, xtd::int32 milliseconds_timeout) -> bool {
272 auto task_pointers = std::vector<itask*> {};
273 for (auto& task : tasks)
274 task_pointers.push_back(task.get());
275 return wait_all(xtd::array<itask*> {task_pointers}, milliseconds_timeout);
276 }
277 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()));}
278 static auto wait_all(const xtd::array<xtd::sptr<itask>>& tasks) -> bool {return wait_all(tasks, timeout::infinite);}
279 static auto wait_all(const xtd::array<xtd::sptr<itask>>& tasks, xtd::int32 milliseconds_timeout) -> bool {
280 auto task_pointers = std::vector<itask*> {};
281 for (auto& task : tasks)
282 task_pointers.push_back(task.get());
283 return wait_all(xtd::array<itask*> {task_pointers}, milliseconds_timeout);
284 }
285 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()));}
286 static auto wait_all(const xtd::array<xtd::uptr<itask>>& tasks) -> bool {return wait_all(tasks, timeout::infinite);}
287 static auto wait_all(const xtd::array<xtd::uptr<itask>>& tasks, xtd::int32 milliseconds_timeout) -> bool {
288 auto task_pointers = std::vector<itask*> {};
289 for (auto& task : tasks)
290 task_pointers.push_back(task.get());
291 return wait_all(xtd::array<itask*> {task_pointers}, milliseconds_timeout);
292 }
293 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()));}
294 static auto wait_all(const xtd::array<itask*>& tasks, xtd::int32 milliseconds_timeout) -> bool {
295 if (milliseconds_timeout < timeout::infinite) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);
296
297 if (milliseconds_timeout == timeout::infinite) {
298 for (auto task : tasks)
299 task->wait();
300 return true;
301 }
302
303 auto sw = xtd::diagnostics::stopwatch::start_new();
304 for (auto& task : tasks)
305 if (sw.elapsed_milliseconds() > milliseconds_timeout || task->wait(milliseconds_timeout - xtd::as<xtd::int32>(sw.elapsed_milliseconds()))) return false;
306 return true;
307 }
308
309 template<typename ...items_t>
310 static auto wait_any(items_t... items) -> xtd::usize {return wait_any(xtd::threading::timeout::infinite, items...);}
311 template<typename ...items_t>
312 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...);}
313 template<typename ...items_t>
314 static auto wait_any(xtd::int32 milliseconds_timeout, items_t... items) -> xtd::usize {
315 auto task_pointers = std::vector<itask*> {};
316 fill_task_pointers(task_pointers, items...);
317 return wait_any(xtd::array<itask*> {task_pointers}, milliseconds_timeout);
318 }
319 template<typename item_t>
320 static auto wait_any(const std::initializer_list<item_t>& tasks) -> xtd::usize {return wait_any(tasks, timeout::infinite);}
321 template<typename item_t>
322 static auto wait_any(const std::initializer_list<item_t>& tasks, xtd::int32 milliseconds_timeout) -> xtd::usize {
323 auto task_pointers = std::vector<itask*> {};
324 for (auto& task : tasks)
325 task_pointers.push_back(const_cast<item_t*>(&task));
326 return wait_any(xtd::array<itask*> {task_pointers}, milliseconds_timeout);
327 }
328 template<typename item_t>
329 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()));}
330 static auto wait_any(const std::initializer_list<xtd::sptr<itask>>& tasks) -> xtd::usize {return wait_any(tasks, xtd::threading::timeout::infinite);}
331 static auto wait_any(const std::initializer_list<xtd::sptr<itask>>& tasks, xtd::int32 milliseconds_timeout) -> xtd::usize {
332 auto task_pointers = std::vector<itask*> {};
333 for (auto& task : tasks)
334 task_pointers.push_back(task.get());
335 return wait_any(xtd::array<itask*> {task_pointers}, milliseconds_timeout);
336 }
337 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()));}
338 static auto wait_any(const std::initializer_list<xtd::uptr<itask>>& tasks) -> xtd::usize {return wait_any(tasks, xtd::threading::timeout::infinite);}
339 static auto wait_any(const std::initializer_list<xtd::uptr<itask>>& tasks, xtd::int32 milliseconds_timeout) -> xtd::usize {
340 auto task_pointers = std::vector<itask*> {};
341 for (auto& task : tasks)
342 task_pointers.push_back(task.get());
343 return wait_any(xtd::array<itask*> {task_pointers}, milliseconds_timeout);
344 }
345 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()));}
346 static auto wait_any(const xtd::array<xtd::sptr<itask>>& tasks) -> xtd::usize {return wait_any(tasks, timeout::infinite);}
347 static auto wait_any(const xtd::array<xtd::sptr<itask>>& tasks, xtd::int32 milliseconds_timeout) -> xtd::usize {
348 auto task_pointers = std::vector<itask*> {};
349 for (auto& task : tasks)
350 task_pointers.push_back(task.get());
351 return wait_any(xtd::array<itask*> {task_pointers}, milliseconds_timeout);
352 }
353 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()));}
354 static auto wait_any(const xtd::array<xtd::uptr<itask>>& tasks) -> xtd::usize {return wait_any(tasks, timeout::infinite);}
355 static auto wait_any(const xtd::array<xtd::uptr<itask>>& tasks, xtd::int32 milliseconds_timeout) -> xtd::usize {
356 auto task_pointers = std::vector<itask*> {};
357 for (auto& task : tasks)
358 task_pointers.push_back(task.get());
359 return wait_any(xtd::array<itask*> {task_pointers}, milliseconds_timeout);
360 }
361 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()));}
362 static auto wait_any(const xtd::array<itask*>& tasks, xtd::int32 milliseconds_timeout) -> xtd::usize {
363 if (milliseconds_timeout < xtd::threading::timeout::infinite) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);
364
365 auto sleep_duration = 1;
366 const auto max_sleep = 10;
367 auto sw = xtd::diagnostics::stopwatch::start_new();
368
369 while (milliseconds_timeout == xtd::threading::timeout::infinite || sw.elapsed_milliseconds() <= milliseconds_timeout) {
370 for (auto index = xtd::usize {0}; index < tasks.length(); ++index)
371 if (tasks[index]->wait(0)) return index;
372
373 xtd::threading::thread::sleep(sleep_duration);
374 sleep_duration = std::min(sleep_duration + 1, max_sleep);
375 }
376
377 return wait_timeout;
378 }
379
380 static auto yield() -> task<result_t>;
382
383 private:
384 template<typename task_result_t>
385 friend class task;
386 template<typename batic_task_result_t>
387 friend class batic_task;
388
389 basic_task() = default;
390 basic_task(basic_task&&) = default;
391 basic_task(const basic_task&) = default;
392 auto operator=(basic_task&&) -> basic_task& = default;
393 auto operator=(const basic_task&) -> basic_task& = default;
394
395 [[nodiscard]] auto async_wait_handle() noexcept -> xtd::threading::wait_handle& override {return data_->async_event;}
396 [[nodiscard]] auto completed_synchronously() const noexcept -> bool override {return false;}
397
398 template<typename item_t, typename ...items_t>
399 static auto fill_task_pointers(std::vector<itask*>& itask_pointer, item_t& first, items_t& ... rest) -> void {
400 itask_pointer.push_back(&first);
401 fill_task_pointers(itask_pointer, rest...);
402 }
403 template<typename item_t>
404 static auto fill_task_pointers(std::vector<itask*>& itask_pointer, item_t& item) -> void {
405 itask_pointer.push_back(&item);
406 }
407
408 static auto generate_id() noexcept -> xtd::usize {
409 static auto id = xtd::usize {0};
410 return ++id;
411 }
412
413 struct data {
414 using result_type = std::conditional_t<std::is_same_v<result_t, void>, std::uint8_t, result_t>;
415
416 xtd::async_callback async_callback;
417 xtd::threading::manual_reset_event async_event;
418 xtd::any_object async_state;
419 xtd::optional<xtd::threading::cancellation_token> cancellation_token;
420 xtd::action<> continuation;
421 xtd::threading::tasks::task_creation_options creation_options = xtd::threading::tasks::task_creation_options::none;
422 const xtd::any_object empty_state;
423 xtd::threading::auto_reset_event end_event;
424 xtd::exception_services::exception_dispatch_info exception;
425 xtd::func<result_t> func;
426 xtd::usize id = generate_id();
427 xtd::func<result_t, const xtd::any_object&> parameterized_func;
428 result_type result;
429 const xtd::any_object* state = &empty_state;
430 xtd::threading::auto_reset_event start_event;
431 xtd::threading::tasks::task_status status = xtd::threading::tasks::task_status::created;
432 xtd::object sync_root;
433
434 xtd::threading::wait_or_timer_callback task_proc {delegate_(const xtd::any_object& state, bool timed_out) {
435 auto previous_current_id = current_id_;
436 current_id_ = id;
437
438 scope_exit_ {
439 current_id_ = previous_current_id;
440 end_event.set();
441 if (!continuation.is_empty()) continuation();
442 };
443
444 status = xtd::threading::tasks::task_status::running;
445 try {
446 if (cancellation_token && cancellation_token->wait_handle().wait_one(0)) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::task_canceled);
447 if constexpr(std::is_same_v<result_t, void>) {
448 if (!func.is_empty()) func();
449 else if (!parameterized_func.is_empty()) parameterized_func(state);
450 } else {
451 if (!func.is_empty()) result = func();
452 else if (!parameterized_func.is_empty()) result = parameterized_func(state);
453 }
454 if (cancellation_token && cancellation_token->wait_handle().wait_one(0)) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::task_canceled);
455 status = xtd::threading::tasks::task_status::ran_to_completion;
456 } catch (const xtd::threading::tasks::task_canceled_exception& e) {
457 exception = xtd::exception_services::exception_dispatch_info::capture(e);
458 status = xtd::threading::tasks::task_status::canceled;
459 } catch (const xtd::exception& e) {
460 exception = xtd::exception_services::exception_dispatch_info::capture(e);
461 status = xtd::threading::tasks::task_status::faulted;
462 } catch (const std::exception& e) {
463 exception = xtd::exception_services::exception_dispatch_info::capture(xtd::exception {e.what()});
464 status = xtd::threading::tasks::task_status::faulted;
465 } catch (...) {
466 exception = xtd::exception_services::exception_dispatch_info::capture(xtd::exception {"Unknown exception"});
467 status = xtd::threading::tasks::task_status::faulted;
468 }
469 }};
470 };
471
472 xtd::sptr<data> data_ = xtd::new_sptr<data>();
473 inline static thread_local xtd::usize current_id_ = 0;
474 };
475 }
476 }
477}
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:70
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::itask
Represents an interface for an asynchronous operation.
Definition itask.hpp:19
xtd::threading::tasks::task_factory
Provides support for creating and scheduling Task objects.
Definition task_factory.hpp:19
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::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
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(async_result ar)> async_callback
References a method to be called when a corresponding asynchronous operation completes.
Definition delegate.hpp:40
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:128
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:943
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
sptr< type_t > new_sptr(args_t &&... args)
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::collections::generic::sync_root
virtual auto sync_root() const noexcept -> const xtd::object &=0
Gets an object that can be used to synchronize access to the the xtd::collections::generic::icollecti...
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
read_only_span< type_t, count > first() const
Obtains a subspan consisting of the first count elements of the sequence.
Definition read_only_span.hpp:282
xtd::data
constexpr const_pointer data() const noexcept
Gets direct access to the underlying contiguous storage.
Definition read_only_span.hpp:201
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_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.
usize.hpp
Contains xtd::usize type.
Generated on for xtd by Gammasoft. All rights reserved.