Struct csf::fp::CMap

pub struct CMap<C, S = BuildDefaultSeededHasher> { /* private fields */ }

Finger-printing based compressed static function (immutable map) that maps hashable keys to values of any type.

To represent a function f:X→Y, it uses the space slightly larger than |X|H, where H is the entropy of the distribution of the f values over X. The expected time complexity is O(c) for evaluation and O(|X|c) for construction (not counting building the encoding dictionary), where c is the average codeword length (given in code fragments) of the values.

Implementations

impl<C: Coding, S: BuildSeededHasher> CMap<C, S>

pub fn get_stats<K: Hash + ?Sized, A: AccessStatsCollector>( &self, k: &K, access_stats: &mut A ) -> Option<<<C as Coding>::Decoder<'_> as Decoder>::Decoded>

Gets the value associated with the given key k and reports statistics to access_stats.

pub fn get<K: Hash + ?Sized>( &self, k: &K ) -> Option<<<C as Coding>::Decoder<'_> as Decoder>::Decoded>

Gets the value associated with the given key k.

impl<C: SerializableCoding, S: BuildSeededHasher> CMap<C, S>

pub fn write_bytes(&self, bytes_per_value: usize) -> usize

Returns number of bytes which write will write, assuming that each call to write_value writes bytes_per_value bytes.

pub fn write<F>(&self, output: &mut dyn Write, write_value: F) -> Result<()>

where F: FnMut(&mut dyn Write, &C::Value) -> Result<()>,

Writes self to the output, using write_value to write values.

pub fn read_with_hasher<F>( input: &mut dyn Read, read_value: F, hasher: S ) -> Result<Self>

where F: FnMut(&mut dyn Read) -> Result<C::Value>,

Read self from the input, using read_value to read values (hasher must be the same as used by written BBMap).

impl<C: SerializableCoding> CMap<C>

pub fn read<F>(input: &mut dyn Read, read_value: F) -> Result<Self>

where F: FnMut(&mut dyn Read) -> Result<C::Value>,

Reads Self from the input, using read_value to read values. Only BBMaps that use default hasher can be read by this method.

impl<C: Coding, S: BuildSeededHasher> CMap<C, S>

pub fn from_slices_with_coding_conf<K, LSC, CSB, BS, BC>( keys: &mut [K], values: &[C::Value], value_coding: C, conf: CMapConf<BC, LSC, CSB, S>, stats: &mut BS ) -> Self

where K: Hash, LSC: LevelSizeChooser, CSB: CollisionSolverBuilder + IsLossless, BS: BuildStatsCollector,

pub fn from_slices_with_conf<K, LSC, CSB, BS, BC>( keys: &mut [K], values: &[C::Value], conf: CMapConf<BC, LSC, CSB, S>, stats: &mut BS ) -> Self

where K: Hash, LSC: LevelSizeChooser, CSB: CollisionSolverBuilder + IsLossless, BS: BuildStatsCollector, BC: BuildCoding<C::Value, Coding = C>,

pub fn from_map_with_coding_conf<K, H, LSC, CSB, BS, BC>( map: &HashMap<K, C::Value, H>, value_coding: C, conf: CMapConf<BC, LSC, CSB, S>, stats: &mut BS ) -> Self

where K: Hash + Clone, LSC: LevelSizeChooser, CSB: CollisionSolverBuilder + IsLossless, BS: BuildStatsCollector,

pub fn from_map_with_conf<K, H, LSC, CSB, BS, BC>( map: &HashMap<K, C::Value, H>, conf: CMapConf<BC, LSC, CSB, S>, stats: &mut BS ) -> Self

where K: Hash + Clone, LSC: LevelSizeChooser, CSB: CollisionSolverBuilder + IsLossless, BS: BuildStatsCollector, BC: BuildCoding<C::Value, Coding = C>,

impl<C: Coding> CMap<C>

pub fn from_slices_with_coding<K: Hash, BS: BuildStatsCollector>( keys: &mut [K], values: &[C::Value], value_coding: C, stats: &mut BS ) -> Self

impl<V: Hash + Eq + Clone> CMap<Coding<V>>

pub fn from_slices<K: Hash, BS: BuildStatsCollector>( keys: &mut [K], values: &[V], stats: &mut BS ) -> Self

pub fn from_map<K: Hash + Clone, H, BS: BuildStatsCollector>( map: &HashMap<K, V, H>, stats: &mut BS ) -> Self

Trait Implementations

impl<K: Hash + Clone, V: Hash + Eq + Clone, H> From<&HashMap<K, V, H>> for CMap<Coding<V>>

fn from(map: &HashMap<K, V, H>) -> Self

Converts to this type from the input type.

impl<K: Hash + Clone, V: Hash + Eq + Clone, H> From<HashMap<K, V, H>> for CMap<Coding<V>>

fn from(map: HashMap<K, V, H>) -> Self

Converts to this type from the input type.

impl<C: GetSize, S> GetSize for CMap<C, S>

fn size_bytes_dyn(&self) -> usize

Returns approximate number of bytes occupied by dynamic (heap) part of self. Same as self.size_bytes() - std::mem::size_of_val(self).

const USES_DYN_MEM: bool = true

true if and only if the variables of this type can use dynamic (heap) memory.

fn size_bytes_content_dyn(&self) -> usize

Returns approximate number of bytes occupied by dynamic (heap) part of self content. It usually equals to size_bytes_dyn(). However, sometimes it is smaller by the amount of memory reserved but not yet used (e.g., size_bytes_content_dyn() only takes into account the length of the vector and not its capacity).

fn size_bytes(&self) -> usize

Returns approximate, total (including heap memory) number of bytes occupied by self.