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> [src]

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

fn into_inner(slot: ManuallyDrop<T>) -> T [src]

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

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

Trait Implementations

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

fn default() -> ManuallyDrop<T> [src]

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

fn clone(&self) -> ManuallyDrop<T> [src]

fn clone_from(&mut self, source: &ManuallyDrop<T>) [src]

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

fn partial_cmp(&self, other: &ManuallyDrop<T>) -> Option<Ordering> [src]

fn lt(&self, other: &ManuallyDrop<T>) -> bool [src]

fn le(&self, other: &ManuallyDrop<T>) -> bool [src]

fn gt(&self, other: &ManuallyDrop<T>) -> bool [src]

fn ge(&self, other: &ManuallyDrop<T>) -> bool [src]

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

type Target = T

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

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

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

fn hash<H>(&self, state: &mut H) where
    H: Hasher,  [src]

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

1.3.0

[src]

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

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

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

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

fn cmp(&self, other: &ManuallyDrop<T>) -> Ordering [src]

fn max(self, other: Self) -> Self

1.21.0

[src]

fn min(self, other: Self) -> Self

1.21.0

[src]

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

fn eq(&self, other: &ManuallyDrop<T>) -> bool [src]

fn ne(&self, other: &ManuallyDrop<T>) -> bool [src]

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

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