Struct DungeonCore 

pub struct DungeonCore<L, V = DefaultVtable>
where
    L: IsLayout + Cleanup<V>,
    V: VTable,
{ /* private fields */ }

Core of a dungeon type.

DungeonCore can store any type that fits in it’s layout L and a vtable of type V can be generated for. This type does not perform any dynamic memory allocation. It can be thought of as a single value arena.

DungeonCore always contains a value of some type.

The space overhead of DungeonCore is kept as small as possible. In most cases, the space overhead of DungeonCore is the size of a single usize. The space overhead is directly tied to the size of the V type.

DungeonCore is generic over the traits that the values it stores must implement. The required traits are set by the V type. When using DefaultVtable, the default required traits are Send + Sync + Unpin + Debug.

Examples

use dungeon_cell::{DungeonCore, layout_for};

// create a DungeonCore with a layout required to store i32 or f64
let mut core = DungeonCore::<layout_for!(i32, f64)>::default();

// we can store a i32 and get it back
core.store(1234);
assert_eq!(core.take::<i32>(), Some(1234));

// we can store a f64 and get it back
core.store(1.234);
assert_eq!(core.take::<f64>(), Some(1.234));

// we can't take a type the core isn't storing
core.store(1234);
assert_eq!(core.take::<f64>(), None);

// we can borrow both unique and shared
core.store(1234);
*core.borrow_mut::<i32>().unwrap() += 10;
assert_eq!(core.borrow::<i32>(), Some(&1244));

Implementations

impl<L: IsLayout + Cleanup<V>, V: VTable> DungeonCore<L, V>

pub const fn new<T: Dynamic<V::Bounds>>(value: T) -> Self

where V: ConstVTableOf<T>,

Create a DungeonCore storing a value of type T.

Examples

use dungeon_cell::{DungeonCore, layout_for};

let core = DungeonCore::<layout_for!(i32)>::new(123_i32);

pub fn store<T: Dynamic<V::Bounds>>(&mut self, value: T)

where V: VTableOf<T>,

Store a value of type T.

The currently stored value will be dropped.

Examples

use dungeon_cell::{DungeonCore, layout_for};

let mut core = DungeonCore::<layout_for!(u8)>::default();

core.store(4u8);

assert_eq!(core.take::<u8>(), Some(4));

pub fn replace<T: Dynamic<V::Bounds>, U: Inspect<V::Id>>( &mut self, value: T, ) -> Result<U, T>

where V: VTableOf<T>,

Replace the value stored with a new one.

If the currently stored value is of type U, then the value will be stored. If the DungeonCore is storing a value of another type, then a Err is returned with value and the stored value is unaffected.

Examples

use dungeon_cell::{DungeonCore, layout_for};

let mut core = DungeonCore::<layout_for!(i32)>::new(123i32);

assert_eq!(core.replace(4u8), Ok(123i32));
assert_eq!(core.replace(()), Ok(4u8));
assert_eq!(core.replace(456i32), Err::<u8, _>(456i32));

pub fn take<T: Inspect<V::Id>>(&mut self) -> Option<T>

where V: VTableOf<()>, (): Dynamic<V::Bounds>,

Gain ownership of the value inside the DungeonCore.

This will leave the DungeonCore storing a () if the currently stored value is of type T. If the DungeonCore is storing a value of another type, then a None is returned and the stored value is unaffected.

Examples

use dungeon_cell::{DungeonCore, layout_for};

let mut core = DungeonCore::<layout_for!(u8)>::new(4u8);

assert_eq!(core.take::<u8>(), Some(4));
assert_eq!(core.take::<u8>(), None);

pub fn borrow<T: Inspect<V::Id>>(&self) -> Option<&T>

Borrow the stored value.

If the DungeonCore is storing a value of another type, then a None is returned.

Examples

use dungeon_cell::{DungeonCore, layout_for};

