Struct Receiver 

pub struct Receiver<T, Codec = Json, const BUFFER: usize = remoc::::rch::mpsc::receiver::Receiver::{constant#0}, const MAX_ITEM_SIZE: usize = remoc::::rch::mpsc::receiver::Receiver::{constant#1}> { /* private fields */ }

Receive values from the associated Sender, which may be located on a remote endpoint.

Instances are created by the channel function.

Implementations

impl<T, Codec, const BUFFER: usize, const MAX_ITEM_SIZE: usize> Receiver<T, Codec, BUFFER, MAX_ITEM_SIZE>

pub async fn recv(&mut self) -> Result<Option<T>, RecvError>

Receives the next value for this receiver.

This function returns Ok(None) when all channel senders have been dropped.

When a receive error occurs due to a connection failure and other senders are still present, it is held back and returned after all other senders have been dropped or failed. Use error to check if such an error is present.

pub fn poll_recv( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<Option<T>, RecvError>>

Polls to receive the next message on this channel.

This function returns Poll::Ready(Ok(None)) when all channel senders have been dropped.

When a receive error occurs due to a connection failure and other senders are still present, it is held back and returned after all other senders have been dropped or failed. Use error to check if such an error is present.

pub fn try_recv(&mut self) -> Result<T, TryRecvError>

Tries to receive the next message on this channel, if one is immediately available.

This function returns Err(RecvError::Closed) when all channel senders have been dropped and Err(RecvError::Empty) if no value to receive is currently available.

When a receive error occurs due to a connection failure and other senders are still present, it is held back and returned after all other senders have been dropped or failed. Use error to check if such an error is present.

pub fn blocking_recv(&mut self) -> Result<Option<T>, RecvError>

Blocking receive to call outside of asynchronous contexts.

This function returns Ok(None) when the channel sender has been dropped.

Panics

This function panics if called within an asynchronous execution context.

pub fn close(&mut self)

Closes the receiving half of a channel without dropping it.

This allows to process outstanding values while stopping the sender from sending new values.

pub fn error(&self) -> &Option<RecvError>

Returns the first error that occurred during receiving due to a connection failure, but is being held back because other senders are still connected to this receiver.

Use take_error to clear it.

pub fn take_error(&mut self) -> Option<RecvError>

Returns the held back error and clears it.

See recv and error for details.

pub fn set_codec<NewCodec>(self) -> Receiver<T, NewCodec, BUFFER, MAX_ITEM_SIZE>

Sets the codec that will be used when sending this receiver to a remote endpoint.

pub fn set_buffer<const NEW_BUFFER: usize>( self, ) -> Receiver<T, Codec, NEW_BUFFER, MAX_ITEM_SIZE>

Sets the buffer size that will be used when sending this receiver to a remote endpoint.

pub fn max_item_size(&self) -> usize

The maximum item size in bytes.

pub fn set_max_item_size<const NEW_MAX_ITEM_SIZE: usize>( self, ) -> Receiver<T, Codec, BUFFER, NEW_MAX_ITEM_SIZE>

Sets the maximum item size in bytes.

pub fn remote_max_item_size(&self) -> Option<usize>

The maximum item size of the remote sender.

If this is larger than max_item_size sending of oversized items will succeed but receiving will fail with a MaxItemSizeExceeded error.

impl<T, Codec, const BUFFER: usize, const MAX_ITEM_SIZE: usize> Receiver<T, Codec, BUFFER, MAX_ITEM_SIZE>

where T: RemoteSend + Clone, Codec: Codec,

pub fn distribute( self, wait_on_empty: bool, ) -> Distributor<T, Codec, BUFFER, MAX_ITEM_SIZE>

Distribute received items over multiple receivers.

Each value is received by one of the receivers.

If wait_on_empty is true, the distributor waits if all subscribers are closed. Otherwise it terminates.

Trait Implementations

impl<T, Codec, const BUFFER: usize, const MAX_ITEM_SIZE: usize> Debug for Receiver<T, Codec, BUFFER, MAX_ITEM_SIZE>

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

Formats the value using the given formatter.

impl<'de, T, Codec, const BUFFER: usize, const MAX_ITEM_SIZE: usize> Deserialize<'de> for Receiver<T, Codec, BUFFER, MAX_ITEM_SIZE>

where T: RemoteSend, Codec: Codec,

fn deserialize<D>( deserializer: D, ) -> Result<Receiver<T, Codec, BUFFER, MAX_ITEM_SIZE>, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserializes the receiver after it has been received over a chmux channel.

impl<T, Codec, const BUFFER: usize, const MAX_ITEM_SIZE: usize> Drop for Receiver<T, Codec, BUFFER, MAX_ITEM_SIZE>

fn drop(&mut self)

Executes the destructor for this type.

impl<T, Codec, const BUFFER: usize, const MAX_ITEM_SIZE: usize> Serialize for Receiver<T, Codec, BUFFER, MAX_ITEM_SIZE>

where T: RemoteSend, Codec: Codec,

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

where S: Serializer,

Serializes this receiver for sending over a chmux channel.

impl<T, Codec, const BUFFER: usize, const MAX_ITEM_SIZE: usize> Stream for Receiver<T, Codec, BUFFER, MAX_ITEM_SIZE>

type Item = Result<T, RecvError>

Values yielded by the stream.

fn poll_next( self: Pin<&mut Receiver<T, Codec, BUFFER, MAX_ITEM_SIZE>>, cx: &mut Context<'_>, ) -> Poll<Option<<Receiver<T, Codec, BUFFER, MAX_ITEM_SIZE> as Stream>::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.

impl<T, Codec, const BUFFER: usize, const MAX_ITEM_SIZE: usize> Unpin for Receiver<T, Codec, BUFFER, MAX_ITEM_SIZE>