Struct GenerationalRef

pub struct GenerationalRef<R> { /* private fields */ }

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

GenerationalRef implements Deref which means you can call methods on the inner value just like you would on a reference to the inner value. If you need to get the inner reference directly, you can call GenerationalRef::deref.

Example

let owner = UnsyncStorage::owner();
let value = owner.insert(String::from("hello"));
let reference = value.read();

// You call methods like `as_str` on the reference just like you would with the inner String
assert_eq!(reference.as_str(), "hello");

Matching on GenerationalRef

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

enum Colors {
    Red,
    Green
}
let owner = UnsyncStorage::owner();
let value = owner.insert(Colors::Red);
let reference = value.read();

match reference {
    // Since we are matching on the `GenerationalRef` type instead of &Colors, we can't match on the enum directly
    Colors::Red => {}
    Colors::Green => {}
}

error[E0308]: mismatched types
  --> packages/generational-box/tests/basic.rs:25:9
  |
2 |         Red,
  |         --- unit variant defined here
...
3 |     match reference {
  |           --------- this expression has type `GenerationalRef<Ref<'_, Colors>>`
4 |         // Since we are matching on the `GenerationalRef` type instead of &Colors, we can't match on the enum directly
5 |         Colors::Red => {}
  |         ^^^^^^^^^^^ expected `GenerationalRef<Ref<'_, Colors>>`, found `Colors`
  |
  = note: expected struct `GenerationalRef<Ref<'_, Colors>>`
               found enum `Colors`

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

use std::ops::Deref;
enum Colors {
    Red,
    Green
}
let owner = UnsyncStorage::owner();
let value = owner.insert(Colors::Red);
let reference = value.read();

// Deref converts the `GenerationalRef` into a `&Colors`
match reference.deref() {
    // Now we can match on the inner value
    Colors::Red => {}
    Colors::Green => {}
}

Implementations

impl<T: ?Sized + 'static, R: Deref<Target = T>> GenerationalRef<R>

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

Map the inner value to a new type

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

Try to map the inner value to a new type

Trait Implementations

impl<T: ?Sized + Debug, R: Deref<Target = T>> Debug for GenerationalRef<R>

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

Formats the value using the given formatter.

impl<T: ?Sized + 'static, R: Deref<Target = T>> Deref for GenerationalRef<R>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T: ?Sized + Display, R: Deref<Target = T>> Display for GenerationalRef<R>

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

Formats the value using the given formatter.