Struct Packed 

pub struct Packed<C, const P: usize> { /* private fields */ }

Unpacks P sub-codes from one stored byte, then defers to C.

The i4 tier is Packed<Grid<16>, 2>. Low sub-code first — normative, pinned by case nibble-order and asserted by CK-03.

P is arbitrary: two nibbles, four two-bit codes, eight one-bit codes. The sub-code width is 8 / P, so P must divide 8, which Packed::new checks once at construction.

Implementations

impl<C, const P: usize> Packed<C, P>

pub const SUB_BITS: u32

Bits per sub-code.

pub fn new(inner: C) -> Option<Self>

Wrap inner, unpacking P sub-codes per byte.

None when P does not divide 8, which means no such packing exists.

Trait Implementations

impl<C: Clone, const P: usize> Clone for Packed<C, P>

fn clone(&self) -> Packed<C, P>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E, Bd, C, const P: usize> Codec<E, Bd> for Packed<C, P>

where E: IntegerElement, Bd: Bound, C: Codec<E, Bd>, C::Code: From<u8>,

const MAX_BLOCK: usize

The most alphabet elements one code can produce.

const TIER: TierId = TierId::Packed

Which tier this is, for reports and for the kappa manifest.

const IS_FIXED_WIDTH: bool = C::IS_FIXED_WIDTH

Is decode_len always MAX_BLOCK?

type Code = u8

The stored code type.

fn decode_element(&self, code: Self::Code, i: usize) -> Alphabet<E, Bd>

Decode element i of the block code names. Total for every i.

fn decode_len(&self, _code: Self::Code) -> usize

How many elements code actually produces.

fn decode_into(&self, code: Self::Code, out: &mut [Alphabet<E, Bd>]) -> usize

Decode one code, returning how many elements were written.

fn decode_seq(&self, codes: &[Self::Code], out: &mut [Alphabet<E, Bd>]) -> usize

Bulk path, returning how many elements were written in total.

impl<C: Copy, const P: usize> Copy for Packed<C, P>

impl<C: Debug, const P: usize> Debug for Packed<C, P>

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

Formats the value using the given formatter.

impl<E, Bd, C, const P: usize> Enumerable<E, Bd> for Packed<C, P>

where E: IntegerElement, Bd: Bound, C: Enumerable<E, Bd>, C::Code: From<u8>,

const CODE_SPACE: usize

The number of distinct codes.

fn code_at(index: usize) -> Self::Code

The index-th code. Total for index < CODE_SPACE.

fn index_of(code: Self::Code) -> usize

Where code sits in the enumeration.

const SIGN_BIT_BOOK: bool = false

Whether the decoded book is the sign bit-decomposition: CODE_SPACE is a power of two and book[c][t] == 2 * bit(c, t) - 1 for every code c and every t below its log.

fn as_index_stream(codes: &[Self::Code]) -> Option<IndexStream<'_>>

The stored code stream, read as the index stream it already is.