Struct reqwest_dav::re_exports::tokio::sync::futures::Notified
source · [−]pub struct Notified<'a> { /* private fields */ }
Expand description
Future returned from Notify::notified()
.
This future is fused, so once it has completed, any future calls to poll
will immediately return Poll::Ready
.
Implementations
sourceimpl Notified<'_>
impl Notified<'_>
sourcepub fn enable(self: Pin<&mut Notified<'_>>) -> bool
pub fn enable(self: Pin<&mut Notified<'_>>) -> bool
Adds this future to the list of futures that are ready to receive
wakeups from calls to notify_one
.
Polling the future also adds it to the list, so this method should only
be used if you want to add the future to the list before the first call
to poll
. (In fact, this method is equivalent to calling poll
except
that no Waker
is registered.)
This has no effect on notifications sent using notify_waiters
, which
are received as long as they happen after the creation of the Notified
regardless of whether enable
or poll
has been called.
This method returns true if the Notified
is ready. This happens in the
following situations:
- The
notify_waiters
method was called between the creation of theNotified
and the call to this method. - This is the first call to
enable
orpoll
on this future, and theNotify
was holding a permit from a previous call tonotify_one
. The call consumes the permit in that case. - The future has previously been enabled or polled, and it has since
then been marked ready by either consuming a permit from the
Notify
, or by a call tonotify_one
ornotify_waiters
that removed it from the list of futures ready to receive wakeups.
If this method returns true, any future calls to poll on the same future
will immediately return Poll::Ready
.
Examples
Unbound multi-producer multi-consumer (mpmc) channel.
The call to enable
is important because otherwise if you have two
calls to recv
and two calls to send
in parallel, the following could
happen:
- Both calls to
try_recv
returnNone
. - Both new elements are added to the vector.
- The
notify_one
method is called twice, adding only a single permit to theNotify
. - Both calls to
recv
reach theNotified
future. One of them consumes the permit, and the other sleeps forever.
By adding the Notified
futures to the list by calling enable
before
try_recv
, the notify_one
calls in step three would remove the
futures from the list and mark them notified instead of adding a permit
to the Notify
. This ensures that both futures are woken.
use tokio::sync::Notify;
use std::collections::VecDeque;
use std::sync::Mutex;
struct Channel<T> {
messages: Mutex<VecDeque<T>>,
notify_on_sent: Notify,
}
impl<T> Channel<T> {
pub fn send(&self, msg: T) {
let mut locked_queue = self.messages.lock().unwrap();
locked_queue.push_back(msg);
drop(locked_queue);
// Send a notification to one of the calls currently
// waiting in a call to `recv`.
self.notify_on_sent.notify_one();
}
pub fn try_recv(&self) -> Option<T> {
let mut locked_queue = self.messages.lock().unwrap();
locked_queue.pop_front()
}
pub async fn recv(&self) -> T {
let future = self.notify_on_sent.notified();
tokio::pin!(future);
loop {
// Make sure that no wakeup is lost if we get
// `None` from `try_recv`.
future.as_mut().enable();
if let Some(msg) = self.try_recv() {
return msg;
}
// Wait for a call to `notify_one`.
//
// This uses `.as_mut()` to avoid consuming the future,
// which lets us call `Pin::set` below.
future.as_mut().await;
// Reset the future in case another call to
// `try_recv` got the message before us.
future.set(self.notify_on_sent.notified());
}
}
}
Trait Implementations
impl<'a> Send for Notified<'a>
impl<'a> Sync for Notified<'a>
Auto Trait Implementations
impl<'a> !RefUnwindSafe for Notified<'a>
impl<'a> !Unpin for Notified<'a>
impl<'a> !UnwindSafe for Notified<'a>
Blanket Implementations
sourceimpl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
impl<T> FutureExt for Twhere
T: Future + ?Sized,
impl<T> FutureExt for Twhere
T: Future + ?Sized,
fn map<U, F>(self, f: F) -> Map<Self, F>ⓘNotable traits for Map<Fut, F>impl<Fut, F> Future for Map<Fut, F>where
Map<Fut, F>: Future, type Output = <Map<Fut, F> as Future>::Output;
where
F: FnOnce(Self::Output) -> U,
fn map<U, F>(self, f: F) -> Map<Self, F>ⓘNotable traits for Map<Fut, F>impl<Fut, F> Future for Map<Fut, F>where
Map<Fut, F>: Future, type Output = <Map<Fut, F> as Future>::Output;
where
F: FnOnce(Self::Output) -> U,
Map<Fut, F>: Future, type Output = <Map<Fut, F> as Future>::Output;
Map this future’s output to a different type, returning a new future of the resulting type. Read more
fn map_into<U>(self) -> MapInto<Self, U>ⓘNotable traits for MapInto<Fut, T>impl<Fut, T> Future for MapInto<Fut, T>where
Map<Fut, IntoFn<T>>: Future, type Output = <Map<Fut, IntoFn<T>> as Future>::Output;
where
Self::Output: Into<U>,
fn map_into<U>(self) -> MapInto<Self, U>ⓘNotable traits for MapInto<Fut, T>impl<Fut, T> Future for MapInto<Fut, T>where
Map<Fut, IntoFn<T>>: Future, type Output = <Map<Fut, IntoFn<T>> as Future>::Output;
where
Self::Output: Into<U>,
Map<Fut, IntoFn<T>>: Future, type Output = <Map<Fut, IntoFn<T>> as Future>::Output;
Map this future’s output to a different type, returning a new future of the resulting type. Read more
fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F>ⓘNotable traits for Then<Fut1, Fut2, F>impl<Fut1, Fut2, F> Future for Then<Fut1, Fut2, F>where
Flatten<Map<Fut1, F>, Fut2>: Future, type Output = <Flatten<Map<Fut1, F>, Fut2> as Future>::Output;
where
F: FnOnce(Self::Output) -> Fut,
Fut: Future,
fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F>ⓘNotable traits for Then<Fut1, Fut2, F>impl<Fut1, Fut2, F> Future for Then<Fut1, Fut2, F>where
Flatten<Map<Fut1, F>, Fut2>: Future, type Output = <Flatten<Map<Fut1, F>, Fut2> as Future>::Output;
where
F: FnOnce(Self::Output) -> Fut,
Fut: Future,
Flatten<Map<Fut1, F>, Fut2>: Future, type Output = <Flatten<Map<Fut1, F>, Fut2> as Future>::Output;
Chain on a computation for when a future finished, passing the result of
the future to the provided closure f
. Read more
fn left_future<B>(self) -> Either<Self, B>ⓘNotable traits for Either<A, B>impl<A, B> Future for Either<A, B>where
A: Future,
B: Future<Output = <A as Future>::Output>, type Output = <A as Future>::Output;
where
B: Future<Output = Self::Output>,
fn left_future<B>(self) -> Either<Self, B>ⓘNotable traits for Either<A, B>impl<A, B> Future for Either<A, B>where
A: Future,
B: Future<Output = <A as Future>::Output>, type Output = <A as Future>::Output;
where
B: Future<Output = Self::Output>,
A: Future,
B: Future<Output = <A as Future>::Output>, type Output = <A as Future>::Output;
Wrap this future in an Either
future, making it the left-hand variant
of that Either
. Read more
fn right_future<A>(self) -> Either<A, Self>ⓘNotable traits for Either<A, B>impl<A, B> Future for Either<A, B>where
A: Future,
B: Future<Output = <A as Future>::Output>, type Output = <A as Future>::Output;
where
A: Future<Output = Self::Output>,
fn right_future<A>(self) -> Either<A, Self>ⓘNotable traits for Either<A, B>impl<A, B> Future for Either<A, B>where
A: Future,
B: Future<Output = <A as Future>::Output>, type Output = <A as Future>::Output;
where
A: Future<Output = Self::Output>,
A: Future,
B: Future<Output = <A as Future>::Output>, type Output = <A as Future>::Output;
Wrap this future in an Either
future, making it the right-hand variant
of that Either
. Read more
fn into_stream(self) -> IntoStream<Self>
fn into_stream(self) -> IntoStream<Self>
Convert this future into a single element stream. Read more
fn flatten(self) -> Flatten<Self>ⓘNotable traits for Flatten<F>impl<F> Future for Flatten<F>where
F: Future,
Flatten<F, <F as Future>::Output>: Future, type Output = <Flatten<F, <F as Future>::Output> as Future>::Output;
where
Self::Output: Future,
fn flatten(self) -> Flatten<Self>ⓘNotable traits for Flatten<F>impl<F> Future for Flatten<F>where
F: Future,
Flatten<F, <F as Future>::Output>: Future, type Output = <Flatten<F, <F as Future>::Output> as Future>::Output;
where
Self::Output: Future,
F: Future,
Flatten<F, <F as Future>::Output>: Future, type Output = <Flatten<F, <F as Future>::Output> as Future>::Output;
Flatten the execution of this future when the output of this future is itself another future. Read more
fn flatten_stream(self) -> FlattenStream<Self>where
Self::Output: Stream,
fn flatten_stream(self) -> FlattenStream<Self>where
Self::Output: Stream,
Flatten the execution of this future when the successful result of this future is a stream. Read more
fn fuse(self) -> Fuse<Self>ⓘNotable traits for Fuse<Fut>impl<Fut> Future for Fuse<Fut>where
Fut: Future, type Output = <Fut as Future>::Output;
fn fuse(self) -> Fuse<Self>ⓘNotable traits for Fuse<Fut>impl<Fut> Future for Fuse<Fut>where
Fut: Future, type Output = <Fut as Future>::Output;
Fut: Future, type Output = <Fut as Future>::Output;
Fuse a future such that poll
will never again be called once it has
completed. This method can be used to turn any Future
into a
FusedFuture
. Read more
fn inspect<F>(self, f: F) -> Inspect<Self, F>ⓘNotable traits for Inspect<Fut, F>impl<Fut, F> Future for Inspect<Fut, F>where
Map<Fut, InspectFn<F>>: Future, type Output = <Map<Fut, InspectFn<F>> as Future>::Output;
where
F: FnOnce(&Self::Output),
fn inspect<F>(self, f: F) -> Inspect<Self, F>ⓘNotable traits for Inspect<Fut, F>impl<Fut, F> Future for Inspect<Fut, F>where
Map<Fut, InspectFn<F>>: Future, type Output = <Map<Fut, InspectFn<F>> as Future>::Output;
where
F: FnOnce(&Self::Output),
Map<Fut, InspectFn<F>>: Future, type Output = <Map<Fut, InspectFn<F>> as Future>::Output;
Do something with the output of a future before passing it on. Read more
fn unit_error(self) -> UnitError<Self>ⓘNotable traits for UnitError<Fut>impl<Fut> Future for UnitError<Fut>where
Map<Fut, OkFn<()>>: Future, type Output = <Map<Fut, OkFn<()>> as Future>::Output;
fn unit_error(self) -> UnitError<Self>ⓘNotable traits for UnitError<Fut>impl<Fut> Future for UnitError<Fut>where
Map<Fut, OkFn<()>>: Future, type Output = <Map<Fut, OkFn<()>> as Future>::Output;
Map<Fut, OkFn<()>>: Future, type Output = <Map<Fut, OkFn<()>> as Future>::Output;
Turns a Future<Output = T>
into a
TryFuture<Ok = T, Error = ()
>. Read more
fn never_error(self) -> NeverError<Self>ⓘNotable traits for NeverError<Fut>impl<Fut> Future for NeverError<Fut>where
Map<Fut, OkFn<Infallible>>: Future, type Output = <Map<Fut, OkFn<Infallible>> as Future>::Output;
fn never_error(self) -> NeverError<Self>ⓘNotable traits for NeverError<Fut>impl<Fut> Future for NeverError<Fut>where
Map<Fut, OkFn<Infallible>>: Future, type Output = <Map<Fut, OkFn<Infallible>> as Future>::Output;
Map<Fut, OkFn<Infallible>>: Future, type Output = <Map<Fut, OkFn<Infallible>> as Future>::Output;
Turns a Future<Output = T>
into a
TryFuture<Ok = T, Error = Never
>. Read more
fn poll_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Self::Output>where
Self: Unpin,
fn poll_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Self::Output>where
Self: Unpin,
A convenience for calling Future::poll
on Unpin
future types.
fn now_or_never(self) -> Option<Self::Output>
fn now_or_never(self) -> Option<Self::Output>
Evaluates and consumes the future, returning the resulting output if
the future is ready after the first call to Future::poll
. Read more
sourceimpl<T> Instrument for T
impl<T> Instrument for T
sourcefn instrument(self, span: Span) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T>where
T: Future, type Output = <T as Future>::Output;
fn instrument(self, span: Span) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T>where
T: Future, type Output = <T as Future>::Output;
T: Future, type Output = <T as Future>::Output;
sourcefn in_current_span(self) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T>where
T: Future, type Output = <T as Future>::Output;
fn in_current_span(self) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T>where
T: Future, type Output = <T as Future>::Output;
T: Future, type Output = <T as Future>::Output;
sourceimpl<F> IntoFuture for Fwhere
F: Future,
impl<F> IntoFuture for Fwhere
F: Future,
type IntoFuture = F
type IntoFuture = F
Which kind of future are we turning this into?
sourcefn into_future(self) -> <F as IntoFuture>::IntoFuture
fn into_future(self) -> <F as IntoFuture>::IntoFuture
Creates a future from a value. Read more
impl<V, T> VZip<V> for Twhere
V: MultiLane<T>,
impl<V, T> VZip<V> for Twhere
V: MultiLane<T>,
fn vzip(self) -> V
sourceimpl<T> WithSubscriber for T
impl<T> WithSubscriber for T
sourcefn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T>where
T: Future, type Output = <T as Future>::Output;
where
S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T>where
T: Future, type Output = <T as Future>::Output;
where
S: Into<Dispatch>,
T: Future, type Output = <T as Future>::Output;
Attaches the provided Subscriber
to this type, returning a
WithDispatch
wrapper. Read more
sourcefn with_current_subscriber(self) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T>where
T: Future, type Output = <T as Future>::Output;
fn with_current_subscriber(self) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T>where
T: Future, type Output = <T as Future>::Output;
T: Future, type Output = <T as Future>::Output;
Attaches the current default Subscriber
to this type, returning a
WithDispatch
wrapper. Read more