5#include "../Async/Internal/IntrusiveDoubleLinkedList.h"
6#include "../File/File.h"
7#include "../FileSystem/FileSystem.h"
8#include "../Foundation/Function.h"
9#include "../Foundation/OpaqueObject.h"
10#include "../Socket/Socket.h"
11#include "../Threading/Atomic.h"
12#include "../Threading/ThreadPool.h"
52struct AsyncTaskSequence;
56struct AsyncWinOverlapped;
57struct AsyncWinOverlappedDefinition
59 static constexpr int Windows =
sizeof(
void*) * 4 +
sizeof(
uint64_t);
60 static constexpr size_t Alignment =
alignof(
void*);
62 using Object = AsyncWinOverlapped;
64using WinOverlappedOpaque = OpaqueObject<AsyncWinOverlappedDefinition>;
66struct AsyncWinWaitDefinition
68 using Handle = FileDescriptor::Handle;
69 static constexpr Handle Invalid = FileDescriptor::Invalid;
71 static Result releaseHandle(Handle& waitHandle);
73struct WinWaitHandle :
public UniqueHandle<AsyncWinWaitDefinition>
121 void setDebugName(
const char* newDebugName);
155 AsyncRequest(
Type type) : state(State::Free), type(type), flags(0), unused(0), userFlags(0) {}
194 void queueSubmission(AsyncEventLoop& eventLoop);
196 AsyncSequence* sequence =
nullptr;
198 AsyncTaskSequence* getTask();
201 Function<void(AsyncResult&)>* closeCallback =
nullptr;
203 friend struct AsyncEventLoop;
204 friend struct AsyncResult;
208 [[nodiscard]]
static const char* TypeToString(
Type type);
219#if SC_ASYNC_ENABLE_LOG
220 const char* debugName =
"None";
243 bool runningAsync =
false;
244 bool tracked =
false;
246 IntrusiveDoubleLinkedList<AsyncRequest> submissions;
260 : eventLoop(eventLoop), async(request), hasBeenReactivated(hasBeenReactivated), returnCode(res)
276 bool shouldCallCallback =
true;
277 bool* hasBeenReactivated =
nullptr;
285template <
typename T,
typename C>
288 T& getAsync() {
return static_cast<T&
>(AsyncResult::async); }
289 const T& getAsync()
const {
return static_cast<const T&
>(AsyncResult::async); }
380 status = completionData.exitStatus;
397 FileDescriptor::Handle handle = FileDescriptor::Invalid;
398#if SC_PLATFORM_WINDOWS
400 detail::WinWaitHandle waitHandle;
402#elif SC_PLATFORM_LINUX
412struct AsyncSocketAcceptData
414#if SC_PLATFORM_WINDOWS
415 void (*pAcceptEx)() =
nullptr;
418 uint8_t acceptBuffer[288] = {0};
419#elif SC_PLATFORM_LINUX
420 AlignedStorage<28> sockAddrHandle;
426struct AsyncSocketAcceptBase :
public AsyncRequest
430 struct CompletionData :
public AsyncCompletionData
432 SocketDescriptor acceptedClient;
435 struct Result :
public AsyncResultOf<AsyncSocketAccept, CompletionData>
437 using AsyncResultOf<AsyncSocketAccept, CompletionData>::AsyncResultOf;
442 return client.assign(
move(completionData.acceptedClient));
448 SC::Result start(AsyncEventLoop& eventLoop,
const SocketDescriptor& socketDescriptor, AsyncSocketAcceptData& data);
451 Function<void(Result&)> callback;
452 SocketDescriptor::Handle handle = SocketDescriptor::Invalid;
454 AsyncSocketAcceptData* acceptData =
nullptr;
471 using AsyncSocketAcceptBase::start;
477 detail::AsyncSocketAcceptData data;
501 SocketDescriptor::Handle handle = SocketDescriptor::Invalid;
508#if SC_PLATFORM_WINDOWS
509 void (*pConnectEx)() =
nullptr;
540 SocketDescriptor::Handle
handle = SocketDescriptor::Invalid;
551 size_t totalBytesWritten = 0;
552#if SC_PLATFORM_WINDOWS
605 bool disconnected =
false;
631 SocketDescriptor::Handle handle = SocketDescriptor::Invalid;
637#if SC_PLATFORM_WINDOWS
693 bool endOfFile =
false;
728 bool useOffset =
false;
729 bool endedSync =
false;
732#if SC_PLATFORM_WINDOWS
770 writtenSizeInBytes = completionData.numBytes;
807#if SC_PLATFORM_WINDOWS
808 bool endedSync =
false;
810 bool isWatchable =
false;
812 bool useOffset =
false;
813 uint64_t offset = 0xffffffffffffffff;
815 size_t totalBytesWritten = 0;
816#if SC_PLATFORM_WINDOWS
835#if SC_PLATFORM_WINDOWS
836 [[nodiscard]]
void* getOverlappedPtr();
845 FileDescriptor::Handle handle = FileDescriptor::Invalid;
846#if SC_PLATFORM_WINDOWS
857 FileDescriptor::Handle handle = FileDescriptor::Invalid;
866struct AsyncCompletionVariant
868 AsyncCompletionVariant() {}
869 ~AsyncCompletionVariant() { destroy(); }
871 AsyncCompletionVariant(
const AsyncCompletionVariant&) =
delete;
872 AsyncCompletionVariant(AsyncCompletionVariant&&) =
delete;
873 AsyncCompletionVariant& operator=(
const AsyncCompletionVariant&) =
delete;
874 AsyncCompletionVariant& operator=(AsyncCompletionVariant&&) =
delete;
881 AsyncCompletionData completionDataLoopWork;
882 AsyncLoopTimeout::CompletionData completionDataLoopTimeout;
883 AsyncLoopWakeUp::CompletionData completionDataLoopWakeUp;
884 AsyncProcessExit::CompletionData completionDataProcessExit;
885 AsyncSocketAccept::CompletionData completionDataSocketAccept;
886 AsyncSocketConnect::CompletionData completionDataSocketConnect;
887 AsyncSocketSend::CompletionData completionDataSocketSend;
888 AsyncSocketSendTo::CompletionData completionDataSocketSendTo;
889 AsyncSocketReceive::CompletionData completionDataSocketReceive;
890 AsyncSocketReceiveFrom::CompletionData completionDataSocketReceiveFrom;
891 AsyncFileRead::CompletionData completionDataFileRead;
892 AsyncFileWrite::CompletionData completionDataFileWrite;
893 AsyncFilePoll::CompletionData completionDataFilePoll;
895 AsyncFileSystemOperationCompletionData completionDataFileSystemOperation;
898 auto& getCompletion(AsyncLoopWork&) {
return completionDataLoopWork; }
899 auto& getCompletion(AsyncLoopTimeout&) {
return completionDataLoopTimeout; }
900 auto& getCompletion(AsyncLoopWakeUp&) {
return completionDataLoopWakeUp; }
901 auto& getCompletion(AsyncProcessExit&) {
return completionDataProcessExit; }
902 auto& getCompletion(AsyncSocketAccept&) {
return completionDataSocketAccept; }
903 auto& getCompletion(AsyncSocketConnect&) {
return completionDataSocketConnect; }
904 auto& getCompletion(AsyncSocketSend&) {
return completionDataSocketSend; }
905 auto& getCompletion(AsyncSocketReceive&) {
return completionDataSocketReceive; }
906 auto& getCompletion(AsyncFileRead&) {
return completionDataFileRead; }
907 auto& getCompletion(AsyncFileWrite&) {
return completionDataFileWrite; }
908 auto& getCompletion(AsyncFilePoll&) {
return completionDataFilePoll; }
909 auto& getCompletion(AsyncFileSystemOperation&) {
return completionDataFileSystemOperation; }
911 template <
typename T>
912 auto& construct(T& t)
915 placementNew(getCompletion(t));
918 return getCompletion(t);
936 detail::AsyncCompletionVariant completion;
1006#ifdef RemoveDirectory
1007#undef RemoveDirectory
1009 enum class Operation
1101 Operation operation = Operation::None;
1107 struct FileDescriptorData
1109 FileDescriptor::Handle handle;
1120 FileDescriptor::Handle handle;
1127 FileDescriptor::Handle handle;
1128 Span<const char> buffer;
1135 StringSpan destinationPath;
1136 FileSystemCopyFlags copyFlags;
1139 using CopyDirectoryData = CopyFileData;
1141 using CloseData = FileDescriptorData;
1157 CloseData closeData;
1159 WriteData writeData;
1160 CopyFileData copyFileData;
1161 CopyDirectoryData copyDirectoryData;
1162 RenameData renameData;
1163 RemoveData removeData;
1168 SC::Result start(AsyncEventLoop& eventLoop, FileDescriptor::Handle fileDescriptor);
1180 int numberOfEvents = 0;
1356 struct InternalDefinition
1358 static constexpr int Windows = 520;
1359 static constexpr int Apple = 512;
1360 static constexpr int Linux = 720;
1361 static constexpr int Default = Linux;
1363 static constexpr size_t Alignment = 8;
1365 using Object = Internal;
1372 InternalOpaque internalOpaque;
1412#pragma warning(push)
1413#pragma warning(disable : 4324)
1431 bool wakeUpHasBeenCalled =
false;
unsigned short uint16_t
Platform independent (2) bytes unsigned int.
Definition PrimitiveTypes.h:37
constexpr T && move(T &value)
Converts an lvalue to an rvalue reference.
Definition Compiler.h:257
unsigned char uint8_t
Platform independent (1) byte unsigned int.
Definition PrimitiveTypes.h:36
unsigned long long uint64_t
Platform independent (8) bytes unsigned int.
Definition PrimitiveTypes.h:42
unsigned int uint32_t
Platform independent (4) bytes unsigned int.
Definition PrimitiveTypes.h:38
short int16_t
Platform independent (2) bytes signed int.
Definition PrimitiveTypes.h:45
int int32_t
Platform independent (4) bytes signed int.
Definition PrimitiveTypes.h:46
#define SC_TRY(expression)
Checks the value of the given expression and if failed, returns this value to caller.
Definition Result.h:48
A buffer of bytes with given alignment.
Definition AlignedStorage.h:29
Empty base struct for all AsyncRequest-derived CompletionData (internal) structs.
Definition Async.h:251
Allow library user to provide callbacks signaling different phases of async event loop cycle.
Definition Async.h:1186
Monitors Async I/O events from a background thread using a blocking kernel function (no CPU usage on ...
Definition Async.h:1386
Function< void(void)> onNewEventsAvailable
Informs to call dispatchCompletions on GUI Event Loop.
Definition Async.h:1387
Result startMonitoring()
Queue all async requests submissions and start monitoring loop events on a background thread.
Result close()
Stop monitoring the AsyncEventLoop, disposing all resources.
Result stopMonitoringAndDispatchCompletions()
Stops monitoring events on the background thread and dispatches callbacks for completed requests.
Result create(AsyncEventLoop &eventLoop)
Create the monitoring thread for an AsyncEventLoop.
Options given to AsyncEventLoop::create.
Definition Async.h:1201
ApiType apiType
Criteria to choose Async IO API.
Definition Async.h:1208
ApiType
Definition Async.h:1203
@ Automatic
Platform specific backend chooses the best API.
@ ForceUseEpoll
(Linux only) Tries to use epoll
@ ForceUseIOURing
(Linux only) Tries to use io_uring (failing if it's not found on the system)
Asynchronous I/O (files, sockets, timers, processes, fs events, threads wake-up) (see Async) AsyncEve...
Definition Async.h:1198
Result associateExternallyCreatedFileDescriptor(FileDescriptor &outDescriptor)
Associates a previously created File Descriptor with the eventLoop.
Result wakeUpFromExternalThread()
Wake up the event loop from a thread different than the one where run() is called (and potentially bl...
Result runNoWait()
Process active requests if any, dispatching their completions, or returns immediately without blockin...
static Result removeAllAssociationsFor(SocketDescriptor &outDescriptor)
Removes association of a TCP Socket with any event loop.
void updateTime()
Updates loop time to "now".
static bool isExcludedFromActiveCount(const AsyncRequest &async)
Checks if excludeFromActiveCount() has been called on the given request.
Result associateExternallyCreatedSocket(SocketDescriptor &outDescriptor)
Associates a previously created TCP / UDP socket with the eventLoop.
Result blockingPoll(AsyncKernelEvents &kernelEvents)
Blocks until at least one event happens, ensuring forward progress, without executing completions.
void clearSequence(AsyncSequence &sequence)
Clears the sequence.
int getNumberOfSubmittedRequests() const
Obtain the total number of submitted requests.
Result submitRequests(AsyncKernelEvents &kernelEvents)
Submits all queued async requests.
void enumerateRequests(Function< void(AsyncRequest &)> enumerationCallback)
Enumerates all requests objects associated with this loop.
TimeMs getLoopTime() const
Get Loop time (monotonic)
Result start(AsyncRequest &async)
Queues an async request request that has been correctly setup.
AsyncLoopTimeout * findEarliestLoopTimeout() const
Returns the next AsyncLoopTimeout that will be executed (shortest relativeTimeout)
void setListeners(AsyncEventLoopListeners *listeners)
Sets reference to listeners that will signal different events in loop lifetime.
Result dispatchCompletions(AsyncKernelEvents &kernelEvents)
Invokes completions for the AsyncKernelEvents collected by a call to AsyncEventLoop::blockingPoll.
void interrupt()
Interrupts the event loop even if it has active request on it.
Result wakeUpFromExternalThread(AsyncLoopWakeUp &wakeUp)
Wake up the event loop from a thread different than the one where run() is called (and potentially bl...
bool isInitialized() const
Returns true if create has been already called (successfully)
Result create(Options options=Options())
Creates the event loop kernel object.
static bool tryLoadingLiburing()
Check if liburing is loadable (only on Linux)
Result createAsyncTCPSocket(SocketFlags::AddressFamily family, SocketDescriptor &outDescriptor)
Creates an async TCP (IPV4 / IPV6) socket registered with the eventLoop.
Result close()
Closes the event loop kernel object.
Result createAsyncUDPSocket(SocketFlags::AddressFamily family, SocketDescriptor &outDescriptor)
Creates an async UCP (IPV4 / IPV6) socket registered with the eventLoop.
static Result removeAllAssociationsFor(FileDescriptor &outDescriptor)
Removes association of a File Descriptor with any event loop.
Result runOnce()
Blocks until at least one request proceeds, ensuring forward progress, dispatching all completions.
void excludeFromActiveCount(AsyncRequest &async)
Excludes the request from active handles count (to avoid it keeping event loop alive)
Result run()
Blocks until there are no more active queued requests, dispatching all completions.
void includeInActiveCount(AsyncRequest &async)
Reverses the effect of excludeFromActiveCount for the request.
int getNumberOfActiveRequests() const
Obtain the total number of active requests.
Starts an handle polling operation.
Definition Async.h:826
SC::Result start(AsyncEventLoop &eventLoop, FileDescriptor::Handle fileDescriptor)
Starts a file descriptor poll operation, monitoring its readiness with appropriate OS API.
Starts a file read operation, reading bytes from a file (or pipe).
Definition Async.h:687
FileDescriptor::Handle handle
The writeable span of memory where to data will be written.
Definition Async.h:710
Span< char > buffer
Callback called when some data has been read from the file into the buffer.
Definition Async.h:709
void setOffset(uint64_t fileOffset)
Sets the offset in bytes at which start reading.
Definition Async.h:718
uint64_t getOffset() const
The file/pipe descriptor handle to read data from.
Definition Async.h:714
Starts an asynchronous file system operation (open, close, read, write, sendFile, stat,...
Definition Async.h:1000
SC::Result copyDirectory(AsyncEventLoop &eventLoop, StringSpan path, StringSpan destinationPath, FileSystemCopyFlags copyFlags=FileSystemCopyFlags())
Copies a directory from one location to another.
SC::Result removeEmptyDirectory(AsyncEventLoop &eventLoop, StringSpan path)
Removes a directory asynchronously.
SC::Result rename(AsyncEventLoop &eventLoop, StringSpan path, StringSpan newPath)
Renames a file.
SC::Result removeFile(AsyncEventLoop &eventLoop, StringSpan path)
Removes a file asynchronously.
SC::Result setThreadPool(ThreadPool &threadPool)
Sets the thread pool to use for the operation.
SC::Result read(AsyncEventLoop &eventLoop, FileDescriptor::Handle handle, Span< char > buffer, uint64_t offset)
Reads data from a file descriptor at a given offset.
SC::Result write(AsyncEventLoop &eventLoop, FileDescriptor::Handle handle, Span< const char > buffer, uint64_t offset)
Writes data to a file descriptor at a given offset.
SC::Result close(AsyncEventLoop &eventLoop, FileDescriptor::Handle handle)
Closes a file descriptor asynchronously.
Function< void(Result &)> callback
Called after the operation is completed, on the event loop thread.
Definition Async.h:1029
SC::Result copyFile(AsyncEventLoop &eventLoop, StringSpan path, StringSpan destinationPath, FileSystemCopyFlags copyFlags=FileSystemCopyFlags())
Copies a file from one location to another.
SC::Result open(AsyncEventLoop &eventLoop, StringSpan path, FileOpen mode)
Opens a file asynchronously and returns its corresponding file descriptor.
Starts a file write operation, writing bytes to a file (or pipe).
Definition Async.h:756
uint64_t getOffset() const
Returns the last offset set with AsyncFileWrite::setOffset.
Definition Async.h:793
FileDescriptor::Handle handle
The file/pipe descriptor to write data to.
Definition Async.h:785
SC::Result start(AsyncEventLoop &eventLoop, Span< const char > data)
Sets async request members and calls AsyncEventLoop::start.
void setOffset(uint64_t fileOffset)
Sets the offset in bytes at which start writing.
Definition Async.h:797
Function< void(Result &)> callback
Callback called when descriptor is ready to be written with more data.
Definition Async.h:783
Span< Span< const char > > buffers
The read-only spans of memory where to read the data from.
Definition Async.h:789
SC::Result start(AsyncEventLoop &eventLoop, Span< Span< const char > > data)
Sets async request members and calls AsyncEventLoop::start.
Span< const char > buffer
The read-only span of memory where to read the data from.
Definition Async.h:788
bool singleBuffer
Controls if buffer or buffers will be used.
Definition Async.h:790
Allows user to supply a block of memory that will store kernel I/O events retrieved from AsyncEventLo...
Definition Async.h:1176
Span< uint8_t > eventsMemory
User supplied block of memory used to store kernel I/O events.
Definition Async.h:1177
Starts a Timeout that is invoked only once after expiration (relative) time has passed.
Definition Async.h:302
TimeMs getExpirationTime() const
Gets computed absolute expiration time that determines when this timeout get executed.
Definition Async.h:317
SC::Result start(AsyncEventLoop &eventLoop, TimeMs relativeTimeout)
Sets async request members and calls AsyncEventLoop::start.
TimeMs relativeTimeout
First timer expiration (relative) time in milliseconds.
Definition Async.h:314
Function< void(Result &)> callback
Called after given expiration time since AsyncLoopTimeout::start has passed.
Definition Async.h:312
Starts a wake-up operation, allowing threads to execute callbacks on loop thread.
Definition Async.h:338
SC::Result start(AsyncEventLoop &eventLoop, EventObject &eventObject)
Sets async request members and calls AsyncEventLoop::start.
Function< void(Result &)> callback
Callback called by SC::AsyncEventLoop::run after SC::AsyncLoopWakeUp::wakeUp.
Definition Async.h:351
SC::Result wakeUp(AsyncEventLoop &eventLoop)
Wakes up event loop, scheduling AsyncLoopWakeUp::callback on next AsyncEventLoop::run (or its variati...
EventObject * eventObject
Optional EventObject to let external threads wait for the callback to end.
Definition Async.h:352
Executes work in a thread pool and then invokes a callback on the event loop thread.
Definition Async.h:947
Function< void(Result &)> callback
Called to execute the work in a background threadpool thread.
Definition Async.h:958
SC::Result setThreadPool(ThreadPool &threadPool)
Sets the ThreadPool that will supply the thread to run the async work on.
Starts monitoring a process, notifying about its termination.
Definition Async.h:366
SC::Result start(AsyncEventLoop &eventLoop, FileDescriptor::Handle process)
Sets async request members and calls AsyncEventLoop::start.
Function< void(Result &)> callback
Called when process has exited.
Definition Async.h:391
Base class for all async requests, holding state and type.
Definition Async.h:117
bool isCancelling() const
Returns true if this request is being cancelled.
AsyncRequest(Type type)
Constructs a free async request of given type.
Definition Async.h:155
Result start(AsyncEventLoop &eventLoop)
Shortcut for AsyncEventLoop::start.
uint16_t getUserFlags() const
Gets user flags, holding some meaningful data for the caller.
Definition Async.h:184
Function< void(AsyncResult &)> * getCloseCallback()
Returns currently set close callback (if any) passed to AsyncRequest::stop.
Definition Async.h:187
bool isActive() const
Returns true if this request is active or being reactivated.
bool isFree() const
Returns true if this request is free.
void disableThreadPool()
Disables the thread-pool usage for this request.
Type getType() const
Returns request type.
Definition Async.h:175
void setUserFlags(uint16_t externalFlags)
Sets user flags, holding some meaningful data for the caller.
Definition Async.h:181
Result executeOn(AsyncTaskSequence &task, ThreadPool &pool)
Adds the request to be executed on a specific AsyncTaskSequence.
Result stop(AsyncEventLoop &eventLoop, Function< void(AsyncResult &)> *afterStopped=nullptr)
Ask to stop current async operation.
void executeOn(AsyncSequence &sequence)
Adds the request to be executed on a specific AsyncSequence.
Type
Type of async request.
Definition Async.h:136
@ SocketSend
Request is an AsyncSocketSend object.
@ SocketReceive
Request is an AsyncSocketReceive object.
@ SocketAccept
Request is an AsyncSocketAccept object.
@ FileWrite
Request is an AsyncFileWrite object.
@ SocketSendTo
Request is an SocketSendTo object.
@ FileSystemOperation
Request is an AsyncFileSystemOperation object.
@ LoopTimeout
Request is an AsyncLoopTimeout object.
@ ProcessExit
Request is an AsyncProcessExit object.
@ FileRead
Request is an AsyncFileRead object.
@ SocketReceiveFrom
Request is an SocketReceiveFrom object.
@ FilePoll
Request is an AsyncFilePoll object.
@ LoopWakeUp
Request is an AsyncLoopWakeUp object.
@ SocketConnect
Request is an AsyncSocketConnect object.
@ LoopWork
Request is an AsyncLoopWork object.
Helper holding CompletionData for a specific AsyncRequest-derived class.
Definition Async.h:287
Base class for all async results (argument of completion callbacks).
Definition Async.h:257
const SC::Result & isValid() const
Check if the returnCode of this result is valid.
Definition Async.h:268
AsyncResult(AsyncEventLoop &eventLoop, AsyncRequest &request, SC::Result &res, bool *hasBeenReactivated=nullptr)
Constructs an async result from a request and a result.
Definition Async.h:259
void reactivateRequest(bool shouldBeReactivated)
Ask the event loop to re-activate this request after it was already completed.
Execute AsyncRequests serially, by submitting the next one after the previous one is completed.
Definition Async.h:235
bool clearSequenceOnError
Do not queue next requests in the sequence when current one returns error.
Definition Async.h:240
bool clearSequenceOnCancel
Do not queue next requests in the sequence when current one is cancelled.
Definition Async.h:239
Starts a socket accept operation, obtaining a new socket from a listening socket.
Definition Async.h:469
SC::Result start(AsyncEventLoop &eventLoop, const SocketDescriptor &socketDescriptor)
Sets async request members and calls AsyncEventLoop::start.
Starts a socket connect operation, connecting to a remote endpoint.
Definition Async.h:489
Function< void(Result &)> callback
Called after socket is finally connected to endpoint.
Definition Async.h:499
SC::Result start(AsyncEventLoop &eventLoop, const SocketDescriptor &descriptor, SocketIPAddress address)
Sets async request members and calls AsyncEventLoop::start.
Starts an unconnected socket receive from operation, receiving bytes from a remote endpoint.
Definition Async.h:652
SC::Result get(Span< char > &outData)
Get a Span of the actually read data.
Definition Async.h:615
Starts a socket receive operation, receiving bytes from a remote endpoint.
Definition Async.h:599
AsyncSocketReceive(Type type)
The Socket Descriptor handle to read data from.
Definition Async.h:634
SC::Result start(AsyncEventLoop &eventLoop, const SocketDescriptor &descriptor, Span< char > data)
Sets async request members and calls AsyncEventLoop::start.
Span< char > buffer
The writeable span of memory where to data will be written.
Definition Async.h:630
Function< void(Result &)> callback
Called after data has been received.
Definition Async.h:628
Starts an unconnected socket send to operation, sending bytes to a remote endpoint.
Definition Async.h:567
Starts a socket send operation, sending bytes to a remote endpoint.
Definition Async.h:523
Function< void(Result &)> callback
Called when socket is ready to send more data.
Definition Async.h:538
bool singleBuffer
Controls if buffer or buffers will be used.
Definition Async.h:544
SC::Result start(AsyncEventLoop &eventLoop, const SocketDescriptor &descriptor, Span< const char > data)
Sets async request members and calls AsyncEventLoop::start.
Span< Span< const char > > buffers
Spans of bytes to send (singleBuffer == false)
Definition Async.h:543
Span< const char > buffer
Span of bytes to send (singleBuffer == true)
Definition Async.h:542
SC::Result start(AsyncEventLoop &eventLoop, const SocketDescriptor &descriptor, Span< Span< const char > > data)
Sets async request members and calls AsyncEventLoop::start.
SocketDescriptor::Handle handle
The socket to send data to.
Definition Async.h:540
An AsyncSequence using a SC::ThreadPool to execute one or more SC::AsyncRequest in a background threa...
Definition Async.h:928
Atomic variables (only for int and bool for now).
Definition Atomic.h:41
An automatically reset event object to synchronize two threads.
Definition Threading.h:237
[UniqueHandleDeclaration2Snippet]
Definition File.h:78
Options used to open a file descriptor.
Definition File.h:49
A structure to describe copy flags.
Definition FileSystem.h:25
Wraps function pointers, member functions and lambdas without ever allocating.
Definition Function.h:19
Hides implementation details from public headers (static PIMPL).
Definition OpaqueObject.h:31
An ascii string used as boolean result. SC_TRY macro forwards errors to caller.
Definition Result.h:12
Low-level OS socket handle.
Definition Socket.h:153
AddressFamily
Sets the address family of an IP Address (IPv4 or IPV6)
Definition Socket.h:60
@ AddressFamilyIPV4
IP Address is IPV4.
Definition Socket.h:61
Native representation of an IP Address.
Definition Socket.h:100
View over a contiguous sequence of items (pointer + size in elements).
Definition Span.h:29
constexpr bool sliceStartLength(SizeType offsetInElements, SizeType lengthInElements, Span &destination) const
Creates another Span, starting at an offset in elements from current Span of specified length.
Definition Span.h:120
An read-only view over a string (to avoid including Strings library when parsing is not needed).
Definition StringSpan.h:37
A small task containing a function to execute that can be queued in the thread pool.
Definition ThreadPool.h:19
Simple thread pool that executes tasks in a fixed number of worker threads.
Definition ThreadPool.h:41
A native OS thread.
Definition Threading.h:121
A vocabulary type representing a time interval in milliseconds since epoch.
Definition PrimitiveTypes.h:63