Struct Storage 

pub struct Storage<K, V> { /* private fields */ }

Storage.

Fundamentally, storages are solely thin wrappers around implementors of the Collection trait, which allows to dereference or downcast to a concrete type, if known, both, immutably and mutably. Collection is a convenience trait, is dyn-compatible, and combines several of the Store traits.

While zrx-store implements generic key-value stores, zrx-storage focuses on providing abstractions and utilities for orchestrating immutable and mutable access across multiple key-value stores with varying semantics, encapsulating boilerplate, and making it easy to write reusable operators.

Examples

use zrx_storage::Storage;

// Create storage and initial state
let mut storage = Storage::default();
storage.insert("a", 4);
storage.insert("b", 2);
storage.insert("c", 3);
storage.insert("d", 1);

// Create iterator over the storage
for (key, value) in &*storage {
    println!("{key}: {value}");
}

Implementations

impl<K, V> Storage<K, V>

pub fn new<T>(collection: T) -> Self

where T: Collection<K, V>,

Creates a new storage from the given collection.

Examples

use std::collections::HashMap;
use zrx_storage::Storage;

// Create storage
let mut storage = Storage::new(HashMap::new());

// Insert value
storage.insert("key", 42);

pub fn downcast_ref<T>(&self) -> Result<&T>

where T: Collection<K, V>,

Attempts to downcast to a mutable reference of T.

This method is a wrapper around the method with the same name that is implemented for Collection trait objects, and is primarily provided for convenience, so failed downcasts return a Result instead of an Option, turning them into errors.

Errors

Returns Error::Downcast if conversion fails.

Examples

use std::collections::HashMap;
use zrx_storage::Storage;

// Create storage and initial state
let mut storage = Storage::new(HashMap::new());
storage.insert("key", 42);

// Downcast storage to inner collection
let store = storage.downcast_ref::<HashMap<_, _>>()?;

pub fn downcast_mut<T>(&mut self) -> Result<&mut T>

where T: Collection<K, V>,

Attempts to downcast to a mutable reference of T.

This method is a wrapper around the method with the same name that is implemented for Collection trait objects, and is primarily provided for convenience, so failed downcasts return a Result instead of an Option, turning them into errors.

Errors

Returns Error::Downcast if conversion fails.

Examples

use std::collections::HashMap;
use zrx_storage::Storage;

// Create storage and initial state
let mut storage = Storage::new(HashMap::new());
storage.insert("key", 42);

// Downcast storage to inner collection
let store = storage.downcast_mut::<HashMap<_, _>>()?;

Trait Implementations

impl<K: Debug, V: Debug> Debug for Storage<K, V>

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

Formats the value using the given formatter.

impl<K, V> Default for Storage<K, V>

where K: Key, V: Value,

fn default() -> Self

Creates a storage with HashMap::default as a collection.

Note that this method does not allow to customize the BuildHasher, but uses ahash by default, which is the fastest known hasher.

Examples

use zrx_storage::Storage;

// Create storage
let mut storage = Storage::default();

// Insert value
storage.insert("key", 42);

impl<K, V> Deref for Storage<K, V>

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

Dereferences to the inner collection.

type Target = dyn Collection<K, V>

The resulting type after dereferencing.

impl<K, V> DerefMut for Storage<K, V>

fn deref_mut(&mut self) -> &mut Self::Target

Dereferences to the inner collection mutably.

impl<T, K, V> From<T> for Storage<K, V>

where T: IntoIterator<Item = (K, V)>, K: Key, V: Value,

fn from(iter: T) -> Self

Creates a storage from an iterator.

This implementation allows to create storages directly from iterators of key-value pairs, which is particularly useful for testing, as well as documentation examples. Note that the inner collection will always be a HashMap when using this method.

Examples

use zrx_storage::Storage;

// Create storage from iterator
let mut storage = Storage::from([("key", 42)]);

impl<K, V> FromIterator<(K, V)> for Storage<K, V>

where K: Key, V: Value,

fn from_iter<T>(iter: T) -> Self

where T: IntoIterator<Item = (K, V)>,

Creates a storage from an iterator.

When creating storages directly from an iterator, which is primarily intended for testing, the inner collection is a HashMap.

Examples

use zrx_storage::Storage;

// Create storage from iterator
let mut storage = Storage::from_iter([("key", 42)]);