Struct GenerationalRefMut

pub struct GenerationalRefMut<W> { /* private fields */ }

A mutable reference to a value in a generational box. This reference acts similarly to std::cell::RefMut, but has extra debug information to track when all references to the value are created and dropped.

GenerationalRefMut implements DerefMut which means you can call methods on the inner value just like you would on a mutable reference to the inner value. If you need to get the inner reference directly, you can call GenerationalRefMut::deref_mut.

Example

let owner = UnsyncStorage::owner();
let mut value = owner.insert(String::from("hello"));
let mut mutable_reference = value.write();

// You call methods like `push_str` on the reference just like you would with the inner String
mutable_reference.push_str("world");

Matching on GenerationalMut

You need to get the inner mutable reference with GenerationalRefMut::deref_mut before you match the inner value. If you try to match without calling GenerationalRefMut::deref_mut, you will get an error like this:

enum Colors {
    Red(u32),
    Green
}
let owner = UnsyncStorage::owner();
let mut value = owner.insert(Colors::Red(0));
let mut mutable_reference = value.write();

match mutable_reference {
    // Since we are matching on the `GenerationalRefMut` type instead of &mut Colors, we can't match on the enum directly
    Colors::Red(brightness) => *brightness += 1,
    Colors::Green => {}
}

error[E0308]: mismatched types
  --> packages/generational-box/tests/basic.rs:25:9
   |
9  |     match mutable_reference {
   |           ----------------- this expression has type `GenerationalRefMut<RefMut<'_, fn(u32) -> Colors {Colors::Red}>>`
10 |         // Since we are matching on the `GenerationalRefMut` type instead of &mut Colors, we can't match on the enum directly
11 |         Colors::Red(brightness) => *brightness += 1,
   |         ^^^^^^^^^^^^^^^^^^^^^^^ expected `GenerationalRefMut<RefMut<'_, ...>>`, found `Colors`
   |
   = note: expected struct `GenerationalRefMut<RefMut<'_, fn(u32) -> Colors {Colors::Red}>>`
               found enum `Colors`

Instead, you need to call deref mut on the reference to get the inner value before you match on it:

use std::ops::DerefMut;
enum Colors {
    Red(u32),
    Green
}
let owner = UnsyncStorage::owner();
let mut value = owner.insert(Colors::Red(0));
let mut mutable_reference = value.write();

// DerefMut converts the `GenerationalRefMut` into a `&mut Colors`
match mutable_reference.deref_mut() {
    // Now we can match on the inner value
    Colors::Red(brightness) => *brightness += 1,
    Colors::Green => {}
}

Implementations

impl<T: ?Sized + 'static, R: DerefMut<Target = T>> GenerationalRefMut<R>

pub fn map<R2, F: FnOnce(R) -> R2>(self, f: F) -> GenerationalRefMut<R2>

Map the inner value to a new type

pub fn try_map<R2, F: FnOnce(R) -> Option<R2>>( self, f: F, ) -> Option<GenerationalRefMut<R2>>

Try to map the inner value to a new type

Trait Implementations

impl<T: ?Sized, W: DerefMut<Target = T>> Deref for GenerationalRefMut<W>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T: ?Sized, W: DerefMut<Target = T>> DerefMut for GenerationalRefMut<W>

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

Mutably dereferences the value.