Struct async_std::pin::Pin 1.33.0[−][src]
#[repr(transparent)]pub struct Pin<P> { /* fields omitted */ }
unstable
only.Expand description
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
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.
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.
}
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
.
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.
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();
}
}
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.
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
.
Converts this Pin<&mut T>
into a Pin<&T>
with the same lifetime.
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
.
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.
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.
pub fn static_ref(r: &'static T) -> Pin<&'static T>ⓘ
🔬 This is a nightly-only experimental API. (pin_static_ref
)
pub fn static_ref(r: &'static T) -> Pin<&'static T>ⓘ
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.
pub fn as_deref_mut(self) -> Pin<&'a mut <P as Deref>::Target>ⓘ
🔬 This is a nightly-only experimental API. (pin_deref_mut
)
pub fn as_deref_mut(self) -> Pin<&'a mut <P as Deref>::Target>ⓘ
pin_deref_mut
)Gets a pinned mutable reference from this nested pinned pointer.
This is a generic method to go from Pin<&mut Pin<Pointer<T>>>
to Pin<&mut T>
. It is
safe because the existence of a Pin<Pointer<T>>
ensures that the pointee, T
, cannot
move in the future, and this method does not enable the pointee to move. “Malicious”
implementations of P::DerefMut
are likewise ruled out by the contract of
Pin::new_unchecked
.
pub fn static_mut(r: &'static mut T) -> Pin<&'static mut T>ⓘ
🔬 This is a nightly-only experimental API. (pin_static_ref
)
pub fn static_mut(r: &'static mut T) -> Pin<&'static mut T>ⓘ
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
Attempt to return the contents of the internal buffer, filling it with more data from the inner reader if it is empty. Read more
Attempt to read from the AsyncRead
into buf
. Read more
Returns the contents of the internal buffer, filling it with more data from the inner reader if it is empty. Read more
Tells this buffer that amt
bytes have been consumed from the buffer, so they
should no longer be returned in calls to read
. Read more
Reads all bytes into buf
until the delimiter byte
or EOF is reached. Read more
Reads all bytes and appends them into buf
until a newline (the 0xA byte) is
reached. Read more
Returns a stream over the lines of this byte stream. Read more
Converts a Box<T>
into a Pin<Box<T>>
This conversion does not allocate on the heap and happens in place.
Returns true
if the underlying future should no longer be polled.
Returns true
if the stream should no longer be polled.
Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available. Read more
unstable
only.Returns a Future that delays execution for a specified time. Read more
fn flatten(self) -> ImplFuture<<Self::Output as IntoFuture>::Output> where
Self: Sized,
<Self as Future>::Output: IntoFuture,
fn flatten(self) -> ImplFuture<<Self::Output as IntoFuture>::Output> where
Self: Sized,
<Self as Future>::Output: IntoFuture,
unstable
only.Flatten out the execution of this future when the result itself can be converted into another future. Read more
unstable
only.Waits for one of two similarly-typed futures to complete. Read more
unstable
only.Waits for one of two similarly-typed fallible futures to complete. Read more
unstable
only.Waits for two similarly-typed fallible futures to complete. Read more
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
Attempt to read from the AsyncRead
into buf
.
Attempt to read from the AsyncRead
into bufs
using vectored IO operations.
Reads some bytes from the byte stream. Read more
fn read_vectored<'a>(
&'a mut self,
bufs: &'a mut [IoSliceMut<'a>]
) -> ImplFuture<Result<usize>> where
Self: Unpin,
fn read_vectored<'a>(
&'a mut self,
bufs: &'a mut [IoSliceMut<'a>]
) -> ImplFuture<Result<usize>> where
Self: Unpin,
Reads all bytes from the byte stream. Read more
Reads all bytes from the byte stream and appends them into a string. Read more
Reads the exact number of bytes required to fill buf
. Read more
Creates an adaptor which will read at most limit
bytes from it. Read more
Creates a “by reference” adaptor for this instance of Read
. Read more
Transforms this Read
instance to a Stream
over its bytes. Read more
async_stream
)The type of items yielded by the stream.
async_stream
)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. Read more
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. Read more
Attempts to receive the next item from the stream. Read more
Advances the stream and returns the next value. Read more
Creates a stream that yields its first n
elements. Read more
Creates a stream that yields elements based on a predicate. Read more
unstable
only.Limit the amount of items yielded per timeslice in a stream. Read more
Creates a stream that yields each step
th element. Read more
Takes two streams and creates a new stream over both in sequence. Read more
Creates an stream which copies all of its elements. Read more
Creates an stream which copies all of its elements. Read more
Creates a stream that yields the provided values infinitely and in order. Read more
Creates a stream that gives the current element’s count as well as the next value. Read more
unstable
only.Creates a stream that is delayed before it starts yielding items. Read more
Takes a closure and creates a stream that calls that closure on every element of this stream. Read more
A combinator that does something with each element in the stream, passing the value on. Read more
Returns the last element of the stream. Read more
Creates a stream which ends after the first None
. Read more
Creates a stream that uses a predicate to determine if an element should be yielded. Read more
unstable
only.Creates an stream that works like map, but flattens nested structure. Read more
Both filters and maps a stream. Read more
Returns the element that gives the minimum value with respect to the
specified key function. If several elements are equally minimum,
the first element is returned. If the stream is empty, None
is returned. Read more
Returns the element that gives the maximum value with respect to the
specified key function. If several elements are equally maximum,
the first element is returned. If the stream is empty, None
is returned. Read more
Returns the element that gives the minimum value with respect to the
specified comparison function. If several elements are equally minimum,
the first element is returned. If the stream is empty, None
is returned. Read more
Returns the element that gives the maximum value. If several elements are equally maximum,
the first element is returned. If the stream is empty, None
is returned. Read more
Returns the element that gives the minimum value. If several elements are equally minimum,
the first element is returned. If the stream is empty, None
is returned. Read more
Returns the element that gives the maximum value with respect to the
specified comparison function. If several elements are equally maximum,
the first element is returned. If the stream is empty, None
is returned. Read more
Returns the nth element of the stream. Read more
Tests if every element of the stream matches a predicate. Read more
Searches for an element in a stream that satisfies a predicate. Read more
Applies function to the elements of stream and returns the first non-none result. Read more
A combinator that applies a function to every element in a stream producing a single, final value. Read more
unstable
only.A combinator that applies a function to every element in a stream creating two collections from it. Read more
Call a closure on each element of the stream. Read more
Tests if any element of the stream matches a predicate. Read more
Combinator that skip
s elements based on a predicate. Read more
Creates a combinator that skips the first n
elements. Read more
A combinator that applies a function as long as it returns successfully, producing a single, final value. Immediately returns the error when the function returns unsuccessfully. Read more
Applies a falliable function to each element in a stream, stopping at first error and returning it. Read more
‘Zips up’ two streams into a single stream of pairs. Read more
unstable
only.Combines multiple streams into a single stream of all their outputs. Read more
Lexicographically compares the elements of this Stream
with those
of another. Read more
Searches for an element in a Stream that satisfies a predicate, returning its index. Read more
Lexicographically compares the elements of this Stream
with those
of another using ‘Ord’. Read more
Determines if the elements of this Stream
are lexicographically
not equal to those of another. Read more
Determines if the elements of this Stream
are lexicographically
greater than or equal to those of another. Read more
Determines if the elements of this Stream
are lexicographically
equal to those of another. Read more
Determines if the elements of this Stream
are lexicographically
greater than those of another. Read more
Determines if the elements of this Stream
are lexicographically
less or equal to those of another. Read more
Determines if the elements of this Stream
are lexicographically
less than those of another. Read more
Attempt to write bytes from buf
into the object.
Attempt to flush the object, ensuring that any buffered data reach their destination. Read more
Attempt to close the object.
Attempt to write bytes from bufs
into the object using vectored IO operations.
Writes some bytes into the byte stream. Read more
Flushes the stream to ensure that all buffered contents reach their destination. Read more
Writes an entire buffer into the byte stream. Read more
Auto Trait Implementations
impl<P> RefUnwindSafe for Pin<P> where
P: RefUnwindSafe,
impl<P> UnwindSafe for Pin<P> where
P: UnwindSafe,
Blanket Implementations
Returns the contents of the internal buffer, filling it with more data if empty. Read more
fn read_until(
&'a mut self,
byte: u8,
buf: &'a mut Vec<u8, Global>
) -> ReadUntilFuture<'a, Self> where
Self: Unpin,
fn read_until(
&'a mut self,
byte: u8,
buf: &'a mut Vec<u8, Global>
) -> ReadUntilFuture<'a, Self> where
Self: Unpin,
Reads all bytes and appends them into buf
until the delimiter byte
or EOF is found. Read more
Reads all bytes and appends them into buf
until a newline (the 0xA byte) or EOF is found. Read more
Returns a stream over the lines of this byte stream. Read more
Reads some bytes from the byte stream. Read more
fn read_vectored(
&'a mut self,
bufs: &'a mut [IoSliceMut<'a>]
) -> ReadVectoredFuture<'a, Self> where
Self: Unpin,
fn read_vectored(
&'a mut self,
bufs: &'a mut [IoSliceMut<'a>]
) -> ReadVectoredFuture<'a, Self> where
Self: Unpin,
fn read_to_end(
&'a mut self,
buf: &'a mut Vec<u8, Global>
) -> ReadToEndFuture<'a, Self> where
Self: Unpin,
fn read_to_end(
&'a mut self,
buf: &'a mut Vec<u8, Global>
) -> ReadToEndFuture<'a, Self> where
Self: Unpin,
fn read_to_string(
&'a mut self,
buf: &'a mut String
) -> ReadToStringFuture<'a, Self> where
Self: Unpin,
fn read_to_string(
&'a mut self,
buf: &'a mut String
) -> ReadToStringFuture<'a, Self> where
Self: Unpin,
Reads the exact number of bytes required to fill buf
. Read more
Creates an adapter which will read at most limit
bytes from it. Read more
Creates an adapter which will chain this stream with another. Read more
Boxes the reader and changes its type to dyn AsyncRead + Send + 'a
. Read more
Writes some bytes into the byte stream. Read more
fn write_vectored(
&'a mut self,
bufs: &'a [IoSlice<'a>]
) -> WriteVectoredFuture<'a, Self> where
Self: Unpin,
fn write_vectored(
&'a mut self,
bufs: &'a [IoSlice<'a>]
) -> WriteVectoredFuture<'a, Self> where
Self: Unpin,
Writes an entire buffer into the byte stream. Read more
Flushes the stream to ensure that all buffered contents reach their destination. Read more
Closes the writer. Read more
Boxes the writer and changes its type to dyn AsyncWrite + Send + 'a
. Read more
Mutably borrows from an owned value. Read more
A convenience for calling Future::poll()
on !
Unpin
types.
Returns the result of self
or other
future, preferring self
if both are ready. Read more
Returns the result of self
or other
future, with no preference if both are ready. Read more
Catches panics while polling the future. Read more
Boxes the future and changes its type to dyn Future + Send + 'a
. Read more
Boxes the future and changes its type to dyn Future + 'a
. Read more
into_future
)The output that the future will produce on completion.
type Future = F
type Future = F
into_future
)Which kind of future are we turning this into?
into_future
)Creates a future from a value.
A convenience for calling Stream::poll_next()
on !
Unpin
types.
Retrieves the next item in the stream. Read more
Retrieves the next item in the stream. Read more
Counts the number of items in the stream. Read more
Maps items of the stream to new values using a closure. Read more
Maps items to streams and then concatenates them. Read more
Concatenates inner streams. Read more
Maps items of the stream to new values using an async closure. Read more
Keeps items of the stream for which predicate
returns true
. Read more
Filters and maps items of the stream using a closure. Read more
Takes items while predicate
returns true
. Read more
Skips items while predicate
returns true
. Read more
Appends another stream to the end of this one. Read more
Clones all items. Read more
Copies all items. Read more
Collects all items in the stream into a collection. Read more
fn try_collect<T, E, C>(self) -> TryCollectFuture<Self, C> where
Self: Stream<Item = Result<T, E>>,
C: Default + Extend<T>,
fn try_collect<T, E, C>(self) -> TryCollectFuture<Self, C> where
Self: Stream<Item = Result<T, E>>,
C: Default + Extend<T>,
Collects all items in the fallible stream into a collection. Read more
Partitions items into those for which predicate
is true
and those for which it is
false
, and then collects them into two collections. Read more
fn fold<T, F>(self, init: T, f: F) -> FoldFuture<Self, F, T> where
F: FnMut(T, Self::Item) -> T,
fn fold<T, F>(self, init: T, f: F) -> FoldFuture<Self, F, T> where
F: FnMut(T, Self::Item) -> T,
Accumulates a computation over the stream. Read more
Accumulates a fallible computation over the stream. Read more
Maps items of the stream to new values using a state value and a closure. Read more
Repeats the stream from beginning to end, forever. Read more
Enumerates items, mapping them to (index, item)
. Read more
Calls a closure on each item and passes it on. Read more
Gets the n
th item of the stream. Read more
Returns the last item in the stream. Read more
Finds the first item of the stream for which predicate
returns true
. Read more
Finds the index of the first item of the stream for which predicate
returns true
. Read more
Tests if predicate
returns true
for all items in the stream. Read more
Tests if predicate
returns true
for any item in the stream. Read more
Calls a closure on each item of the stream. Read more
fn try_for_each<F, E>(&mut self, f: F) -> TryForEachFuture<'_, Self, F> where
Self: Unpin,
F: FnMut(Self::Item) -> Result<(), E>,
fn try_for_each<F, E>(&mut self, f: F) -> TryForEachFuture<'_, Self, F> where
Self: Unpin,
F: FnMut(Self::Item) -> Result<(), E>,
Calls a fallible closure on each item of the stream, stopping on first error. Read more
Zips up two streams into a single stream of pairs. Read more
Collects a stream of pairs into a pair of collections. Read more
Merges with other
stream, preferring items from self
whenever both streams are ready. Read more
Merges with other
stream, with no preference for either stream when both are ready. Read more
Boxes the stream and changes its type to dyn Stream + Send + 'a
. Read more
Boxes the stream and changes its type to dyn Stream + 'a
. Read more