Struct orga::store::BufStore

pub struct BufStore<S: Store> { /* fields omitted */ }

Wraps a Store and records mutations in an in-memory map, so that modifications do not affect the underlying Store until flush is called.

Implementations

impl BufStore<NullStore>

pub fn new() -> Self

Constructs a BufStore with no underlying store.

impl<S: Store> BufStore<S>

pub fn wrap(store: S) -> Self

Constructs a BufStore by wrapping the given store.

Calls to get will first check the BufStore map, and if no entry is found will be passed to the underlying store.

pub fn wrap_with_map(store: S, map: Map) -> Self

Creates a BufStore by wrapping the given store, using a pre-populated in-memory buffer of key/value entries.

pub fn into_map(self) -> Map

Consumes the BufStore and returns its in-memory buffer of key/value entries.

Trait Implementations

impl Default for BufStore<NullStore>

fn default() -> Self

Returns the "default value" for a type.

impl<S: Store> Flush for BufStore<S>

fn flush(&mut self) -> Result<()>

Consumes the BufStore's in-memory buffer and writes all of its values to the underlying store.

After calling flush, the BufStore will still be valid and wrap the underlying store, but its in-memory buffer will be empty.

impl<'a, S> Iter<'a> for BufStore<S> where
    S: Store + Iter<'a> + 'a, 

type Iter = Iter<'a, S::Iter>

fn iter_from(&'a self, start: &[u8]) -> Self::Iter

fn iter(&'a self) -> Self::Iter

impl<S: Store> Read for BufStore<S>

fn get(&self, key: &[u8]) -> Result<Option<Vec<u8>>>

Gets a value by key.

fn wrap<T: State<Self>>(self) -> Result<T>

Wraps self with a given state::State implementation, provided for convenience.

fn into_shared(self) -> Shared<Self>

Wraps self with Shared, allowing it to be cloned so that multiple callers can share the reference to the underlying store.

fn prefix(self, prefix: u8) -> Prefixed<Self>

Wraps self with Prefixed using the given prefix byte, so that all operations have the prefix prepended to their keys.

fn into_splitter(self) -> Splitter<Self>

Wraps self with Splitter so that prefixed substores may be created by calling .split().

fn as_ref<'a>(&'a self) -> &'a Self

Returns an immutable reference to the store.

impl<S: Store> Write for BufStore<S>

fn put(&mut self, key: Vec<u8>, value: Vec<u8>) -> Result<()>

Writes a key and value to the store.

fn delete(&mut self, key: &[u8]) -> Result<()>

Deletes the value with the given key.

fn as_mut<'a>(&'a mut self) -> &'a mut Self

Returns a mutable reference to the store.