Struct polkadot_node_subsystem::gen::Pin

impl Pinwhere P: Deref, ::Target: Unpin,

const: unstable · source

pub fn new(pointer: P) -> Pin

Construct a new Pin 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 fn into_inner(pin: Pin) -> P

Unwraps this Pin returning the underlying pointer.

This requires that the data inside this Pin implements Unpin so that we can ignore the pinning invariants when unwrapping it.

impl Pinwhere P: Deref,

const: unstable · source

pub unsafe fn new_unchecked(pointer: P) -> Pin

Construct a new Pin 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.

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 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); // Potential UB down the road ⚠️
    // 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(); // Potential UB down the road ⚠️
    // 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.
 }

Pinning of closure captures

Particular care is required when using Pin::new_unchecked in a closure: Pin::new_unchecked(&mut var) where var is a by-value (moved) closure capture implicitly makes the promise that the closure itself is pinned, and that all uses of this closure capture respect that pinning.

use std::pin::Pin;
use std::task::Context;
use std::future::Future;

fn move_pinned_closure(mut x: impl Future, cx: &mut Context<'_>) {
    // Create a closure that moves `x`, and then internally uses it in a pinned way.
    let mut closure = move || unsafe {
        let _ignore = Pin::new_unchecked(&mut x).poll(cx);
    };
    // Call the closure, so the future can assume it has been pinned.
    closure();
    // Move the closure somewhere else. This also moves `x`!
    let mut moved = closure;
    // Calling it again means we polled the future from two different locations,
    // violating the pinning API contract.
    moved(); // Potential UB ⚠️
}

When passing a closure to another API, it might be moving the closure any time, so Pin::new_unchecked on closure captures may only be used if the API explicitly documents that the closure is pinned.

The better alternative is to avoid all that trouble and do the pinning in the outer function instead (here using the pin! macro):

use std::pin::pin;
use std::task::Context;
use std::future::Future;

fn move_pinned_closure(mut x: impl Future, cx: &mut Context<'_>) {
    let mut x = pin!(x);
    // Create a closure that captures `x: Pin<&mut _>`, which is safe to move.
    let mut closure = move || {
        let _ignore = x.as_mut().poll(cx);
    };
    // Call the closure, so the future can assume it has been pinned.
    closure();
    // Move the closure somewhere else.
    let mut moved = closure;
    // Calling it again here is fine (except that we might be polling a future that already
    // returned `Poll::Ready`, but that is a separate problem).
    moved();
}

pub fn as_ref(&self) -> Pin<&::Target>

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) · source

pub unsafe fn into_inner_unchecked(pin: Pin) -> P

Unwraps this Pin 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 Pinwhere P: DerefMut,

pub fn as_mut(&mut self) -> Pin<&mut ::Target>

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: ::Target)where ::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.

Example

use std::pin::Pin;

let mut val: u8 = 5;
let mut pinned: Pin<&mut u8> = Pin::new(&mut val);
println!("{}", pinned); // 5
pinned.as_mut().set(10);
println!("{}", pinned); // 10

impl<'a, T> Pin<&'a T>where T: ?Sized,

pub unsafe fn map_unchecked<U, F>(self, func: F) -> Pin<&'a U>where 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.

const: unstable · source

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.

impl<'a, T> Pin<&'a mut T>where T: ?Sized,

const: unstable · source

pub fn into_ref(self) -> Pin<&'a T>

Converts this Pin<&mut T> into a Pin<&T> with the same lifetime.

const: unstable · source

pub fn get_mut(self) -> &'a mut Twhere 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 · source

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.

pub unsafe fn map_unchecked_mut<U, F>(self, func: F) -> Pin<&'a mut U>where 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,

1.61.0 (const: unstable) · source

