Struct high_mem_utils::DropBy

pub struct DropBy<T, F: FnMut(T)> {
    pub value: Option<T>,
    pub clos: F,
}

A wrapper that calls the given closure at Drop. Useful when you have a conditional assign of one that,once assigned,you want to warranty a call to it with the given T,and then drop it.

Currently this type has a value field of an Option<T>,because the closure needs to take ownership doing use of the take method on Option.In case of None because there's no meaningful value for the closure,drop returns at that point.

It derefs to Option.

Fields

value: Option<T>

clos: F

Methods

impl<T, F: FnMut(T)> DropBy<T, F>

pub const fn new(value: T, clos: F) -> Self

Creates a new DropBy with the value and the closure that takes the value at their Drop impl.

pub fn into_inner(&mut self) -> Option<T>

Takes the value,disabling any code in the closure.

pub fn drop_by(&mut self)

This function takes the value and calls the closure with it,allowing re-use the container.

This struct implements Drop so the name can conflict with they method,other way will be called "drop".

pub fn set(&mut self, value: T)

Convenience function for self.value = Some(some_value).

pub unsafe fn into_inner_unchecked(&mut self) -> T

Takes and unwraps the value,disabling any code in the closure.

Safety

This will panic if the type contained is None with debug_assertions enabled,otherwise triggers UB.

Methods from Deref<Target = Option<T>>

#[must_use = "if you intended to assert that this has a value, consider `.unwrap()` instead"] pub fn is_some(&self) -> bool

Returns true if the option is a Some value.

Examples

let x: Option<u32> = Some(2);
assert_eq!(x.is_some(), true);

let x: Option<u32> = None;
assert_eq!(x.is_some(), false);

#[must_use = "if you intended to assert that this doesn\'t have a value, consider `.and_then(|| panic!(\"`Option` had a value when expected `None`\"))` instead"] pub fn is_none(&self) -> bool

Returns true if the option is a None value.

Examples

let x: Option<u32> = Some(2);
assert_eq!(x.is_none(), false);

let x: Option<u32> = None;
assert_eq!(x.is_none(), true);

#[must_use] pub fn contains<U>(&self, x: &U) -> bool where
    U: PartialEq<T>, 

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

Returns true if the option is a Some value containing the given value.

Examples

#![feature(option_result_contains)]

let x: Option<u32> = Some(2);
assert_eq!(x.contains(&2), true);

let x: Option<u32> = Some(3);
assert_eq!(x.contains(&2), false);

let x: Option<u32> = None;
assert_eq!(x.contains(&2), false);

pub fn as_ref(&self) -> Option<&T>

Converts from &Option<T> to Option<&T>.

Examples

Converts an Option<String> into an Option<usize>, preserving the original. The map method takes the self argument by value, consuming the original, so this technique uses as_ref to first take an Option to a reference to the value inside the original.

let text: Option<String> = Some("Hello, world!".to_string());
// First, cast `Option<String>` to `Option<&String>` with `as_ref`,
// then consume *that* with `map`, leaving `text` on the stack.
let text_length: Option<usize> = text.as_ref().map(|s| s.len());
println!("still can print text: {:?}", text);

pub fn as_mut(&mut self) -> Option<&mut T>

Converts from &mut Option<T> to Option<&mut T>.

Examples

let mut x = Some(2);
match x.as_mut() {
    Some(v) => *v = 42,
    None => {},
}
assert_eq!(x, Some(42));

pub fn as_pin_ref(self: Pin<&Option<T>>) -> Option<Pin<&T>>

Converts from Pin<&Option<T>> to Option<Pin<&T>>.

pub fn as_pin_mut(self: Pin<&mut Option<T>>) -> Option<Pin<&mut T>>

Converts from Pin<&mut Option<T>> to Option<Pin<&mut T>>.

pub fn iter(&self) -> Iter<T>

Returns an iterator over the possibly contained value.

Examples

let x = Some(4);
assert_eq!(x.iter().next(), Some(&4));

let x: Option<u32> = None;
assert_eq!(x.iter().next(), None);

pub fn iter_mut(&mut self) -> IterMut<T>

Returns a mutable iterator over the possibly contained value.

Examples

let mut x = Some(4);
match x.iter_mut().next() {
    Some(v) => *v = 42,
    None => {},
}
assert_eq!(x, Some(42));

let mut x: Option<u32> = None;
assert_eq!(x.iter_mut().next(), None);

pub fn get_or_insert(&mut self, v: T) -> &mut T

Inserts v into the option if it is None, then returns a mutable reference to the contained value.

Examples

let mut x = None;

{
    let y: &mut u32 = x.get_or_insert(5);
    assert_eq!(y, &5);

    *y = 7;
}

assert_eq!(x, Some(7));

pub fn get_or_insert_with<F>(&mut self, f: F) -> &mut T where
    F: FnOnce() -> T, 

Inserts a value computed from f into the option if it is None, then returns a mutable reference to the contained value.

Examples

let mut x = None;

{
    let y: &mut u32 = x.get_or_insert_with(|| 5);
    assert_eq!(y, &5);

    *y = 7;
}

assert_eq!(x, Some(7));

pub fn take(&mut self) -> Option<T>

Takes the value out of the option, leaving a None in its place.

Examples

let mut x = Some(2);
let y = x.take();
assert_eq!(x, None);
assert_eq!(y, Some(2));

let mut x: Option<u32> = None;
let y = x.take();
assert_eq!(x, None);
assert_eq!(y, None);

pub fn replace(&mut self, value: T) -> Option<T>

Replaces the actual value in the option by the value given in parameter, returning the old value if present, leaving a Some in its place without deinitializing either one.

Examples

let mut x = Some(2);
let old = x.replace(5);
assert_eq!(x, Some(5));
assert_eq!(old, Some(2));

let mut x = None;
let old = x.replace(3);
assert_eq!(x, Some(3));
assert_eq!(old, None);

pub fn as_deref(&self) -> Option<&<T as Deref>::Target>

Converts from Option<T> (or &Option<T>) to Option<&T::Target>.

Leaves the original Option in-place, creating a new one with a reference to the original one, additionally coercing the contents via Deref.

Examples

let x: Option<String> = Some("hey".to_owned());
assert_eq!(x.as_deref(), Some("hey"));

let x: Option<String> = None;
assert_eq!(x.as_deref(), None);

pub fn as_deref_mut(&mut self) -> Option<&mut <T as Deref>::Target>

Converts from Option<T> (or &mut Option<T>) to Option<&mut T::Target>.

Leaves the original Option in-place, creating a new one containing a mutable reference to the inner type's Deref::Target type.

Examples

let mut x: Option<String> = Some("hey".to_owned());
assert_eq!(x.as_deref_mut().map(|x| {
    x.make_ascii_uppercase();
    x
}), Some("HEY".to_owned().as_mut_str()));

Trait Implementations

impl<T, F: FnMut(T)> AsMut<Option<T>> for DropBy<T, F>

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

Performs the conversion.

impl<T, F: FnMut(T)> AsRef<Option<T>> for DropBy<T, F>

fn as_ref(&self) -> &Option<T>

Performs the conversion.

impl<T, F: FnMut(T)> Deref for DropBy<T, F>

type Target = Option<T>

The resulting type after dereferencing.

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

Dereferences the value.

impl<T, F: FnMut(T)> DerefMut for DropBy<T, F>

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

Mutably dereferences the value.

impl<T, F: FnMut(T)> Drop for DropBy<T, F>

fn drop(&mut self)

Executes the destructor for this type.