Struct HashMapper 

pub struct HashMapper<T, const NBITS: usize>
where
    T: Hash,
{ /* private fields */ }

Store hash-to-string association for a hash value

A hash mapping can be loaded from and written to files. Such files store one line per hash, formatted as <hex-value> <string>.

Implementations

impl<T, const N: usize> HashMapper<T, N>

where T: Eq + Hash + Copy,

pub fn new() -> Self

Create a new, empty mapping

pub fn get(&self, hash: T) -> Option<&str>

Get a value from the mapping

pub fn seek(&self, hash: T) -> HashOrStr<T, &str>

Return a matching string (if known) or the hash

Use this method to get a string representation with a fallback for unknown hashes.

let mut mapper = HashMapper::<u16>::new();
mapper.insert(42, "forty-two".to_string());
assert_eq!(format!("{}", mapper.seek(42)), "forty-two");
assert_eq!(format!("{}", mapper.seek(0x1234)), "{1234}");

pub fn is_empty(&self) -> bool

Return true if the mapping is empty

pub fn is_known(&self, hash: T) -> bool

Return true if the given hash is known

pub fn insert(&mut self, hash: T, value: String)

Add a hash to the mapper

Important: the caller must ensure the value matches the hash.

impl<T, const N: usize> HashMapper<T, N>

where T: Num + Eq + Hash + Copy,

pub fn from_reader<R: BufRead>(reader: R) -> Result<Self, HashError>

Create a new mapping, loaded from a reader

pub fn from_path<P: AsRef<Path>>(path: P) -> Result<Self, HashError>

Create a new mapping, loaded from a file

pub fn load_reader<R: BufRead>(&mut self, reader: R) -> Result<(), HashError>

Load hash mapping from a reader

pub fn load_path<P: AsRef<Path>>(&mut self, path: P) -> Result<(), HashError>

Load hash mapping from a file

impl<T, const N: usize> HashMapper<T, N>

where T: Eq + Hash + Copy + LowerHex,

pub fn write<W: Write>(&self, writer: &mut W) -> Result<()>

Write hash mapping to a writer

pub fn write_path<P: AsRef<Path>>(&self, path: P) -> Result<()>

Write hash map to a file

File is upadeted atomically.

Trait Implementations

impl<T, const N: usize> Debug for HashMapper<T, N>

where T: Hash,

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

Formats the value using the given formatter.

impl<T, const NBITS: usize> Default for HashMapper<T, NBITS>

where T: Hash + Default,

fn default() -> HashMapper<T, NBITS>

Returns the “default value” for a type.