SC::AsyncSocketReceiveFrom Struct Reference

Starts a unconnectedsocket receive from operation, receiving bytes from a remote endpoint. More...

#include <Async.h>

Inheritance diagram for SC::AsyncSocketReceiveFrom:

Public Member Functions
SC::Result	start (AsyncEventLoop &eventLoop, const SocketDescriptor &descriptor, Span< char > data)
	Sets async request members and calls AsyncEventLoop::start.
Result	start (AsyncEventLoop &eventLoop)
	Shortcut for AsyncEventLoop::start.
Public Member Functions inherited from SC::AsyncSocketReceive
SC::Result	start (AsyncEventLoop &eventLoop, const SocketDescriptor &descriptor, Span< char > data)
	Sets async request members and calls AsyncEventLoop::start.
Result	start (AsyncEventLoop &eventLoop)
	Shortcut for AsyncEventLoop::start.
Public Member Functions inherited from SC::AsyncRequest
void	setDebugName (const char *newDebugName)
void	executeOn (AsyncSequence &sequence)
	Adds the request to be executed on a specific AsyncSequence.
Result	executeOn (AsyncTaskSequence &task, ThreadPool &pool)
	Adds the request to be executed on a specific AsyncTaskSequence.
void	disableThreadPool ()
	Disables the thread-pool usage for this request.
	AsyncRequest (Type type)
	Constructs a free async request of given type.
Result	stop (AsyncEventLoop &eventLoop, Function< void(AsyncResult &)> *afterStopped=nullptr)
	Ask to stop current async operation.
bool	isFree () const
	Returns true if this request is free.
bool	isCancelling () const
	Returns true if this request is being cancelled.
bool	isActive () const
	Returns true if this request is active or being reactivated.
Type	getType () const
	Returns request type.
Result	start (AsyncEventLoop &eventLoop)
	Shortcut for AsyncEventLoop::start.
void	setUserFlags (uint16_t externalFlags)
	Sets user flags, holding some meaningful data for the caller.
uint16_t	getUserFlags () const
	Gets user flags, holding some meaningful data for the caller.
Function< void(AsyncResult &)> *	getCloseCallback ()
	Returns currently set close callback (if any) passed to AsyncRequest::stop.
const Function< void(AsyncResult &)> *	getCloseCallback () const

Friends
struct	AsyncSocketReceive
struct	AsyncEventLoop

Additional Inherited Members
Public Types inherited from SC::AsyncRequest
enum class	Type : uint8_t {   LoopTimeout ,   LoopWakeUp ,   LoopWork ,   ProcessExit ,   SocketAccept ,   SocketConnect ,   SocketSend ,   SocketSendTo ,   SocketReceive ,   SocketReceiveFrom ,   FileRead ,   FileWrite ,   FilePoll ,   FileSystemOperation }
	Type of async request. More...
Public Attributes inherited from SC::AsyncSocketReceive
Function< void(Result &)>	callback
	Called after data has been received.
Span< char >	buffer
	The writeable span of memory where to data will be written.
SocketDescriptor::Handle	handle = SocketDescriptor::Invalid
Public Attributes inherited from SC::AsyncRequest
AsyncRequest *	next = nullptr
AsyncRequest *	prev = nullptr
Protected Member Functions inherited from SC::AsyncSocketReceive
	AsyncSocketReceive (Type type)
	The Socket Descriptor handle to read data from.
SC::Result	validate (AsyncEventLoop &)
Protected Member Functions inherited from SC::AsyncRequest
Result	checkState ()
void	queueSubmission (AsyncEventLoop &eventLoop)
AsyncTaskSequence *	getTask ()
Protected Attributes inherited from SC::AsyncRequest
AsyncSequence *	sequence = nullptr

Detailed Description

Starts a unconnectedsocket receive from operation, receiving bytes from a remote endpoint.

Callback will be called when some data is read from socket.
Typical use case is to receive data from an unconnected UDP socket.
Socket library can be used to create a Socket but the socket should be created with SC::SocketFlags::NonBlocking and associated to the event loop with SC::AsyncEventLoop::associateExternallyCreatedSocket or though AsyncSocketAccept.
Alternatively SC::AsyncEventLoop::createAsyncUDPSocket creates and associates the socket to the loop.

// Assuming an already created (and running) AsyncEventLoop named `eventLoop`
// ...
char receivedData[100] = {0}; // A buffer to hold data read from the socket
AsyncSocketReceiveFrom receiveAsync;
receiveAsync.callback = [&](AsyncSocketReceive::Result& res)
{
    Span<char> readData;
    if(res.get(readData))
    {
        if(res.completionData.disconnected)
        {
            // Last callback invocation done when other side of the socket has disconnected.
            // - completionData.disconnected is == true
            // - readData.sizeInBytes() is == 0
            console.print("Client disconnected");
        }
        else
        {
            // readData is a slice of receivedData with the received bytes
            console.print("{} bytes have been read", readData.sizeInBytes());
            
            // Get the source address / port of the received data
            SocketIPAddress sourceAddress = res.getSourceAddress();
            SocketIPAddress::AsciiBuffer buffer;
            console.print("Source address: {}:{}", sourceAddress.toString(buffer), sourceAddress.getPort());
            
            // IMPORTANT: Reactivate the request to receive more data
            res.reactivateRequest(true);
        }
    }
    else
    {
        // Some error occurred, check res.returnCode
    }
};
// Assuming client is an unconnected UDP Socket
SC_TRY(receiveAsync.start(eventLoop, client, {receivedData, sizeof(receivedData)}));

Member Function Documentation

start() [1/2]

Result SC::AsyncRequest::start

(

AsyncEventLoop &

eventLoop

)

Shortcut for AsyncEventLoop::start.

start() [2/2]

SC::Result SC::AsyncSocketReceive::start	(	AsyncEventLoop &	eventLoop,
		const SocketDescriptor &	descriptor,
		Span< char >	data )

Sets async request members and calls AsyncEventLoop::start.

---

The documentation for this struct was generated from the following file:

• Async.h