let core = DungeonCore::<layout_for!(u8)>::new(4u8);

assert_eq!(core.borrow::<u8>(), Some(&4));
assert_eq!(core.borrow::<i8>(), None);

pub fn borrow_mut<T: Inspect<V::Id>>(&mut self) -> Option<&mut T>

Mutably borrow the stored value.

If the DungeonCore is storing a value of another type, then a None is returned.

Examples

use dungeon_cell::{DungeonCore, layout_for};

let mut core = DungeonCore::<layout_for!(u8)>::new(4u8);

*core.borrow_mut::<u8>().unwrap() += 2;

assert_eq!(core.take::<u8>(), Some(6));

assert_eq!(core.borrow_mut::<u8>(), None);

pub fn type_descriptor(&self) -> &Descriptor<V::Id>

Return type Descriptor for the currently stored value.

descriptor.

Examples

use dungeon_cell::{DungeonCore, layout_for};
use dungeon_cell::vtable::Descriptor;

let core = DungeonCore::<layout_for!(i32)>::new(123i32);

assert_eq!(*core.type_descriptor(), Descriptor::new::<i32>());

assert_eq!(core.type_descriptor().size(), 4);
assert_eq!(core.type_descriptor().alignment(), 4);
assert_eq!(core.type_descriptor().type_name(), "i32");

pub fn try_swap<L2: IsLayout + Cleanup<V>>( &mut self, other: &mut DungeonCore<L2, V>, ) -> bool

Try to swap the values of this DungeonCore with another one.

The values can only be swapped if they can be stored in the opposite core. A true will be returned if the swap happened.

Examples

use dungeon_cell::{DungeonCore, layout_for};

let mut a = DungeonCore::<layout_for!(i32)>::new(123u8);
let mut b = DungeonCore::<layout_for!(i16)>::new(456u16);

assert!(a.try_swap(&mut b));

assert_eq!(a.take::<u16>(), Some(456));
assert_eq!(b.take::<u8>(), Some(123));

use dungeon_cell::{DungeonCore, layout_for};

let mut a = DungeonCore::<layout_for!(u8)>::new(123u8);
let mut b = DungeonCore::<layout_for!(u16)>::new(456u16);

assert!(!a.try_swap(&mut b));

assert_eq!(a.take::<u8>(), Some(123));
assert_eq!(b.take::<u16>(), Some(456));

pub fn into_larger<L2: IsLayout + Cleanup<V>>(self) -> DungeonCore<L2, V>

Convert the DungeonCore into a larger size or alignment DungeonCore.

Examples

use dungeon_cell::{DungeonCore, layout_for};

let core = DungeonCore::<layout_for!(u8)>::new(123u8);
let mut core = core.into_larger::<layout_for!(u16)>();

assert_eq!(core.take::<u8>(), Some(123));

use dungeon_cell::{DungeonCore, layout_for};

let core = DungeonCore::<layout_for!(u16)>::new(123u16);
let core = core.into_larger::<layout_for!(u8)>();

pub fn try_into_smaller<L2: IsLayout + Cleanup<V>>( self, ) -> Result<DungeonCore<L2, V>, Self>

Try to convert the DungeonCore into a smaller size or alignment DungeonCore

This is only possible if the value stored can be stored in the smaller DungeonCore. A Err with the current DungeonCore will be returned if the value cannot be stored in the smaller core.

This method will return Ok for all cases where Self::into_larger() works.

Examples

use dungeon_cell::{DungeonCore, layout_for};

let core = DungeonCore::<layout_for!(u16)>::new(123u8);
let mut core = core.try_into_smaller::<layout_for!(u8)>().unwrap();

assert_eq!(core.take::<u8>(), Some(123));

use dungeon_cell::{DungeonCore, layout_for};

let core = DungeonCore::<layout_for!(u16)>::new(123u16);

assert!(core.try_into_smaller::<layout_for!(u8)>().is_err());

