Struct constriction::stream::queue::RangeDecoder

pub struct RangeDecoder<Word, State, Backend>where
    Word: BitArray,
    State: BitArray,
    Backend: ReadWords<Word, Queue>,{ /* private fields */ }

Implementations

impl<Word, State, Backend> RangeDecoder<Word, State, Backend>where
    Word: BitArray + Into<State>,
    State: BitArray + AsPrimitive<Word>,
    Backend: ReadWords<Word, Queue>,

pub fn from_compressed<Buf>(compressed: Buf) -> Result<Self, Backend::ReadError>where
    Buf: IntoReadWords<Word, Queue, IntoReadWords = Backend>,

pub fn with_backend(backend: Backend) -> Result<Self, Backend::ReadError>

pub fn for_compressed<'a, Buf>(
    compressed: &'a Buf
) -> Result<Self, Backend::ReadError>where
    Buf: AsReadWords<'a, Word, Queue, AsReadWords = Backend>,

pub fn from_raw_parts(
    bulk: Backend,
    state: RangeCoderState<Word, State>,
    point: State
) -> Result<Self, Backend>

Low-level constructor that assembles a RangeDecoder from its internal components.

The arguments bulk, state, and point correspond to the three return values of the method into_raw_parts.

The construction fails if the argument point lies outside of the range represented by state. In this case, the method returns the (unmodified) argument bulk back to the caller, wrapped in an Err variant.

pub fn into_raw_parts(self) -> (Backend, RangeCoderState<Word, State>, State)

Low-level method that disassembles the RangeDecoder into its internal components.

Can be used together with from_raw_parts.

pub fn maybe_exhausted(&self) -> bool

Same as Decoder::maybe_exhausted, but can be called on a concrete type without type annotations.

Trait Implementations

impl<Word, State, Backend> Clone for RangeDecoder<Word, State, Backend>where
    Word: BitArray + Clone,
    State: BitArray + Clone,
    Backend: ReadWords<Word, Queue> + Clone,

fn clone(&self) -> RangeDecoder<Word, State, Backend>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Word, State, Backend> Code for RangeDecoder<Word, State, Backend>where
    Word: BitArray + Into<State>,
    State: BitArray + AsPrimitive<Word>,
    Backend: ReadWords<Word, Queue>,

type State = RangeCoderState<Word, State>

The internal coder state, as returned by the method state.

type Word = Word

The smallest unit of compressed data that this coder can emit or read at once. Most coders guarantee that encoding emits at most one Word per symbol (plus a constant overhead).

fn state(&self) -> Self::State

Returns the current internal state of the coder.

fn encoder_maybe_full<const PRECISION: usize>(&self) -> boolwhere
    Self: Encode<PRECISION>,

Checks if there might not be any room to encode more data.

fn decoder_maybe_exhausted<const PRECISION: usize>(&self) -> boolwhere
    Self: Decode<PRECISION>,

Checks if there might be no compressed data left for decoding.

impl<Word, State, Backend> Debug for RangeDecoder<Word, State, Backend>where
    Word: BitArray + Debug,
    State: BitArray + Debug,
    Backend: ReadWords<Word, Queue> + Debug,

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

Formats the value using the given formatter.

impl<Word, State, Backend, const PRECISION: usize> Decode<PRECISION> for RangeDecoder<Word, State, Backend>where
    Word: BitArray + Into<State>,
    State: BitArray + AsPrimitive<Word>,
    Backend: ReadWords<Word, Queue>,

fn decode_symbol<D>(
    &mut self,
    model: D
) -> Result<D::Symbol, CoderError<Self::FrontendError, Self::BackendError>>where
    D: DecoderModel<PRECISION>,
    D::Probability: Into<Self::Word>,
    Self::Word: AsPrimitive<D::Probability>,

Decodes a single symbol and pops it off the compressed data.

This is a low level method. You usually probably want to call a batch method like decode_symbols or decode_iid_symbols instead.

This method is called decode_symbol rather than decode_symbol to stress the fact that the Coder is a stack: decode_symbol will return the last symbol that was previously encoded via encode_symbol.

Note that this method cannot fail. It will still produce symbols in a deterministic way even if the coder is empty, but such symbols will not recover any previously encoded data and will generally have low entropy. Still, being able to pop off an arbitrary number of symbols can sometimes be useful in edge cases of, e.g., the bits-back algorithm.

type FrontendError = DecoderFrontendError

The error type for logical decoding errors.

type BackendError = <Backend as ReadWords<Word, Queue>>::ReadError

The error type for reading in encoded data.

fn maybe_exhausted(&self) -> bool

Checks if there might be no compressed data left for decoding.

fn decode_symbols<'s, I, M>(
    &'s mut self,
    models: I
) -> DecodeSymbols<'s, Self, I::IntoIter, PRECISION> where
    I: IntoIterator<Item = M> + 's,
    M: DecoderModel<PRECISION>,
    M::Probability: Into<Self::Word>,
    Self::Word: AsPrimitive<M::Probability>,

Decodes a sequence of symbols, using an individual entropy model for each symbol.

fn try_decode_symbols<'s, I, M, E>(
    &'s mut self,
    models: I
) -> TryDecodeSymbols<'s, Self, I::IntoIter, PRECISION> where
    I: IntoIterator<Item = Result<M, E>> + 's,
    M: DecoderModel<PRECISION>,
    M::Probability: Into<Self::Word>,
    Self::Word: AsPrimitive<M::Probability>,

Decodes a sequence of symbols from a fallible iterator over entropy models.

fn decode_iid_symbols<M>(
    &mut self,
    amt: usize,
    model: M
) -> DecodeIidSymbols<'_, Self, M, PRECISION> where
    M: DecoderModel<PRECISION> + Copy,
    M::Probability: Into<Self::Word>,
    Self::Word: AsPrimitive<M::Probability>,

Decodes amt symbols using the same entropy model for all symbols.

impl<Word, State, Backend> From<RangeEncoder<Word, State, Backend>> for RangeDecoder<Word, State, Backend::IntoReadWords>where
    Word: BitArray + Into<State>,
    State: BitArray + AsPrimitive<Word>,
    Backend: WriteWords<Word> + IntoReadWords<Word, Queue>,

fn from(encoder: RangeEncoder<Word, State, Backend>) -> Self

Converts to this type from the input type.

impl<Word, State, Backend> PosSeek for RangeDecoder<Word, State, Backend>where
    Word: BitArray,
    State: BitArray,
    Backend: ReadWords<Word, Queue> + PosSeek,
    Self: Code,

type Position = (<Backend as PosSeek>::Position, <RangeDecoder<Word, State, Backend> as Code>::State)

impl<Word, State, Backend> Seek for RangeDecoder<Word, State, Backend>where
    Word: BitArray + Into<State>,
    State: BitArray + AsPrimitive<Word>,
    Backend: ReadWords<Word, Queue> + Seek,

fn seek(&mut self, pos_and_state: Self::Position) -> Result<(), ()>

Jumps to a given position in the compressed data.