Struct rumqttlog::Receiver

pub struct Receiver<T> { /* fields omitted */ }

The receiving side of a channel.

Receivers can be cloned and shared among threads. When all receivers associated with a channel are dropped, the channel becomes closed.

The channel can also be closed manually by calling Receiver::close().

Receivers implement the [Stream] trait.

Implementations

impl<T> Receiver<T>

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

Attempts to receive a message from the channel.

If the channel is empty or closed, this method returns an error.

Examples

use jackiechan::{bounded, TryRecvError};

let (s, r) = bounded(10);
assert_eq!(s.send(1), Ok(()));

assert_eq!(r.try_recv(), Ok(1));
assert_eq!(r.try_recv(), Err(TryRecvError::Empty));

drop(s);
assert_eq!(r.try_recv(), Err(TryRecvError::Closed));

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

Receives a message from the channel.

If the channel is empty, this method waits until there is a message.

If the channel is closed, this method receives a message or returns an error if there are no more messages.

Examples

use jackiechan::{bounded, RecvError};

let (s, r) = bounded(10);

assert_eq!(s.send(1), Ok(()));
drop(s);

assert_eq!(r.recv(), Ok(1));
assert_eq!(r.recv(), Err(RecvError));

pub fn recv_timeout(&self, timeout: Duration) -> Result<T, RecvTimeoutError>

Receives a message from the channel.

If the channel is empty, this method waits until there is a message.

If the channel is closed, this method receives a message or returns an error if there are no more messages.

Examples

use jackiechan::{bounded, RecvTimeoutError};
use std::time::Duration;

let (s, r) = bounded(10);

assert_eq!(s.send(1), Ok(()));
assert_eq!(r.recv_timeout(Duration::from_secs(1)), Ok(1));
assert_eq!(r.recv_timeout(Duration::from_secs(1)), Err(RecvTimeoutError::Timeout));

pub fn recv_deadline(&self, deadline: Instant) -> Result<T, RecvTimeoutError>

Receives a message from the channel.

If the channel is empty, this method waits until there is a message.

If the channel is closed, this method receives a message or returns an error if there are no more messages.

Examples

use jackiechan::{bounded, RecvTimeoutError};
use std::time::{Instant, Duration};

let (s, r) = bounded(10);

assert_eq!(s.send(1), Ok(()));

assert_eq!(r.recv_deadline(Instant::now() + Duration::from_secs(1)), Ok(1));
assert_eq!(r.recv_deadline(Instant::now() + Duration::from_secs(1)), Err(RecvTimeoutError::Timeout));

pub async fn async_recv(&'_ self) -> Result<T, RecvError>

Receives a message from the channel. If the channel is empty, this method waits until there is a message.

If the channel is closed, this method receives a message or returns an error if there are no more messages.

pub fn close(&self) -> bool

Closes the channel.

Returns true if this call has closed the channel and it was not closed already.

The remaining messages can still be received.

Examples

use jackiechan::{bounded, RecvError};

let (s, r) = bounded(10);
assert_eq!(s.send(1), Ok(()));

assert!(r.close());
assert_eq!(r.recv(), Ok(1));
assert_eq!(r.recv(), Err(RecvError));

pub fn is_closed(&self) -> bool

Returns true if the channel is closed.

Examples

use jackiechan::{bounded, RecvError};

let (s, r) = bounded::<()>(10);
assert!(!r.is_closed());

drop(s);
assert!(r.is_closed());

pub fn is_empty(&self) -> bool

Returns true if the channel is empty.

Examples

use jackiechan::bounded;

let (s, r) = bounded(10);

assert!(s.is_empty());
s.send(1);
assert!(!s.is_empty());

pub fn is_full(&self) -> bool

Returns true if the channel is full.

Examples

use jackiechan::bounded;

let (s, r) = bounded(1);

assert!(!r.is_full());
s.send(1);
assert!(r.is_full());

pub fn len(&self) -> usize

Returns the number of messages in the channel.

Examples

use jackiechan::bounded;

let (s, r) = bounded(10);
assert_eq!(r.len(), 0);

s.send(1);
s.send(2);
assert_eq!(r.len(), 2);

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

Returns the channel capacity if it’s bounded.

Examples

use jackiechan::{bounded};

let (s, r) = bounded::<i32>(5);
assert_eq!(r.capacity(), Some(5));

pub fn receiver_count(&self) -> usize

Returns the number of receivers for the channel.

Examples

use jackiechan::bounded;

let (s, r) = bounded::<()>(10);
assert_eq!(r.receiver_count(), 1);

let r2 = r.clone();
assert_eq!(r.receiver_count(), 2);

pub fn sender_count(&self) -> usize

Returns the number of senders for the channel.

Examples

use jackiechan::bounded;

let (s, r) = bounded::<()>(10);
assert_eq!(r.sender_count(), 1);

let s2 = s.clone();
assert_eq!(r.sender_count(), 2);

Trait Implementations

impl<T> Clone for Receiver<T>

pub fn clone(&self) -> Receiver<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for Receiver<T>

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

Formats the value using the given formatter.

impl<T> Drop for Receiver<T>

pub fn drop(&mut self)

Executes the destructor for this type.

impl<T> Stream for Receiver<T>

type Item = T

Values yielded by the stream.

pub fn poll_next(
    self: Pin<&mut Receiver<T>>,
    cx: &mut Context<'_>
) -> Poll<Option<<Receiver<T> 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.