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