Struct ReplaceDrop

pub struct ReplaceDrop<T: ReplaceDropImpl>(/* private fields */);

A wrapper around ManuallyDrop that instead of removing the drop, replaces it Example:

use replace_drop::{ReplaceDropImpl, ReplaceDrop};
struct MyData { data: i32 }
unsafe impl ReplaceDropImpl for MyData {
    unsafe fn drop(&mut self) {
        println!("Called drop with {}", self.data)
    }    
}

let data = MyData {data: 3};
let data2 = MyData {data: 3};
drop(data); // Prints nothing
let data_replace_drop = ReplaceDrop::new(data2);
drop(data_replace_drop); // Prints "Called drop with 3"

Implementations

impl<T: ReplaceDropImpl> ReplaceDrop<T>

pub fn new(val: T) -> Self

Examples found in repository

examples/calling_drop.rs (line 44)

fn main() {
    let _ = ReplaceDrop::new(Outer(Inner));
    // Prints:
    // Outer 2!
    // Inner!
    // Inner 2!
    // Outer!
    // Inner!
}

pub fn new_from_manually_drop(val: ManuallyDrop<T>) -> Self

pub fn into_inner(self) -> T

Trait Implementations

impl<T: Clone + ReplaceDropImpl> Clone for ReplaceDrop<T>

fn clone(&self) -> ReplaceDrop<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + ReplaceDropImpl> Debug for ReplaceDrop<T>

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

Formats the value using the given formatter.

impl<T: ReplaceDropImpl> Deref for ReplaceDrop<T>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T: ReplaceDropImpl> DerefMut for ReplaceDrop<T>

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

Mutably dereferences the value.

impl<T: ReplaceDropImpl> Drop for ReplaceDrop<T>

fn drop(&mut self)

Executes the destructor for this type.