Trait Storage 

pub trait Storage {
    type Stored<T>: DerefMut<Target = T> + From<T>;

    // Required method
    fn name() -> &'static str ;
}

🫗 Allows data structures to be generic over their storage strategy.

---

^{📍 sys/mem/alloc}

---

There are two reference implementations:

• Bare, storing data inline via BareBox.
• Boxed, storing data on the heap via Box.

Examples

use core::array::from_fn;
use devela::Storage;

/// Generically store a generic array of generic size.
pub struct MyStructure<T, S: Storage, const L: usize> {
    data: S::Stored<[T; L]>,
}

impl<T: Default, S: Storage, const L: usize> MyStructure<T, S, L> {
    pub fn new() -> Self {
        Self {
            data: S::Stored::from(from_fn(|_| T::default())),
        }
    }
}

// The array is stored inline (stack-allocated).
assert_eq![100, size_of::<MyStructure::<u8, (), 100>>()];

// The array is stored in the heap.
#[cfg(feature = "alloc")]
assert_eq![8, size_of::<MyStructure::<u8, devela::Boxed, 100>>()];

Required Associated Types

type Stored<T>: DerefMut<Target = T> + From<T>

The stored associated type.

Any stored type must support mutable dereferencing and construction from T.

Required Methods

fn name() -> &'static str

Returns the static name of the storage implementation.

This can be useful for debugging.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl Storage for Bare

A zero-sized marker for a storage type that wraps its data in a BareBox.

This implementation is equivalent to the one for Boxed which uses Box for storage.

type Stored<T> = BareBox<T>

impl Storage for Boxed

Available on crate feature alloc only.

This implementation is equivalent to the one for Bare which uses BareBox for storage.

type Stored<T> = Box<T>