Struct SeqVecBuilder 

pub struct SeqVecBuilder<T: Storable, E: Endianness> { /* private fields */ }

A builder for creating a SeqVec from a collection of sequences.

This builder is the primary entry point for constructing a compressed sequence vector when the sequences are already available in memory. It allows configuration of the compression codec.

The builder always produces an owned SeqVec<T, E, Vec<u64>>.

Construction Strategy

When the codec is Codec::Auto or requires parameter estimation (e.g., Rice { log2_b: None }), the builder performs a two-pass construction:

1. Analysis pass: Collects all elements to determine the optimal codec.
2. Encoding pass: Compresses the data using the selected codec.

When a fully-specified codec is provided (e.g., Gamma, Delta, Zeta { k: Some(3) }), the builder performs single-pass construction, avoiding the temporary allocation of all elements.

Examples

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

let sequences: &[&[u32]] = &[&[1, 2, 3], &[10, 20], &[100]];

// Automatic codec selection (two-pass)
let vec_auto: LESeqVec<u32> = SeqVec::builder()
    .codec(Codec::Auto)
    .build(sequences)?;

// Explicit codec (single-pass, more efficient)
let vec_gamma: LESeqVec<u32> = SeqVec::builder()
    .codec(Codec::Gamma)
    .build(sequences)?;

Implementations

impl<T: Storable, E: Endianness> SeqVecBuilder<T, E>

pub fn new() -> Self

Creates a new builder with default settings.

The default codec is Codec::Auto, which analyzes the data to select the best codec.

pub fn codec(self, codec_spec: Codec) -> Self

Sets the compression codec to use.

For the available codecs, see Codec.

pub fn store_lengths(self, store: bool) -> Self

Enables or disables storing explicit sequence lengths.

When enabled, the builder stores a compact FixedVec of per-sequence lengths. This allows O(1) length queries and enables faster decoding paths that avoid end-bit checks.

The default is false to minimize memory usage.

pub fn build<S: AsRef<[T]>>( self, sequences: &[S], ) -> Result<SeqVec<T, E, Vec<u64>>, SeqVecError>

where T: 'static, BufBitWriter<E, MemWordWriterVec<u64, Vec<u64>>>: BitWrite<E, Error = Infallible> + CodesWrite<E>,

Builds the SeqVec from a slice of sequences.

Each element represents a sequence to compress and store. Empty sequences are supported.

Type Requirements

The sequences can be any type that implements AsRef<[T]>, such as &[T], Vec<T>, or Box<[T]>.

Arguments

• sequences - A slice of sequences to compress. Each sequence is accessed via AsRef<[T]>.

Errors

Returns a SeqVecError if:

• Codec resolution fails.
• An I/O error occurs during encoding.

Examples

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

// From slice of slices
let data: &[&[u32]] = &[&[1, 2], &[3, 4, 5]];
let vec: LESeqVec<u32> = SeqVec::builder().build(data)?;

// From Vec of Vecs
let data: Vec<Vec<u32>> = vec![vec![1, 2], vec![3, 4, 5]];
let vec: LESeqVec<u32> = SeqVec::builder().build(&data)?;

Trait Implementations

impl<T: Clone + Storable, E: Clone + Endianness> Clone for SeqVecBuilder<T, E>

fn clone(&self) -> SeqVecBuilder<T, E>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Storable, E: Debug + Endianness> Debug for SeqVecBuilder<T, E>

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

Formats the value using the given formatter.

impl<T: Storable, E: Endianness> Default for SeqVecBuilder<T, E>

fn default() -> Self

Returns the “default value” for a type.