Struct AtomicFixedVecBuilder 

pub struct AtomicFixedVecBuilder<T: Storable<u64>> { /* private fields */ }

A builder for creating an AtomicFixedVec from a slice of integers.

This builder analyzes a slice to determine the bit_width based on the selected BitWidth strategy and then constructs the thread-safe vector.

Example

use compressed_intvec::prelude::*;
use compressed_intvec::fixed::{AtomicFixedVec, UAtomicFixedVec, BitWidth};

let data: &[u32] = &[10, 20, 30, 40, 50];

// The builder can infer the minimal bit width (6 bits for 50).
let vec: UAtomicFixedVec<u32> = AtomicFixedVec::builder()
    .build(data)
    .unwrap();

assert_eq!(vec.bit_width(), 6);

// Or a specific strategy can be chosen.
let vec_pow2: UAtomicFixedVec<u32> = AtomicFixedVec::builder()
    .bit_width(BitWidth::PowerOfTwo)
    .build(data)
    .unwrap();

assert_eq!(vec_pow2.bit_width(), 8);

// You can also specify an explicit bit width.
let vec_explicit: UAtomicFixedVec<u32> = AtomicFixedVec::builder()
   .bit_width(BitWidth::Explicit(10))
   .build(data)
   .unwrap();

assert_eq!(vec_explicit.bit_width(), 10);

Implementations

impl<T> AtomicFixedVecBuilder<T>

where T: Storable<u64> + Copy + ToPrimitive,

pub fn new() -> Self

Creates a new builder with the default BitWidth::Minimal strategy.

pub fn bit_width(self, strategy: BitWidth) -> Self

Sets the strategy for determining the number of bits for each element.

This can be one of:

• BitWidth::Minimal: Automatically determines the minimal bit width needed.
• BitWidth::PowerOfTwo: Rounds up to the next power of two.
• BitWidth::Explicit: Uses the specified number of bits explicitly.

Note

Choosing BitWidth::Minimal and BitWidth::PowerOfTwo introduces a one-time overhead at construction time to find the maximum value in the input slice.

Performance

Choosing BitWidth::PowerOfTwo allows for true atomic operations on the vector, resulting in better performance for concurrent access patterns. However, it may use more space than necessary.

pub fn build(self, input: &[T]) -> Result<AtomicFixedVec<T>, Error>

Builds the AtomicFixedVec from a slice of data.

This method consumes the builder and returns a new AtomicFixedVec. The initial data is populated using non-atomic writes, as the vector is not yet shared during construction.

Errors

Returns an Error if a value in the input is too large for the specified bit_width, or if the parameters are invalid.

Trait Implementations

impl<T: Clone + Storable<u64>> Clone for AtomicFixedVecBuilder<T>

fn clone(&self) -> AtomicFixedVecBuilder<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Storable<u64>> Debug for AtomicFixedVecBuilder<T>

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

Formats the value using the given formatter.

impl<T> Default for AtomicFixedVecBuilder<T>

where T: Storable<u64>,

fn default() -> Self

Returns the “default value” for a type.