Trait generational_box::AnyStorage

pub trait AnyStorage: Default {
    type Ref<'a, T: ?Sized + 'static>: Deref<Target = T>;
    type Mut<'a, T: ?Sized + 'static>: DerefMut<Target = T>;

    // Required methods
    fn downcast_lifetime_ref<'a: 'b, 'b, T: ?Sized + 'static>(
        ref_: Self::Ref<'a, T>
    ) -> Self::Ref<'b, T>;
    fn downcast_lifetime_mut<'a: 'b, 'b, T: ?Sized + 'static>(
        mut_: Self::Mut<'a, T>
    ) -> Self::Mut<'b, T>;
    fn try_map_mut<T: ?Sized + 'static, U: ?Sized + 'static>(
        mut_ref: Self::Mut<'_, T>,
        f: impl FnOnce(&mut T) -> Option<&mut U>
    ) -> Option<Self::Mut<'_, U>>;
    fn try_map<T: ?Sized, U: ?Sized + 'static>(
        ref_: Self::Ref<'_, T>,
        f: impl FnOnce(&T) -> Option<&U>
    ) -> Option<Self::Ref<'_, U>>;
    fn data_ptr(&self) -> *const ();
    fn manually_drop(&self) -> bool;
    fn recycle(location: &MemoryLocation<Self>);
    fn claim() -> MemoryLocation<Self>;

    // Provided methods
    fn map_mut<T: ?Sized + 'static, U: ?Sized + 'static>(
        mut_ref: Self::Mut<'_, T>,
        f: impl FnOnce(&mut T) -> &mut U
    ) -> Self::Mut<'_, U> { ... }
    fn map<T: ?Sized, U: ?Sized + 'static>(
        ref_: Self::Ref<'_, T>,
        f: impl FnOnce(&T) -> &U
    ) -> Self::Ref<'_, U> { ... }
    fn owner() -> Owner<Self> { ... }
}

A trait for any storage backing type.

Required Associated Types

type Ref<'a, T: ?Sized + 'static>: Deref<Target = T>

The reference this storage type returns.

type Mut<'a, T: ?Sized + 'static>: DerefMut<Target = T>

The mutable reference this storage type returns.

Required Methods

fn downcast_lifetime_ref<'a: 'b, 'b, T: ?Sized + 'static>( ref_: Self::Ref<'a, T> ) -> Self::Ref<'b, T>

Downcast a reference in a Ref to a more specific lifetime

This function enforces the variance of the lifetime parameter 'a in Ref. Rust will typically infer this cast with a concrete type, but it cannot with a generic type.

fn downcast_lifetime_mut<'a: 'b, 'b, T: ?Sized + 'static>( mut_: Self::Mut<'a, T> ) -> Self::Mut<'b, T>

Downcast a mutable reference in a RefMut to a more specific lifetime

This function enforces the variance of the lifetime parameter 'a in Mut. Rust will typically infer this cast with a concrete type, but it cannot with a generic type.

fn try_map_mut<T: ?Sized + 'static, U: ?Sized + 'static>( mut_ref: Self::Mut<'_, T>, f: impl FnOnce(&mut T) -> Option<&mut U> ) -> Option<Self::Mut<'_, U>>

Try to map the mutable ref.

fn try_map<T: ?Sized, U: ?Sized + 'static>( ref_: Self::Ref<'_, T>, f: impl FnOnce(&T) -> Option<&U> ) -> Option<Self::Ref<'_, U>>

Try to map the ref.

fn data_ptr(&self) -> *const ()

Get the data pointer. No guarantees are made about the data pointer. It should only be used for debugging.

fn manually_drop(&self) -> bool

Drop the value from the storage. This will return true if the value was taken.

fn recycle(location: &MemoryLocation<Self>)

Recycle a memory location. This will drop the memory location and return it to the runtime.

fn claim() -> MemoryLocation<Self>

Claim a new memory location. This will either create a new memory location or recycle an old one.

Provided Methods

fn map_mut<T: ?Sized + 'static, U: ?Sized + 'static>( mut_ref: Self::Mut<'_, T>, f: impl FnOnce(&mut T) -> &mut U ) -> Self::Mut<'_, U>

Map the mutable ref.

fn map<T: ?Sized, U: ?Sized + 'static>( ref_: Self::Ref<'_, T>, f: impl FnOnce(&T) -> &U ) -> Self::Ref<'_, U>

Map the ref.

fn owner() -> Owner<Self>

Create a new owner. The owner will be responsible for dropping all of the generational boxes that it creates.

Object Safety

This trait is not object safe.

Implementors

impl AnyStorage for SyncStorage

type Ref<'a, R: ?Sized + 'static> = GenerationalRef<MappedRwLockReadGuard<'a, RawRwLock, R>>

type Mut<'a, W: ?Sized + 'static> = GenerationalRefMut<MappedRwLockWriteGuard<'a, RawRwLock, W>>

impl AnyStorage for UnsyncStorage

type Ref<'a, R: ?Sized + 'static> = GenerationalRef<Ref<'a, R>>

type Mut<'a, W: ?Sized + 'static> = GenerationalRefMut<RefMut<'a, W>>