Struct VecRefMut 

pub struct VecRefMut<'a, T: ?Sized> { /* private fields */ }

Wraps a mutably borrowed value from a VecCell.

Implementations

impl<'a, T: ?Sized> VecRefMut<'a, T>

pub fn get(&self) -> &T

Returns an immutable reference to the borrowed value. The reference may not outlive this VecRefMut instance.

Example

let mut vec: VecCell<String> = VecCell::new();

vec.push(String::from("hello"));
vec.push(String::from("world"));

let guard = vec.borrow_mut(0).unwrap();
assert_eq!(guard.get(), "hello");

pub fn map<'b, U: ?Sized, F>( original: VecRefMut<'b, T>, f: F, ) -> VecRefMut<'b, U>

where F: FnOnce(&mut T) -> &mut U,

Transforms a VecRefMut<'_, T> into a VecRefMut<'_, U> from a function that maps &mut T to &mut U.

This function does not use self and must be called explicitly via VecRefMut::map(value, function).

Examples

fn return_favorite_value_mut<'a>(array: &'a VecCell<Vec<u8>>) -> VecRefMut<'a, u8> {
    VecRefMut::map(array.borrow_mut(42).unwrap(), |vec| &mut vec[7])
}

pub fn try_map<'b, U: ?Sized, F, E>( original: VecRefMut<'b, T>, f: F, ) -> Result<VecRefMut<'b, U>, E>

where F: FnOnce(&mut T) -> Result<&mut U, E>,

Variant of VecRefMut::map, where the callback (f) may fail.

f must return a Result; if it returns Ok(x), then try_map returns Ok(VecRefMut(x)). Otherwise, it returns Err(err).

Trait Implementations

impl<'a, T: Debug + ?Sized> Debug for VecRefMut<'a, T>

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

Formats the value using the given formatter.

impl<'a, T: ?Sized> Deref for VecRefMut<'a, T>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<'a, T: ?Sized> DerefMut for VecRefMut<'a, T>

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

Mutably dereferences the value.

impl<'a, T: Display + ?Sized> Display for VecRefMut<'a, T>

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

Formats the value using the given formatter.

impl<'a, T: PartialEq + ?Sized> PartialEq<T> for VecRefMut<'a, T>

fn eq(&self, other: &T) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, T: PartialEq + ?Sized> PartialEq for VecRefMut<'a, T>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.