pub fn static_ref(r: &'static T) -> Pin<&'static T>

Get a pinned reference from a static reference.

This is safe, because T is borrowed for the 'static lifetime, which never ends.

impl<'a, P> Pin<&'a mut Pin>where P: DerefMut,

pub fn as_deref_mut(self) -> Pin<&'a mut ::Target>

🔬This is a nightly-only experimental API. (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.

impl<T> Pin<&'static mut T>where T: ?Sized,

1.61.0 (const: unstable) · source

pub fn static_mut(r: &'static mut T) -> Pin<&'static mut T>

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 AsyncBufRead for Pinwhere P: DerefMut + Unpin, ::Target: AsyncBufRead,

fn poll_fill_buf( self: Pin<&mut Pin>, cx: &mut Context<'_> ) -> Poll<Result<&[u8], Error>>

Attempt to return the contents of the internal buffer, filling it with more data from the inner reader if it is empty. Read more

fn consume(self: Pin<&mut Pin>, amt: usize)

Tells this buffer that amt bytes have been consumed from the buffer, so they should no longer be returned in calls to poll_read. Read more

impl AsyncBufRead for Pinwhere P: DerefMut + Unpin, ::Target: AsyncBufRead,

fn poll_fill_buf( self: Pin<&mut Pin>, cx: &mut Context<'_> ) -> Poll<Result<&[u8], Error>>

Attempts to return the contents of the internal buffer, filling it with more data from the inner reader if it is empty. Read more

fn consume(self: Pin<&mut Pin>, amt: usize)

Tells this buffer that amt bytes have been consumed from the buffer, so they should no longer be returned in calls to poll_read. Read more

impl AsyncIterator for Pinwhere P: DerefMut, ::Target: AsyncIterator,

type Item = <::Target as AsyncIterator>::Item

🔬This is a nightly-only experimental API. (async_iterator)

The type of items yielded by the async iterator.

fn poll_next( self: Pin<&mut Pin>, cx: &mut Context<'_> ) -> Poll<Option<<Pin as AsyncIterator>::Item>>

🔬This is a nightly-only experimental API. (async_iterator)

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

fn size_hint(&self) -> (usize, Option<usize>)

🔬This is a nightly-only experimental API. (async_iterator)

Returns the bounds on the remaining length of the async iterator. Read more

impl AsyncRead for Pinwhere P: DerefMut + Unpin, ::Target: AsyncRead,

fn poll_read( self: Pin<&mut Pin>, cx: &mut Context<'_>, buf: &mut [u8] ) -> Poll<Result<usize, Error>>

Attempt to read from the AsyncRead into buf. Read more

fn poll_read_vectored( self: Pin<&mut Pin>, cx: &mut Context<'_>, bufs: &mut [IoSliceMut<'_>] ) -> Poll<Result<usize, Error>>

Attempt to read from the AsyncRead into bufs using vectored IO operations. Read more

impl AsyncRead for Pinwhere P: DerefMut + Unpin, ::Target: AsyncRead,

fn poll_read( self: Pin<&mut Pin>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_> ) -> Poll<Result<(), Error>>

Attempts to read from the AsyncRead into buf. Read more

impl AsyncSeek for Pinwhere P: DerefMut + Unpin, ::Target: AsyncSeek,

fn poll_seek( self: Pin<&mut Pin>, cx: &mut Context<'_>, pos: SeekFrom ) -> Poll<Result<u64, Error>>

Attempt to seek to an offset, in bytes, in a stream. Read more

impl AsyncSeek for Pinwhere P: DerefMut + Unpin, ::Target: AsyncSeek,

fn start_seek(self: Pin<&mut Pin>, pos: SeekFrom) -> Result<(), Error>

Attempts to seek to an offset, in bytes, in a stream. Read more

fn poll_complete( self: Pin<&mut Pin>, cx: &mut Context<'_> ) -> Poll<Result<u64, Error>>

Waits for a seek operation to complete. Read more

impl AsyncWrite for Pinwhere P: DerefMut + Unpin, ::Target: AsyncWrite,

fn poll_write( self: Pin<&mut Pin>, cx: &mut Context<'_>, buf: &[u8] ) -> Poll<Result<usize, Error>>

Attempt to write bytes from buf into the object. Read more

fn poll_write_vectored( self: Pin<&mut Pin>, cx: &mut Context<'_>, bufs: &[IoSlice<'_>] ) -> Poll<Result<usize, Error>>

Attempt to write bytes from bufs into the object using vectored IO operations. Read more

fn poll_flush( self: Pin<&mut Pin>, cx: &mut Context<'_> ) -> Poll<Result<(), Error>>

Attempt to flush the object, ensuring that any buffered data reach their destination. Read more

fn poll_close( self: Pin<&mut Pin>, cx: &mut Context<'_> ) -> Poll<Result<(), Error>>

Attempt to close the object. Read more

impl AsyncWrite for Pinwhere P: DerefMut + Unpin, ::Target: AsyncWrite,

fn poll_write( self: Pin<&mut Pin>, cx: &mut Context<'_>, buf: &[u8] ) -> Poll<Result<usize, Error>>

Attempt to write bytes from buf into the object. Read more

fn poll_write_vectored( self: Pin<&mut Pin>, cx: &mut Context<'_>, bufs: &[IoSlice<'_>] ) -> Poll<Result<usize, Error>>

Like poll_write, except that it writes from a slice of buffers. Read more

fn is_write_vectored(&self) -> bool

Determines if this writer has an efficient poll_write_vectored implementation. Read more

fn poll_flush( self: Pin<&mut Pin>, cx: &mut Context<'_> ) -> Poll<Result<(), Error>>

Attempts to flush the object, ensuring that any buffered data reach their destination. Read more

fn poll_shutdown( self: Pin<&mut Pin>, cx: &mut Context<'_> ) -> Poll<Result<(), Error>>

Initiates or attempts to shut down this writer, returning success when the I/O connection has completely shut down. Read more

impl Body for Pinwhere P: Unpin + DerefMut, ::Target: Body,

type Data = <::Target as Body>::Data

Values yielded by the Body.

type Error = <::Target as Body>::Error

The error type this Body might generate.

fn poll_data( self: Pin<&mut Pin>, cx: &mut Context<'_> ) -> Poll<Option<Result<<Pin as Body>::Data, <Pin as Body>::Error>>>

Attempt to pull out the next data buffer of this stream.

fn poll_trailers( self: Pin<&mut Pin>, cx: &mut Context<'_> ) -> Poll<Result<Option<HeaderMap<HeaderValue>>, <Pin as Body>::Error>>

Poll for an optional single HeaderMap of trailers. Read more

fn is_end_stream(&self) -> bool

Returns true when the end of stream has been reached. Read more

fn size_hint(&self) -> SizeHint

Returns the bounds on the remaining length of the stream. Read more

fn data(&mut self) -> Data<'_, Self> ⓘwhere Self: Unpin + Sized,

Returns future that resolves to next data chunk, if any.

fn trailers(&mut self) -> Trailers<'_, Self> ⓘwhere Self: Unpin + Sized,

Returns future that resolves to trailers, if any.

fn map_data<F, B>(self, f: F) -> MapData<Self, F>where Self: Sized, F: FnMut(Self::Data) -> B, B: Buf,

Maps this body’s data value to a different value.

fn map_err<F, E>(self, f: F) -> MapErr<Self, F>where Self: Sized, F: FnMut(Self::Error) -> E,

Maps this body’s error value to a different value.

impl Clone for Pinwhere P: Clone,

fn clone(&self) -> Pin

Returns a copy of the value. Read more

1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more

impl Debug for Pinwhere P: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more

impl Deref for Pinwhere P: Deref,

type Target = ::Target

The resulting type after dereferencing.

fn deref(&self) -> &::Target

Dereferences the value.

impl DerefMut for Pinwhere P: DerefMut, ::Target: Unpin,

fn deref_mut(&mut self) -> &mut ::Target

Mutably dereferences the value.

impl Display for Pinwhere P: Display,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more

impl<T, A> From<Box<T, A>> for Pin<Box<T, A>>where A: Allocator + 'static, T: ?Sized,

fn from(boxed: Box<T, A>) -> Pin<Box<T, A>>

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.

impl<'a, F> From<Pin<Box<F, Global>>> for FutureObj<'a, ()>where F: Future<Output = ()> + Send + 'a,

fn from(boxed: Pin<Box<F, Global>>) -> FutureObj<'a, ()> ⓘ

Converts to this type from the input type.

impl<'a, F> From<Pin<Box<F, Global>>> for LocalFutureObj<'a, ()>where F: Future<Output = ()> + 'a,

fn from(boxed: Pin<Box<F, Global>>) -> LocalFutureObj<'a, ()> ⓘ

Converts to this type from the input type.

impl<'a> From<Pin<Box<dyn Future<Output = ()> + 'a, Global>>> for LocalFutureObj<'a, ()>

fn from( boxed: Pin<Box<dyn Future<Output = ()> + 'a, Global>> ) -> LocalFutureObj<'a, ()> ⓘ

Converts to this type from the input type.

impl<'a> From<Pin<Box<dyn Future<Output = ()> + Send + 'a, Global>>> for FutureObj<'a, ()>

fn from( boxed: Pin<Box<dyn Future<Output = ()> + Send + 'a, Global>> ) -> FutureObj<'a, ()> ⓘ

Converts to this type from the input type.

impl FusedFuture for Pinwhere P: DerefMut + Unpin, ::Target: FusedFuture,

fn is_terminated(&self) -> bool

Returns true if the underlying future should no longer be polled.

impl FusedStream for Pinwhere P: DerefMut + Unpin, ::Target: FusedStream,

fn is_terminated(&self) -> bool

Returns true if the stream should no longer be polled.

1.36.0 · source§

impl Future for Pinwhere P: DerefMut, ::Target: Future,

type Output = <::Target as Future>::Output

The type of value produced on completion.

fn poll( self: Pin<&mut Pin>, cx: &mut Context<'_> ) -> Poll<<Pin as Future>::Output>

Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available. Read more