pub fn into_less_bounds<Bnew>( self, ) -> DungeonCore<L, <V as VTableSubset<Bnew>>::Subset>

where V: VTableSubset<Bnew>, L: Cleanup<<V as VTableSubset<Bnew>>::Subset>,

impl<L: IsLayout + Cleanup<V>, V: VTable> DungeonCore<L, V>

pub const unsafe fn new_unchecked<T>(value: T, vtable: V) -> Self

Create DungeonCore storing a given value and vtable.

Safety

The vtable must be for the type T.

A valid vtable for a type T can be created using VTableOf or ConstVTableOf.

pub unsafe fn store_unchecked<T>(&mut self, value: T, vtable: V)

Unchecked form of Self::store.

The stored value will be forgotten. Its drop logic will not be ran.

Safety

The vtable must be for the type T.

A valid vtable for a type T can be created using VTableOf or ConstVTableOf.

pub unsafe fn replace_unchecked<T, U>(&mut self, value: T, vtable: V) -> (U, V)

Unchecked form of Self::replace.

The vtable instance for the value is also returned.

Safety

• The DungeonCore must be storing a valid value of type U.
• The vtable must be for the type T.

pub unsafe fn borrow_unchecked<T>(&self) -> &T

Unchecked form of Self::borrow.

Safety

The DungeonCore must be storing a valid value of type T.

pub unsafe fn borrow_mut_unchecked<T>(&mut self) -> &mut T

Unchecked form of Self::borrow_mut.

Safety

The DungeonCore must be storing a valid value of type T.

pub const unsafe fn raw_internals(&self) -> (&[MaybeUninit<u8>], &V)

Get the internal vtable and buffer of the DungeonCore.

Invariants

The buffer contains a valid value of the type the vtable is for. The buffer has the layout described by generic L. The type implements the bounds given by B.

Safety

After the borrow of self ends, the buffer must still contain a valid value of the type the vtable is for. The vtable must be valid in the event of a panic.

pub unsafe fn raw_internals_mut(&mut self) -> (&mut [MaybeUninit<u8>], &mut V)

Get the internal vtable and buffer of the DungeonCore mutably.

Invariants

The buffer contains a valid value of the type the vtable is for. The buffer has the layout described by generic L. The type implements the bounds given by B.

Safety

After the borrow of self ends, the buffer must still contain a valid value of the type the vtable is for. Both the vtable and value in the buffer can change. The vtable and buffer must be valid in the event of a panic.

pub const fn into_raw_internals(self) -> (Buffer<L::Size>, V)

Convert into the internal vtable and buffer.

Trait Implementations

impl<L: IsLayout + Cleanup<V>, V> Clone for DungeonCore<L, V>

where V: Clone + VTable, <L as Cleanup<V>>::Storage: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<L: IsLayout + Cleanup<V>, V: VTable> Debug for DungeonCore<L, V>

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

Formats the value using the given formatter.

impl<L: IsLayout + Cleanup<V>, V> Default for DungeonCore<L, V>

where V: VTableOf<()> + VTable, (): Dynamic<V::Bounds>,

fn default() -> Self

Create a DungeonCore storing the value ().

impl<L: IsLayout + Cleanup<V>, V> Copy for DungeonCore<L, V>

where V: Copy + VTable, <L as Cleanup<V>>::Storage: Copy,

impl<L: IsLayout + Cleanup<V>, V> Send for DungeonCore<L, V>

where V: Send + VTable, <V::Bounds as IsBound>::SendMarker: Send,

impl<L: IsLayout + Cleanup<V>, V> Sync for DungeonCore<L, V>

where V: Sync + VTable, <V::Bounds as IsBound>::SyncMarker: Sync,

impl<L: IsLayout + Cleanup<V>, V> Unpin for DungeonCore<L, V>

where V: Unpin + VTable, <V::Bounds as IsBound>::UnpinMarker: Unpin,