Struct TurboQuantBlockedCodes 

pub struct TurboQuantBlockedCodes { /* private fields */ }

Block-major packed TurboQuant coordinate codes.

Rows are grouped in fixed 32-row blocks. For each block, all rows for packed byte 0 are stored contiguously, then all rows for packed byte 1, and so on. This preserves the same packed row representation as TurboQuantPackedCodes while making search-time scans load one byte position across a whole block.

Implementations

impl TurboQuantBlockedCodes

pub fn new( bit_width: TurboQuantBitWidth, dimensions: usize, rows: usize, ) -> TurboQuantCodecResult<Self>

Allocate zero-filled blocked-code storage.

Errors

Returns an error when dimensions are invalid or the computed byte size overflows usize.

pub fn from_row_major( codes: &TurboQuantPackedCodes, ) -> TurboQuantCodecResult<Self>

Repack row-major packed codes into block-major storage.

Errors

Returns an error if the blocked storage size overflows usize.

pub const fn bit_width(&self) -> TurboQuantBitWidth

Return the bit width used by the blocked codes.

pub const fn dimensions(&self) -> usize

Return the number of dimensions encoded in each row.

pub const fn rows(&self) -> usize

Return the number of encoded rows.

pub const fn bytes_per_row(&self) -> usize

Return the byte stride for one packed row.

pub fn block_count(&self) -> usize

Return the number of row blocks in the backing storage.

pub fn block_len(&self, block: usize) -> usize

Return the number of real rows in block.

pub fn block_byte(&self, block: usize, byte: usize) -> &[u8]

Return the packed bytes for one byte position across a 32-row block.

The returned slice always has TURBO_QUANT_BLOCK_ROWS bytes. Tail lanes beyond Self::block_len are zero padding.

pub fn row_byte(&self, row: usize, byte: usize) -> TurboQuantCodecResult<u8>

Return one packed row byte.

Errors

Returns a bounds error when row or byte is outside the matrix.

pub fn write_row_bytes( &mut self, row: usize, bytes: &[u8], ) -> TurboQuantCodecResult<()>

Overwrite one packed row from caller-provided row-major bytes.

Errors

Returns a bounds error when row is outside the matrix, or a byte-length mismatch when bytes does not contain exactly one packed row.

pub fn as_bytes(&self) -> &[u8]

Return the blocked backing bytes.

pub fn estimated_bytes(&self) -> usize

Return the blocked-code byte footprint.

pub fn resize_rows(&mut self, rows: usize) -> TurboQuantCodecResult<()>

Resize the row count while preserving existing packed rows.

Newly added rows are zero-filled. Shrinking clears rows that remain in a retained tail block, so later growth cannot expose stale packed bytes.

Errors

Returns an error when the computed byte size overflows usize.

pub fn swap_remove_row(&mut self, row: usize) -> TurboQuantCodecResult<()>

Remove one row by moving the current last row into its slot.

This preserves the packed row bytes without decoding individual coordinate codes. Tail bytes are cleared through Self::resize_rows.

Errors

Returns a bounds error when row is outside the matrix, or an overflow error if shrinking the storage would overflow internal size accounting.

pub fn read(&self, row: usize, dimension: usize) -> TurboQuantCodecResult<u8>

Read one packed coordinate code.

Errors

Returns bounds errors when row or dimension is outside the packed matrix.

pub fn write( &mut self, row: usize, dimension: usize, code: u8, ) -> TurboQuantCodecResult<()>

Write one packed coordinate code.

Errors

Returns bounds errors when row or dimension is outside the packed matrix, and TurboQuantCodecError::InvalidCode when code exceeds this storage’s bit width.

Trait Implementations

impl Clone for TurboQuantBlockedCodes

fn clone(&self) -> TurboQuantBlockedCodes

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TurboQuantBlockedCodes

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

Formats the value using the given formatter.

impl Eq for TurboQuantBlockedCodes

impl PartialEq for TurboQuantBlockedCodes

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