Struct sux::dict::rear_coded_list::RearCodedList

pub struct RearCodedList<D: AsRef<[u8]> = Vec<u8>, P: AsRef<[usize]> = Vec<usize>> { /* private fields */ }

Immutable lists of strings compressed by prefix omission via rear coding.

Prefix omission compresses a list of strings omitting the common prefixes of consecutive strings. To do so, it stores the length of what remains after the common prefix (hence, rear coding). It is usually applied to lists strings sorted in ascending order.

The encoding is done in blocks of k strings: in each block the first string is encoded without compression, wheres the other strings are encoded with the common prefix removed.

Implementations

impl<D: AsRef<[u8]>, P: AsRef<[usize]>> RearCodedList<D, P>

pub fn get_inplace(&self, index: usize, result: &mut Vec<u8>)

Write the index-th string to result as bytes. This is useful to avoid allocating a new string for every query and skipping the UTF-8 validity check.

impl<D: AsRef<[u8]>, P: AsRef<[usize]>> RearCodedList<D, P>

pub fn into_iter_from(&self, from: usize) -> ValueIterator<'_, D, P>

Trait Implementations

impl<D: Clone + AsRef<[u8]>, P: Clone + AsRef<[usize]>> Clone for RearCodedList<D, P>

fn clone(&self) -> RearCodedList<D, P>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<D: AsRef<[u8]>, P: AsRef<[usize]>> CopyType for RearCodedList<D, P>

type Copy = Deep

impl<D, P> CopyType for RearCodedList<D, P>

where usize: MemSize, bool: MemSize, D: MemSize + AsRef<[u8]>, P: MemSize + AsRef<[usize]>,

type Copy = False

impl<D: Debug + AsRef<[u8]>, P: Debug + AsRef<[usize]>> Debug for RearCodedList<D, P>

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

Formats the value using the given formatter.

impl<D, P> DeserializeInner for RearCodedList<D, P>

where usize: DeserializeInner, bool: DeserializeInner, D: DeserializeInner + AsRef<[u8]>, P: DeserializeInner + AsRef<[usize]>, for<'epserde_desertype> <D as DeserializeInner>::DeserType<'epserde_desertype>: AsRef<[u8]>, for<'epserde_desertype> <P as DeserializeInner>::DeserType<'epserde_desertype>: AsRef<[usize]>,

fn _deserialize_full_inner( backend: &mut impl ReadWithPos ) -> Result<Self, Error>

type DeserType<'epserde_desertype> = RearCodedList<<D as DeserializeInner>::DeserType<'epserde_desertype>, <P as DeserializeInner>::DeserType<'epserde_desertype>>

The deserialization type associated with this type. It can be retrieved conveniently with the alias DeserType.

fn _deserialize_eps_inner<'a>( backend: &mut SliceWithPos<'a> ) -> Result<Self::DeserType<'a>, Error>

impl<D: AsRef<[u8]>, P: AsRef<[usize]>> IndexedDict for RearCodedList<D, P>

fn contains(&self, string: &Self::Input) -> bool

Return whether the string is contained in the array. If the strings in the list are sorted this is done with a binary search, otherwise it is done with a linear search.

type Output = String

type Input = str

unsafe fn get_unchecked(&self, index: usize) -> Self::Output

Return the value at the specified index.

fn len(&self) -> usize

Return the length (number of items) of the dictionary.

fn get(&self, index: usize) -> Self::Output

Return the value at the specified index.

fn is_empty(&self) -> bool

Return true if len is zero.

impl<'a, D: AsRef<[u8]>, P: AsRef<[usize]>> IntoIterator for &'a RearCodedList<D, P>

type Item = String

The type of the elements being iterated over.

type IntoIter = ValueIterator<'a, D, P>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, D: AsRef<[u8]>, P: AsRef<[usize]>> IntoLender for &'a RearCodedList<D, P>

type Lender = Iterator<'a, D, P>

fn into_lender(self) -> Iterator<'a, D, P>

impl<'a, 'all, D: AsRef<[u8]>, P: AsRef<[usize]>> Lending<'all> for &'a RearCodedList<D, P>

type Lend = &'all str

The type being lent.

impl<D, P> MemDbgImpl for RearCodedList<D, P>

where usize: MemDbgImpl, bool: MemDbgImpl, D: MemDbgImpl + AsRef<[u8]>, P: MemDbgImpl + AsRef<[usize]>,

fn _mem_dbg_rec_on( &self, _memdbg_writer: &mut impl Write, _memdbg_total_size: usize, _memdbg_max_depth: usize, _memdbg_prefix: &mut String, _memdbg_is_last: bool, _memdbg_flags: DbgFlags ) -> Result

impl<D, P> MemSize for RearCodedList<D, P>

where usize: MemSize, bool: MemSize, D: MemSize + AsRef<[u8]>, P: MemSize + AsRef<[usize]>,

fn mem_size(&self, _memsize_flags: SizeFlags) -> usize

Return the (recursively computed) overall memory size of the structure in bytes.

impl<D: AsRef<[u8]> + ReprHash, P: AsRef<[usize]> + ReprHash> ReprHash for RearCodedList<D, P>

fn repr_hash(hasher: &mut impl Hasher, offset_of: &mut usize)

Accumulate representional information in hasher assuming to be positioned at offset_of.

fn repr_hash_val(&self, hasher: &mut impl Hasher, offset_of: &mut usize)

Call ReprHash::repr_hash on a value.

impl<D, P> SerializeInner for RearCodedList<D, P>

where usize: SerializeInner, bool: SerializeInner, D: SerializeInner + AsRef<[u8]>, P: SerializeInner + AsRef<[usize]>,

const IS_ZERO_COPY: bool = _

Inner constant used by the derive macros to keep track recursively of whether the type satisfies the conditions for being zero-copy. It is checked at runtime against the trait implemented by the type, and if a ZeroCopy type has this constant set to false serialization will panic.

const ZERO_COPY_MISMATCH: bool = _

Inner constant used by the derive macros to keep track of whether all fields of a type are zero-copy but neither the attribute #[zero_copy] nor the attribute #[deep_copy] was specified. It is checked at runtime, and if it is true a warning will be issued, as the type could be zero-copy, which would be more efficient.

fn _serialize_inner(&self, backend: &mut impl WriteWithNames) -> Result<()>

Serialize this structure using the given backend.

impl<D: AsRef<[u8]> + TypeHash, P: AsRef<[usize]> + TypeHash> TypeHash for RearCodedList<D, P>

fn type_hash(hasher: &mut impl Hasher)

Accumulate type information in hasher.

fn type_hash_val(&self, hasher: &mut impl Hasher)

Call TypeHash::type_hash on a value.