Struct building_blocks_storage::chunk::storage::compressible::CompressibleChunkStorage

pub struct CompressibleChunkStorage<N, Compr> where
    Compr: Compression,  { /* fields omitted */ }

A two-tier chunk storage. The first tier is an LRU cache of uncompressed chunks. The second tier is a Slab of compressed chunks.

Implementations

impl<N, By, Chan> CompressibleChunkStorage<N, FastArrayCompression<N, FastChannelsCompression<By, Chan>>> where
    PointN<N>: Copy,
    ChunkKey<N>: Clone + Eq + Hash,
    FastChannelsCompression<By, Chan>: Compression, 

pub fn with_bytes_compression(bytes_compression: By) -> Self

impl<N, Compr> CompressibleChunkStorage<N, Compr> where
    Compr: Compression, 

pub fn compression(&self) -> &Compr

impl<N, Compr> CompressibleChunkStorage<N, Compr> where
    ChunkKey<N>: Clone + Eq + Hash,
    Compr: Compression, 

pub fn new(compression: Compr) -> Self

pub fn len_cached(&self) -> usize

pub fn len_compressed(&self) -> usize

pub fn reader<'a>(
    &'a self,
    local_cache: &'a LocalChunkCache<N, Compr::Data>
) -> CompressibleChunkStorageReader<'a, N, Compr>

Returns a reader that implements ChunkReadStorage.

pub fn copy_without_caching(
    &self,
    key: ChunkKey<N>
) -> Option<MaybeCompressed<Compr::Data, Compressed<Compr>>> where
    Compr::Data: Clone,
    Compressed<Compr>: Clone, 

Returns a copy of the Chunk at key.

WARNING: the cache will not be updated. This method should be used for a read-modify-write workflow where it would be inefficient to cache the chunk only for it to be overwritten by the modified version.

pub fn remove(
    &mut self,
    key: ChunkKey<N>
) -> Option<MaybeCompressed<Compr::Data, Compressed<Compr>>>

Remove the Chunk at key.

pub fn compress_lru(&mut self)

Compress the least-recently-used, cached chunk. On access, compressed chunks will be decompressed and cached.

pub fn remove_lru(&mut self) -> Option<(ChunkKey<N>, Compr::Data)>

Remove the least-recently-used, cached chunk.

This is useful for removing a batch of chunks at a time before compressing them in parallel. Then call insert_compressed.

pub fn insert_compressed(
    &mut self,
    key: ChunkKey<N>,
    compressed_chunk: Compressed<Compr>
) -> Option<MaybeCompressed<Compr::Data, Compressed<Compr>>>

Insert a compressed chunk. Returns the old chunk if one exists.

pub fn flush_local_cache(
    &mut self,
    local_cache: LocalChunkCache<N, Compr::Data>
)

Consumes and flushes the chunk cache into the chunk map. This is not strictly necessary, but it will help with caching efficiency.

pub fn insert_chunk(
    &mut self,
    key: ChunkKey<N>,
    chunk: Compr::Data
) -> Option<MaybeCompressed<Compr::Data, Compressed<Compr>>>

Inserts chunk at key and returns the old chunk.

Trait Implementations

impl<N, Compr> ChunkWriteStorage<N, <Compr as Compression>::Data> for CompressibleChunkStorage<N, Compr> where
    ChunkKey<N>: Clone + Eq + Hash,
    Compr: Compression, 

fn get_mut(&mut self, key: ChunkKey<N>) -> Option<&mut Compr::Data>

Mutably borrow the chunk at key.

fn get_mut_or_insert_with(
    &mut self,
    key: ChunkKey<N>,
    create_chunk: impl FnOnce() -> Compr::Data
) -> &mut Compr::Data

Mutably borrow the chunk at key. If it doesn’t exist, insert the return value of create_chunk.

fn replace(
    &mut self,
    key: ChunkKey<N>,
    chunk: Compr::Data
) -> Option<Compr::Data>

Replace the chunk at key with chunk, returning the old value.

fn write(&mut self, key: ChunkKey<N>, chunk: Compr::Data)

Overwrite the chunk at key with chunk. Drops the previous value.

fn delete(&mut self, key: ChunkKey<N>)

Removes and drops the chunk at key.

fn pop(&mut self, key: ChunkKey<N>) -> Option<Compr::Data>

Removes and returns the chunk at key.

impl<N, Compr> IntoIterator for CompressibleChunkStorage<N, Compr> where
    N: 'static,
    Compr: 'static + Compression, 

type IntoIter = Box<dyn Iterator<Item = Self::Item>>

Which kind of iterator are we turning this into?

type Item = (ChunkKey<N>, Compr::Data)

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, N, Compr> IterChunkKeys<'a, N> for CompressibleChunkStorage<N, Compr> where
    N: 'a,
    ChunkKey<N>: Clone + Eq + Hash,
    Compr::Data: 'a,
    Compr: Compression, 

type Iter = LruChunkCacheKeys<'a, N, Compr::Data>

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