Enum Codes

#[non_exhaustive]
pub enum Codes {
    Unary,
    Gamma,
    Delta,
    Omega,
    VByteLe,
    VByteBe,
    Zeta {
        k: usize,
    },
    Pi {
        k: usize,
    },
    Golomb {
        b: usize,
    },
    ExpGolomb {
        k: usize,
    },
    Rice {
        log2_b: usize,
    },
}

An enum whose variants represent all the available codes.

This enum is kept in sync with implementations in the codes module.

Both Display and FromStr are implemented for this enum in a dual way, which makes it possible to store a code as a string in a configuration file, and then parse it back.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Unary

Gamma

Delta

Omega

VByteLe

VByteBe

Zeta

Fields

k: usize

Pi

Fields

k: usize

Golomb

Fields

b: usize

ExpGolomb

Fields

k: usize

Rice

Fields

log2_b: usize

Implementations

impl Codes

pub fn read<E: Endianness, CR: CodesRead<E> + ?Sized>( &self, reader: &mut CR, ) -> Result<u64, CR::Error>

Delegate to the DynamicCodeRead implementation.

This inherent method is provided to reduce ambiguity in method resolution.

pub fn write<E: Endianness, CW: CodesWrite<E> + ?Sized>( &self, writer: &mut CW, value: u64, ) -> Result<usize, CW::Error>

Delegate to the DynamicCodeWrite implementation.

This inherent method is provided to reduce ambiguity in method resolution.

pub fn to_code_const(&self) -> Result<usize>

Convert a code to the constant enum code_consts used for ConstCode. This is mostly used to verify that the code is supported by ConstCode.

pub fn from_code_const(const_code: usize) -> Result<Self>

Convert a value from code_consts to a code.

Trait Implementations

impl Clone for Codes

fn clone(&self) -> Codes

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CodeLen for Codes

fn len(&self, value: u64) -> usize

Return the length of the codeword for value.

impl CopyType for Codes

where usize: MemSize,

type Copy = False

impl Debug for Codes

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

Formats the value using the given formatter.

impl Display for Codes

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

Formats the value using the given formatter.

impl DynamicCodeRead for Codes

fn read<E: Endianness, CR: CodesRead<E> + ?Sized>( &self, reader: &mut CR, ) -> Result<u64, CR::Error>

impl DynamicCodeWrite for Codes

fn write<E: Endianness, CW: CodesWrite<E> + ?Sized>( &self, writer: &mut CW, value: u64, ) -> Result<usize, CW::Error>

impl FromStr for Codes

type Err = CodeError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl MemDbgImpl for Codes

where usize: MemDbgImpl,

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

fn _mem_dbg_depth_on( &self, writer: &mut impl Write, total_size: usize, max_depth: usize, prefix: &mut String, field_name: Option<&str>, is_last: bool, padded_size: usize, flags: DbgFlags, ) -> Result<(), Error>

impl MemSize for Codes

where usize: MemSize,

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

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

impl PartialEq for Codes

Some codes are equivalent, so we implement PartialEq to make them interchangeable so Codes::Unary == Codes::Rice{log2_b: 0}.

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<E: Endianness, CR: CodesRead<E> + ?Sized> StaticCodeRead<E, CR> for Codes

fn read(&self, reader: &mut CR) -> Result<u64, CR::Error>

impl<E: Endianness, CW: CodesWrite<E> + ?Sized> StaticCodeWrite<E, CW> for Codes

fn write(&self, writer: &mut CW, value: u64) -> Result<usize, CW::Error>

impl Copy for Codes

impl Eq for Codes