Sane C++ Libraries
C++ Platform Abstraction Libraries
Loading...
Searching...
No Matches
Await.h
1// Copyright (c) Stefano Cristiano
2// SPDX-License-Identifier: MIT
3#pragma once
4
5#include "../Common/CompilerMacrosExport.h"
6#include "../Common/CompilerMacrosStdCpp.h"
7#include "../Common/CompilerMacrosStdVersion.h"
8#ifndef SC_EXPORT_LIBRARY_AWAIT
9#define SC_EXPORT_LIBRARY_AWAIT 0
10#endif
11#define SC_AWAIT_EXPORT SC_COMPILER_LIBRARY_EXPORT(SC_EXPORT_LIBRARY_AWAIT)
12
13#include "../Common/Assert.h"
14
15#define SC_AWAIT_ASSERT_RELEASE(e) SC_ASSERT_PROVIDER_RELEASE(SC::AwaitAssert, e)
16#define SC_AWAIT_ASSERT_DEBUG(e) SC_ASSERT_PROVIDER_DEBUG(SC::AwaitAssert, e)
17#define SC_AWAIT_TRUST_RESULT(expression) SC_AWAIT_ASSERT_RELEASE(expression)
18
19#ifndef SC_AWAIT_ENABLE_NO_STDLIB_COROUTINE
20#define SC_AWAIT_ENABLE_NO_STDLIB_COROUTINE 0
21#endif
22
23#if !SC_INCLUDE_STD_CPP && !SC_AWAIT_ENABLE_NO_STDLIB_COROUTINE
24#error "SC::Await requires SC_INCLUDE_STD_CPP=1 or SC_AWAIT_ENABLE_NO_STDLIB_COROUTINE=1."
25#endif
26
27#if !SC_LANGUAGE_CPP_AT_LEAST_20
28#error "SC::Await requires C++20 or newer."
29#endif
30
31#include "../Async/Async.h"
32#include "../Common/Result.h"
33#include "Internal/AwaitCoroutine.h"
34
41
44namespace SC
45{
46SC_DECLARE_ASSERT_PROVIDER(AwaitAssert, SC_AWAIT_EXPORT);
47
48struct AwaitEventLoop;
49struct AwaitAllocator;
50struct AwaitAllocatorInterface;
51struct AwaitTask;
52struct AwaitCancellationHandler;
53struct AwaitSleepAwaiter;
54struct AwaitSocketAcceptAwaiter;
55struct AwaitSocketConnectAwaiter;
56struct AwaitSocketSendAwaiter;
57struct AwaitSocketSendToAwaiter;
58struct AwaitSocketSendAllAwaiter;
59struct AwaitSocketSendAllBuffersAwaiter;
60struct AwaitSocketReceiveAwaiter;
61struct AwaitSocketReceiveExactAwaiter;
62struct AwaitSocketReceiveLineAwaiter;
63struct AwaitSocketReceiveFromAwaiter;
64struct AwaitLoopWakeUp;
65struct AwaitLoopWakeUpAwaiter;
66struct AwaitFileReadAwaiter;
67struct AwaitFileReadUntilFullOrEOFAwaiter;
68struct AwaitFileWriteAwaiter;
69struct AwaitFileSendAwaiter;
70struct AwaitFilePollAwaiter;
71struct AwaitFileSystemOperationAwaiter;
72struct AwaitProcessExitAwaiter;
73struct AwaitSignalAwaiter;
74struct AwaitTaskGroup;
75struct AwaitTaskRegistry;
76struct AwaitTaskGroupWaitAllAwaiter;
77struct AwaitTaskGroupWaitAnyAwaiter;
78struct AwaitTaskRegistryWaitAllAwaiter;
79struct AwaitTaskRegistryWaitAnyAwaiter;
80struct AwaitTaskSpawnAwaiter;
81struct AwaitTaskTimeoutAwaiter;
82struct AwaitLoopWorkAwaiter;
83
84SC_AWAIT_EXPORT const char* AwaitCancellationMessage();
85SC_AWAIT_EXPORT Result AwaitCancelledResult();
86SC_AWAIT_EXPORT bool AwaitIsCancelled(Result result);
87
88SC_AWAIT_EXPORT const char* AwaitWrongEventLoopMessage();
89SC_AWAIT_EXPORT Result AwaitWrongEventLoopResult();
90SC_AWAIT_EXPORT bool AwaitIsWrongEventLoop(Result result);
91
93#define SC_CO_TRY(expression) \
94 { \
95 if (auto _exprResConv = SC::Result(expression)) \
96 SC_LANGUAGE_LIKELY { (void)0; } \
97 else \
98 { \
99 co_return _exprResConv; \
100 } \
101 }
102
103struct AwaitSocketSendResult
104{
105 size_t numBytes = 0;
106};
107
109struct AwaitSocketReceiveResult
110{
111 Span<char> data;
112 bool disconnected = false;
113};
114
116struct AwaitSocketReceiveLineResult
117{
118 Span<char> line;
119 bool disconnected = false;
120 bool lineComplete = false;
121};
122
124struct AwaitSocketReceiveFromResult
125{
126 Span<char> data;
127 SocketIPAddress sourceAddress;
128 SocketAddress sourceSocketAddress;
129 bool disconnected = false;
130};
131
133struct AwaitFileReadResult
134{
135 Span<char> data;
136 bool endOfFile = false;
137};
138
139struct AwaitFileWriteResult
140{
141 size_t numBytes = 0;
142};
143
144struct AwaitFileReadOptions
145{
146 ThreadPool* threadPool = nullptr;
147 uint64_t offset = 0;
148 bool useOffset = false;
149};
150
151struct AwaitFileWriteOptions
152{
153 ThreadPool* threadPool = nullptr;
154 uint64_t offset = 0;
155 bool useOffset = false;
156};
157
158struct AwaitFileSendOptions
159{
160 int64_t offset = 0;
161 size_t length = 0;
162 size_t pipeSize = 0;
163 ThreadPool* threadPool = nullptr;
164};
165
166struct AwaitFileSendResult
167{
168 size_t bytesTransferred = 0;
169 bool usedZeroCopy = false;
170 bool complete = false;
171};
172
173struct AwaitTimeoutResult
174{
175 bool timedOut = false;
176};
177
178struct AwaitProcessExitResult
179{
180 int exitStatus = -1;
181};
182
183struct AwaitSignalResult
184{
185 int signalNumber = 0;
186 uint32_t deliveryCount = 0;
187};
188
189struct AwaitLoopWakeUpResult
190{
191 uint32_t deliveryCount = 0;
192};
193
194struct AwaitTaskGroupWaitAnyResult
195{
196 size_t index = size_t(-1);
197 AwaitTask* task = nullptr;
198};
199
200struct AwaitTaskGroupResultSummary
201{
202 size_t numTasks = 0;
203 size_t numCompleted = 0;
204 size_t numSucceeded = 0;
205 size_t numFailed = 0;
206 size_t firstFailureIndex = size_t(-1);
207 AwaitTask* firstFailureTask = nullptr;
208 Result firstFailure = Result(true);
209};
210
211struct AwaitTaskRegistrySpawnResult
212{
213 size_t index = size_t(-1);
214 AwaitTask* task = nullptr;
215};
216
217struct AwaitTaskRegistryWaitAnyResult
218{
219 size_t index = size_t(-1);
220 AwaitTask* task = nullptr;
221};
222
223enum class AwaitTaskGroupCancelPolicy : uint8_t
224{
225 CancelChildren,
226 LeaveChildrenRunning,
227};
228
229enum class AwaitTaskGroupWaitAnyPolicy : uint8_t
230{
231 CancelRemaining,
232 LeaveRemainingRunning,
233};
234
235enum class AwaitTaskRegistryWaitAnyPolicy : uint8_t
236{
237 CancelRemaining,
238 LeaveRemainingRunning,
239};
240
241enum class AwaitAllocatorMode : uint8_t
242{
243 None,
244 Fixed,
245 Virtual,
246 Malloc,
247 Polymorphic,
248};
249
250struct AwaitAllocatorStatistics
251{
252 size_t numAllocations = 0;
253 size_t numReleases = 0;
254
255 size_t requestedBytesAllocated = 0;
256 size_t requestedBytesReleased = 0;
257
258 size_t bytesInUse = 0;
259 size_t peakBytesInUse = 0;
260 size_t largestRequestedAllocationSize = 0;
261
262 size_t numAllocationFailures = 0;
263 size_t lastFailedAllocationSize = 0;
264 size_t largestFailedAllocationSize = 0;
265};
266
267struct AwaitAllocatorVirtualOptions
268{
269 size_t reserveBytes = 0;
270 size_t initialCommitBytes = 0;
271};
272
273struct AwaitAllocatorInterface
274{
275 virtual void* allocateImpl(const void* owner, size_t numBytes, size_t alignment) = 0;
276 virtual void releaseImpl(void* memory) = 0;
277 virtual ~AwaitAllocatorInterface() {}
278};
279
280enum class AwaitFileSystemOperationType : uint8_t
281{
282 Open,
283 Close,
284 Read,
285 Write,
286 CopyFile,
287 CopyDirectory,
288 Rename,
289 RemoveEmptyDirectory,
290 RemoveFile,
291};
292
294struct AwaitCancellationHandler
295{
296 void* object = nullptr;
297
298 Result (*cancel)(void* object, AwaitEventLoop& eventLoop) = nullptr;
299};
300
302struct SC_AWAIT_EXPORT AwaitAllocator
303{
304 AwaitAllocator() = default;
305 AwaitAllocator(const AwaitAllocator&) = delete;
306 AwaitAllocator& operator=(const AwaitAllocator&) = delete;
307 AwaitAllocator(AwaitAllocator&&) = delete;
308 AwaitAllocator& operator=(AwaitAllocator&&) = delete;
309 ~AwaitAllocator();
310
311 [[nodiscard]] Result createFixed(Span<char> storage);
312 [[nodiscard]] Result createVirtual(AwaitAllocatorVirtualOptions options);
313 [[nodiscard]] Result createMalloc();
314 [[nodiscard]] Result createPolymorphic(AwaitAllocatorInterface& customAllocatorInterface);
315 [[nodiscard]] Result close();
316
317 [[nodiscard]] void* allocate(const void* owner, size_t numBytes, size_t alignment);
318 void release(void* memory);
319 static void releaseFromAnyAllocator(void* memory);
320
321 [[nodiscard]] AwaitAllocatorMode mode() const;
322 [[nodiscard]] AwaitAllocatorStatistics statistics() const;
323 [[nodiscard]] bool isOpen() const;
324
325 [[nodiscard]] size_t used() const;
326 [[nodiscard]] size_t capacity() const;
327 [[nodiscard]] size_t peakUsed() const;
328 [[nodiscard]] size_t largestAllocationSize() const;
329 [[nodiscard]] size_t failedAllocationSize() const;
330 [[nodiscard]] size_t reservedBytes() const;
331 [[nodiscard]] size_t committedBytes() const;
332
333 private:
334 struct BlockHeader;
335
336 Result initializeFixedStorage(Span<char> storage);
337 void* allocateFromBlocks(const void* owner, size_t numBytes, size_t alignment);
338 void releaseBlock(BlockHeader& header);
339 bool ensureCommitted(size_t sizeInBytes);
340 void releaseVirtualMemory();
341 void recordAllocationFailure(size_t numBytes);
342 void resetState();
343
344 AwaitAllocatorMode currentMode = AwaitAllocatorMode::None;
345 AwaitAllocatorStatistics currentStatistics;
346 Span<char> fixedStorage;
347 BlockHeader* firstBlock = nullptr;
348 AwaitAllocatorInterface* allocatorInterface = nullptr;
349
350 void* virtualMemory = nullptr;
351 size_t virtualReservedBytes = 0;
352 size_t virtualCommittedBytes = 0;
353};
354
356struct SC_AWAIT_EXPORT AwaitTask
357{
358 struct Promise;
359 using promise_type = Promise;
360 using Handle = AwaitCoroutineTypedHandle<Promise>;
361
362 AwaitTask() = default;
363 explicit AwaitTask(Handle newHandle);
364
365 AwaitTask(const AwaitTask&) = delete;
366 AwaitTask& operator=(const AwaitTask&) = delete;
367
368 AwaitTask(AwaitTask&& other) noexcept;
369 AwaitTask& operator=(AwaitTask&& other) noexcept;
370 ~AwaitTask();
371
372 [[nodiscard]] bool isValid() const;
373 [[nodiscard]] bool isStarted() const;
374 [[nodiscard]] bool isCompleted() const;
375 [[nodiscard]] bool isActive() const;
376 [[nodiscard]] bool isCancellationRequested() const;
377
378 [[nodiscard]] Result result() const;
379
380 Result cancel(AwaitEventLoop& await);
381
382 bool await_ready() const;
383 bool await_suspend(Handle continuation);
384 Result await_resume() const;
385
386 private:
387 friend struct AwaitEventLoop;
388 friend struct AwaitTaskGroup;
389 friend struct AwaitTaskGroupWaitAllAwaiter;
390 friend struct AwaitTaskGroupWaitAnyAwaiter;
391 friend struct AwaitTaskRegistryWaitAllAwaiter;
392 friend struct AwaitTaskRegistryWaitAnyAwaiter;
393 friend struct AwaitTaskSpawnAwaiter;
394 friend struct AwaitTaskTimeoutAwaiter;
395
396 Result start();
397 void resume();
398 void destroy();
399
400 Handle handle = {};
401};
402
404struct SC_AWAIT_EXPORT AwaitTask::Promise
405{
406 Promise();
407
408 template <typename First, typename... Rest>
409 Promise(First& first, Rest&... rest) : Promise()
410 {
411 eventLoop = findEventLoop(first, rest...);
412 }
413
414 template <typename... Rest>
415 Promise(AwaitEventLoop& await, Rest&...) : Promise()
416 {
417 eventLoop = &await;
418 }
419
420 static AwaitEventLoop* findEventLoop();
421 static AwaitEventLoop* findEventLoop(AwaitEventLoop& await);
422
423 template <typename First, typename... Rest>
424 static AwaitEventLoop* findEventLoop(First&, Rest&... rest)
425 {
426 return findEventLoop(rest...);
427 }
428
429 static void* allocateFrame(size_t size, AwaitEventLoop* eventLoop) noexcept;
430 static void deallocateFrame(void* frame) noexcept;
431
432 static void* operator new(size_t size) noexcept;
433
434 template <typename First, typename... Rest>
435 static void* operator new(size_t size, First& first, Rest&... rest) noexcept
436 {
437 return allocateFrame(size, findEventLoop(first, rest...));
438 }
439
440 template <typename... Rest>
441 static void* operator new(size_t size, AwaitEventLoop& await, Rest&...) noexcept
442 {
443 return allocateFrame(size, &await);
444 }
445
446 static void operator delete(void* frame, size_t) noexcept;
447
448 static AwaitTask get_return_object_on_allocation_failure();
449
450 AwaitTask get_return_object();
451
452 AwaitSuspendAlways initial_suspend() noexcept;
453
454 struct FinalSuspend
455 {
456 bool await_ready() noexcept;
457 void await_suspend(AwaitTask::Handle handle) noexcept;
458 void await_resume() noexcept;
459 };
460
461 FinalSuspend final_suspend() noexcept;
462
463 void return_value(Result newResult) noexcept;
464
465 void unhandled_exception() noexcept;
466
467 Result taskResult;
468
469 AwaitTask::Handle continuation;
470 AwaitTask::Handle deferredDestroyNext;
471 AwaitCancellationHandler cancellation;
472 AwaitEventLoop* eventLoop;
473 void* completionObject;
474 void (*completionCallback)(void* object);
475
476 bool started;
477 bool completed;
478 bool cancellationRequested;
479 bool inCompletionCallback;
480 bool destroyDeferred;
481};
482
484struct SC_AWAIT_EXPORT AwaitEventLoop
485{
486 explicit AwaitEventLoop(AsyncEventLoop& asyncEventLoop, AwaitAllocator& allocator);
487
488 [[nodiscard]] AsyncEventLoop& asyncEventLoop();
489 [[nodiscard]] const AsyncEventLoop& asyncEventLoop() const;
490 [[nodiscard]] AwaitAllocator& allocator();
491
492 Result spawn(AwaitTask& task);
493
494 Result run();
495 Result runOnce();
496 Result runNoWait();
497
498 AwaitSleepAwaiter sleep(TimeMs duration);
499 AwaitSocketAcceptAwaiter accept(const SocketDescriptor& serverSocket, SocketDescriptor& outClient);
500 AwaitSocketConnectAwaiter connect(const SocketDescriptor& socket, SocketIPAddress address);
501 AwaitSocketConnectAwaiter connect(const SocketDescriptor& socket, SocketAddress address);
502 AwaitSocketSendAwaiter send(const SocketDescriptor& socket, Span<const char> data,
503 AwaitSocketSendResult* outResult = nullptr);
504 AwaitSocketSendAwaiter send(const SocketDescriptor& socket, Span<Span<const char>> data,
505 AwaitSocketSendResult* outResult = nullptr);
506 AwaitSocketSendToAwaiter sendTo(const SocketDescriptor& socket, SocketIPAddress address, Span<const char> data,
507 AwaitSocketSendResult* outResult = nullptr);
508 AwaitSocketSendToAwaiter sendTo(const SocketDescriptor& socket, SocketIPAddress address,
509 Span<Span<const char>> data, AwaitSocketSendResult* outResult = nullptr);
510 AwaitSocketSendToAwaiter sendTo(const SocketDescriptor& socket, SocketAddress address, Span<const char> data,
511 AwaitSocketSendResult* outResult = nullptr);
512 AwaitSocketSendToAwaiter sendTo(const SocketDescriptor& socket, SocketAddress address, Span<Span<const char>> data,
513 AwaitSocketSendResult* outResult = nullptr);
514 AwaitSocketSendAllAwaiter sendAll(const SocketDescriptor& socket, Span<const char> data,
515 AwaitSocketSendResult* outResult = nullptr);
516 AwaitSocketSendAllBuffersAwaiter sendAll(const SocketDescriptor& socket, Span<Span<const char>> data,
517 AwaitSocketSendResult* outResult = nullptr);
518 AwaitSocketReceiveAwaiter receive(const SocketDescriptor& socket, Span<char> buffer,
519 AwaitSocketReceiveResult& outResult);
520 AwaitSocketReceiveExactAwaiter receiveExact(const SocketDescriptor& socket, Span<char> buffer,
521 AwaitSocketReceiveResult* outResult = nullptr);
522 AwaitSocketReceiveLineAwaiter receiveLine(const SocketDescriptor& socket, Span<char> buffer,
523 AwaitSocketReceiveLineResult& outResult);
524 AwaitSocketReceiveFromAwaiter receiveFrom(const SocketDescriptor& socket, Span<char> buffer,
525 AwaitSocketReceiveFromResult& outResult);
526
527 AwaitFileReadAwaiter fileRead(const FileDescriptor& file, Span<char> buffer, AwaitFileReadResult& outResult,
528 AwaitFileReadOptions options = {});
529 AwaitFileReadUntilFullOrEOFAwaiter fileReadUntilFullOrEOF(const FileDescriptor& file, Span<char> buffer,
530 AwaitFileReadResult& outResult,
531 AwaitFileReadOptions options = {});
532
533 AwaitFileWriteAwaiter fileWrite(const FileDescriptor& file, Span<const char> data,
534 AwaitFileWriteResult* outResult = nullptr, AwaitFileWriteOptions options = {});
535 AwaitFileWriteAwaiter fileWrite(const FileDescriptor& file, Span<Span<const char>> data,
536 AwaitFileWriteResult* outResult = nullptr, AwaitFileWriteOptions options = {});
537 AwaitFileSendAwaiter fileSend(const FileDescriptor& file, const SocketDescriptor& socket,
538 AwaitFileSendResult& outResult, AwaitFileSendOptions options = {});
539 AwaitFilePollAwaiter filePoll(const FileDescriptor& file);
540
541 AwaitLoopWakeUpAwaiter wakeUp(AwaitLoopWakeUp& wakeUp, AwaitLoopWakeUpResult& outResult,
542 AsyncLoopWakeUpOptions options = {});
543
544 AwaitFileSystemOperationAwaiter fsOpen(ThreadPool& threadPool, StringSpan path, FileOpen mode,
545 FileDescriptor& outFile);
546 AwaitFileSystemOperationAwaiter fsClose(ThreadPool& threadPool, FileDescriptor& file);
547 AwaitFileSystemOperationAwaiter fsRead(ThreadPool& threadPool, FileDescriptor& file, Span<char> buffer,
548 AwaitFileReadResult& outResult, uint64_t offset = 0);
549 AwaitFileSystemOperationAwaiter fsWrite(ThreadPool& threadPool, FileDescriptor& file, Span<const char> data,
550 AwaitFileWriteResult* outResult = nullptr, uint64_t offset = 0);
551 AwaitFileSystemOperationAwaiter fsCopyFile(ThreadPool& threadPool, StringSpan path, StringSpan destinationPath,
552 FileSystemCopyFlags copyFlags = FileSystemCopyFlags());
553 AwaitFileSystemOperationAwaiter fsCopyDirectory(ThreadPool& threadPool, StringSpan path, StringSpan destinationPath,
554 FileSystemCopyFlags copyFlags = FileSystemCopyFlags());
555 AwaitFileSystemOperationAwaiter fsRename(ThreadPool& threadPool, StringSpan path, StringSpan newPath);
556 AwaitFileSystemOperationAwaiter fsRemoveEmptyDirectory(ThreadPool& threadPool, StringSpan path);
557 AwaitFileSystemOperationAwaiter fsRemoveFile(ThreadPool& threadPool, StringSpan path);
558 AwaitProcessExitAwaiter processExit(FileDescriptor::Handle process, AwaitProcessExitResult& outResult);
559 AwaitSignalAwaiter signal(int signalNumber, AwaitSignalResult& outResult);
560 AwaitTaskSpawnAwaiter spawnAndWait(AwaitTask& task);
561 AwaitTaskTimeoutAwaiter waitFor(AwaitTask& task, TimeMs timeout, AwaitTimeoutResult* outResult = nullptr);
562 AwaitLoopWorkAwaiter loopWork(ThreadPool& threadPool, Function<Result()> work);
563
564 private:
565 friend struct AwaitTask;
566
567 void deferDestroy(AwaitTask::Handle handle);
568 void drainDeferredDestroys();
569
570 AsyncEventLoop& eventLoop;
571 AwaitAllocator* frameAllocator;
572 AwaitTask::Handle deferredDestroyList;
573};
574
576struct SC_AWAIT_EXPORT AwaitLoopWakeUp
577{
578 Result wakeUp(AwaitEventLoop& await);
579 Result wakeUp(AsyncEventLoop& eventLoop);
580
581 [[nodiscard]] bool isActive() const;
582
583 private:
584 friend struct AwaitLoopWakeUpAwaiter;
585
586 AsyncLoopWakeUp request;
587};
588
590struct SC_AWAIT_EXPORT AwaitSleepAwaiter
591{
592 AwaitSleepAwaiter(AwaitEventLoop& await, TimeMs duration);
593
594 AwaitEventLoop& await;
595 TimeMs duration;
596 AsyncLoopTimeout request;
597 Result operationResult = Result(true);
598
599 bool await_ready() const;
600 bool await_suspend(AwaitTask::Handle continuation);
601 Result await_resume();
602
603 private:
604 static Result cancel(void* object, AwaitEventLoop& eventLoop);
605
606 Result cancel(AwaitEventLoop& eventLoop);
607
608 AwaitTask::Handle continuation;
609 Function<void(AsyncResult&)> stopCallback;
610};
611
613struct SC_AWAIT_EXPORT AwaitLoopWakeUpAwaiter
614{
615 AwaitLoopWakeUpAwaiter(AwaitEventLoop& await, AwaitLoopWakeUp& wakeUp, AwaitLoopWakeUpResult& outResult,
616 AsyncLoopWakeUpOptions options);
617
618 AwaitEventLoop& await;
619 AwaitLoopWakeUp& wakeUp;
620 AwaitLoopWakeUpResult& outResult;
621 AsyncLoopWakeUpOptions options;
622 Result operationResult = Result(true);
623
624 bool await_ready() const;
625 bool await_suspend(AwaitTask::Handle continuation);
626 Result await_resume();
627
628 private:
629 static Result cancel(void* object, AwaitEventLoop& eventLoop);
630
631 Result cancel(AwaitEventLoop& eventLoop);
632
633 AwaitTask::Handle continuation;
634 Function<void(AsyncResult&)> stopCallback;
635};
636
638struct SC_AWAIT_EXPORT AwaitSocketAcceptAwaiter
639{
640 AwaitSocketAcceptAwaiter(AwaitEventLoop& await, const SocketDescriptor& serverSocket, SocketDescriptor& outClient);
641
642 AwaitEventLoop& await;
643 const SocketDescriptor& serverSocket;
644 SocketDescriptor& outClient;
645 AsyncSocketAccept request;
646 Result operationResult = Result(true);
647
648 bool await_ready() const;
649 bool await_suspend(AwaitTask::Handle continuation);
650 Result await_resume();
651
652 private:
653 static Result cancel(void* object, AwaitEventLoop& eventLoop);
654
655 Result cancel(AwaitEventLoop& eventLoop);
656
657 AwaitTask::Handle continuation;
658 Function<void(AsyncResult&)> stopCallback;
659};
660
662struct SC_AWAIT_EXPORT AwaitSocketConnectAwaiter
663{
664 AwaitSocketConnectAwaiter(AwaitEventLoop& await, const SocketDescriptor& socket, SocketIPAddress address);
665 AwaitSocketConnectAwaiter(AwaitEventLoop& await, const SocketDescriptor& socket, SocketAddress address);
666
667 AwaitEventLoop& await;
668 const SocketDescriptor& socket;
669 SocketAddress address;
670 AsyncSocketConnect request;
671 Result operationResult = Result(true);
672
673 bool await_ready() const;
674 bool await_suspend(AwaitTask::Handle continuation);
675 Result await_resume();
676
677 private:
678 static Result cancel(void* object, AwaitEventLoop& eventLoop);
679
680 Result cancel(AwaitEventLoop& eventLoop);
681
682 AwaitTask::Handle continuation;
683 Function<void(AsyncResult&)> stopCallback;
684};
685
687struct SC_AWAIT_EXPORT AwaitSocketSendAwaiter
688{
689 AwaitSocketSendAwaiter(AwaitEventLoop& await, const SocketDescriptor& socket, Span<const char> data,
690 AwaitSocketSendResult* outResult);
691 AwaitSocketSendAwaiter(AwaitEventLoop& await, const SocketDescriptor& socket, Span<Span<const char>> data,
692 AwaitSocketSendResult* outResult);
693
694 AwaitEventLoop& await;
695 const SocketDescriptor& socket;
696 Span<const char> data;
697 Span<Span<const char>> buffers;
698 AwaitSocketSendResult* outResult = nullptr;
699 AsyncSocketSend request;
700 Result operationResult = Result(true);
701 bool singleBuffer = true;
702
703 bool await_ready() const;
704 bool await_suspend(AwaitTask::Handle continuation);
705 Result await_resume();
706
707 private:
708 static Result cancel(void* object, AwaitEventLoop& eventLoop);
709
710 Result cancel(AwaitEventLoop& eventLoop);
711
712 AwaitTask::Handle continuation;
713 Function<void(AsyncResult&)> stopCallback;
714};
715
717struct SC_AWAIT_EXPORT AwaitSocketSendToAwaiter
718{
719 AwaitSocketSendToAwaiter(AwaitEventLoop& await, const SocketDescriptor& socket, SocketIPAddress address,
720 Span<const char> data, AwaitSocketSendResult* outResult);
721 AwaitSocketSendToAwaiter(AwaitEventLoop& await, const SocketDescriptor& socket, SocketIPAddress address,
722 Span<Span<const char>> data, AwaitSocketSendResult* outResult);
723 AwaitSocketSendToAwaiter(AwaitEventLoop& await, const SocketDescriptor& socket, SocketAddress address,
724 Span<const char> data, AwaitSocketSendResult* outResult);
725 AwaitSocketSendToAwaiter(AwaitEventLoop& await, const SocketDescriptor& socket, SocketAddress address,
726 Span<Span<const char>> data, AwaitSocketSendResult* outResult);
727
728 AwaitEventLoop& await;
729 const SocketDescriptor& socket;
730 SocketAddress address;
731 Span<const char> data;
732 Span<Span<const char>> buffers;
733 AwaitSocketSendResult* outResult = nullptr;
734 AsyncSocketSendTo request;
735 Result operationResult = Result(true);
736 bool singleBuffer = true;
737
738 bool await_ready() const;
739 bool await_suspend(AwaitTask::Handle continuation);
740 Result await_resume();
741
742 private:
743 static Result cancel(void* object, AwaitEventLoop& eventLoop);
744
745 Result cancel(AwaitEventLoop& eventLoop);
746
747 AwaitTask::Handle continuation;
748 Function<void(AsyncResult&)> stopCallback;
749};
750
752struct SC_AWAIT_EXPORT AwaitSocketSendAllAwaiter
753{
754 AwaitSocketSendAllAwaiter(AwaitEventLoop& await, const SocketDescriptor& socket, Span<const char> data,
755 AwaitSocketSendResult* outResult);
756
757 AwaitEventLoop& await;
758 const SocketDescriptor& socket;
759 Span<const char> data;
760 AwaitSocketSendResult* outResult = nullptr;
761 AsyncSocketSend request;
762 Result operationResult = Result(true);
763 size_t numBytesSent = 0;
764
765 bool await_ready() const;
766 bool await_suspend(AwaitTask::Handle continuation);
767 Result await_resume();
768
769 private:
770 static Result cancel(void* object, AwaitEventLoop& eventLoop);
771
772 Result cancel(AwaitEventLoop& eventLoop);
773
774 AwaitTask::Handle continuation;
775 Function<void(AsyncResult&)> stopCallback;
776};
777
779struct SC_AWAIT_EXPORT AwaitSocketSendAllBuffersAwaiter
780{
781 AwaitSocketSendAllBuffersAwaiter(AwaitEventLoop& await, const SocketDescriptor& socket, Span<Span<const char>> data,
782 AwaitSocketSendResult* outResult);
783
784 AwaitEventLoop& await;
785 const SocketDescriptor& socket;
786 Span<Span<const char>> data;
787 AwaitSocketSendResult* outResult = nullptr;
788 AsyncSocketSend request;
789 AsyncLoopTimeout deferredStart;
790 Result operationResult = Result(true);
791 size_t numBytesSent = 0;
792 size_t bufferIndex = 0;
793 size_t bufferOffset = 0;
794
795 bool await_ready() const;
796 bool await_suspend(AwaitTask::Handle continuation);
797 Result await_resume();
798
799 private:
800 static Result cancel(void* object, AwaitEventLoop& eventLoop);
801
802 Result cancel(AwaitEventLoop& eventLoop);
803 bool findNextBuffer();
804 Result startCurrentBuffer();
805 Result updateRequestBuffer();
806
807 AwaitTask::Handle continuation;
808 Function<void(AsyncResult&)> stopCallback;
809};
810
812struct SC_AWAIT_EXPORT AwaitSocketReceiveAwaiter
813{
814 AwaitSocketReceiveAwaiter(AwaitEventLoop& await, const SocketDescriptor& socket, Span<char> buffer,
815 AwaitSocketReceiveResult& outResult);
816
817 AwaitEventLoop& await;
818 const SocketDescriptor& socket;
819 Span<char> buffer;
820 AwaitSocketReceiveResult& outResult;
821 AsyncSocketReceive request;
822 Result operationResult = Result(true);
823
824 bool await_ready() const;
825 bool await_suspend(AwaitTask::Handle continuation);
826 Result await_resume();
827
828 private:
829 static Result cancel(void* object, AwaitEventLoop& eventLoop);
830
831 Result cancel(AwaitEventLoop& eventLoop);
832
833 AwaitTask::Handle continuation;
834 Function<void(AsyncResult&)> stopCallback;
835};
836
838struct SC_AWAIT_EXPORT AwaitSocketReceiveExactAwaiter
839{
840 AwaitSocketReceiveExactAwaiter(AwaitEventLoop& await, const SocketDescriptor& socket, Span<char> buffer,
841 AwaitSocketReceiveResult* outResult);
842
843 AwaitEventLoop& await;
844 const SocketDescriptor& socket;
845 Span<char> buffer;
846 AwaitSocketReceiveResult* outResult = nullptr;
847 AsyncSocketReceive request;
848 Result operationResult = Result(true);
849 size_t numBytesReceived = 0;
850
851 bool await_ready() const;
852 bool await_suspend(AwaitTask::Handle continuation);
853 Result await_resume();
854
855 private:
856 static Result cancel(void* object, AwaitEventLoop& eventLoop);
857
858 Result cancel(AwaitEventLoop& eventLoop);
859 Result startRemainingReceive();
860 Result updateRequestBuffer();
861 Result updateOutResult(bool disconnected);
862
863 AwaitTask::Handle continuation;
864 Function<void(AsyncResult&)> stopCallback;
865};
866
868struct SC_AWAIT_EXPORT AwaitSocketReceiveLineAwaiter
869{
870 AwaitSocketReceiveLineAwaiter(AwaitEventLoop& await, const SocketDescriptor& socket, Span<char> buffer,
871 AwaitSocketReceiveLineResult& outResult);
872
873 AwaitEventLoop& await;
874 const SocketDescriptor& socket;
875 Span<char> buffer;
876 AwaitSocketReceiveLineResult& outResult;
877 AsyncSocketReceive request;
878 Result operationResult = Result(true);
879 size_t numBytesReceived = 0;
880 char currentByte = 0;
881 bool lineComplete = false;
882
883 bool await_ready() const;
884 bool await_suspend(AwaitTask::Handle continuation);
885 Result await_resume();
886
887 private:
888 static Result cancel(void* object, AwaitEventLoop& eventLoop);
889
890 Result cancel(AwaitEventLoop& eventLoop);
891 Result startNextByte();
892 Result updateOutResult(bool disconnected);
893
894 AwaitTask::Handle continuation;
895 Function<void(AsyncResult&)> stopCallback;
896};
897
899struct SC_AWAIT_EXPORT AwaitSocketReceiveFromAwaiter
900{
901 AwaitSocketReceiveFromAwaiter(AwaitEventLoop& await, const SocketDescriptor& socket, Span<char> buffer,
902 AwaitSocketReceiveFromResult& outResult);
903
904 AwaitEventLoop& await;
905 const SocketDescriptor& socket;
906 Span<char> buffer;
907 AwaitSocketReceiveFromResult& outResult;
908 AsyncSocketReceiveFrom request;
909 Result operationResult = Result(true);
910
911 bool await_ready() const;
912 bool await_suspend(AwaitTask::Handle continuation);
913 Result await_resume();
914
915 private:
916 static Result cancel(void* object, AwaitEventLoop& eventLoop);
917
918 Result cancel(AwaitEventLoop& eventLoop);
919
920 AwaitTask::Handle continuation;
921 Function<void(AsyncResult&)> stopCallback;
922};
923
925struct SC_AWAIT_EXPORT AwaitFileReadAwaiter
926{
927 AwaitFileReadAwaiter(AwaitEventLoop& await, const FileDescriptor& file, Span<char> buffer,
928 AwaitFileReadResult& outResult, AwaitFileReadOptions options);
929
930 AwaitEventLoop& await;
931 const FileDescriptor& file;
932 Span<char> buffer;
933 AwaitFileReadResult& outResult;
934 AsyncFileRead request;
935 AsyncTaskSequence taskSequence;
936 AwaitFileReadOptions options;
937 Result operationResult = Result(true);
938
939 bool await_ready() const;
940 bool await_suspend(AwaitTask::Handle continuation);
941 Result await_resume();
942
943 private:
944 static Result cancel(void* object, AwaitEventLoop& eventLoop);
945
946 Result cancel(AwaitEventLoop& eventLoop);
947
948 AwaitTask::Handle continuation;
949 Function<void(AsyncResult&)> stopCallback;
950};
951
953struct SC_AWAIT_EXPORT AwaitFileReadUntilFullOrEOFAwaiter
954{
955 AwaitFileReadUntilFullOrEOFAwaiter(AwaitEventLoop& await, const FileDescriptor& file, Span<char> buffer,
956 AwaitFileReadResult& outResult, AwaitFileReadOptions options);
957
958 AwaitEventLoop& await;
959 const FileDescriptor& file;
960 Span<char> buffer;
961 AwaitFileReadResult& outResult;
962 AsyncFileRead request;
963 AsyncTaskSequence taskSequence;
964 AwaitFileReadOptions options;
965 Result operationResult = Result(true);
966 size_t numBytesRead = 0;
967
968 bool await_ready() const;
969 bool await_suspend(AwaitTask::Handle continuation);
970 Result await_resume();
971
972 private:
973 static Result cancel(void* object, AwaitEventLoop& eventLoop);
974
975 Result cancel(AwaitEventLoop& eventLoop);
976 Result startRemainingRead();
977 Result updateRequestBufferAndOffset();
978 Result updateOutResult(bool endOfFile);
979
980 AwaitTask::Handle continuation;
981 Function<void(AsyncResult&)> stopCallback;
982};
983
985struct SC_AWAIT_EXPORT AwaitFileWriteAwaiter
986{
987 AwaitFileWriteAwaiter(AwaitEventLoop& await, const FileDescriptor& file, Span<const char> data,
988 AwaitFileWriteResult* outResult, AwaitFileWriteOptions options);
989 AwaitFileWriteAwaiter(AwaitEventLoop& await, const FileDescriptor& file, Span<Span<const char>> data,
990 AwaitFileWriteResult* outResult, AwaitFileWriteOptions options);
991
992 AwaitEventLoop& await;
993 const FileDescriptor& file;
994 Span<const char> data;
995 Span<Span<const char>> buffers;
996 AwaitFileWriteResult* outResult = nullptr;
997 AsyncFileWrite request;
998 AsyncTaskSequence taskSequence;
999 AwaitFileWriteOptions options;
1000 Result operationResult = Result(true);
1001 bool singleBuffer = true;
1002
1003 bool await_ready() const;
1004 bool await_suspend(AwaitTask::Handle continuation);
1005 Result await_resume();
1006
1007 private:
1008 static Result cancel(void* object, AwaitEventLoop& eventLoop);
1009
1010 Result cancel(AwaitEventLoop& eventLoop);
1011
1012 AwaitTask::Handle continuation;
1013 Function<void(AsyncResult&)> stopCallback;
1014};
1015
1017struct SC_AWAIT_EXPORT AwaitFileSendAwaiter
1018{
1019 AwaitFileSendAwaiter(AwaitEventLoop& await, const FileDescriptor& file, const SocketDescriptor& socket,
1020 AwaitFileSendResult& outResult, AwaitFileSendOptions options);
1021
1022 AwaitEventLoop& await;
1023 const FileDescriptor& file;
1024 const SocketDescriptor& socket;
1025 AwaitFileSendResult& outResult;
1026 AwaitFileSendOptions options;
1027 AsyncFileSend request;
1028 AsyncTaskSequence taskSequence;
1029 Result operationResult = Result(true);
1030
1031 bool await_ready() const;
1032 bool await_suspend(AwaitTask::Handle continuation);
1033 Result await_resume();
1034
1035 private:
1036 static Result cancel(void* object, AwaitEventLoop& eventLoop);
1037
1038 Result cancel(AwaitEventLoop& eventLoop);
1039
1040 AwaitTask::Handle continuation;
1041 Function<void(AsyncResult&)> stopCallback;
1042};
1043
1045struct SC_AWAIT_EXPORT AwaitFilePollAwaiter
1046{
1047 AwaitFilePollAwaiter(AwaitEventLoop& await, const FileDescriptor& file);
1048
1049 AwaitEventLoop& await;
1050 const FileDescriptor& file;
1051 AsyncFileReadiness request;
1052 Result operationResult = Result(true);
1053
1054 bool await_ready() const;
1055 bool await_suspend(AwaitTask::Handle continuation);
1056 Result await_resume();
1057
1058 private:
1059 static Result cancel(void* object, AwaitEventLoop& eventLoop);
1060
1061 Result cancel(AwaitEventLoop& eventLoop);
1062
1063 AwaitTask::Handle continuation;
1064 Function<void(AsyncResult&)> stopCallback;
1065};
1066
1068struct SC_AWAIT_EXPORT AwaitFileSystemOperationAwaiter
1069{
1070 AwaitFileSystemOperationAwaiter(AwaitEventLoop& await, ThreadPool& threadPool,
1071 AwaitFileSystemOperationType operation, StringSpan path,
1072 StringSpan otherPath = StringSpan(), FileOpen mode = FileOpen(),
1073 FileDescriptor* outFile = nullptr,
1074 FileSystemCopyFlags copyFlags = FileSystemCopyFlags());
1075 AwaitFileSystemOperationAwaiter(AwaitEventLoop& await, ThreadPool& threadPool,
1076 AwaitFileSystemOperationType operation, FileDescriptor& file);
1077 AwaitFileSystemOperationAwaiter(AwaitEventLoop& await, ThreadPool& threadPool,
1078 AwaitFileSystemOperationType operation, FileDescriptor& file, Span<char> buffer,
1079 AwaitFileReadResult& outResult, uint64_t offset);
1080 AwaitFileSystemOperationAwaiter(AwaitEventLoop& await, ThreadPool& threadPool,
1081 AwaitFileSystemOperationType operation, FileDescriptor& file, Span<const char> data,
1082 AwaitFileWriteResult* outResult, uint64_t offset);
1083
1084 AwaitEventLoop& await;
1085 ThreadPool& threadPool;
1086 AwaitFileSystemOperationType operation;
1087 StringSpan path;
1088 StringSpan otherPath;
1089 FileOpen mode;
1090 FileDescriptor* outFile = nullptr;
1091 FileDescriptor* fileToClose = nullptr;
1092 FileDescriptor* fileToUse = nullptr;
1093 Span<char> readBuffer;
1094 Span<const char> writeBuffer;
1095 AwaitFileReadResult* outReadResult = nullptr;
1096 AwaitFileWriteResult* outWriteResult = nullptr;
1097 uint64_t offset = 0;
1098 FileSystemCopyFlags copyFlags;
1099 AsyncFileSystemOperation request;
1100 Result operationResult = Result(true);
1101
1102 bool await_ready() const;
1103 bool await_suspend(AwaitTask::Handle continuation);
1104 Result await_resume();
1105
1106 private:
1107 static Result cancel(void* object, AwaitEventLoop& eventLoop);
1108
1109 Result cancel(AwaitEventLoop& eventLoop);
1110
1111 AwaitTask::Handle continuation;
1112 Function<void(AsyncResult&)> stopCallback;
1113};
1114
1116struct SC_AWAIT_EXPORT AwaitTaskGroup
1117{
1118 AwaitTaskGroup(AwaitEventLoop& await, Span<AwaitTask*> taskStorage,
1119 AwaitTaskGroupCancelPolicy cancelPolicy = AwaitTaskGroupCancelPolicy::CancelChildren);
1120
1121 Result spawn(AwaitTask& task);
1122 Result spawnAll(Span<AwaitTask*> taskList);
1123 AwaitTaskGroupWaitAllAwaiter waitAll();
1124 AwaitTaskGroupWaitAnyAwaiter waitAny(
1125 AwaitTaskGroupWaitAnyResult& outResult,
1126 AwaitTaskGroupWaitAnyPolicy waitAnyPolicy = AwaitTaskGroupWaitAnyPolicy::CancelRemaining);
1127 Result collectResults(Span<Result> outResults, AwaitTaskGroupResultSummary* outSummary = nullptr) const;
1128 Result summarizeResults(AwaitTaskGroupResultSummary& outSummary) const;
1129
1130 [[nodiscard]] size_t size() const;
1131 [[nodiscard]] size_t capacity() const;
1132 [[nodiscard]] size_t remainingCapacity() const;
1133 [[nodiscard]] bool isEmpty() const;
1134 [[nodiscard]] bool isFull() const;
1135
1136 private:
1137 friend struct AwaitTaskGroupWaitAllAwaiter;
1138 friend struct AwaitTaskGroupWaitAnyAwaiter;
1139
1140 AwaitEventLoop& await;
1141 Span<AwaitTask*> tasks;
1142 AwaitTaskGroupCancelPolicy cancelPolicy;
1143 size_t numTasks = 0;
1144};
1145
1147struct SC_AWAIT_EXPORT AwaitTaskRegistry
1148{
1149 AwaitTaskRegistry(AwaitEventLoop& await, Span<AwaitTask> taskStorage);
1150
1151 Result spawn(AwaitTask&& task, AwaitTaskRegistrySpawnResult* outResult = nullptr);
1152 Result cancelAll();
1153 AwaitTaskRegistryWaitAllAwaiter waitAll();
1154 AwaitTaskRegistryWaitAnyAwaiter waitAny(
1155 AwaitTaskRegistryWaitAnyResult& outResult,
1156 AwaitTaskRegistryWaitAnyPolicy waitAnyPolicy = AwaitTaskRegistryWaitAnyPolicy::CancelRemaining);
1157
1158 size_t clearCompleted(AwaitTaskGroupResultSummary* outSummary = nullptr);
1159
1160 [[nodiscard]] AwaitTask* taskAt(size_t index);
1161 [[nodiscard]] const AwaitTask* taskAt(size_t index) const;
1162 [[nodiscard]] size_t size() const;
1163 [[nodiscard]] size_t activeCount() const;
1164 [[nodiscard]] size_t completedCount() const;
1165 [[nodiscard]] size_t capacity() const;
1166 [[nodiscard]] size_t remainingCapacity() const;
1167 [[nodiscard]] bool isEmpty() const;
1168 [[nodiscard]] bool isFull() const;
1169 [[nodiscard]] bool hasActiveTasks() const;
1170 [[nodiscard]] bool hasCompletedTasks() const;
1171
1172 private:
1173 friend struct AwaitTaskRegistryWaitAllAwaiter;
1174 friend struct AwaitTaskRegistryWaitAnyAwaiter;
1175
1176 AwaitEventLoop& await;
1177 Span<AwaitTask> tasks;
1178};
1179
1181struct SC_AWAIT_EXPORT AwaitTaskRegistryWaitAllAwaiter
1182{
1183 explicit AwaitTaskRegistryWaitAllAwaiter(AwaitTaskRegistry& registry);
1184
1185 AwaitTaskRegistry& registry;
1186 Result operationResult = Result(true);
1187
1188 bool await_ready() const;
1189 bool await_suspend(AwaitTask::Handle continuation);
1190 Result await_resume();
1191
1192 private:
1193 static Result cancel(void* object, AwaitEventLoop& eventLoop);
1194 static void onTaskCompleted(void* object);
1195
1196 Result cancel(AwaitEventLoop& eventLoop);
1197 void onTaskCompleted();
1198 void finish(Result result);
1199 void clearTaskCallbacks();
1200 Result collectResult() const;
1201
1202 AwaitTask::Handle continuation;
1203 size_t totalTasks = 0;
1204 size_t completedTasks = 0;
1205 bool finished = false;
1206};
1207
1209struct SC_AWAIT_EXPORT AwaitTaskRegistryWaitAnyAwaiter
1210{
1211 AwaitTaskRegistryWaitAnyAwaiter(AwaitTaskRegistry& registry, AwaitTaskRegistryWaitAnyResult& outResult,
1212 AwaitTaskRegistryWaitAnyPolicy waitAnyPolicy);
1213
1214 AwaitTaskRegistry& registry;
1215 AwaitTaskRegistryWaitAnyResult& outResult;
1216 AwaitTaskRegistryWaitAnyPolicy waitAnyPolicy;
1217 Result operationResult = Result(true);
1218
1219 bool await_ready() const;
1220 bool await_suspend(AwaitTask::Handle continuation);
1221 Result await_resume();
1222
1223 private:
1224 static Result cancel(void* object, AwaitEventLoop& eventLoop);
1225 static void onTaskCompleted(void* object);
1226
1227 Result cancel(AwaitEventLoop& eventLoop);
1228 void onTaskCompleted();
1229 void finish(Result result);
1230 void clearTaskCallbacks();
1231 Result setWinner(size_t index);
1232 Result cancelRemaining(AwaitEventLoop& eventLoop);
1233
1234 AwaitTask::Handle continuation;
1235 size_t totalTasks = 0;
1236 size_t completedTasks = 0;
1237 size_t winnerIndex = size_t(-1);
1238 bool cancelling = false;
1239 bool finished = false;
1240};
1241
1243struct SC_AWAIT_EXPORT AwaitTaskGroupWaitAllAwaiter
1244{
1245 explicit AwaitTaskGroupWaitAllAwaiter(AwaitTaskGroup& group);
1246
1247 AwaitTaskGroup& group;
1248 Result operationResult = Result(true);
1249
1250 bool await_ready() const;
1251 bool await_suspend(AwaitTask::Handle continuation);
1252 Result await_resume();
1253
1254 private:
1255 static Result cancel(void* object, AwaitEventLoop& eventLoop);
1256 static void onTaskCompleted(void* object);
1257
1258 Result cancel(AwaitEventLoop& eventLoop);
1259 void onTaskCompleted();
1260 void finish(Result result);
1261 void clearChildCallbacks();
1262 Result collectResult() const;
1263
1264 AwaitTask::Handle continuation;
1265 size_t completedTasks = 0;
1266 bool finished = false;
1267};
1268
1270struct SC_AWAIT_EXPORT AwaitTaskGroupWaitAnyAwaiter
1271{
1272 AwaitTaskGroupWaitAnyAwaiter(AwaitTaskGroup& group, AwaitTaskGroupWaitAnyResult& outResult,
1273 AwaitTaskGroupWaitAnyPolicy waitAnyPolicy);
1274
1275 AwaitTaskGroup& group;
1276 AwaitTaskGroupWaitAnyResult& outResult;
1277 AwaitTaskGroupWaitAnyPolicy waitAnyPolicy;
1278 Result operationResult = Result(true);
1279
1280 bool await_ready() const;
1281 bool await_suspend(AwaitTask::Handle continuation);
1282 Result await_resume();
1283
1284 private:
1285 static Result cancel(void* object, AwaitEventLoop& eventLoop);
1286 static void onTaskCompleted(void* object);
1287
1288 Result cancel(AwaitEventLoop& eventLoop);
1289 void onTaskCompleted();
1290 void finish(Result result);
1291 void clearChildCallbacks();
1292 Result setWinner(size_t index);
1293 Result cancelRemaining(AwaitEventLoop& eventLoop);
1294
1295 AwaitTask::Handle continuation;
1296 size_t completedTasks = 0;
1297 size_t winnerIndex = size_t(-1);
1298 bool cancelling = false;
1299 bool finished = false;
1300};
1301
1303struct SC_AWAIT_EXPORT AwaitProcessExitAwaiter
1304{
1305 AwaitProcessExitAwaiter(AwaitEventLoop& await, FileDescriptor::Handle process, AwaitProcessExitResult& outResult);
1306
1307 AwaitEventLoop& await;
1308 FileDescriptor::Handle process = FileDescriptor::Invalid;
1309 AwaitProcessExitResult& outResult;
1310 AsyncProcessExit request;
1311 Result operationResult = Result(true);
1312
1313 bool await_ready() const;
1314 bool await_suspend(AwaitTask::Handle continuation);
1315 Result await_resume();
1316
1317 private:
1318 static Result cancel(void* object, AwaitEventLoop& eventLoop);
1319
1320 Result cancel(AwaitEventLoop& eventLoop);
1321
1322 AwaitTask::Handle continuation;
1323 Function<void(AsyncResult&)> stopCallback;
1324};
1325
1327struct SC_AWAIT_EXPORT AwaitSignalAwaiter
1328{
1329 AwaitSignalAwaiter(AwaitEventLoop& await, int signalNumber, AwaitSignalResult& outResult);
1330
1331 AwaitEventLoop& await;
1332 int signalNumber = 0;
1333 AwaitSignalResult& outResult;
1334 AsyncSignal request;
1335 Result operationResult = Result(true);
1336
1337 bool await_ready() const;
1338 bool await_suspend(AwaitTask::Handle continuation);
1339 Result await_resume();
1340
1341 private:
1342 static Result cancel(void* object, AwaitEventLoop& eventLoop);
1343
1344 Result cancel(AwaitEventLoop& eventLoop);
1345
1346 AwaitTask::Handle continuation;
1347 Function<void(AsyncResult&)> stopCallback;
1348};
1349
1351struct SC_AWAIT_EXPORT AwaitTaskSpawnAwaiter
1352{
1353 AwaitTaskSpawnAwaiter(AwaitEventLoop& await, AwaitTask& task);
1354
1355 AwaitEventLoop& await;
1356 AwaitTask& task;
1357 Result operationResult = Result(true);
1358
1359 bool await_ready() const;
1360 bool await_suspend(AwaitTask::Handle continuation);
1361 Result await_resume();
1362
1363 private:
1364 static Result cancel(void* object, AwaitEventLoop& eventLoop);
1365
1366 Result cancel(AwaitEventLoop& eventLoop);
1367
1368 AwaitTask::Handle continuation;
1369};
1370
1372struct SC_AWAIT_EXPORT AwaitTaskTimeoutAwaiter
1373{
1374 AwaitTaskTimeoutAwaiter(AwaitEventLoop& await, AwaitTask& task, TimeMs timeout, AwaitTimeoutResult* outResult);
1375
1376 AwaitEventLoop& await;
1377 AwaitTask& task;
1378 TimeMs timeout;
1379 AwaitTimeoutResult* outResult = nullptr;
1380 AsyncLoopTimeout timeoutRequest;
1381 Result operationResult = Result(true);
1382
1383 bool await_ready() const;
1384 bool await_suspend(AwaitTask::Handle continuation);
1385 Result await_resume();
1386
1387 private:
1388 static Result cancel(void* object, AwaitEventLoop& eventLoop);
1389 static void onTaskCompleted(void* object);
1390
1391 Result cancel(AwaitEventLoop& eventLoop);
1392 void onTaskCompleted();
1393 void finish(Result result);
1394
1395 AwaitTask::Handle continuation;
1396 Function<void(AsyncResult&)> stopCallback;
1397 bool cancelling = false;
1398 bool childCompleted = false;
1399 bool timeoutStopped = false;
1400 bool timeoutFired = false;
1401 bool finished = false;
1402};
1403
1405struct SC_AWAIT_EXPORT AwaitLoopWorkAwaiter
1406{
1407 AwaitLoopWorkAwaiter(AwaitEventLoop& await, ThreadPool& threadPool, Function<Result()> work);
1408
1409 AwaitEventLoop& await;
1410 ThreadPool& threadPool;
1411 Function<Result()> work;
1412 AsyncLoopWork request;
1413 Result operationResult = Result(true);
1414
1415 bool await_ready() const;
1416 bool await_suspend(AwaitTask::Handle continuation);
1417 Result await_resume();
1418
1419 private:
1420 static Result cancel(void* object, AwaitEventLoop& eventLoop);
1421
1422 Result cancel(AwaitEventLoop& eventLoop);
1423
1424 AwaitTask::Handle continuation;
1425 Function<void(AsyncResult&)> stopCallback;
1426};
1427} // namespace SC
SC::AsyncEventLoop
Asynchronous I/O (files, sockets, timers, processes, fs events, threads wake-up) (see Async) AsyncEve...
Definition Async.h:1506
SC::AsyncFileRead
Starts a file read operation, reading bytes from a file (or pipe).
Definition Async.h:839
SC::AsyncFileReadiness
Starts a file descriptor readiness operation.
Definition Async.h:996
SC::AsyncFileSend
Sends file contents to a socket using zero-copy when available (sendfile, TransmitFile).
Definition Async.h:1087
SC::AsyncFileSystemOperation
Starts an asynchronous file system operation (open, close, read, write, sendFile, stat,...
Definition Async.h:1303
SC::AsyncFileWrite
Starts a file write operation, writing bytes to a file (or pipe).
Definition Async.h:919
SC::AsyncLoopTimeout
Starts a Timeout that is invoked only once after expiration (relative) time has passed.
Definition Async.h:332
SC::AsyncLoopWakeUpOptions
Options for AsyncLoopWakeUp configuration.
Definition Async.h:362
SC::AsyncLoopWakeUp
Starts a wake-up operation, allowing threads to execute callbacks on loop thread.
Definition Async.h:388
SC::AsyncLoopWork
Executes work in a thread pool and then invokes a callback on the event loop thread.
Definition Async.h:1250
SC::AsyncProcessExit
Starts monitoring a process, notifying about its termination.
Definition Async.h:425
SC::AsyncResult
Base class for all async results (argument of completion callbacks).
Definition Async.h:287
SC::AsyncSignal
Starts monitoring a signal, notifying about its reception.
Definition Async.h:502
SC::AsyncSocketAccept
Starts a socket accept operation, obtaining a new socket from a listening socket.
Definition Async.h:599
SC::AsyncSocketConnect
Starts a socket connect operation, connecting to a remote endpoint.
Definition Async.h:619
SC::AsyncSocketReceiveFrom
Starts an unconnected socket receive from operation, receiving bytes from a remote endpoint.
Definition Async.h:800
SC::AsyncSocketReceive
Starts a socket receive operation, receiving bytes from a remote endpoint.
Definition Async.h:738
SC::AsyncSocketSendTo
Starts an unconnected socket send to operation, sending bytes to a remote endpoint.
Definition Async.h:700
SC::AsyncSocketSend
Starts a socket send operation, sending bytes to a remote endpoint.
Definition Async.h:654
SC::AsyncTaskSequence
An AsyncSequence using a SC::ThreadPool to execute one or more SC::AsyncRequest in a background threa...
Definition Async.h:1231
SC::AwaitAllocatorInterface
Definition Await.h:274
SC::AwaitAllocatorStatistics
Definition Await.h:251
SC::AwaitAllocatorVirtualOptions
Definition Await.h:268
SC::AwaitAllocator
Explicit allocator used by AwaitTask coroutine frame allocation.
Definition Await.h:303
SC::AwaitCancellationHandler
Cancellation hook installed by the awaiter currently suspending an AwaitTask.
Definition Await.h:295
SC::AwaitEventLoop
Coroutine-friendly wrapper around an existing AsyncEventLoop.
Definition Await.h:485
SC::AwaitFilePollAwaiter
Awaiter for a single AsyncFileReadiness operation.
Definition Await.h:1046
SC::AwaitFileReadAwaiter
Awaiter for a single AsyncFileRead operation.
Definition Await.h:926
SC::AwaitFileReadOptions
Definition Await.h:145
SC::AwaitFileReadResult
Result object populated by AwaitEventLoop::fileRead.
Definition Await.h:134
SC::AwaitFileReadUntilFullOrEOFAwaiter
Awaiter that reads until the caller buffer is full or EOF is reached.
Definition Await.h:954
SC::AwaitFileSendAwaiter
Awaiter for a single AsyncFileSend operation.
Definition Await.h:1018
SC::AwaitFileSendOptions
Definition Await.h:159
SC::AwaitFileSendResult
Definition Await.h:167
SC::AwaitFileSystemOperationAwaiter
Awaiter for selected AsyncFileSystemOperation path operations.
Definition Await.h:1069
SC::AwaitFileWriteAwaiter
Awaiter for a single AsyncFileWrite operation.
Definition Await.h:986
SC::AwaitFileWriteOptions
Definition Await.h:152
SC::AwaitFileWriteResult
Definition Await.h:140
SC::AwaitLoopWakeUpAwaiter
Awaiter for a single AsyncLoopWakeUp delivery.
Definition Await.h:614
SC::AwaitLoopWakeUpResult
Definition Await.h:190
SC::AwaitLoopWakeUp
Stable wake-up object that can resume an AwaitLoopWakeUpAwaiter from another thread.
Definition Await.h:577
SC::AwaitLoopWorkAwaiter
Awaiter for a single AsyncLoopWork operation.
Definition Await.h:1406
SC::AwaitProcessExitAwaiter
Awaiter for a single AsyncProcessExit operation.
Definition Await.h:1304
SC::AwaitProcessExitResult
Definition Await.h:179
SC::AwaitSignalAwaiter
Awaiter for a single one-shot AsyncSignal operation.
Definition Await.h:1328
SC::AwaitSignalResult
Definition Await.h:184
SC::AwaitSleepAwaiter
Awaiter for a single AsyncLoopTimeout operation.
Definition Await.h:591
SC::AwaitSocketAcceptAwaiter
Awaiter for a single AsyncSocketAccept operation.
Definition Await.h:639
SC::AwaitSocketConnectAwaiter
Awaiter for a single AsyncSocketConnect operation.
Definition Await.h:663
SC::AwaitSocketReceiveAwaiter
Awaiter for a single AsyncSocketReceive operation.
Definition Await.h:813
SC::AwaitSocketReceiveExactAwaiter
Awaiter that reactivates AsyncSocketReceive until the whole caller buffer is filled.
Definition Await.h:839
SC::AwaitSocketReceiveFromAwaiter
Awaiter for a single AsyncSocketReceiveFrom operation.
Definition Await.h:900
SC::AwaitSocketReceiveFromResult
Result object populated by AwaitEventLoop::receiveFrom.
Definition Await.h:125
SC::AwaitSocketReceiveFromResult::sourceSocketAddress
SocketAddress sourceSocketAddress
Family-neutral source address.
Definition Await.h:128
SC::AwaitSocketReceiveFromResult::sourceAddress
SocketIPAddress sourceAddress
IPv4/IPv6 compatibility result.
Definition Await.h:127
SC::AwaitSocketReceiveLineAwaiter
Awaiter that reads a ' '-terminated line into caller-provided storage.
Definition Await.h:869
SC::AwaitSocketReceiveLineResult
Result object populated by AwaitEventLoop::receiveLine.
Definition Await.h:117
SC::AwaitSocketReceiveResult
Result object populated by AwaitEventLoop::receive.
Definition Await.h:110
SC::AwaitSocketSendAllAwaiter
Awaiter that reactivates AsyncSocketSend until the whole buffer is sent.
Definition Await.h:753
SC::AwaitSocketSendAllBuffersAwaiter
Awaiter that sends every buffer in a scatter/gather list.
Definition Await.h:780
SC::AwaitSocketSendAwaiter
Awaiter for a single AsyncSocketSend operation.
Definition Await.h:688
SC::AwaitSocketSendResult
Definition Await.h:104
SC::AwaitSocketSendToAwaiter
Awaiter for a single AsyncSocketSendTo operation.
Definition Await.h:718
SC::AwaitTaskGroupResultSummary
Definition Await.h:201
SC::AwaitTaskGroupWaitAllAwaiter
Awaiter that waits for every active task in an AwaitTaskGroup.
Definition Await.h:1244
SC::AwaitTaskGroupWaitAnyAwaiter
Awaiter that waits for the first active task in an AwaitTaskGroup to complete.
Definition Await.h:1271
SC::AwaitTaskGroupWaitAnyResult
Definition Await.h:195
SC::AwaitTaskGroup
Caller-storage structured group of child tasks owned by the current scope.
Definition Await.h:1117
SC::AwaitTaskRegistrySpawnResult
Definition Await.h:212
SC::AwaitTaskRegistryWaitAllAwaiter
Awaiter that waits for every valid task in an AwaitTaskRegistry.
Definition Await.h:1182
SC::AwaitTaskRegistryWaitAnyAwaiter
Awaiter that waits for the first valid task in an AwaitTaskRegistry to complete.
Definition Await.h:1210
SC::AwaitTaskRegistry
Caller-owned fixed-slot registry for detached/background tasks.
Definition Await.h:1148
SC::AwaitTaskSpawnAwaiter
Awaiter that starts a child task if needed, then waits for it to complete.
Definition Await.h:1352
SC::AwaitTaskTimeoutAwaiter
Awaiter that waits for a child task, cancelling it if a timeout expires first.
Definition Await.h:1373
SC::AwaitTask::Promise
Coroutine promise implementation used by AwaitTask.
Definition Await.h:405
SC::AwaitTask
Caller-owned coroutine task returning a plain SC::Result.
Definition Await.h:357
SC::AwaitTimeoutResult
Definition Await.h:174
SC::FileDescriptor
[UniqueHandleDeclaration2Snippet]
Definition File.h:130
SC::FileOpen
Options used to open a file descriptor.
Definition File.h:101
SC::FileSystemCopyFlags
A structure to describe copy flags.
Definition FileSystem.h:76
SC::SocketAddress
Family-neutral native socket address.
Definition Socket.h:168
SC::SocketDescriptor
Low-level OS socket handle.
Definition Socket.h:207
SC::SocketIPAddress
Native representation of an IP Address.
Definition Socket.h:117
SC::ThreadPool
Simple thread pool that executes tasks in a fixed number of worker threads.
Definition ThreadPool.h:38