Struct SeqVecReader 

pub struct SeqVecReader<'a, T: Storable, E: Endianness, B: AsRef<[u64]>>
where
    for<'b> BufBitReader<E, MemWordReader<u64, &'b [u64], true>, DefaultReadParams>: BitRead<E, Error = Infallible> + CodesRead<E> + BitSeek<Error = Infallible>,
{ /* private fields */ }

A stateful reader for a SeqVec that provides convenient random sequence access with optimized reader reuse.

This reader is created by the SeqVec::reader method. It provides a convenient interface for performing multiple random sequence lookups, with internal reader reuse for efficiency.

Design

Unlike the stateless SeqVec accessors, SeqVecReader maintains an internal VarVecBitReader and CodecReader that are reused across multiple accesses. This design mirrors VarVecReader in the variable module.

The reader exposes only stateful, allocation-aware APIs that benefit from internal reader reuse. For lazy iteration, use SeqVec::get directly.

Examples

use compressed_intvec::seq::{SeqVec, USeqVec};

let sequences: &[&[u32]] = &[
    &[10, 20, 30],
    &[100, 200],
    &[1000, 2000, 3000, 4000],
];
let vec: USeqVec<u32> = SeqVec::from_slices(sequences)?;

// Create a reusable reader
let mut reader = vec.reader();

// Perform multiple random reads with optimized decode_into()
let mut buffer = Vec::new();
reader.decode_into(2, &mut buffer).unwrap();
assert_eq!(buffer, vec![1000, 2000, 3000, 4000]);

// Or use SeqVec::get() for lazy iteration
let seq0: Vec<u32> = vec.get(0).unwrap().collect();
assert_eq!(seq0, vec![10, 20, 30]);

Implementations

impl<'a, T: Storable, E: Endianness, B: AsRef<[u64]>> SeqVecReader<'a, T, E, B>

where for<'b> BufBitReader<E, MemWordReader<u64, &'b [u64], true>, DefaultReadParams>: BitRead<E, Error = Infallible> + CodesRead<E> + BitSeek<Error = Infallible>,

pub fn decode_vec(&mut self, index: usize) -> Option<Vec<T>>

Retrieves the sequence at index as a Vec<T>, or None if out of bounds.

This method reuses the internal bitstream reader and codec dispatcher, providing better performance than collecting a SeqVec::get iterator into a vector. For optimal memory allocation, ensure the builder option SeqVecBuilder::store_lengths was used during construction.

Examples

use compressed_intvec::seq::{SeqVec, LESeqVec};

let sequences: &[&[u32]] = &[&[1, 2, 3], &[10, 20]];
let vec: LESeqVec<u32> = SeqVec::from_slices(sequences)?;

let mut reader = vec.reader();
assert_eq!(reader.decode_vec(0), Some(vec![1, 2, 3]));
assert_eq!(reader.decode_vec(2), None);

pub fn decode_into(&mut self, index: usize, buf: &mut Vec<T>) -> Option<usize>

Retrieves the sequence at index into the provided buffer, returning the number of elements decoded.

The buffer is cleared before decoding. This method is useful for reusing allocations across multiple sequence retrievals.

Returns None if index is out of bounds.

This implementation reuses the internal bitstream reader and codec dispatcher, avoiding the overhead of creating a temporary iterator.

Examples

use compressed_intvec::seq::{SeqVec, LESeqVec};

let sequences: &[&[u32]] = &[&[1, 2, 3], &[10, 20, 30, 40]];
let vec: LESeqVec<u32> = SeqVec::from_slices(sequences)?;

let mut reader = vec.reader();
let mut buffer = Vec::new();

// Decode first sequence
let count = reader.decode_into(0, &mut buffer).unwrap();
assert_eq!(count, 3);
assert_eq!(buffer, vec![1, 2, 3]);

// Reuse buffer for second sequence
let count = reader.decode_into(1, &mut buffer).unwrap();
assert_eq!(count, 4);
assert_eq!(buffer, vec![10, 20, 30, 40]);

pub unsafe fn decode_into_unchecked( &mut self, index: usize, buf: &mut Vec<T>, ) -> usize

Retrieves the sequence at index into the provided buffer without bounds checking.

Safety

Calling this method with an out-of-bounds index is undefined behavior.

Trait Implementations

impl<T: Storable, E: Endianness, B: AsRef<[u64]>> Debug for SeqVecReader<'_, T, E, B>

where for<'b> BufBitReader<E, MemWordReader<u64, &'b [u64], true>, DefaultReadParams>: BitRead<E, Error = Infallible> + CodesRead<E> + BitSeek<Error = Infallible>,

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

Formats the value using the given formatter.