Struct 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 duplicate 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) -> bool

where Self: Encode<PRECISION>,

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

fn decoder_maybe_exhausted<const PRECISION: usize>(&self) -> bool

where 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>,

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 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 using the given entropy model.

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.