logo

Struct async_std::pin::Pin

1.33.0 · source · []
#[repr(transparent)]
pub struct Pin<P> { /* private fields */ }
Available on 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

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.

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();
    }
}

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.

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.

Get a pinned reference from a static reference.

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

🔬 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.

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

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

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

The type of items yielded by the async iterator.

🔬 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

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

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

Attempt to read from the AsyncRead into buf. Read more

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

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

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

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

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

Attempt to close the object. Read more

Returns a copy of the value. Read more

Performs copy-assignment from source. Read more

Formats the value using the given formatter. Read more

The resulting type after dereferencing.

Dereferences the value.

Mutably dereferences the value.

Formats the value using the given formatter. Read more

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.

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

Returns true if the stream should no longer be polled.

The type of value produced on completion.

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

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

The type of value this generator yields. Read more

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

The type of value this generator returns. Read more

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

Resumes the execution of this generator. Read more

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

The type of value this generator yields. Read more

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

The type of value this generator returns. Read more

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

Resumes the execution of this generator. Read more

Feeds this value into the given Hasher. Read more

Feeds a slice of this type into the given Hasher. Read more

This method returns an Ordering between self and other. Read more

Compares and returns the maximum of two values. Read more

Compares and returns the minimum of two values. Read more

Restrict a value to a certain interval. Read more

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more

Formats the value using the given formatter.

Values yielded by the 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

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

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Returns the contents of the internal buffer, filling it with more data if empty. Read more

Consumes amt buffered bytes. Read more

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

Returns a stream over the contents of this reader split on the specified byte. Read more

Reads some bytes from the byte stream. Read more

Like read(), except it reads into a slice of buffers. Read more

Reads the entire contents and appends them to a Vec. Read more

Reads the entire contents and appends them to a String. Read more

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

Converts this AsyncRead into a Stream of bytes. 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

Seeks to a new position in a byte stream. Read more

Writes some bytes into the byte stream. Read more

Like write(), except that it writes a slice of buffers. Read more

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

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Returns the argument unchanged.

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

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

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

The output that the future will produce on completion.

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

Which kind of future are we turning this into?

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

Creates a future from a value. Read more

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 only the first n items of the stream. Read more

Takes items while predicate returns true. Read more

Skips the first n items of the stream. Read more

Skips items while predicate returns true. Read more

Yields every stepth item. 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

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

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

Fuses the stream so that it stops yielding items after the first None. 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 nth 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

Applies a closure to items in the stream and returns the first Some result. 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

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

The resulting type after obtaining ownership.

Creates owned data from borrowed data, usually by cloning. Read more

Uses borrowed data to replace owned data, usually by cloning. Read more

Converts the given value to a String. Read more

The type returned in the event of a conversion error.

Performs the conversion.

The type of successful values yielded by this future

The type of failures yielded by this future

Poll this TryFuture as if it were a Future. Read more

The type returned in the event of a conversion error.

Performs the conversion.

The type of successful values yielded by this future

The type of failures yielded by this future

Poll this TryStream as if it were a Stream. Read more