[−][src]Struct high_mem_utils::DontDropOpt
A wrapper for an implementation of drop that mem::forget
the previous value and replace it with None.
This might be useful if you want assuring that a particular destructor not run if it can lead to a double-free or another memory issue.
This type is particularly not recomended for reference types because as such they can never be null and the value is still dropped.
This type has the same implications that mem::forget
except for the fact that this ensures that the
value is never dropped even on panic,unless you abort.
It derefs to Option
Methods
impl<T> DontDropOpt<T>
[src]
pub fn new(a: T) -> Self
[src]
Construct a new DontDropOpt
from a value,this has no effect if the value is a reference.
pub fn into_inner(&mut self) -> Option<T>
[src]
Returns the value,allowing it to be dropped again.
pub fn forget(&mut self)
[src]
Takes the value away from the Option<T> and forgets it,preventing further access and allowing the container to be re-used.
pub fn set(&mut self, value: T)
[src]
Convenience function for self.0 = Some(some_value)
.
pub unsafe fn into_inner_unchecked(&mut self) -> T
[src]
Unwraps the Option
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
1.0.0[src]
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
1.0.0[src]
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>,
[src]
U: PartialEq<T>,
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>
1.0.0[src]
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>
1.0.0[src]
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>>
1.33.0[src]
pub fn as_pin_mut(self: Pin<&mut Option<T>>) -> Option<Pin<&mut T>>
1.33.0[src]
pub fn iter(&self) -> Iter<T>
1.0.0[src]
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>
1.0.0[src]
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
1.20.0[src]
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,
1.20.0[src]
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>
1.0.0[src]
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>
1.31.0[src]
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>
1.40.0[src]
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>
1.40.0[src]
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> Deref for DontDropOpt<T>
[src]
type Target = Option<T>
The resulting type after dereferencing.
fn deref(&self) -> &Self::Target
[src]
impl<T> DerefMut for DontDropOpt<T>
[src]
impl<T> Drop for DontDropOpt<T>
[src]
Auto Trait Implementations
impl<T> RefUnwindSafe for DontDropOpt<T> where
T: RefUnwindSafe,
T: RefUnwindSafe,
impl<T> Send for DontDropOpt<T> where
T: Send,
T: Send,
impl<T> Sync for DontDropOpt<T> where
T: Sync,
T: Sync,
impl<T> Unpin for DontDropOpt<T> where
T: Unpin,
T: Unpin,
impl<T> UnwindSafe for DontDropOpt<T> where
T: UnwindSafe,
T: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,