Struct building_blocks::prelude::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,
    ChunkKey<N>: Eq,
    ChunkKey<N>: Hash,
    FastChannelsCompression<By, Chan>: Compression, 

pub fn with_bytes_compression(
    bytes_compression: By
) -> CompressibleChunkStorage<N, FastArrayCompression<N, FastChannelsCompression<By, Chan>>>

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

pub fn compression(&self) -> &Compr

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

pub fn new(compression: Compr) -> CompressibleChunkStorage<N, Compr>

pub fn len_cached(&self) -> usize

pub fn len_compressed(&self) -> usize

pub fn reader(
    &'a self,
    local_cache: &'a LocalCache<ChunkKey<N>, <Compr as Compression>::Data, RandomState>
) -> CompressibleChunkStorageReader<'a, N, Compr>

Returns a reader that implements ChunkReadStorage.

pub fn copy_without_caching(
    &self,
    key: ChunkKey<N>
) -> Option<MaybeCompressed<<Compr as Compression>::Data, Compressed<Compr>>> where
    <Compr as Compression>::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 as Compression>::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 as Compression>::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 as Compression>::Data, Compressed<Compr>>>

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

pub fn flush_local_cache(
    &mut self,
    local_cache: LocalCache<ChunkKey<N>, <Compr as Compression>::Data, RandomState>
)

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 as Compression>::Data
) -> Option<MaybeCompressed<<Compr as Compression>::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
    Compr: Compression,
    ChunkKey<N>: Clone,
    ChunkKey<N>: Eq,
    ChunkKey<N>: Hash, 

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

Mutably borrow the chunk at key.

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

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

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

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

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

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

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

Removes and drops the chunk at key.

pub fn pop(&mut self, key: ChunkKey<N>) -> Option<<Compr as Compression>::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 = <CompressibleChunkStorage<N, Compr> as IntoIterator>::Item> + 'static, Global>

Which kind of iterator are we turning this into?

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

The type of the elements being iterated over.

pub fn into_iter(
    self
) -> <CompressibleChunkStorage<N, Compr> as IntoIterator>::IntoIter

Creates an iterator from a value.

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

type Iter = Keys<'a, ChunkKey<N>, CacheEntry<(<Compr as Compression>::Data, usize), CompressedLocation>>

pub fn chunk_keys(
    &'a self
) -> <CompressibleChunkStorage<N, Compr> as IterChunkKeys<'a, N>>::Iter