Struct KeyCodec 

pub struct KeyCodec { /* private fields */ }

Bit-packed key layout: a small prefix id in the leading reserved bits, payload in the remainder.

For example, with 4 reserved bits the first nibble selects the prefix and the rest of the key carries the encoded logical payload.

Implementations

impl KeyCodec

pub const fn new(reserved_bits: u8, prefix: u16) -> Self

Build a codec with reserved_bits high bits reserved for prefix.

pub const fn reserved_bits(self) -> u8

The number of reserved high bits at the start of the key.

pub const fn prefix(self) -> u16

Family id stored in the reserved high bits.

pub const fn min_key_len(self) -> usize

Minimum key length in bytes needed to store this codec’s reserved bits.

pub const fn max_payload_capacity_bytes(self) -> usize

Maximum logical payload bytes that can ever fit under this codec.

pub const fn payload_capacity_bytes(self) -> usize

Maximum logical payload bytes that fit under this codec.

This reflects the global physical key cap rather than a per-key fixed width. Families that need an exact key length should use Self::payload_capacity_bytes_for_key_len.

pub const fn payload_capacity_bytes_for_key_len(self, key_len: usize) -> usize

Maximum logical payload bytes that fit in a key of key_len bytes.

pub const fn min_key_len_for_payload(self, payload_len: usize) -> usize

Smallest physical key length that can store payload_len bytes.

pub const fn payload_bit_offset(self, payload_byte_offset: usize) -> usize

Absolute bit offset for a payload byte offset within the physical key.

pub fn new_key_with_len( self, total_bytes: usize, ) -> Result<KeyMut, KeyCodecError>

Create a zero-filled key buffer with the prefix id written in the reserved bits.

pub fn new_key(self) -> Key

Create the shortest zero-filled key for this prefix.

pub fn encode(self, payload: &[u8]) -> Result<Key, KeyCodecError>

Encode an entire logical payload into a physical key.

pub fn decode( self, key: &Key, payload_len: usize, ) -> Result<Vec<u8>, KeyCodecError>

Decode payload_len bytes from a key that belongs to this codec.

pub fn write_payload( self, key: &mut KeyMut, payload_byte_offset: usize, bytes: &[u8], ) -> Result<(), KeyCodecError>

Write logical payload bytes at a byte offset within the shifted payload.

pub fn fill_payload( self, key: &mut KeyMut, payload_byte_offset: usize, len: usize, value: u8, ) -> Result<(), KeyCodecError>

Fill a payload byte range with a repeated byte value.

pub fn read_payload( self, key: &Key, payload_byte_offset: usize, len: usize, ) -> Result<Vec<u8>, KeyCodecError>

Read logical payload bytes at a byte offset within the shifted payload.

pub fn read_payload_exact<const N: usize>( self, key: &Key, payload_byte_offset: usize, ) -> Result<[u8; N], KeyCodecError>

Read an exact-size payload slice into an array.

pub fn copy_payload( self, src: &Key, src_payload_byte_offset: usize, dst: &mut KeyMut, dst_payload_byte_offset: usize, len: usize, ) -> Result<(), KeyCodecError>

Copy payload bytes from one codec-managed key into another.

pub fn matches(self, key: &Key) -> bool

True when the key belongs to this codec prefix.

pub fn prefix_bounds_for_len( self, total_bytes: usize, ) -> Result<(Key, Key), KeyCodecError>

Inclusive lower and upper bounds for keys in this prefix with a fixed byte length.

pub fn prefix_bounds(self) -> (Key, Key)

Inclusive lower and upper bounds for this prefix across the full supported key-length domain.

Trait Implementations

impl Clone for KeyCodec

fn clone(&self) -> KeyCodec

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for KeyCodec

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

Formats the value using the given formatter.

impl Hash for KeyCodec

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for KeyCodec

fn eq(&self, other: &KeyCodec) -> 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 Copy for KeyCodec

impl Eq for KeyCodec

impl StructuralPartialEq for KeyCodec