Struct constriction::symbol::SymbolCoder

pub struct SymbolCoder<Word: BitArray, S: Semantics, B = Vec<Word>> { /* fields omitted */ }

Generic symbol coder for 3 out of 4 possible cases

You likely won’t spell out this type explicitly. It’s more convenient to use one of the type aliases QueueEncoder or StackCoder (or the more opinionated aliases DefaultQueueEncoder and DefaultStackCoder).

Depending on the type parameter S, this type supports:

• encoding on a queue (i.e., writing prefix codes); this is type aliased as QueueEncoder.
• encoding and decoding on a stack (i.e., writing suffix codes and reading them back in reoverse order). This is type aliased as StackCoder.

This type does not support decoding from a queue. Use a QueueDecoder for this purpose.

Implementations

impl<Word: BitArray, S: Semantics, B> SymbolCoder<Word, S, B>

pub fn new() -> Self where
    B: Default, 

pub fn len(&self) -> usize where
    B: BoundedReadWords<Word, Stack>, 

Returns the correct len for, e.g., B = Vec<Word> regardless of whether S = Queue or S = Stack.

pub fn is_empty(&self) -> bool where
    B: BoundedReadWords<Word, Stack>, 

Returns true if no bits are on the SymbolCoder.

impl<Word: BitArray> SymbolCoder<Word, Stack, B>

pub fn with_bit_capacity(bit_capacity: usize) -> Self

pub fn get_compressed(&mut self) -> StackCoderGuard<'_, Word>

impl<Word: BitArray> SymbolCoder<Word, Queue, B>

pub fn with_bit_capacity(bit_capacity: usize) -> Self

pub fn get_compressed(&mut self) -> QueueEncoderGuard<'_, Word>

impl<Word: BitArray, B> SymbolCoder<Word, Queue, B>

pub fn from_compressed(compressed: B) -> Self where
    B: Default, 

pub fn into_decoder(
    self
) -> Result<QueueDecoder<Word, B::IntoReadWords>, B::WriteError> where
    B: WriteWords<Word> + IntoReadWords<Word, Queue>, 

pub fn into_compressed(self) -> Result<B, B::WriteError> where
    B: WriteWords<Word>, 

pub fn into_overshooting_iter(
    self
) -> Result<impl Iterator<Item = Result<bool, <B::IntoReadWords as ReadWords<Word, Queue>>::ReadError>>, B::WriteError> where
    B: WriteWords<Word> + IntoReadWords<Word, Queue>, 

impl<Word: BitArray, B: WriteWords<Word>> SymbolCoder<Word, Stack, B>

pub fn from_compressed(
    compressed: B
) -> Result<Self, CoderError<B, B::ReadError>> where
    B: ReadWords<Word, Stack>, 

Errors

• Returns Err(CoderError::FrontendError(compressed)) if compressed ends in a zero which is not allowed for stacks (because we need a terminal “one” bit to identify the head position). Note that “EOF” is not considered an error, and the method will return with a success if called with an empty backend.
• Returns Err(CoderError::BackendError(err)) if reading the last word from the backend resulted in Err(err).
• Returns Ok(stack_coder) in all other cases, including the case where the backend is empty.

pub fn into_compressed(self) -> Result<B, B::WriteError>

pub fn encode_symbols_reverse<Symbol, C, I>(
    &mut self,
    symbols_and_codebooks: I
) -> Result<(), CoderError<DefaultEncoderFrontendError, B::WriteError>> where
    Symbol: Borrow<C::Symbol>,
    C: EncoderCodebook,
    I: IntoIterator<Item = (Symbol, C)>,
    I::IntoIter: DoubleEndedIterator, 

pub fn encode_iid_symbols_reverse<Symbol, C, I>(
    &mut self,
    symbols: I,
    codebook: &C
) -> Result<(), CoderError<DefaultEncoderFrontendError, B::WriteError>> where
    Symbol: Borrow<C::Symbol>,
    C: EncoderCodebook,
    I: IntoIterator<Item = Symbol>,
    I::IntoIter: DoubleEndedIterator, 

pub fn into_decoder(self) -> SymbolCoder<Word, Stack, B::IntoReadWords> where
    B: IntoReadWords<Word, Stack>, 

pub fn as_decoder<'a>(&'a self) -> SymbolCoder<Word, Stack, B::AsReadWords> where
    B: AsReadWords<'a, Word, Stack>, 

pub fn into_iterator(
    self
) -> impl Iterator<Item = Result<bool, <B::IntoReadWords as ReadWords<Word, Stack>>::ReadError>> where
    B: IntoReadWords<Word, Stack>, 

Consumes the coder and returns an iterator over bits (in reverse direction)

You often don’t need to call this method since a StackCoder is already an iterator if the backend implements ReadWords<Word, Stack> (as the default backend Vec<Word> does).

pub fn iter<'a>(
    &'a self
) -> impl Iterator<Item = Result<bool, <<B as AsReadWords<'a, Word, Stack>>::AsReadWords as ReadWords<Word, Stack>>::ReadError>> + 'a where
    B: AsReadWords<'a, Word, Stack>, 

Returns an iterator over bits (in reverse direction) that leaves the current coder untouched.

You often don’t need to call this method since a StackCoder is already an iterator if the backend implements ReadWords<Word, Stack> (as the default backend Vec<Word> does).

Trait Implementations

impl<Word: Clone + BitArray, S: Clone + Semantics, B: Clone> Clone for SymbolCoder<Word, S, B>

fn clone(&self) -> SymbolCoder<Word, S, B>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Word: Debug + BitArray, S: Debug + Semantics, B: Debug> Debug for SymbolCoder<Word, S, B>

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

Formats the value using the given formatter.

impl<Word: Default + BitArray, S: Default + Semantics, B: Default> Default for SymbolCoder<Word, S, B>

fn default() -> SymbolCoder<Word, S, B>

Returns the “default value” for a type.

impl<Word: PartialEq + BitArray, S: PartialEq + Semantics, B: PartialEq> PartialEq<SymbolCoder<Word, S, B>> for SymbolCoder<Word, S, B>

fn eq(&self, other: &SymbolCoder<Word, S, B>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &SymbolCoder<Word, S, B>) -> bool

This method tests for !=.

impl<Word: Eq + BitArray, S: Eq + Semantics, B: Eq> Eq for SymbolCoder<Word, S, B>

impl<Word: BitArray, S: Semantics, B> StructuralEq for SymbolCoder<Word, S, B>

impl<Word: BitArray, S: Semantics, B> StructuralPartialEq for SymbolCoder<Word, S, B>