Struct CompressibleChunkStorage 

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

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, ) -> 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 ChunkKey<N>: Clone + Eq + Hash, Compr: Compression,

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

pub fn len_cached(&self) -> usize

pub fn len_compressed(&self) -> usize

pub fn reader<'a>( &'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 ChunkKey<N>: Clone + Eq + Hash, Compr: Compression,

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

Mutably borrow the chunk at key.

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.

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.

fn write(&mut self, key: ChunkKey<N>, chunk: <Compr as Compression>::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 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>>

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.

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, ChunkKey<N>: Clone + Eq + Hash, <Compr as Compression>::Data: 'a, Compr: Compression,

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

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