Struct merkletree::store::LevelCacheStore

pub struct LevelCacheStore<E: Element, R: Read + Send + Sync> { /* fields omitted */ }

The LevelCacheStore is used to reduce the on-disk footprint even further to the minimum at the cost of build time performance. Each LevelCacheStore is created with a StoreConfig object which contains the number of binary tree levels above the base that are 'cached'. This implementation has hard requirements about the on disk file size based on that number of levels, so on-disk files are tied, structurally to the configuration they were built with and can only be accessed with the same number of levels.

NOTE: Unlike other store types, writes of any kind are not supported (except deletion) since we're accessing specially crafted on-disk data that requires a particular access pattern dictated at the time of creation/compaction.

Methods

impl<E: Element, R: Read + Send + Sync> LevelCacheStore<E, R>

pub fn new_from_disk_with_reader(
    store_range: usize,
    branches: usize,
    config: &StoreConfig,
    reader: ExternalReader<R>
) -> Result<Self>

Used for opening v2 compacted DiskStores.

pub fn set_external_reader(&mut self, reader: ExternalReader<R>) -> Result<bool>

impl<E: Element, R: Read + Send + Sync> LevelCacheStore<E, R>

pub fn store_size(&self) -> usize

pub fn is_consistent_v1(
    store_range: usize,
    branches: usize,
    config: &StoreConfig
) -> Result<bool>

pub fn is_consistent(
    store_range: usize,
    branches: usize,
    config: &StoreConfig
) -> Result<bool>

pub fn store_read_range(&self, start: usize, end: usize) -> Result<Vec<u8>>

pub fn store_read_into(
    &self,
    start: usize,
    end: usize,
    buf: &mut [u8]
) -> Result<()>

pub fn store_copy_from_slice(&mut self, _start: usize, _slice: &[u8])

Trait Implementations

impl<E: Element, R: Read + Send + Sync> Debug for LevelCacheStore<E, R>

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

Formats the value using the given formatter.

impl<E: Element, R: Read + Send + Sync> Store<E> for LevelCacheStore<E, R>

fn new_with_config(
    size: usize,
    branches: usize,
    config: StoreConfig
) -> Result<Self>

Creates a new store which can store up to size elements.

fn new(_size: usize) -> Result<Self>

fn new_from_slice_with_config(
    _size: usize,
    _branches: usize,
    _data: &[u8],
    _config: StoreConfig
) -> Result<Self>

fn new_from_slice(_size: usize, _data: &[u8]) -> Result<Self>

fn new_from_disk(
    store_range: usize,
    branches: usize,
    config: &StoreConfig
) -> Result<Self>

fn write_at(&mut self, _el: E, _index: usize) -> Result<()>

fn copy_from_slice(&mut self, _buf: &[u8], _start: usize) -> Result<()>

fn read_at(&self, index: usize) -> Result<E>

fn read_into(&self, index: usize, buf: &mut [u8]) -> Result<()>

fn read_range_into(
    &self,
    start: usize,
    end: usize,
    buf: &mut [u8]
) -> Result<()>

fn read_range(&self, r: Range<usize>) -> Result<Vec<E>>

fn len(&self) -> usize

fn loaded_from_disk(&self) -> bool

fn compact(
    &mut self,
    _branches: usize,
    _config: StoreConfig,
    _store_version: u32
) -> Result<bool>

fn delete(config: StoreConfig) -> Result<()>

fn is_empty(&self) -> bool

fn push(&mut self, el: E) -> Result<()>

fn sync(&self) -> Result<()>

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

fn last(&self) -> Result<E>

fn build_small_tree<A: Algorithm<E>, U: Unsigned>(
    &mut self,
    leafs: usize,
    height: usize
) -> Result<E>

fn process_layer<A: Algorithm<E>, U: Unsigned>(
    &mut self,
    width: usize,
    level: usize,
    read_start: usize,
    write_start: usize
) -> Result<()>

fn build<A: Algorithm<E>, U: Unsigned>(
    &mut self,
    leafs: usize,
    height: usize,
    _config: Option<StoreConfig>
) -> Result<E>