#[repr(transparent)]pub struct Pin<P> { /* private fields */ }
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
sourceimpl<P> Pin<P> where
P: Deref,
<P as Deref>::Target: Unpin,
impl<P> Pin<P> where
P: Deref,
<P as Deref>::Target: Unpin,
const: unstable · sourcepub fn new(pointer: P) -> Pin<P>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
pub fn new(pointer: P) -> Pin<P>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
1.39.0 (const: unstable) · sourcepub fn into_inner(pin: Pin<P>) -> P
pub fn into_inner(pin: Pin<P>) -> P
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.
sourceimpl<P> Pin<P> where
P: Deref,
impl<P> Pin<P> where
P: Deref,
const: unstable · sourcepub unsafe fn new_unchecked(pointer: P) -> Pin<P>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
pub unsafe fn new_unchecked(pointer: P) -> Pin<P>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
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.
}
RunA 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.
}
Runsourcepub fn as_ref(&self) -> Pin<&<P as Deref>::Target>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
pub fn as_ref(&self) -> Pin<&<P as Deref>::Target>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
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
.
1.39.0 (const: unstable) · sourcepub unsafe fn into_inner_unchecked(pin: Pin<P>) -> P
pub unsafe fn into_inner_unchecked(pin: Pin<P>) -> P
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.
sourceimpl<P> Pin<P> where
P: DerefMut,
impl<P> Pin<P> where
P: DerefMut,
sourcepub fn as_mut(&mut self) -> Pin<&mut <P as Deref>::Target>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
pub fn as_mut(&mut self) -> Pin<&mut <P as Deref>::Target>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
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();
}
}
Runsourceimpl<'a, T> Pin<&'a T> where
T: ?Sized,
impl<'a, T> Pin<&'a T> where
T: ?Sized,
sourcepub unsafe fn map_unchecked<U, F>(self, func: F) -> Pin<&'a U>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
where
F: FnOnce(&T) -> &U,
U: ?Sized,
pub unsafe fn map_unchecked<U, F>(self, func: F) -> Pin<&'a U>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
where
F: FnOnce(&T) -> &U,
U: ?Sized,
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
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.
const: unstable · sourcepub fn get_ref(self) -> &'a T
pub fn get_ref(self) -> &'a T
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
.
sourceimpl<'a, T> Pin<&'a mut T> where
T: ?Sized,
impl<'a, T> Pin<&'a mut T> where
T: ?Sized,
const: unstable · sourcepub fn into_ref(self) -> Pin<&'a T>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
pub fn into_ref(self) -> Pin<&'a T>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
Converts this Pin<&mut T>
into a Pin<&T>
with the same lifetime.
const: unstable · sourcepub fn get_mut(self) -> &'a mut T where
T: Unpin,
pub fn get_mut(self) -> &'a mut T where
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
.
const: unstable · sourcepub unsafe fn get_unchecked_mut(self) -> &'a mut T
pub unsafe fn get_unchecked_mut(self) -> &'a mut T
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.
sourcepub unsafe fn map_unchecked_mut<U, F>(self, func: F) -> Pin<&'a mut U>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
where
F: FnOnce(&mut T) -> &mut U,
U: ?Sized,
pub unsafe fn map_unchecked_mut<U, F>(self, func: F) -> Pin<&'a mut U>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
where
F: FnOnce(&mut T) -> &mut U,
U: ?Sized,
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
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.
sourceimpl<T> Pin<&'static T> where
T: ?Sized,
impl<T> Pin<&'static T> where
T: ?Sized,
1.61.0 (const: unstable) · sourcepub fn static_ref(r: &'static T) -> Pin<&'static T>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
pub fn static_ref(r: &'static T) -> Pin<&'static T>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
Get a pinned reference from a static reference.
This is safe, because T
is borrowed for the 'static
lifetime, which
never ends.
sourceimpl<'a, P> Pin<&'a mut Pin<P>> where
P: DerefMut,
impl<'a, P> Pin<&'a mut Pin<P>> where
P: DerefMut,
sourcepub fn as_deref_mut(self) -> Pin<&'a mut <P as Deref>::Target>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
pub fn as_deref_mut(self) -> Pin<&'a mut <P as Deref>::Target>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
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
.
sourceimpl<T> Pin<&'static mut T> where
T: ?Sized,
impl<T> Pin<&'static mut T> where
T: ?Sized,
1.61.0 (const: unstable) · sourcepub fn static_mut(r: &'static mut T) -> Pin<&'static mut T>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
pub fn static_mut(r: &'static mut T) -> Pin<&'static mut T>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
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
sourceimpl<P> AsyncIterator for Pin<P> where
P: DerefMut,
<P as Deref>::Target: AsyncIterator,
impl<P> AsyncIterator for Pin<P> where
P: DerefMut,
<P as Deref>::Target: AsyncIterator,
type Item = <<P as Deref>::Target as AsyncIterator>::Item
type Item = <<P as Deref>::Target as AsyncIterator>::Item
The type of items yielded by the async iterator.
sourcefn poll_next(
self: Pin<&mut Pin<P>>,
cx: &mut Context<'_>
) -> Poll<Option<<Pin<P> as AsyncIterator>::Item>>
fn poll_next(
self: Pin<&mut Pin<P>>,
cx: &mut Context<'_>
) -> Poll<Option<<Pin<P> as AsyncIterator>::Item>>
Attempt to pull out the next value of this async iterator, registering the
current task for wakeup if the value is not yet available, and returning
None
if the async iterator is exhausted. Read more
sourceimpl<P> Clone for Pin<P> where
P: Clone,
impl<P> Clone for Pin<P> where
P: Clone,
sourcefn clone(&self) -> Pin<P>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
fn clone(&self) -> Pin<P>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
Returns a copy of the value. Read more
1.0.0 · sourcefn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source
. Read more
const: unstable · sourceimpl<T, A> From<Box<T, A>> for Pin<Box<T, A>> where
A: Allocator + 'static,
T: ?Sized,
impl<T, A> From<Box<T, A>> for Pin<Box<T, A>> where
A: Allocator + 'static,
T: ?Sized,
const: unstable · sourcefn from(boxed: Box<T, A>) -> Pin<Box<T, A>>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
fn from(boxed: Box<T, A>) -> Pin<Box<T, A>>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
P: DerefMut,
<P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output;
Converts a Box<T>
into a Pin<Box<T>>
. If T
does not implement Unpin
, then
*boxed
will be pinned in memory and unable to be moved.
This conversion does not allocate on the heap and happens in place.
This is also available via Box::into_pin
.
Constructing and pinning a Box
with <Pin<Box<T>>>::from(Box::new(x))
can also be written more concisely using Box::pin(x)
.
This From
implementation is useful if you already have a Box<T>
, or you are
constructing a (pinned) Box
in a different way than with Box::new
.
sourceimpl<'_, G, R> Generator<R> for Pin<&'_ mut G> where
G: Generator<R> + ?Sized,
impl<'_, G, R> Generator<R> for Pin<&'_ mut G> where
G: Generator<R> + ?Sized,
sourceimpl<G, R, A> Generator<R> for Pin<Box<G, A>> where
G: Generator<R> + ?Sized,
A: Allocator + 'static,
impl<G, R, A> Generator<R> for Pin<Box<G, A>> where
G: Generator<R> + ?Sized,
A: Allocator + 'static,
1.41.0 · sourceimpl<P> Ord for Pin<P> where
P: Deref,
<P as Deref>::Target: Ord,
impl<P> Ord for Pin<P> where
P: Deref,
<P as Deref>::Target: Ord,
1.41.0 · sourceimpl<P, Q> PartialEq<Pin<Q>> for Pin<P> where
P: Deref,
Q: Deref,
<P as Deref>::Target: PartialEq<<Q as Deref>::Target>,
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 · sourceimpl<P, Q> PartialOrd<Pin<Q>> for Pin<P> where
P: Deref,
Q: Deref,
<P as Deref>::Target: PartialOrd<<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>,
sourcefn partial_cmp(&self, other: &Pin<Q>) -> Option<Ordering>
fn partial_cmp(&self, other: &Pin<Q>) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
sourcefn lt(&self, other: &Pin<Q>) -> bool
fn lt(&self, other: &Pin<Q>) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
sourcefn le(&self, other: &Pin<Q>) -> bool
fn le(&self, other: &Pin<Q>) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
impl<P, U> CoerceUnsized<Pin<U>> for Pin<P> where
P: CoerceUnsized<U>,
impl<P> Copy for Pin<P> where
P: Copy,
impl<P, U> DispatchFromDyn<Pin<U>> for Pin<P> where
P: DispatchFromDyn<U>,
impl<P> Eq for Pin<P> where
P: Deref,
<P as Deref>::Target: Eq,
Auto Trait Implementations
impl<P> RefUnwindSafe for Pin<P> where
P: RefUnwindSafe,
impl<P> Send for Pin<P> where
P: Send,
impl<P> Sync for Pin<P> where
P: Sync,
impl<P> Unpin for Pin<P> where
P: Unpin,
impl<P> UnwindSafe for Pin<P> where
P: UnwindSafe,
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
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