Struct clear_on_drop::ClearOnDrop

pub struct ClearOnDrop<P> where
    P: DerefMut,
    P::Target: Clear,  { /* fields omitted */ }

Zeroizes a storage location when dropped.

This struct contains a reference to a memory location, either as a mutable borrow (&mut T), or as a owned container (Box<T> or similar). When this struct is dropped, the referenced location is overwritten with its Default value.

Example

#[derive(Default)]
struct MyData {
    value: u32,
}

let mut place = MyData { value: 0 };
{
    let mut key = ClearOnDrop::new(&mut place);
    key.value = 0x01234567;
    // ...
}   // key is dropped here
assert_eq!(place.value, 0);

Implementations

impl<P> ClearOnDrop<P> where
    P: DerefMut,
    P::Target: Clear, 

pub fn new(place: P) -> Self

Creates a new ClearOnDrop which clears place on drop.

The place parameter can be a &mut T, a Box<T>, or other containers which behave like Box<T>.

Note: only the first level of dereference will be cleared. Do not use &mut Box<T> or similar as the place, since the heap contents won't be cleared in that case. If you need the place back, use ClearOnDrop::into_place(...) instead of a borrow.

pub fn into_place(c: Self) -> P

Consumes the ClearOnDrop, returning the place after clearing.

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

pub fn into_uncleared_place(c: Self) -> P

Consumes the ClearOnDrop, returning the place without clearing.

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

Trait Implementations

impl<P, T: ?Sized> AsMut<T> for ClearOnDrop<P> where
    P: DerefMut + AsMut<T>,
    P::Target: Clear, 

fn as_mut(&mut self) -> &mut T

Performs the conversion.

impl<P, T: ?Sized> AsRef<T> for ClearOnDrop<P> where
    P: DerefMut + AsRef<T>,
    P::Target: Clear, 

fn as_ref(&self) -> &T

Performs the conversion.

impl<P, T: ?Sized> Borrow<T> for ClearOnDrop<P> where
    P: DerefMut + Borrow<T>,
    P::Target: Clear,
    T: Clear, 

fn borrow(&self) -> &T

Immutably borrows from an owned value.

impl<P, T: ?Sized> BorrowMut<T> for ClearOnDrop<P> where
    P: DerefMut + BorrowMut<T>,
    P::Target: Clear,
    T: Clear, 

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value.

impl<P> Clone for ClearOnDrop<P> where
    P: DerefMut + Clone,
    P::Target: Clear, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<P> Debug for ClearOnDrop<P> where
    P: DerefMut + Debug,
    P::Target: Clear, 

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

Formats the value using the given formatter.

impl<P> Deref for ClearOnDrop<P> where
    P: DerefMut,
    P::Target: Clear, 

type Target = P::Target

The resulting type after dereferencing.

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

Dereferences the value.

impl<P> DerefMut for ClearOnDrop<P> where
    P: DerefMut,
    P::Target: Clear, 

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

Mutably dereferences the value.

impl<P> Drop for ClearOnDrop<P> where
    P: DerefMut,
    P::Target: Clear, 

fn drop(&mut self)

Executes the destructor for this type.

impl<P> Eq for ClearOnDrop<P> where
    P: DerefMut + Eq,
    P::Target: Clear, 

impl<P> Hash for ClearOnDrop<P> where
    P: DerefMut + Hash,
    P::Target: Clear, 

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given [Hasher].

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

Feeds a slice of this type into the given [Hasher].

impl<P> Ord for ClearOnDrop<P> where
    P: DerefMut + Ord,
    P::Target: Clear, 

fn cmp(&self, other: &Self) -> Ordering

This method returns an [Ordering] between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

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

Restrict a value to a certain interval.

impl<P, Q> PartialEq<ClearOnDrop<Q>> for ClearOnDrop<P> where
    P: DerefMut + PartialEq<Q>,
    P::Target: Clear,
    Q: DerefMut,
    Q::Target: Clear, 

fn eq(&self, other: &ClearOnDrop<Q>) -> bool

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

fn ne(&self, other: &ClearOnDrop<Q>) -> bool

This method tests for !=.

impl<P, Q> PartialOrd<ClearOnDrop<Q>> for ClearOnDrop<P> where
    P: DerefMut + PartialOrd<Q>,
    P::Target: Clear,
    Q: DerefMut,
    Q::Target: Clear, 

fn partial_cmp(&self, other: &ClearOnDrop<Q>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &ClearOnDrop<Q>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &ClearOnDrop<Q>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &ClearOnDrop<Q>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &ClearOnDrop<Q>) -> bool

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