Struct Storage 

pub struct Storage<D = InMemoryDB>
where
    D: DB,
{
    pub arena: Arena<D>,
}

A factory for various storage objects

Fields

arena: Arena<D>

The inner storage arena

Implementations

impl<D> Storage<D>

where D: DB,

pub fn new(cache_size: usize, db: D) -> Storage<D>

Create a new Storage type with given cache size and db.

If the cache_size is zero, then the StorageBackend caches will be unbounded. Otherwise, the read cache will be strictly bounded by cache_size, and the write cache will be truncated to at most that size on StorageBackend flush operations.

Note: the cache size is in number of objects, not number of megabytes of memory! See self::DEFAULT_CACHE_SIZE for a default choice.

pub fn new_from_arena(arena: Arena<D>) -> Storage<D>

Create a new Storage type from an existing Arena

Methods from Deref<Target = Arena<D>>

pub fn with_backend<R>(&self, f: impl FnOnce(&mut StorageBackend<D>) -> R) -> R

Apply a function to the back-end.

This is the only pub way to access the back-end, since safe use of the back-end requires locking.

pub fn alloc<T>(&self, value: T) -> Sp<T, D>

where T: Storable<D>,

Insert value into the arena, and cache its data in the back-end until all Sps for this data are dropped.

pub fn size(&self) -> usize

Returns the number of unique elements stored in the Arena

pub fn get<T>( &self, key: &TypedArenaKey<T, <D as DB>::Hasher>, ) -> Result<Sp<T, D>, Error>

where T: Storable<D>,

Get a pointer into the arena.

This attempts to load the value eagerly, but will fall back on any existing cached value if available, regardless of whether that value is fully forced or not. Will return an Err if the protocol_version in the key does not match that of the Arena.

Warning

This function may perform unbounded recursion, to the depth of the deepest nesting of Sps contained in the result, since it works by recursing down to the leaves and building DAG up from there. If this is not acceptable, then use Self::get_lazy instead, which has no unbounded recursion, and instead loads nested Sps on demand.

pub fn children( &self, key: &ArenaHash<<D as DB>::Hasher>, ) -> Result<Vec<ArenaKey<<D as DB>::Hasher>>, Error>

Retrieves the child keys of a given key.

pub fn get_lazy<T>( &self, key: &TypedArenaKey<T, <D as DB>::Hasher>, ) -> Result<Sp<T, D>, Error>

where T: Storable<D> + Tagged,

Get a pointer into the arena.

This attempts to load the value lazily, but will fall back on any existing cached value if available, regardless of whether that value is fully forced or not. Will return an Err if the protocol_version in the key does not match that of the Arena.

pub fn deserialize_sp<T, R>( &self, reader: &mut R, recursive_depth: u32, ) -> Result<Sp<T, D>, Error>

where T: Storable<D>, R: Read,

Deserializes an SP.

Note

This is a boundary for user controlled input, namely the serialization in reader. So we need to be careful here to gracefully handle malformed (or even maliciously formed?) input. In contrast, the StorageBackend assumes its inputs are sanitized, and panics when receiving malformed inputs (e.g. parents with pointers to non-existent children).

Trait Implementations

impl<D> Clone for Storage<D>

where D: Clone + DB,

fn clone(&self) -> Storage<D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<D> Debug for Storage<D>

where D: Debug + DB,

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

Formats the value using the given formatter.

impl<D> Default for Storage<D>

where D: Default + DB,

fn default() -> Storage<D>

Create a new storage with the default cache size.

impl<D> Deref for Storage<D>

where D: DB,

type Target = Arena<D>

The resulting type after dereferencing.

fn deref(&self) -> &Arena<D>

Dereferences the value.