Awaiter for suspending a coroutine until a network message arrives. More...

#include <NetworkAwaiter.hpp>

Inheritance diagram for MayaFlux::Kriya::NetworkAwaiter:

Collaboration diagram for MayaFlux::Kriya::NetworkAwaiter:

Public Member Functions
bool	await_ready ()
	Check if a message is already queued.

Core::NetworkMessage	await_resume ()
	Return the received message on resume.

void	await_suspend (std::coroutine_handle<> handle)
	Suspend the coroutine and register with the source.

void	deliver (const Core::NetworkMessage &message)
	Called by NetworkSource::signal() with the incoming message.

bool	filter_matches (const void *) const override
	NetworkAwaiter has no filter semantics.

	NetworkAwaiter (const NetworkAwaiter &)=delete

	NetworkAwaiter (NetworkAwaiter &&) noexcept=default

	NetworkAwaiter (Vruta::NetworkSource &source)

NetworkAwaiter &	operator= (const NetworkAwaiter &)=delete

NetworkAwaiter &	operator= (NetworkAwaiter &&) noexcept=delete

void	try_resume (const void *) override
	NetworkAwaiter is driven by deliver(), not dispatch().

	~NetworkAwaiter () override

Public Member Functions inherited from MayaFlux::Kriya::EventAwaiter
	EventAwaiter ()=default

	EventAwaiter (const EventAwaiter &)=delete

	EventAwaiter (EventAwaiter &&) noexcept=default

EventAwaiter &	operator= (const EventAwaiter &)=delete

EventAwaiter &	operator= (EventAwaiter &&) noexcept=default

virtual	~EventAwaiter ()=default

Private Attributes
std::atomic< NetworkAwaiter * >	m_next { nullptr }
	Intrusive list link for lock-free waiter broadcast.

Core::NetworkMessage	m_result

Vruta::NetworkSource &	m_source

Friends
class	Vruta::NetworkSource

Additional Inherited Members
Protected Attributes inherited from MayaFlux::Kriya::EventAwaiter
std::coroutine_handle	m_handle

bool	m_is_suspended {}

Detailed Description

Awaiter for suspending a coroutine until a network message arrives.

Follows the same structural pattern as EventAwaiter. Works with any coroutine type: SoundRoutine, GraphicsRoutine, Event, ComplexRoutine.

Multiple awaiters may register against the same NetworkSource simultaneously. signal() delivers a copy of the message directly to each awaiter — no shared queue contention between waiters.

The queue on NetworkSource is used only by await_ready() for the no-suspend fast path. Once suspended, the awaiter receives its message via deliver() called directly from NetworkSource::signal().

The awaiter does not own the NetworkSource. The source must outlive any suspended awaiter.

Vruta::NetworkSource source({ .transport = NetworkTransport::UDP, .local_port = 8000 });
 
auto routine = [&source]() -> Vruta::Event {
    while (true) {
        auto msg = co_await source.next_message();
        process(msg.data);
    }
};

Definition at line 38 of file NetworkAwaiter.hpp.

The documentation for this class was generated from the following files:

Public Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description