Struct StorageManager

pub struct StorageManager<Id, Element> { /* private fields */ }

This manager handles if multiple storage options have been specified It can load resources from one storage aspect and will

Implementations

impl<Id, Element> StorageManager<Id, Element>

pub fn open_or_create( storage_builder: StorageBuilder<true>, instance: u64, ) -> Result<StorageManager<Id, Element>, StorageError>

Available on crate feature cpu_os_threads only.

Constructs the StorageManager from the instance identifier and the settings given by the StorageBuilder.

use cellular_raza_core::storage::*;
let builder = StorageBuilder::new()
    .location("/tmp")
    .init();

let manager = StorageManager::<usize, f64>::open_or_create(builder, 0)?;

pub fn extract_builder(&self) -> StorageBuilder<true>

Available on crate feature cpu_os_threads only.

Extracts all information given by the StorageBuilder when constructing

pub fn get_instance(&self) -> u64

Available on crate feature cpu_os_threads only.

Get the instance of this object.

These instances should not be overlapping, ie. there should not be two objects existing in parallel with the same instance number.

Trait Implementations

impl<Id, Element> Clone for StorageManager<Id, Element>

where Id: Clone, Element: Clone,

fn clone(&self) -> StorageManager<Id, Element>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Id, Element> Debug for StorageManager<Id, Element>

where Id: Debug, Element: Debug,

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

Formats the value using the given formatter.

impl<Id, Element> StorageInterfaceLoad<Id, Element> for StorageManager<Id, Element>

where Id: Hash + Eq + Clone, Element: Clone,

fn load_single_element( &self, iteration: u64, identifier: &Id, ) -> Result<Option<Element>, StorageError>

where Id: Serialize + for<'a> Deserialize<'a>, Element: for<'a> Deserialize<'a>,

Loads a single element from the storage solution if the element exists.

fn load_all_elements_at_iteration( &self, iteration: u64, ) -> Result<HashMap<Id, Element>, StorageError>

where Id: Hash + Eq + for<'a> Deserialize<'a>, Element: for<'a> Deserialize<'a>,

Gets a snapshot of all elements at a given iteration.

fn get_all_iterations(&self) -> Result<Vec<u64>, StorageError>

Get all iteration values which have been saved.

fn load_element_history( &self, identifier: &Id, ) -> Result<HashMap<u64, Element>, StorageError>

where Id: Eq + Serialize + for<'a> Deserialize<'a>, Element: for<'a> Deserialize<'a>,

Loads the elements history, meaning every occurrence of the element in the storage. This function by default provides the results in ordered fashion such that the time direction is retained. Furthermore this function assumes that a given index occurs over the course of a complete time segment with no interceptions.

fn load_all_elements( &self, ) -> Result<BTreeMap<u64, HashMap<Id, Element>>, StorageError>

where Id: Hash + Eq + for<'a> Deserialize<'a>, Element: for<'a> Deserialize<'a>,

Loads all elements for every iteration. This will yield the complete storage and may result in extremely large allocations of memory.

fn load_all_element_histories( &self, ) -> Result<HashMap<Id, BTreeMap<u64, Element>>, StorageError>

where Id: Hash + Eq + for<'a> Deserialize<'a>, Element: for<'a> Deserialize<'a>,

Similarly to the load_all_elements function, but this function returns all elements as their histories.

impl<Id, Element> StorageInterfaceStore<Id, Element> for StorageManager<Id, Element>

where Id: Hash + Eq + Clone, Element: Clone,

fn store_single_element( &mut self, iteration: u64, identifier: &Id, element: &Element, ) -> Result<(), StorageError>

where Id: Serialize, Element: Serialize,

Saves a single element at given iteration.

fn store_batch_elements<'a, I>( &'a mut self, iteration: u64, identifiers_elements: I, ) -> Result<(), StorageError>

where Id: 'a + Serialize, Element: 'a + Serialize, I: Clone + IntoIterator<Item = (&'a Id, &'a Element)>,

Stores a batch of multiple elements with identifiers all at the same iteration.