pub struct Receiver<T, R = DefaultRecycle> { /* private fields */ }
std
only.Expand description
Synchronously sends values to an associated Receiver
.
Instances of this struct are created by the channel
and
with_recycle
functions.
Implementations§
source§impl<T, R> Receiver<T, R>
impl<T, R> Receiver<T, R>
sourcepub fn recv_ref(&self) -> Option<RecvRef<'_, T>>
pub fn recv_ref(&self) -> Option<RecvRef<'_, T>>
Receives the next message for this receiver, by reference.
This method returns None
if the channel has been closed and there are
no remaining messages in the channel’s buffer. This indicates that no
further values can ever be received from this Receiver
. The channel is
closed when all Sender
s have been dropped.
If there are no messages in the channel’s buffer, but the channel has not yet been closed, this method will block until a message is sent or the channel is closed.
This method returns a RecvRef
that can be used to read from (or
mutate) the received message by reference. When the RecvRef
is
dropped, the receive operation completes and the slot occupied by
the received message becomes usable for a future send_ref
operation.
If all Sender
s for this channel write to the channel’s slots in
place by using the send_ref
or try_send_ref
methods, this
method allows messages that own heap allocations to be reused in
place.
§Examples
use thingbuf::mpsc::blocking;
use std::{thread, fmt::Write};
let (tx, rx) = blocking::channel::<String>(100);
thread::spawn(move || {
let mut value = tx.send_ref().unwrap();
write!(value, "hello world!")
.expect("writing to a `String` should never fail");
});
assert_eq!(Some("hello world!"), rx.recv_ref().as_deref().map(String::as_str));
assert_eq!(None, rx.recv().as_deref());
Values are buffered:
use thingbuf::mpsc::blocking;
use std::fmt::Write;
let (tx, rx) = blocking::channel::<String>(100);
write!(tx.send_ref().unwrap(), "hello").unwrap();
write!(tx.send_ref().unwrap(), "world").unwrap();
assert_eq!("hello", rx.recv_ref().unwrap().as_str());
assert_eq!("world", rx.recv_ref().unwrap().as_str());
sourcepub fn recv(&self) -> Option<T>where
R: Recycle<T>,
pub fn recv(&self) -> Option<T>where
R: Recycle<T>,
Receives the next message for this receiver, by value.
This method returns None
if the channel has been closed and there are
no remaining messages in the channel’s buffer. This indicates that no
further values can ever be received from this Receiver
. The channel is
closed when all Sender
s have been dropped.
If there are no messages in the channel’s buffer, but the channel has not yet been closed, this method will block until a message is sent or the channel is closed.
When a message is received, it is moved out of the channel by value,
and replaced with a new slot according to the configured recycling
policy. If all Sender
s for this channel write to the channel’s
slots in place by using the send_ref
or try_send_ref
methods,
consider using the recv_ref
method instead, to enable the
reuse of heap allocations.
§Examples
use thingbuf::mpsc::blocking;
use std::{thread, fmt::Write};
let (tx, rx) = blocking::channel(100);
thread::spawn(move || {
tx.send(1).unwrap();
});
assert_eq!(Some(1), rx.recv());
assert_eq!(None, rx.recv());
Values are buffered:
use thingbuf::mpsc::blocking;
let (tx, rx) = blocking::channel(100);
tx.send(1).unwrap();
tx.send(2).unwrap();
assert_eq!(Some(1), rx.recv());
assert_eq!(Some(2), rx.recv());
sourcepub fn recv_ref_timeout(
&self,
timeout: Duration
) -> Result<RecvRef<'_, T>, RecvTimeoutError>
Available on non-loom
only.
pub fn recv_ref_timeout( &self, timeout: Duration ) -> Result<RecvRef<'_, T>, RecvTimeoutError>
loom
only.Receives the next message for this receiver, by reference, waiting for at most timeout
.
If there are no messages in the channel’s buffer, but the channel has
not yet been closed, this method will block until a message is sent,
the channel is closed, or the provided timeout
has elapsed.
§Returns
Ok
(
RecvRef
<T>)
if a message was received.Err
(
RecvTimeoutError::Timeout
)
if the timeout has elapsed.Err
(
RecvTimeoutError::Closed
)
if the channel has closed.
§Examples
use thingbuf::mpsc::{blocking, errors::RecvTimeoutError};
use std::{thread, fmt::Write, time::Duration};
let (tx, rx) = blocking::channel::<String>(100);
thread::spawn(move || {
thread::sleep(Duration::from_millis(600));
let mut value = tx.send_ref().unwrap();
write!(value, "hello world!")
.expect("writing to a `String` should never fail");
});
assert_eq!(
Err(&RecvTimeoutError::Timeout),
rx.recv_ref_timeout(Duration::from_millis(400)).as_deref().map(String::as_str)
);
assert_eq!(
Ok("hello world!"),
rx.recv_ref_timeout(Duration::from_millis(400)).as_deref().map(String::as_str)
);
assert_eq!(
Err(&RecvTimeoutError::Closed),
rx.recv_ref_timeout(Duration::from_millis(400)).as_deref().map(String::as_str)
);
sourcepub fn recv_timeout(&self, timeout: Duration) -> Result<T, RecvTimeoutError>where
R: Recycle<T>,
Available on non-loom
only.
pub fn recv_timeout(&self, timeout: Duration) -> Result<T, RecvTimeoutError>where
R: Recycle<T>,
loom
only.Receives the next message for this receiver, by value, waiting for at most timeout
.
If there are no messages in the channel’s buffer, but the channel
has not yet been closed, this method will block until a message is
sent, the channel is closed, or the provided timeout
has elapsed.
When a message is received, it is moved out of the channel by value,
and replaced with a new slot according to the configured recycling
policy. If all Sender
s for this channel write to the
channel’s slots in place by using the send_ref
or
try_send_ref
methods, consider using the recv_ref_timeout
method instead, to enable the reuse of heap allocations.
§Returns
Ok
(<T>)
if a message was received.Err
(
RecvTimeoutError::Timeout
)
if the timeout has elapsed.Err
(
RecvTimeoutError::Closed
)
if the channel has closed.
§Examples
use thingbuf::mpsc::{blocking, errors::RecvTimeoutError};
use std::{thread, fmt::Write, time::Duration};
let (tx, rx) = blocking::channel(100);
thread::spawn(move || {
thread::sleep(Duration::from_millis(600));
tx.send(1).unwrap();
});
assert_eq!(
Err(RecvTimeoutError::Timeout),
rx.recv_timeout(Duration::from_millis(400))
);
assert_eq!(
Ok(1),
rx.recv_timeout(Duration::from_millis(400))
);
assert_eq!(
Err(RecvTimeoutError::Closed),
rx.recv_timeout(Duration::from_millis(400))
);
sourcepub fn try_recv_ref(&self) -> Result<RecvRef<'_, T>, TryRecvError>
pub fn try_recv_ref(&self) -> Result<RecvRef<'_, T>, TryRecvError>
Attempts to receive the next message for this receiver by reference without blocking.
This method differs from recv_ref
by returning immediately if the
channel is empty or closed.
§Errors
This method returns an error when the channel is closed or there are no remaining messages in the channel’s buffer.
§Examples
use thingbuf::mpsc::{blocking, errors::TryRecvError};
let (tx, rx) = blocking::channel(100);
assert!(matches!(rx.try_recv_ref(), Err(TryRecvError::Empty)));
tx.send(1).unwrap();
drop(tx);
assert_eq!(*rx.try_recv_ref().unwrap(), 1);
assert!(matches!(rx.try_recv_ref(), Err(TryRecvError::Closed)));
sourcepub fn try_recv(&self) -> Result<T, TryRecvError>where
R: Recycle<T>,
pub fn try_recv(&self) -> Result<T, TryRecvError>where
R: Recycle<T>,
Attempts to receive the next message for this receiver by value without blocking.
This method differs from recv
by returning immediately if the
channel is empty or closed.
§Errors
This method returns an error when the channel is closed or there are no remaining messages in the channel’s buffer.
§Examples
use thingbuf::mpsc::{blocking, errors::TryRecvError};
let (tx, rx) = blocking::channel(100);
assert_eq!(rx.try_recv(), Err(TryRecvError::Empty));
tx.send(1).unwrap();
drop(tx);
assert_eq!(rx.try_recv().unwrap(), 1);
assert_eq!(rx.try_recv(), Err(TryRecvError::Closed));
sourcepub fn is_closed(&self) -> bool
pub fn is_closed(&self) -> bool
Returns true
if the channel has closed (all corresponding
Sender
s have been dropped).
If this method returns true
, no new messages will become available
on this channel. Previously sent messages may still be available.
sourcepub fn capacity(&self) -> usize
pub fn capacity(&self) -> usize
Returns the total capacity of the channel for this Receiver
.
This includes both occupied and unoccupied entries.
To determine the channel’s remaining unoccupied capacity, use
remaining
instead.
§Examples
use thingbuf::mpsc::blocking::channel;
let (_, rx) = channel::<usize>(100);
assert_eq!(rx.capacity(), 100);
Even after sending several messages, the capacity remains the same:
let (tx, rx) = channel::<usize>(100);
*tx.try_send_ref().unwrap() = 1;
*tx.try_send_ref().unwrap() = 2;
*tx.try_send_ref().unwrap() = 3;
assert_eq!(rx.capacity(), 100);
sourcepub fn remaining(&self) -> usize
pub fn remaining(&self) -> usize
Returns the unoccupied capacity of the channel for this Receiver
(i.e., how many additional elements can be sent before the channel
will be full).
This is equivalent to subtracting the channel’s len
from its capacity
.
§Examples
use thingbuf::mpsc::blocking::channel;
let (tx, rx) = channel::<usize>(100);
assert_eq!(rx.remaining(), 100);
*tx.try_send_ref().unwrap() = 1;
*tx.try_send_ref().unwrap() = 2;
*tx.try_send_ref().unwrap() = 3;
assert_eq!(rx.remaining(), 97);
let _ = rx.try_recv_ref().unwrap();
assert_eq!(rx.remaining(), 98)
sourcepub fn len(&self) -> usize
pub fn len(&self) -> usize
Returns the number of elements in the channel of this Receiver
.
To determine the channel’s remaining unoccupied capacity, use
remaining
instead.
§Examples
use thingbuf::mpsc::blocking::channel;
let (tx, rx) = channel::<usize>(100);
assert_eq!(rx.len(), 0);
*tx.try_send_ref().unwrap() = 1;
*tx.try_send_ref().unwrap() = 2;
*tx.try_send_ref().unwrap() = 3;
assert_eq!(rx.len(), 3);
let _ = rx.try_recv_ref().unwrap();
assert_eq!(rx.len(), 2);
Trait Implementations§
source§impl<'a, T, R> Iterator for &'a Receiver<T, R>
impl<'a, T, R> Iterator for &'a Receiver<T, R>
source§fn next(&mut self) -> Option<Self::Item>
fn next(&mut self) -> Option<Self::Item>
source§fn next_chunk<const N: usize>(
&mut self
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where
Self: Sized,
fn next_chunk<const N: usize>(
&mut self
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where
Self: Sized,
iter_next_chunk
)N
values. Read more1.0.0 · source§fn size_hint(&self) -> (usize, Option<usize>)
fn size_hint(&self) -> (usize, Option<usize>)
1.0.0 · source§fn count(self) -> usizewhere
Self: Sized,
fn count(self) -> usizewhere
Self: Sized,
1.0.0 · source§fn last(self) -> Option<Self::Item>where
Self: Sized,
fn last(self) -> Option<Self::Item>where
Self: Sized,
source§fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
iter_advance_by
)n
elements. Read more1.0.0 · source§fn nth(&mut self, n: usize) -> Option<Self::Item>
fn nth(&mut self, n: usize) -> Option<Self::Item>
n
th element of the iterator. Read more1.28.0 · source§fn step_by(self, step: usize) -> StepBy<Self>where
Self: Sized,
fn step_by(self, step: usize) -> StepBy<Self>where
Self: Sized,
1.0.0 · source§fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
1.0.0 · source§fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
Self: Sized,
U: IntoIterator,
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
Self: Sized,
U: IntoIterator,
source§fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
iter_intersperse
)separator
between adjacent items of the original iterator. Read more1.0.0 · source§fn map<B, F>(self, f: F) -> Map<Self, F>
fn map<B, F>(self, f: F) -> Map<Self, F>
1.0.0 · source§fn filter<P>(self, predicate: P) -> Filter<Self, P>
fn filter<P>(self, predicate: P) -> Filter<Self, P>
1.0.0 · source§fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
1.0.0 · source§fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
1.0.0 · source§fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
1.0.0 · source§fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
1.57.0 · source§fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
1.0.0 · source§fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
n
elements. Read more1.0.0 · source§fn take(self, n: usize) -> Take<Self>where
Self: Sized,
fn take(self, n: usize) -> Take<Self>where
Self: Sized,
n
elements, or fewer
if the underlying iterator ends sooner. Read more1.0.0 · source§fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
source§fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
iter_map_windows
)f
for each contiguous window of size N
over
self
and returns an iterator over the outputs of f
. Like slice::windows()
,
the windows during mapping overlap as well. Read more1.0.0 · source§fn inspect<F>(self, f: F) -> Inspect<Self, F>
fn inspect<F>(self, f: F) -> Inspect<Self, F>
1.0.0 · source§fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
source§fn collect_into<E>(self, collection: &mut E) -> &mut E
fn collect_into<E>(self, collection: &mut E) -> &mut E
iter_collect_into
)1.0.0 · source§fn partition<B, F>(self, f: F) -> (B, B)
fn partition<B, F>(self, f: F) -> (B, B)
source§fn is_partitioned<P>(self, predicate: P) -> bool
fn is_partitioned<P>(self, predicate: P) -> bool
iter_is_partitioned
)true
precede all those that return false
. Read more1.27.0 · source§fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
1.27.0 · source§fn try_for_each<F, R>(&mut self, f: F) -> R
fn try_for_each<F, R>(&mut self, f: F) -> R
1.0.0 · source§fn fold<B, F>(self, init: B, f: F) -> B
fn fold<B, F>(self, init: B, f: F) -> B
1.51.0 · source§fn reduce<F>(self, f: F) -> Option<Self::Item>
fn reduce<F>(self, f: F) -> Option<Self::Item>
source§fn try_reduce<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
fn try_reduce<F, R>( &mut self, f: F ) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
iterator_try_reduce
)1.0.0 · source§fn all<F>(&mut self, f: F) -> bool
fn all<F>(&mut self, f: F) -> bool
1.0.0 · source§fn any<F>(&mut self, f: F) -> bool
fn any<F>(&mut self, f: F) -> bool
1.0.0 · source§fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
1.30.0 · source§fn find_map<B, F>(&mut self, f: F) -> Option<B>
fn find_map<B, F>(&mut self, f: F) -> Option<B>
source§fn try_find<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
fn try_find<F, R>( &mut self, f: F ) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
try_find
)1.0.0 · source§fn position<P>(&mut self, predicate: P) -> Option<usize>
fn position<P>(&mut self, predicate: P) -> Option<usize>
1.6.0 · source§fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
1.15.0 · source§fn max_by<F>(self, compare: F) -> Option<Self::Item>
fn max_by<F>(self, compare: F) -> Option<Self::Item>
1.6.0 · source§fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
1.15.0 · source§fn min_by<F>(self, compare: F) -> Option<Self::Item>
fn min_by<F>(self, compare: F) -> Option<Self::Item>
1.0.0 · source§fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
1.36.0 · source§fn copied<'a, T>(self) -> Copied<Self>
fn copied<'a, T>(self) -> Copied<Self>
source§fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where
Self: Sized,
fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where
Self: Sized,
iter_array_chunks
)N
elements of the iterator at a time. Read more1.11.0 · source§fn product<P>(self) -> P
fn product<P>(self) -> P
source§fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
iter_order_by
)Iterator
with those
of another with respect to the specified comparison function. Read more1.5.0 · source§fn partial_cmp<I>(self, other: I) -> Option<Ordering>
fn partial_cmp<I>(self, other: I) -> Option<Ordering>
PartialOrd
elements of
this Iterator
with those of another. The comparison works like short-circuit
evaluation, returning a result without comparing the remaining elements.
As soon as an order can be determined, the evaluation stops and a result is returned. Read moresource§fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
iter_order_by
)Iterator
with those
of another with respect to the specified comparison function. Read moresource§fn eq_by<I, F>(self, other: I, eq: F) -> bool
fn eq_by<I, F>(self, other: I, eq: F) -> bool
iter_order_by
)1.5.0 · source§fn lt<I>(self, other: I) -> bool
fn lt<I>(self, other: I) -> bool
Iterator
are lexicographically
less than those of another. Read more1.5.0 · source§fn le<I>(self, other: I) -> bool
fn le<I>(self, other: I) -> bool
Iterator
are lexicographically
less or equal to those of another. Read more1.5.0 · source§fn gt<I>(self, other: I) -> bool
fn gt<I>(self, other: I) -> bool
Iterator
are lexicographically
greater than those of another. Read more1.5.0 · source§fn ge<I>(self, other: I) -> bool
fn ge<I>(self, other: I) -> bool
Iterator
are lexicographically
greater than or equal to those of another. Read moresource§fn is_sorted_by<F>(self, compare: F) -> bool
fn is_sorted_by<F>(self, compare: F) -> bool
is_sorted
)source§fn is_sorted_by_key<F, K>(self, f: F) -> bool
fn is_sorted_by_key<F, K>(self, f: F) -> bool
is_sorted
)