1.33.0[−][src]Struct async_std::pin::Pin
unstable
only.A pinned pointer.
This is a wrapper around a kind of pointer which makes that pointer "pin" its
value in place, preventing the value referenced by that pointer from being moved
unless it implements Unpin
.
See the pin
module documentation for an explanation of pinning.
Implementations
impl<P> Pin<P> where
P: Deref,
<P as Deref>::Target: Unpin,
[src]
P: Deref,
<P as Deref>::Target: Unpin,
pub const fn new(pointer: P) -> Pin<P>ⓘ
[src]
Construct a new Pin<P>
around a pointer to some data of a type that
implements Unpin
.
Unlike Pin::new_unchecked
, this method is safe because the pointer
P
dereferences to an Unpin
type, which cancels the pinning guarantees.
pub const fn into_inner(pin: Pin<P>) -> P
1.39.0[src]
Unwraps this Pin<P>
returning the underlying pointer.
This requires that the data inside this Pin
is Unpin
so that we
can ignore the pinning invariants when unwrapping it.
impl<P> Pin<P> where
P: Deref,
[src]
P: Deref,
#[lang = "new_unchecked"]pub const unsafe fn new_unchecked(pointer: P) -> Pin<P>ⓘ
[src]
Construct a new Pin<P>
around a reference to some data of a type that
may or may not implement Unpin
.
If pointer
dereferences to an Unpin
type, Pin::new
should be used
instead.
Safety
This constructor is unsafe because we cannot guarantee that the data
pointed to by pointer
is pinned, meaning that the data will not be moved or
its storage invalidated until it gets dropped. If the constructed Pin<P>
does
not guarantee that the data P
points to is pinned, that is a violation of
the API contract and may lead to undefined behavior in later (safe) operations.
By using this method, you are making a promise about the P::Deref
and
P::DerefMut
implementations, if they exist. Most importantly, they
must not move out of their self
arguments: Pin::as_mut
and Pin::as_ref
will call DerefMut::deref_mut
and Deref::deref
on the pinned pointer
and expect these methods to uphold the pinning invariants.
Moreover, by calling this method you promise that the reference P
dereferences to will not be moved out of again; in particular, it
must not be possible to obtain a &mut P::Target
and then
move out of that reference (using, for example mem::swap
).
For example, calling Pin::new_unchecked
on an &'a mut T
is unsafe because
while you are able to pin it for the given lifetime 'a
, you have no control
over whether it is kept pinned once 'a
ends:
use std::mem; use std::pin::Pin; fn move_pinned_ref<T>(mut a: T, mut b: T) { unsafe { let p: Pin<&mut T> = Pin::new_unchecked(&mut a); // This should mean the pointee `a` can never move again. } mem::swap(&mut a, &mut b); // The address of `a` changed to `b`'s stack slot, so `a` got moved even // though we have previously pinned it! We have violated the pinning API contract. }
A value, once pinned, must remain pinned forever (unless its type implements Unpin
).
Similarly, calling Pin::new_unchecked
on an Rc<T>
is unsafe because there could be
aliases to the same data that are not subject to the pinning restrictions:
use std::rc::Rc; use std::pin::Pin; fn move_pinned_rc<T>(mut x: Rc<T>) { let pinned = unsafe { Pin::new_unchecked(Rc::clone(&x)) }; { let p: Pin<&T> = pinned.as_ref(); // This should mean the pointee can never move again. } drop(pinned); let content = Rc::get_mut(&mut x).unwrap(); // Now, if `x` was the only reference, we have a mutable reference to // data that we pinned above, which we could use to move it as we have // seen in the previous example. We have violated the pinning API contract. }
pub fn as_ref(&self) -> Pin<&<P as Deref>::Target>ⓘ
[src]
Gets a pinned shared reference from this pinned pointer.
This is a generic method to go from &Pin<Pointer<T>>
to Pin<&T>
.
It is safe because, as part of the contract of Pin::new_unchecked
,
the pointee cannot move after Pin<Pointer<T>>
got created.
"Malicious" implementations of Pointer::Deref
are likewise
ruled out by the contract of Pin::new_unchecked
.
pub const unsafe fn into_inner_unchecked(pin: Pin<P>) -> P
1.39.0[src]
Unwraps this Pin<P>
returning the underlying pointer.
Safety
This function is unsafe. You must guarantee that you will continue to
treat the pointer P
as pinned after you call this function, so that
the invariants on the Pin
type can be upheld. If the code using the
resulting P
does not continue to maintain the pinning invariants that
is a violation of the API contract and may lead to undefined behavior in
later (safe) operations.
If the underlying data is Unpin
, Pin::into_inner
should be used
instead.
impl<P> Pin<P> where
P: DerefMut,
[src]
P: DerefMut,
pub fn as_mut(&mut self) -> Pin<&mut <P as Deref>::Target>ⓘ
[src]
Gets a pinned mutable reference from this pinned pointer.
This is a generic method to go from &mut Pin<Pointer<T>>
to Pin<&mut T>
.
It is safe because, as part of the contract of Pin::new_unchecked
,
the pointee cannot move after Pin<Pointer<T>>
got created.
"Malicious" implementations of Pointer::DerefMut
are likewise
ruled out by the contract of Pin::new_unchecked
.
This method is useful when doing multiple calls to functions that consume the pinned type.
Example
use std::pin::Pin; impl Type { fn method(self: Pin<&mut Self>) { // do something } fn call_method_twice(mut self: Pin<&mut Self>) { // `method` consumes `self`, so reborrow the `Pin<&mut Self>` via `as_mut`. self.as_mut().method(); self.as_mut().method(); } }
pub fn set(&mut self, value: <P as Deref>::Target) where
<P as Deref>::Target: Sized,
[src]
<P as Deref>::Target: Sized,
Assigns a new value to the memory behind the pinned reference.
This overwrites pinned data, but that is okay: its destructor gets run before being overwritten, so no pinning guarantee is violated.
impl<'a, T> Pin<&'a T> where
T: ?Sized,
[src]
T: ?Sized,
pub unsafe fn map_unchecked<U, F>(self, func: F) -> Pin<&'a U>ⓘ where
F: FnOnce(&T) -> &U,
U: ?Sized,
[src]
F: FnOnce(&T) -> &U,
U: ?Sized,
Constructs a new pin by mapping the interior value.
For example, if you wanted to get a Pin
of a field of something,
you could use this to get access to that field in one line of code.
However, there are several gotchas with these "pinning projections";
see the pin
module documentation for further details on that topic.
Safety
This function is unsafe. You must guarantee that the data you return will not move so long as the argument value does not move (for example, because it is one of the fields of that value), and also that you do not move out of the argument you receive to the interior function.
pub const fn get_ref(self) -> &'a T
[src]
Gets a shared reference out of a pin.
This is safe because it is not possible to move out of a shared reference.
It may seem like there is an issue here with interior mutability: in fact,
it is possible to move a T
out of a &RefCell<T>
. However, this is
not a problem as long as there does not also exist a Pin<&T>
pointing
to the same data, and RefCell<T>
does not let you create a pinned reference
to its contents. See the discussion on "pinning projections" for further
details.
Note: Pin
also implements Deref
to the target, which can be used
to access the inner value. However, Deref
only provides a reference
that lives for as long as the borrow of the Pin
, not the lifetime of
the Pin
itself. This method allows turning the Pin
into a reference
with the same lifetime as the original Pin
.
impl<'a, T> Pin<&'a mut T> where
T: ?Sized,
[src]
T: ?Sized,
pub const fn into_ref(self) -> Pin<&'a T>ⓘ
[src]
Converts this Pin<&mut T>
into a Pin<&T>
with the same lifetime.
pub const fn get_mut(self) -> &'a mut T where
T: Unpin,
[src]
T: Unpin,
Gets a mutable reference to the data inside of this Pin
.
This requires that the data inside this Pin
is Unpin
.
Note: Pin
also implements DerefMut
to the data, which can be used
to access the inner value. However, DerefMut
only provides a reference
that lives for as long as the borrow of the Pin
, not the lifetime of
the Pin
itself. This method allows turning the Pin
into a reference
with the same lifetime as the original Pin
.
pub const unsafe fn get_unchecked_mut(self) -> &'a mut T
[src]
Gets a mutable reference to the data inside of this Pin
.
Safety
This function is unsafe. You must guarantee that you will never move
the data out of the mutable reference you receive when you call this
function, so that the invariants on the Pin
type can be upheld.
If the underlying data is Unpin
, Pin::get_mut
should be used
instead.
pub unsafe fn map_unchecked_mut<U, F>(self, func: F) -> Pin<&'a mut U>ⓘ where
F: FnOnce(&mut T) -> &mut U,
U: ?Sized,
[src]
F: FnOnce(&mut T) -> &mut U,
U: ?Sized,
Construct a new pin by mapping the interior value.
For example, if you wanted to get a Pin
of a field of something,
you could use this to get access to that field in one line of code.
However, there are several gotchas with these "pinning projections";
see the pin
module documentation for further details on that topic.
Safety
This function is unsafe. You must guarantee that the data you return will not move so long as the argument value does not move (for example, because it is one of the fields of that value), and also that you do not move out of the argument you receive to the interior function.
impl<T> Pin<&'static T> where
T: ?Sized,
[src]
T: ?Sized,
pub const fn static_ref(r: &'static T) -> Pin<&'static T>ⓘ
[src]
pin_static_ref
)Get a pinned reference from a static reference.
This is safe, because T
is borrowed for the 'static
lifetime, which
never ends.
impl<T> Pin<&'static mut T> where
T: ?Sized,
[src]
T: ?Sized,
pub const fn static_mut(r: &'static mut T) -> Pin<&'static mut T>ⓘ
[src]
pin_static_ref
)Get a pinned mutable reference from a static mutable reference.
This is safe, because T
is borrowed for the 'static
lifetime, which
never ends.
Trait Implementations
impl<P> AsyncBufRead for Pin<P> where
P: DerefMut + Unpin,
<P as Deref>::Target: AsyncBufRead,
[src]
P: DerefMut + Unpin,
<P as Deref>::Target: AsyncBufRead,
pub fn poll_fill_buf(
self: Pin<&mut Pin<P>>,
cx: &mut Context<'_>
) -> Poll<Result<&[u8], Error>>
[src]
self: Pin<&mut Pin<P>>,
cx: &mut Context<'_>
) -> Poll<Result<&[u8], Error>>
pub fn consume(self: Pin<&mut Pin<P>>, amt: usize)
[src]
impl<P> AsyncRead for Pin<P> where
P: DerefMut + Unpin,
<P as Deref>::Target: AsyncRead,
[src]
P: DerefMut + Unpin,
<P as Deref>::Target: AsyncRead,
pub fn poll_read(
self: Pin<&mut Pin<P>>,
cx: &mut Context<'_>,
buf: &mut [u8]
) -> Poll<Result<usize, Error>>
[src]
self: Pin<&mut Pin<P>>,
cx: &mut Context<'_>,
buf: &mut [u8]
) -> Poll<Result<usize, Error>>
pub fn poll_read_vectored(
self: Pin<&mut Pin<P>>,
cx: &mut Context<'_>,
bufs: &mut [IoSliceMut<'_>]
) -> Poll<Result<usize, Error>>
[src]
self: Pin<&mut Pin<P>>,
cx: &mut Context<'_>,
bufs: &mut [IoSliceMut<'_>]
) -> Poll<Result<usize, Error>>
impl<P> AsyncSeek for Pin<P> where
P: DerefMut + Unpin,
<P as Deref>::Target: AsyncSeek,
[src]
P: DerefMut + Unpin,
<P as Deref>::Target: AsyncSeek,
pub fn poll_seek(
self: Pin<&mut Pin<P>>,
cx: &mut Context<'_>,
pos: SeekFrom
) -> Poll<Result<u64, Error>>
[src]
self: Pin<&mut Pin<P>>,
cx: &mut Context<'_>,
pos: SeekFrom
) -> Poll<Result<u64, Error>>
impl<P> AsyncWrite for Pin<P> where
P: DerefMut + Unpin,
<P as Deref>::Target: AsyncWrite,
[src]
P: DerefMut + Unpin,
<P as Deref>::Target: AsyncWrite,
pub fn poll_write(
self: Pin<&mut Pin<P>>,
cx: &mut Context<'_>,
buf: &[u8]
) -> Poll<Result<usize, Error>>
[src]
self: Pin<&mut Pin<P>>,
cx: &mut Context<'_>,
buf: &[u8]
) -> Poll<Result<usize, Error>>
pub fn poll_write_vectored(
self: Pin<&mut Pin<P>>,
cx: &mut Context<'_>,
bufs: &[IoSlice<'_>]
) -> Poll<Result<usize, Error>>
[src]
self: Pin<&mut Pin<P>>,
cx: &mut Context<'_>,
bufs: &[IoSlice<'_>]
) -> Poll<Result<usize, Error>>
pub fn poll_flush(
self: Pin<&mut Pin<P>>,
cx: &mut Context<'_>
) -> Poll<Result<(), Error>>
[src]
self: Pin<&mut Pin<P>>,
cx: &mut Context<'_>
) -> Poll<Result<(), Error>>
pub fn poll_close(
self: Pin<&mut Pin<P>>,
cx: &mut Context<'_>
) -> Poll<Result<(), Error>>
[src]
self: Pin<&mut Pin<P>>,
cx: &mut Context<'_>
) -> Poll<Result<(), Error>>
impl<P> BufRead for Pin<P> where
P: DerefMut + Unpin,
<P as Deref>::Target: BufRead,
[src]
P: DerefMut + Unpin,
<P as Deref>::Target: BufRead,
pub fn poll_fill_buf(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<&[u8]>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<&[u8]>>
pub fn consume(self: Pin<&mut Self>, amt: usize)
[src]
pub fn read_until<'a>(
&'a mut self,
byte: u8,
buf: &'a mut Vec<u8>
) -> ImplFuture<usize> where
Self: Unpin,
[src]
&'a mut self,
byte: u8,
buf: &'a mut Vec<u8>
) -> ImplFuture<usize> where
Self: Unpin,
pub fn read_line<'a>(
&'a mut self,
buf: &'a mut String
) -> ImplFuture<Result<usize>> where
Self: Unpin,
[src]
&'a mut self,
buf: &'a mut String
) -> ImplFuture<Result<usize>> where
Self: Unpin,
pub fn lines(self) -> Lines<Self> where
Self: Unpin + Sized,
[src]
Self: Unpin + Sized,
pub fn split(self, byte: u8) -> Split<Self> where
Self: Sized,
[src]
Self: Sized,
impl<P> Clone for Pin<P> where
P: Clone,
[src]
P: Clone,
impl<P, U> CoerceUnsized<Pin<U>> for Pin<P> where
P: CoerceUnsized<U>,
[src]
P: CoerceUnsized<U>,
impl<P> Copy for Pin<P> where
P: Copy,
[src]
P: Copy,
impl<P> Debug for Pin<P> where
P: Debug,
[src]
P: Debug,
impl<P> Deref for Pin<P> where
P: Deref,
[src]
P: Deref,
type Target = <P as Deref>::Target
The resulting type after dereferencing.
pub fn deref(&self) -> &<P as Deref>::Target
[src]
impl<P> DerefMut for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Unpin,
[src]
P: DerefMut,
<P as Deref>::Target: Unpin,
impl<P, U> DispatchFromDyn<Pin<U>> for Pin<P> where
P: DispatchFromDyn<U>,
[src]
P: DispatchFromDyn<U>,
impl<P> Display for Pin<P> where
P: Display,
[src]
P: Display,
impl<P> Eq for Pin<P> where
P: Deref,
<P as Deref>::Target: Eq,
1.41.0[src]
P: Deref,
<P as Deref>::Target: Eq,
impl<T, A> From<Box<T, A>> for Pin<Box<T, A>> where
A: Allocator + 'static,
T: ?Sized,
[src]
A: Allocator + 'static,
T: ?Sized,
pub fn from(boxed: Box<T, A>) -> Pin<Box<T, A>>ⓘ
[src]
Converts a Box<T>
into a Pin<Box<T>>
This conversion does not allocate on the heap and happens in place.
impl<P> FusedFuture for Pin<P> where
P: DerefMut + Unpin,
<P as Deref>::Target: FusedFuture,
[src]
P: DerefMut + Unpin,
<P as Deref>::Target: FusedFuture,
pub fn is_terminated(&self) -> bool
[src]
impl<P> FusedStream for Pin<P> where
P: DerefMut + Unpin,
<P as Deref>::Target: FusedStream,
[src]
P: DerefMut + Unpin,
<P as Deref>::Target: FusedStream,
pub fn is_terminated(&self) -> bool
[src]
impl<P> Future for Pin<P> where
P: Unpin + DerefMut,
<P as Deref>::Target: Future,
1.36.0[src]
P: Unpin + DerefMut,
<P as Deref>::Target: Future,
type Output = <<P as Deref>::Target as Future>::Output
The type of value produced on completion.
pub fn poll(
self: Pin<&mut Pin<P>>,
cx: &mut Context<'_>
) -> Poll<<Pin<P> as Future>::Output>
[src]
self: Pin<&mut Pin<P>>,
cx: &mut Context<'_>
) -> Poll<<Pin<P> as Future>::Output>
impl<P> Future for Pin<P> where
P: DerefMut + Unpin,
<P as Deref>::Target: Future,
[src]
P: DerefMut + Unpin,
<P as Deref>::Target: Future,
type Output = <<P as Deref>::Target as Future>::Output
The type of value produced on completion.
pub fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>
[src]
pub fn delay(self, dur: Duration) -> ImplFuture<Self::Output> where
Self: Sized,
[src]
Self: Sized,
pub fn flatten(self) -> ImplFuture<<Self::Output as IntoFuture>::Output> where
Self: Sized,
Self::Output: IntoFuture,
[src]
Self: Sized,
Self::Output: IntoFuture,
pub fn race<F>(self, other: F) -> ImplFuture<Self::Output> where
Self: Future + Sized,
F: Future<Output = Self::Output>,
[src]
Self: Future + Sized,
F: Future<Output = Self::Output>,
pub fn try_race<F, T, E>(self, other: F) -> ImplFuture<Self::Output> where
Self: Future<Output = Result<T, E>> + Sized,
F: Future<Output = Self::Output>,
[src]
Self: Future<Output = Result<T, E>> + Sized,
F: Future<Output = Self::Output>,
pub fn join<F>(
self,
other: F
) -> ImplFuture<(Self::Output, <F as Future>::Output)> where
Self: Future + Sized,
F: Future,
[src]
self,
other: F
) -> ImplFuture<(Self::Output, <F as Future>::Output)> where
Self: Future + Sized,
F: Future,
pub fn try_join<F, A, B, E>(self, other: F) -> ImplFuture<Result<(A, B), E>> where
Self: Future<Output = Result<A, E>> + Sized,
F: Future<Output = Result<B, E>>,
[src]
Self: Future<Output = Result<A, E>> + Sized,
F: Future<Output = Result<B, E>>,
pub fn timeout(self, dur: Duration) -> ImplFuture<Self::Output> where
Self: Sized,
[src]
Self: Sized,
impl<'_, G, R> Generator<R> for Pin<&'_ mut G> where
G: Generator<R> + ?Sized,
[src]
G: Generator<R> + ?Sized,
type Yield = <G as Generator<R>>::Yield
generator_trait
)The type of value this generator yields. Read more
type Return = <G as Generator<R>>::Return
generator_trait
)The type of value this generator returns. Read more
pub fn resume(
self: Pin<&mut Pin<&'_ mut G>>,
arg: R
) -> GeneratorState<<Pin<&'_ mut G> as Generator<R>>::Yield, <Pin<&'_ mut G> as Generator<R>>::Return>
[src]
self: Pin<&mut Pin<&'_ mut G>>,
arg: R
) -> GeneratorState<<Pin<&'_ mut G> as Generator<R>>::Yield, <Pin<&'_ mut G> as Generator<R>>::Return>
impl<G, R, A> Generator<R> for Pin<Box<G, A>> where
A: Allocator + 'static,
G: Generator<R> + ?Sized,
[src]
A: Allocator + 'static,
G: Generator<R> + ?Sized,
type Yield = <G as Generator<R>>::Yield
generator_trait
)The type of value this generator yields. Read more
type Return = <G as Generator<R>>::Return
generator_trait
)The type of value this generator returns. Read more
pub fn resume(
self: Pin<&mut Pin<Box<G, A>>>,
arg: R
) -> GeneratorState<<Pin<Box<G, A>> as Generator<R>>::Yield, <Pin<Box<G, A>> as Generator<R>>::Return>
[src]
self: Pin<&mut Pin<Box<G, A>>>,
arg: R
) -> GeneratorState<<Pin<Box<G, A>> as Generator<R>>::Yield, <Pin<Box<G, A>> as Generator<R>>::Return>
impl<P> Hash for Pin<P> where
P: Deref,
<P as Deref>::Target: Hash,
1.41.0[src]
P: Deref,
<P as Deref>::Target: Hash,
pub fn hash<H>(&self, state: &mut H) where
H: Hasher,
[src]
H: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<P> Ord for Pin<P> where
P: Deref,
<P as Deref>::Target: Ord,
1.41.0[src]
P: Deref,
<P as Deref>::Target: Ord,
pub fn cmp(&self, other: &Pin<P>) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<P, Q> PartialEq<Pin<Q>> for Pin<P> where
P: Deref,
Q: Deref,
<P as Deref>::Target: PartialEq<<Q as Deref>::Target>,
1.41.0[src]
P: Deref,
Q: Deref,
<P as Deref>::Target: PartialEq<<Q as Deref>::Target>,
impl<P, Q> PartialOrd<Pin<Q>> for Pin<P> where
P: Deref,
Q: Deref,
<P as Deref>::Target: PartialOrd<<Q as Deref>::Target>,
1.41.0[src]
P: Deref,
Q: Deref,
<P as Deref>::Target: PartialOrd<<Q as Deref>::Target>,
pub fn partial_cmp(&self, other: &Pin<Q>) -> Option<Ordering>
[src]
pub fn lt(&self, other: &Pin<Q>) -> bool
[src]
pub fn le(&self, other: &Pin<Q>) -> bool
[src]
pub fn gt(&self, other: &Pin<Q>) -> bool
[src]
pub fn ge(&self, other: &Pin<Q>) -> bool
[src]
impl<P> Pointer for Pin<P> where
P: Pointer,
[src]
P: Pointer,
impl<P> Read for Pin<P> where
P: DerefMut + Unpin,
<P as Deref>::Target: Read,
[src]
P: DerefMut + Unpin,
<P as Deref>::Target: Read,
pub fn poll_read(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &mut [u8]
) -> Poll<Result<usize>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &mut [u8]
) -> Poll<Result<usize>>
pub fn poll_read_vectored(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
bufs: &mut [IoSliceMut<'_>]
) -> Poll<Result<usize>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>,
bufs: &mut [IoSliceMut<'_>]
) -> Poll<Result<usize>>
pub fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> ImplFuture<Result<usize>> where
Self: Unpin,
[src]
Self: Unpin,
pub fn read_vectored<'a>(
&'a mut self,
bufs: &'a mut [IoSliceMut<'a>]
) -> ImplFuture<Result<usize>> where
Self: Unpin,
[src]
&'a mut self,
bufs: &'a mut [IoSliceMut<'a>]
) -> ImplFuture<Result<usize>> where
Self: Unpin,
pub fn read_to_end<'a>(
&'a mut self,
buf: &'a mut Vec<u8>
) -> ImplFuture<Result<usize>> where
Self: Unpin,
[src]
&'a mut self,
buf: &'a mut Vec<u8>
) -> ImplFuture<Result<usize>> where
Self: Unpin,
pub fn read_to_string<'a>(
&'a mut self,
buf: &'a mut String
) -> ImplFuture<Result<usize>> where
Self: Unpin,
[src]
&'a mut self,
buf: &'a mut String
) -> ImplFuture<Result<usize>> where
Self: Unpin,
pub fn read_exact<'a>(&'a mut self, buf: &'a mut [u8]) -> ImplFuture<Result<()>> where
Self: Unpin,
[src]
Self: Unpin,
pub fn take(self, limit: u64) -> Take<Self> where
Self: Sized,
[src]
Self: Sized,
pub fn by_ref(&mut self) -> &mut Self where
Self: Sized,
[src]
Self: Sized,
pub fn bytes(self) -> Bytes<Self> where
Self: Sized,
[src]
Self: Sized,
pub fn chain<R: Read>(self, next: R) -> Chain<Self, R> where
Self: Sized,
[src]
Self: Sized,
impl<P> Seek for Pin<P> where
P: DerefMut + Unpin,
<P as Deref>::Target: Seek,
[src]
P: DerefMut + Unpin,
<P as Deref>::Target: Seek,
pub fn poll_seek(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
pos: SeekFrom
) -> Poll<Result<u64>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>,
pos: SeekFrom
) -> Poll<Result<u64>>
pub fn seek(&mut self, pos: SeekFrom) -> ImplFuture<Result<u64>> where
Self: Unpin,
[src]
Self: Unpin,
impl<P> Stream for Pin<P> where
P: DerefMut + Unpin,
<P as Deref>::Target: Stream,
[src]
P: DerefMut + Unpin,
<P as Deref>::Target: Stream,
type Item = <<P as Deref>::Target as Stream>::Item
Values yielded by the stream.
pub fn poll_next(
self: Pin<&mut Pin<P>>,
cx: &mut Context<'_>
) -> Poll<Option<<Pin<P> as Stream>::Item>>
[src]
self: Pin<&mut Pin<P>>,
cx: &mut Context<'_>
) -> Poll<Option<<Pin<P> as Stream>::Item>>
pub fn size_hint(&self) -> (usize, Option<usize>)
[src]
impl<P> Stream for Pin<P> where
P: DerefMut + Unpin,
<P as Deref>::Target: Stream,
[src]
P: DerefMut + Unpin,
<P as Deref>::Target: Stream,
type Item = <<P as Deref>::Target as Stream>::Item
The type of items yielded by this stream.
pub fn poll_next(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Option<Self::Item>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Option<Self::Item>>
pub fn next(&mut self) -> ImplFuture<Option<Self::Item>> where
Self: Unpin,
[src]
Self: Unpin,
pub fn take(self, n: usize) -> Take<Self> where
Self: Sized,
[src]
Self: Sized,
pub fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
[src]
Self: Sized,
P: FnMut(&Self::Item) -> bool,
pub fn throttle(self, d: Duration) -> Throttle<Self> where
Self: Sized,
[src]
Self: Sized,
pub fn step_by(self, step: usize) -> StepBy<Self> where
Self: Sized,
[src]
Self: Sized,
pub fn chain<U>(self, other: U) -> Chain<Self, U> where
Self: Sized,
U: Stream<Item = Self::Item> + Sized,
[src]
Self: Sized,
U: Stream<Item = Self::Item> + Sized,
pub fn cloned<'a, T>(self) -> Cloned<Self> where
Self: Sized + Stream<Item = &'a T>,
T: Clone + 'a,
[src]
Self: Sized + Stream<Item = &'a T>,
T: Clone + 'a,
pub fn copied<'a, T>(self) -> Copied<Self> where
Self: Sized + Stream<Item = &'a T>,
T: Copy + 'a,
[src]
Self: Sized + Stream<Item = &'a T>,
T: Copy + 'a,
pub fn cycle(self) -> Cycle<Self> where
Self: Clone + Sized,
[src]
Self: Clone + Sized,
pub fn enumerate(self) -> Enumerate<Self> where
Self: Sized,
[src]
Self: Sized,
pub fn delay(self, dur: Duration) -> Delay<Self> where
Self: Sized,
[src]
Self: Sized,
pub fn map<B, F>(self, f: F) -> Map<Self, F> where
Self: Sized,
F: FnMut(Self::Item) -> B,
[src]
Self: Sized,
F: FnMut(Self::Item) -> B,
pub fn inspect<F>(self, f: F) -> Inspect<Self, F> where
Self: Sized,
F: FnMut(&Self::Item),
[src]
Self: Sized,
F: FnMut(&Self::Item),
pub fn last(self) -> ImplFuture<Option<Self::Item>> where
Self: Sized,
[src]
Self: Sized,
pub fn fuse(self) -> Fuse<Self> where
Self: Sized,
[src]
Self: Sized,
pub fn filter<P>(self, predicate: P) -> Filter<Self, P> where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
[src]
Self: Sized,
P: FnMut(&Self::Item) -> bool,
pub fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
Self: Sized,
U: IntoStream,
F: FnMut(Self::Item) -> U,
[src]
Self: Sized,
U: IntoStream,
F: FnMut(Self::Item) -> U,
pub fn flatten(self) -> Flatten<Self> where
Self: Sized,
Self::Item: IntoStream,
[src]
Self: Sized,
Self::Item: IntoStream,
pub fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
Self: Sized,
F: FnMut(Self::Item) -> Option<B>,
[src]
Self: Sized,
F: FnMut(Self::Item) -> Option<B>,
pub fn min_by_key<B, F>(self, key_by: F) -> ImplFuture<Option<Self::Item>> where
Self: Sized,
B: Ord,
F: FnMut(&Self::Item) -> B,
[src]
Self: Sized,
B: Ord,
F: FnMut(&Self::Item) -> B,
pub fn max_by_key<B, F>(self, key_by: F) -> ImplFuture<Option<Self::Item>> where
Self: Sized,
B: Ord,
F: FnMut(&Self::Item) -> B,
[src]
Self: Sized,
B: Ord,
F: FnMut(&Self::Item) -> B,
pub fn min_by<F>(self, compare: F) -> ImplFuture<Option<Self::Item>> where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
[src]
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
pub fn max(self) -> ImplFuture<Option<Self::Item>> where
Self: Sized,
Self::Item: Ord,
[src]
Self: Sized,
Self::Item: Ord,
pub fn min(self) -> ImplFuture<Option<Self::Item>> where
Self: Sized,
Self::Item: Ord,
[src]
Self: Sized,
Self::Item: Ord,
pub fn max_by<F>(self, compare: F) -> ImplFuture<Option<Self::Item>> where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
[src]
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
pub fn nth(&mut self, n: usize) -> ImplFuture<Option<Self::Item>> where
Self: Unpin + Sized,
[src]
Self: Unpin + Sized,
pub fn all<F>(&mut self, f: F) -> ImplFuture<bool> where
Self: Unpin + Sized,
F: FnMut(Self::Item) -> bool,
[src]
Self: Unpin + Sized,
F: FnMut(Self::Item) -> bool,
pub fn find<P>(&mut self, p: P) -> ImplFuture<Option<Self::Item>> where
Self: Unpin + Sized,
P: FnMut(&Self::Item) -> bool,
[src]
Self: Unpin + Sized,
P: FnMut(&Self::Item) -> bool,
pub fn find_map<F, B>(&mut self, f: F) -> ImplFuture<Option<B>> where
Self: Unpin + Sized,
F: FnMut(Self::Item) -> Option<B>,
[src]
Self: Unpin + Sized,
F: FnMut(Self::Item) -> Option<B>,
pub fn fold<B, F>(self, init: B, f: F) -> ImplFuture<B> where
Self: Sized,
F: FnMut(B, Self::Item) -> B,
[src]
Self: Sized,
F: FnMut(B, Self::Item) -> B,
pub fn partition<B, F>(self, f: F) -> ImplFuture<(B, B)> where
Self: Sized,
F: FnMut(&Self::Item) -> bool,
B: Default + Extend<Self::Item>,
[src]
Self: Sized,
F: FnMut(&Self::Item) -> bool,
B: Default + Extend<Self::Item>,
pub fn for_each<F>(self, f: F) -> ImplFuture<()> where
Self: Sized,
F: FnMut(Self::Item),
[src]
Self: Sized,
F: FnMut(Self::Item),
pub fn any<F>(&mut self, f: F) -> ImplFuture<bool> where
Self: Unpin + Sized,
F: FnMut(Self::Item) -> bool,
[src]
Self: Unpin + Sized,
F: FnMut(Self::Item) -> bool,
pub fn by_ref(&mut self) -> &mut Self
[src]
pub fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where
Self: Sized,
F: FnMut(&mut St, Self::Item) -> Option<B>,
[src]
Self: Sized,
F: FnMut(&mut St, Self::Item) -> Option<B>,
pub fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
[src]
Self: Sized,
P: FnMut(&Self::Item) -> bool,
pub fn skip(self, n: usize) -> Skip<Self> where
Self: Sized,
[src]
Self: Sized,
pub fn timeout(self, dur: Duration) -> Timeout<Self> where
Self: Stream + Sized,
[src]
Self: Stream + Sized,
pub fn try_fold<B, F, T, E>(
&mut self,
init: T,
f: F
) -> ImplFuture<Result<T, E>> where
Self: Unpin + Sized,
F: FnMut(B, Self::Item) -> Result<T, E>,
[src]
&mut self,
init: T,
f: F
) -> ImplFuture<Result<T, E>> where
Self: Unpin + Sized,
F: FnMut(B, Self::Item) -> Result<T, E>,
pub fn try_for_each<F, E>(&mut self, f: F) -> ImplFuture<E> where
Self: Unpin + Sized,
F: FnMut(Self::Item) -> Result<(), E>,
[src]
Self: Unpin + Sized,
F: FnMut(Self::Item) -> Result<(), E>,
pub fn zip<U>(self, other: U) -> Zip<Self, U> where
Self: Sized,
U: Stream,
[src]
Self: Sized,
U: Stream,
pub fn unzip<A, B, FromA, FromB>(self) -> ImplFuture<(FromA, FromB)> where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Stream<Item = (A, B)> + Sized,
[src]
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Stream<Item = (A, B)> + Sized,
pub fn collect<'a, B>(self) -> ImplFuture<B> where
Self: Sized + 'a + Send,
B: FromStream<Self::Item>,
Self::Item: Send,
[src]
Self: Sized + 'a + Send,
B: FromStream<Self::Item>,
Self::Item: Send,
pub fn merge<U>(self, other: U) -> Merge<Self, U> where
Self: Sized,
U: Stream<Item = Self::Item> + Sized,
[src]
Self: Sized,
U: Stream<Item = Self::Item> + Sized,
pub fn partial_cmp<S>(self, other: S) -> ImplFuture<Option<Ordering>> where
Self: Sized + Stream,
S: Stream,
Self::Item: PartialOrd<S::Item>,
[src]
Self: Sized + Stream,
S: Stream,
Self::Item: PartialOrd<S::Item>,
pub fn position<P>(&mut self, predicate: P) -> ImplFuture<Option<usize>> where
Self: Unpin + Sized,
P: FnMut(Self::Item) -> bool,
[src]
Self: Unpin + Sized,
P: FnMut(Self::Item) -> bool,
pub fn cmp<S>(self, other: S) -> ImplFuture<Ordering> where
Self: Sized + Stream,
S: Stream,
Self::Item: Ord,
[src]
Self: Sized + Stream,
S: Stream,
Self::Item: Ord,
pub fn count(self) -> ImplFuture<usize> where
Self: Sized,
[src]
Self: Sized,
pub fn ne<S>(self, other: S) -> ImplFuture<bool> where
Self: Sized,
S: Sized + Stream,
Self::Item: PartialEq<S::Item>,
[src]
Self: Sized,
S: Sized + Stream,
Self::Item: PartialEq<S::Item>,
pub fn ge<S>(self, other: S) -> ImplFuture<bool> where
Self: Sized + Stream,
S: Stream,
Self::Item: PartialOrd<S::Item>,
[src]
Self: Sized + Stream,
S: Stream,
Self::Item: PartialOrd<S::Item>,
pub fn eq<S>(self, other: S) -> ImplFuture<bool> where
Self: Sized + Stream,
S: Sized + Stream,
Self::Item: PartialEq<S::Item>,
[src]
Self: Sized + Stream,
S: Sized + Stream,
Self::Item: PartialEq<S::Item>,
pub fn gt<S>(self, other: S) -> ImplFuture<bool> where
Self: Sized + Stream,
S: Stream,
Self::Item: PartialOrd<S::Item>,
[src]
Self: Sized + Stream,
S: Stream,
Self::Item: PartialOrd<S::Item>,
pub fn le<S>(self, other: S) -> ImplFuture<bool> where
Self: Sized + Stream,
S: Stream,
Self::Item: PartialOrd<S::Item>,
[src]
Self: Sized + Stream,
S: Stream,
Self::Item: PartialOrd<S::Item>,
pub fn lt<S>(self, other: S) -> ImplFuture<bool> where
Self: Sized + Stream,
S: Stream,
Self::Item: PartialOrd<S::Item>,
[src]
Self: Sized + Stream,
S: Stream,
Self::Item: PartialOrd<S::Item>,
pub fn sum<'a, S>(self) -> ImplFuture<S> where
Self: Sized + Stream<Item = S> + 'a,
S: Sum<Self::Item>,
[src]
Self: Sized + Stream<Item = S> + 'a,
S: Sum<Self::Item>,
pub fn product<'a, P>(self) -> ImplFuture<P> where
Self: Sized + Stream<Item = P> + 'a,
P: Product,
[src]
Self: Sized + Stream<Item = P> + 'a,
P: Product,
impl<P> Write for Pin<P> where
P: DerefMut + Unpin,
<P as Deref>::Target: Write,
[src]
P: DerefMut + Unpin,
<P as Deref>::Target: Write,
pub fn poll_write(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &[u8]
) -> Poll<Result<usize>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &[u8]
) -> Poll<Result<usize>>
pub fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<()>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<()>>
pub fn poll_close(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<()>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<()>>
pub fn poll_write_vectored(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
bufs: &[IoSlice<'_>]
) -> Poll<Result<usize>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>,
bufs: &[IoSlice<'_>]
) -> Poll<Result<usize>>
pub fn write<'a>(&'a mut self, buf: &'a [u8]) -> ImplFuture<Result<usize>> where
Self: Unpin,
[src]
Self: Unpin,
pub fn flush(&mut self) -> ImplFuture<Result<()>> where
Self: Unpin,
[src]
Self: Unpin,
pub fn write_vectored<'a>(
&'a mut self,
bufs: &'a [IoSlice<'a>]
) -> ImplFuture<Result<usize>> where
Self: Unpin,
[src]
&'a mut self,
bufs: &'a [IoSlice<'a>]
) -> ImplFuture<Result<usize>> where
Self: Unpin,
pub fn write_all<'a>(&'a mut self, buf: &'a [u8]) -> ImplFuture<Result<()>> where
Self: Unpin,
[src]
Self: Unpin,
pub fn write_fmt<'a>(&'a mut self, fmt: Arguments<'_>) -> ImplFuture<Result<()>> where
Self: Unpin,
[src]
Self: Unpin,
Auto Trait Implementations
impl<P> RefUnwindSafe for Pin<P> where
P: RefUnwindSafe,
P: RefUnwindSafe,
impl<P> Send for Pin<P> where
P: Send,
P: Send,
impl<P> Sync for Pin<P> where
P: Sync,
P: Sync,
impl<P> Unpin for Pin<P> where
P: Unpin,
P: Unpin,
impl<P> UnwindSafe for Pin<P> where
P: UnwindSafe,
P: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<R> AsyncBufReadExt for R where
R: AsyncBufRead + ?Sized,
[src]
R: AsyncBufRead + ?Sized,
pub fn fill_buf(&mut self) -> FillBuf<'_, Self> where
Self: Unpin,
[src]
Self: Unpin,
pub fn consume(&mut self, amt: usize) where
Self: Unpin,
[src]
Self: Unpin,
pub fn read_until(
&'a mut self,
byte: u8,
buf: &'a mut Vec<u8, Global>
) -> ReadUntilFuture<'a, Self> where
Self: Unpin,
[src]
&'a mut self,
byte: u8,
buf: &'a mut Vec<u8, Global>
) -> ReadUntilFuture<'a, Self> where
Self: Unpin,
pub fn read_line(&'a mut self, buf: &'a mut String) -> ReadLineFuture<'a, Self> where
Self: Unpin,
[src]
Self: Unpin,
pub fn lines(self) -> Lines<Self> where
Self: Unpin,
[src]
Self: Unpin,
pub fn split(self, byte: u8) -> Split<Self>
[src]
impl<R> AsyncReadExt for R where
R: AsyncRead + ?Sized,
[src]
R: AsyncRead + ?Sized,
pub fn read(&'a mut self, buf: &'a mut [u8]) -> ReadFuture<'a, Self> where
Self: Unpin,
[src]
Self: Unpin,
pub fn read_vectored(
&'a mut self,
bufs: &'a mut [IoSliceMut<'a>]
) -> ReadVectoredFuture<'a, Self> where
Self: Unpin,
[src]
&'a mut self,
bufs: &'a mut [IoSliceMut<'a>]
) -> ReadVectoredFuture<'a, Self> where
Self: Unpin,
pub fn read_to_end(
&'a mut self,
buf: &'a mut Vec<u8, Global>
) -> ReadToEndFuture<'a, Self> where
Self: Unpin,
[src]
&'a mut self,
buf: &'a mut Vec<u8, Global>
) -> ReadToEndFuture<'a, Self> where
Self: Unpin,
pub fn read_to_string(
&'a mut self,
buf: &'a mut String
) -> ReadToStringFuture<'a, Self> where
Self: Unpin,
[src]
&'a mut self,
buf: &'a mut String
) -> ReadToStringFuture<'a, Self> where
Self: Unpin,
pub fn read_exact(&'a mut self, buf: &'a mut [u8]) -> ReadExactFuture<'a, Self> where
Self: Unpin,
[src]
Self: Unpin,
pub fn take(self, limit: u64) -> Take<Self>
[src]
pub fn bytes(self) -> Bytes<Self>
[src]
pub fn chain<R>(self, next: R) -> Chain<Self, R> where
R: AsyncRead,
[src]
R: AsyncRead,
pub fn boxed_reader<'a>(self) -> Pin<Box<dyn AsyncRead + 'a + Send, Global>>ⓘ where
Self: Send + 'a,
[src]
Self: Send + 'a,
impl<S> AsyncSeekExt for S where
S: AsyncSeek + ?Sized,
[src]
S: AsyncSeek + ?Sized,
pub fn seek(&mut self, pos: SeekFrom) -> SeekFuture<'_, Self> where
Self: Unpin,
[src]
Self: Unpin,
impl<W> AsyncWriteExt for W where
W: AsyncWrite + ?Sized,
[src]
W: AsyncWrite + ?Sized,
pub fn write(&'a mut self, buf: &'a [u8]) -> WriteFuture<'a, Self> where
Self: Unpin,
[src]
Self: Unpin,
pub fn write_vectored(
&'a mut self,
bufs: &'a [IoSlice<'a>]
) -> WriteVectoredFuture<'a, Self> where
Self: Unpin,
[src]
&'a mut self,
bufs: &'a [IoSlice<'a>]
) -> WriteVectoredFuture<'a, Self> where
Self: Unpin,
pub fn write_all(&'a mut self, buf: &'a [u8]) -> WriteAllFuture<'a, Self> where
Self: Unpin,
[src]
Self: Unpin,
pub fn flush(&mut self) -> FlushFuture<'_, Self> where
Self: Unpin,
[src]
Self: Unpin,
pub fn close(&mut self) -> CloseFuture<'_, Self> where
Self: Unpin,
[src]
Self: Unpin,
pub fn boxed_writer<'a>(self) -> Pin<Box<dyn AsyncWrite + 'a + Send, Global>>ⓘ where
Self: Send + 'a,
[src]
Self: Send + 'a,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<F> FutureExt for F where
F: Future + ?Sized,
[src]
F: Future + ?Sized,
pub fn poll(&mut self, cx: &mut Context<'_>) -> Poll<Self::Output> where
Self: Unpin,
[src]
Self: Unpin,
pub fn or<F>(self, other: F) -> Or<Self, F> where
F: Future<Output = Self::Output>,
[src]
F: Future<Output = Self::Output>,
pub fn race<F>(self, other: F) -> Race<Self, F> where
F: Future<Output = Self::Output>,
[src]
F: Future<Output = Self::Output>,
pub fn catch_unwind(self) -> CatchUnwind<Self> where
Self: UnwindSafe,
[src]
Self: UnwindSafe,
pub fn boxed<'a>(
self
) -> Pin<Box<dyn Future<Output = Self::Output> + 'a + Send, Global>>ⓘ where
Self: Send + 'a,
[src]
self
) -> Pin<Box<dyn Future<Output = Self::Output> + 'a + Send, Global>>ⓘ where
Self: Send + 'a,
pub fn boxed_local<'a>(
self
) -> Pin<Box<dyn Future<Output = Self::Output> + 'a, Global>>ⓘ where
Self: 'a,
[src]
self
) -> Pin<Box<dyn Future<Output = Self::Output> + 'a, Global>>ⓘ where
Self: 'a,
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<F> IntoFuture for F where
F: Future,
[src]
F: Future,
type Output = <F as Future>::Output
into_future
)The output that the future will produce on completion.
type Future = F
into_future
)Which kind of future are we turning this into?
pub fn into_future(self) -> <F as IntoFuture>::Future
[src]
impl<S> StreamExt for S where
S: Stream + ?Sized,
[src]
S: Stream + ?Sized,
pub fn poll_next(&mut self, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> where
Self: Unpin,
[src]
Self: Unpin,
pub fn next(&mut self) -> NextFuture<'_, Self> where
Self: Unpin,
[src]
Self: Unpin,
pub fn try_next<T, E>(&mut self) -> TryNextFuture<'_, Self> where
Self: Stream<Item = Result<T, E>> + Unpin,
[src]
Self: Stream<Item = Result<T, E>> + Unpin,
pub fn count(self) -> CountFuture<Self>
[src]
pub fn map<T, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> T,
[src]
F: FnMut(Self::Item) -> T,
pub fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
F: FnMut(Self::Item) -> U,
U: Stream,
[src]
F: FnMut(Self::Item) -> U,
U: Stream,
pub fn flatten(self) -> Flatten<Self> where
Self::Item: Stream,
[src]
Self::Item: Stream,
pub fn then<F, Fut>(self, f: F) -> Then<Self, F, Fut> where
F: FnMut(Self::Item) -> Fut,
Fut: Future,
[src]
F: FnMut(Self::Item) -> Fut,
Fut: Future,
pub fn filter<P>(self, predicate: P) -> Filter<Self, P> where
P: FnMut(&Self::Item) -> bool,
[src]
P: FnMut(&Self::Item) -> bool,
pub fn filter_map<T, F>(self, f: F) -> FilterMap<Self, F> where
F: FnMut(Self::Item) -> Option<T>,
[src]
F: FnMut(Self::Item) -> Option<T>,
pub fn take(self, n: usize) -> Take<Self>
[src]
pub fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
[src]
P: FnMut(&Self::Item) -> bool,
pub fn skip(self, n: usize) -> Skip<Self>
[src]
pub fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
[src]
P: FnMut(&Self::Item) -> bool,
pub fn step_by(self, step: usize) -> StepBy<Self>
[src]
pub fn chain<U>(self, other: U) -> Chain<Self, U> where
U: Stream<Item = Self::Item>,
[src]
U: Stream<Item = Self::Item>,
pub fn cloned<'a, T>(self) -> Cloned<Self> where
Self: Stream<Item = &'a T>,
T: Clone + 'a,
[src]
Self: Stream<Item = &'a T>,
T: Clone + 'a,
pub fn copied<'a, T>(self) -> Copied<Self> where
Self: Stream<Item = &'a T>,
T: Copy + 'a,
[src]
Self: Stream<Item = &'a T>,
T: Copy + 'a,
pub fn collect<C>(self) -> CollectFuture<Self, C> where
C: Default + Extend<Self::Item>,
[src]
C: Default + Extend<Self::Item>,
pub fn try_collect<T, E, C>(self) -> TryCollectFuture<Self, C> where
C: Default + Extend<T>,
Self: Stream<Item = Result<T, E>>,
[src]
C: Default + Extend<T>,
Self: Stream<Item = Result<T, E>>,
pub fn partition<B, P>(self, predicate: P) -> PartitionFuture<Self, P, B> where
B: Default + Extend<Self::Item>,
P: FnMut(&Self::Item) -> bool,
[src]
B: Default + Extend<Self::Item>,
P: FnMut(&Self::Item) -> bool,
pub fn fold<T, F>(self, init: T, f: F) -> FoldFuture<Self, F, T> where
F: FnMut(T, Self::Item) -> T,
[src]
F: FnMut(T, Self::Item) -> T,
pub fn try_fold<T, E, F, B>(
&mut self,
init: B,
f: F
) -> TryFoldFuture<'_, Self, F, B> where
F: FnMut(B, T) -> Result<B, E>,
Self: Stream<Item = Result<T, E>> + Unpin,
[src]
&mut self,
init: B,
f: F
) -> TryFoldFuture<'_, Self, F, B> where
F: FnMut(B, T) -> Result<B, E>,
Self: Stream<Item = Result<T, E>> + Unpin,
pub fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where
F: FnMut(&mut St, Self::Item) -> Option<B>,
[src]
F: FnMut(&mut St, Self::Item) -> Option<B>,
pub fn fuse(self) -> Fuse<Self>
[src]
pub fn cycle(self) -> Cycle<Self> where
Self: Clone,
[src]
Self: Clone,
pub fn enumerate(self) -> Enumerate<Self>
[src]
pub fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item),
[src]
F: FnMut(&Self::Item),
pub fn nth(&mut self, n: usize) -> NthFuture<'_, Self> where
Self: Unpin,
[src]
Self: Unpin,
pub fn last(self) -> LastFuture<Self>
[src]
pub fn find<P>(&mut self, predicate: P) -> FindFuture<'_, Self, P> where
P: FnMut(&Self::Item) -> bool,
Self: Unpin,
[src]
P: FnMut(&Self::Item) -> bool,
Self: Unpin,
pub fn find_map<F, B>(&mut self, f: F) -> FindMapFuture<'_, Self, F> where
F: FnMut(Self::Item) -> Option<B>,
Self: Unpin,
[src]
F: FnMut(Self::Item) -> Option<B>,
Self: Unpin,
pub fn position<P>(&mut self, predicate: P) -> PositionFuture<'_, Self, P> where
P: FnMut(Self::Item) -> bool,
Self: Unpin,
[src]
P: FnMut(Self::Item) -> bool,
Self: Unpin,
pub fn all<P>(&mut self, predicate: P) -> AllFuture<'_, Self, P> where
P: FnMut(Self::Item) -> bool,
Self: Unpin,
[src]
P: FnMut(Self::Item) -> bool,
Self: Unpin,
pub fn any<P>(&mut self, predicate: P) -> AnyFuture<'_, Self, P> where
P: FnMut(Self::Item) -> bool,
Self: Unpin,
[src]
P: FnMut(Self::Item) -> bool,
Self: Unpin,
pub fn for_each<F>(self, f: F) -> ForEachFuture<Self, F> where
F: FnMut(Self::Item),
[src]
F: FnMut(Self::Item),
pub fn try_for_each<F, E>(&mut self, f: F) -> TryForEachFuture<'_, Self, F> where
F: FnMut(Self::Item) -> Result<(), E>,
Self: Unpin,
[src]
F: FnMut(Self::Item) -> Result<(), E>,
Self: Unpin,
pub fn zip<U>(self, other: U) -> Zip<Self, U> where
U: Stream,
[src]
U: Stream,
pub fn unzip<A, B, FromA, FromB>(self) -> UnzipFuture<Self, FromA, FromB> where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Stream<Item = (A, B)>,
[src]
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Stream<Item = (A, B)>,
pub fn or<S>(self, other: S) -> Or<Self, S> where
S: Stream<Item = Self::Item>,
[src]
S: Stream<Item = Self::Item>,
pub fn race<S>(self, other: S) -> Race<Self, S> where
S: Stream<Item = Self::Item>,
[src]
S: Stream<Item = Self::Item>,
pub fn boxed<'a>(
self
) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a + Send, Global>>ⓘ where
Self: Send + 'a,
[src]
self
) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a + Send, Global>>ⓘ where
Self: Send + 'a,
pub fn boxed_local<'a>(
self
) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a, Global>>ⓘ where
Self: 'a,
[src]
self
) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a, Global>>ⓘ where
Self: 'a,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T> ToString for T where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<F, T, E> TryFuture for F where
F: Future<Output = Result<T, E>> + ?Sized,
[src]
F: Future<Output = Result<T, E>> + ?Sized,
type Ok = T
The type of successful values yielded by this future
type Error = E
The type of failures yielded by this future
pub fn try_poll(
self: Pin<&mut F>,
cx: &mut Context<'_>
) -> Poll<<F as Future>::Output>
[src]
self: Pin<&mut F>,
cx: &mut Context<'_>
) -> Poll<<F as Future>::Output>
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<S, T, E> TryStream for S where
S: Stream<Item = Result<T, E>> + ?Sized,
[src]
S: Stream<Item = Result<T, E>> + ?Sized,