std::mem::ManuallyDrop

Union std::mem::ManuallyDrop

pub union ManuallyDrop<T> {
    // some fields omitted
}

A wrapper to inhibit compiler from automatically calling T’s destructor.

This wrapper is 0-cost.

Examples

This wrapper helps with explicitly documenting the drop order dependencies between fields of the type:

use std::mem::ManuallyDrop;
struct Peach;
struct Banana;
struct Melon;
struct FruitBox {
    // Immediately clear there’s something non-trivial going on with these fields.
    peach: ManuallyDrop<Peach>,
    melon: Melon, // Field that’s independent of the other two.
    banana: ManuallyDrop<Banana>,
}

impl Drop for FruitBox {
    fn drop(&mut self) {
        unsafe {
            // Explicit ordering in which field destructors are run specified in the intuitive
            // location – the destructor of the structure containing the fields.
            // Moreover, one can now reorder fields within the struct however much they want.
            ManuallyDrop::drop(&mut self.peach);
            ManuallyDrop::drop(&mut self.banana);
        }
        // After destructor for `FruitBox` runs (this function), the destructor for Melon gets
        // invoked in the usual manner, as it is not wrapped in `ManuallyDrop`.
    }
}

Methods

impl<T> ManuallyDrop<T> [src]

fn new(value: T) -> ManuallyDrop<T>

use std::mem::ManuallyDrop;
ManuallyDrop::new(Box::new(()));

fn into_inner(slot: ManuallyDrop<T>) -> T

use std::mem::ManuallyDrop;
let x = ManuallyDrop::new(Box::new(()));
let _: Box<()> = ManuallyDrop::into_inner(x);

unsafe fn drop(slot: &mut ManuallyDrop<T>)

Trait Implementations

impl<T> DerefMut for ManuallyDrop<T> [src]

fn deref_mut(&mut self) -> &mut <ManuallyDrop<T> as Deref>::Target

impl<T> Debug for ManuallyDrop<T> where
    T: Debug,  [src]

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

impl<T> Deref for ManuallyDrop<T> [src]

type Target = T

fn deref(&self) -> &<ManuallyDrop<T> as Deref>::Target