alloc::boxed::PinBox - Rust
Description: API documentation for the Rust `PinBox` struct in crate `alloc`.
Keywords: rust, rustlang, rust-lang, PinBox

# Struct alloc::boxed::PinBox[−][src]

    #[repr(transparent)]
    pub struct PinBox<T: ?Sized> { /* fields omitted */ }

🔬 This is a nightly-only experimental API. (`pin` #49150)

A pinned, heap allocated reference.

## Methods

###

`impl<T> PinBox<T>`

[src]

####

`pub fn new(data: T) -> PinBox<T>`

[src]

🔬 This is a nightly-only experimental API. (`pin` #49150)

Allocate memory on the heap, move the data into it and pin it.

###

`impl<T: ?Sized> PinBox<T>`

[src]

####

`pub fn as_pin_mut<'a>(&'a mut self) -> PinMut<'a, T>`

[src]

🔬 This is a nightly-only experimental API. (`pin` #49150)

Get a pinned reference to the data in this PinBox.

####

`pub unsafe fn from_raw(raw: *mut T) -> Self`

[src]

🔬 This is a nightly-only experimental API. (`pin` #49150)

Constructs a `PinBox` from a raw pointer.

After calling this function, the raw pointer is owned by the resulting `PinBox`. Specifically, the `PinBox` destructor will call the destructor of `T` and free the allocated memory. Since the way `PinBox` allocates and releases memory is unspecified, the only valid pointer to pass to this function is the one taken from another `PinBox` via the `PinBox::into_raw` function.

This function is unsafe because improper use may lead to memory problems. For example, a double-free may occur if the function is called twice on the same raw pointer.

# Examples

    #![feature(pin)]
    use std::boxed::PinBox;
    let x = PinBox::new(5);
    let ptr = PinBox::into_raw(x);
    let x = unsafe { PinBox::from_raw(ptr) };

####

`pub fn into_raw(b: PinBox<T>) -> *mut T`

[src]

🔬 This is a nightly-only experimental API. (`pin` #49150)

Consumes the `PinBox`, returning the wrapped raw pointer.

After calling this function, the caller is responsible for the memory previously managed by the `PinBox`. In particular, the caller should properly destroy `T` and release the memory. The proper way to do so is to convert the raw pointer back into a `PinBox` with the `PinBox::from_raw` function.

Note: this is an associated function, which means that you have to call it as `PinBox::into_raw(b)` instead of `b.into_raw()`. This is so that there is no conflict with a method on the inner type.

# Examples

    #![feature(pin)]
    use std::boxed::PinBox;
    let x = PinBox::new(5);
    let ptr = PinBox::into_raw(x);

####

`pub unsafe fn get_mut<'a>(this: &'a mut PinBox<T>) -> &'a mut T`

[src]

🔬 This is a nightly-only experimental API. (`pin` #49150)

Get a mutable reference to the data inside this PinBox.

This function is unsafe. Users must guarantee that the data is never moved out of this reference.

####
ⓘImportant traits for Box<I>

### Important traits for Box<I>

`impl<I: Iterator + ?Sized> Iterator for Box<I> type Item = I::Item;`

`pub unsafe fn unpin(this: PinBox<T>) -> Box<T>`

[src]

🔬 This is a nightly-only experimental API. (`pin` #49150)

Convert this PinBox into an unpinned Box.

This function is unsafe. Users must guarantee that the data is never moved out of the box.

## Trait Implementations

###

`impl<T: ?Sized> From<Box<T>> for PinBox<T>`

[src]

####

`fn from(boxed: Box<T>) -> PinBox<T>`

[src]

Performs the conversion.

###

`impl<T: Unpin + ?Sized> From<PinBox<T>> for Box<T>`

[src]

####
ⓘImportant traits for Box<I>

### Important traits for Box<I>

`impl<I: Iterator + ?Sized> Iterator for Box<I> type Item = I::Item;`

`fn from(pinned: PinBox<T>) -> Box<T>`

[src]

Performs the conversion.

###

`impl<T: ?Sized> Deref for PinBox<T>`

[src]

#### `type Target = T`

The resulting type after dereferencing.

####

`fn deref(&self) -> &T`

[src]

Dereferences the value.

###

`impl<T: Unpin + ?Sized> DerefMut for PinBox<T>`

[src]

####

`fn deref_mut(&mut self) -> &mut T`

[src]

Mutably dereferences the value.

###

`impl<T: Display + ?Sized> Display for PinBox<T>`

[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result`

[src]

Formats the value using the given formatter. Read more

###

`impl<T: Debug + ?Sized> Debug for PinBox<T>`

[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result`

[src]

Formats the value using the given formatter. Read more

###

`impl<T: ?Sized> Pointer for PinBox<T>`

[src]

####

`fn fmt(&self, f: &mut Formatter) -> Result`

[src]

Formats the value using the given formatter.

###

`impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<PinBox<U>> for PinBox<T>`

[src]

###

`impl<T: ?Sized> Unpin for PinBox<T>`

[src]

###

`impl<F: ?Sized + Future> Future for PinBox<F>`

[src]

#### `type Output = F::Output`

🔬 This is a nightly-only experimental API. (`futures_api` #50547)

futures in libcore are unstable

The result of the `Future`.

####

`fn poll(self: PinMut<Self>, cx: &mut Context) -> Poll<Self::Output>`

[src]

🔬 This is a nightly-only experimental API. (`futures_api` #50547)

futures in libcore are unstable

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

###

`impl<'a, T, F> UnsafeFutureObj<'a, T> for PinBox<F> where F: Future<Output = T> + 'a,`

[src]

####

`fn into_raw(self) -> *mut ()`

[src]

🔬 This is a nightly-only experimental API. (`futures_api` #50547)

futures in libcore are unstable

Convert an owned instance into a (conceptually owned) void pointer.

####

`unsafe fn poll(ptr: *mut (), cx: &mut Context) -> Poll<T>`

[src]

🔬 This is a nightly-only experimental API. (`futures_api` #50547)

futures in libcore are unstable

Poll the future represented by the given void pointer. Read more

####

`unsafe fn drop(ptr: *mut ())`

[src]

🔬 This is a nightly-only experimental API. (`futures_api` #50547)

futures in libcore are unstable

Drops the future represented by the given void pointer. Read more

###

`impl<'a, F: Future<Output = ()> + Send + 'a> From<PinBox<F>> for FutureObj<'a, ()>`

[src]

####

`fn from(boxed: PinBox<F>) -> Self`

[src]

Performs the conversion.

###

`impl<'a, F: Future<Output = ()> + 'a> From<PinBox<F>> for LocalFutureObj<'a, ()>`

[src]

####

`fn from(boxed: PinBox<F>) -> Self`

[src]

Performs the conversion.

## Auto Trait Implementations

###

`impl<T: ?Sized> Send for PinBox<T> where T: Send,`

###

`impl<T: ?Sized> Sync for PinBox<T> where T: Sync,`

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g. `str,u8` or `String,struct:Vec,test`)