Struct ResponseDispatchNotifier

pub struct ResponseDispatchNotifier<R> { /* private fields */ }

A response wrapper that notifies after response has been sent.

Sometimes in interface method implemenations we need to do some other work after the response has been sent off. This wrapper type allows us to do that. Instead of returning your intended response type directly, wrap it in this type and return it from your method. The returned EventListener from new method will be notified when the response has been sent.

A typical use case is sending off signals after the response has been sent. The easiest way to do that is to spawn a task from the method that sends the signal but only after being notified of the response dispatch.

Caveats

The notification indicates that the response has been sent off, not that destination peer has received it. That can only be guaranteed for a peer-to-peer connection.

Implementations

impl<R> ResponseDispatchNotifier<R>

pub fn new(response: R) -> (Self, EventListener)

Create a new NotifyResponse.

pub fn response(&self) -> &R

Get the response.

Trait Implementations

impl<R: Debug> Debug for ResponseDispatchNotifier<R>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, R> Deserialize<'de> for ResponseDispatchNotifier<R>

where R: Deserialize<'de>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Drop for ResponseDispatchNotifier<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<R> Serialize for ResponseDispatchNotifier<R>

where R: Serialize,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<R> Type for ResponseDispatchNotifier<R>

where R: Type,

fn signature() -> Signature<'static>

Get the signature for the implementing type.