Struct NullableBuffer 

pub struct NullableBuffer<T: Clone + Default> {
    values: Vec<T>,
    validity: Option<BitVec>,
}

A contiguous buffer of values with a separate validity bitmap for NA tracking.

When validity is None, all values are valid (common case optimization). NA positions hold Default::default() in the values buffer.

Fields

values: Vec<T>

Dense values. NA positions hold Default::default().

validity: Option<BitVec>

Validity bitmap: bit i is 1 if values[i] is valid, 0 if NA. None means all values are valid (common case optimization).

Implementations

impl<T: Clone + Default> NullableBuffer<T>

pub fn new(len: usize) -> Self

Create a buffer of len elements, all NA.

pub fn from_values(values: Vec<T>) -> Self

Create a buffer from values with no NAs.

pub fn len(&self) -> usize

Number of elements.

pub fn is_empty(&self) -> bool

True if the buffer is empty.

pub fn get(&self, i: usize) -> Option<&T>

Get element i. Returns None if NA, Some(&value) if valid.

Panics

Panics if i >= len.

pub fn set(&mut self, i: usize, val: Option<T>)

Set element i.

Panics

Panics if i >= len.

pub fn is_na(&self, i: usize) -> bool

True if element i is NA.

Panics

Panics if i >= len.

pub fn na_count(&self) -> usize

Number of NA values.

pub fn has_na(&self) -> bool

True if there are any NAs.

pub fn iter(&self) -> NullableIter<'_, T>

Iterate yielding Option<&T> (None for NA positions).

pub fn into_vec(self) -> Vec<Option<T>>

Convert to Vec<Option<T>> (for backward compatibility).

pub fn to_option_vec(&self) -> Vec<Option<T>>

Borrow as Vec<Option<T>> (allocates).

pub fn values_slice(&self) -> &[T]

Raw values slice. NA positions hold Default::default().

pub fn values_slice_mut(&mut self) -> &mut [T]

Mutable access to the raw values slice.

pub fn validity(&self) -> Option<&BitVec>

Access the validity bitmap (None means all valid).

pub fn slice<R: RangeBounds<usize>>(&self, range: R) -> NullableBuffer<T>

Extract a sub-range as a new NullableBuffer.

fn ensure_validity(&mut self)

Ensure the validity bitmap exists (lazily allocate when first NA is added).

pub fn reverse(&mut self)

Reverse the buffer in-place.

pub fn extend(&mut self, other: &NullableBuffer<T>)

Extend this buffer with elements from another.

pub fn truncate(&mut self, len: usize)

Truncate the buffer to len elements.

pub fn push(&mut self, val: Option<T>)

Push an element onto the end.

impl<T: Clone + Default + Copy> NullableBuffer<T>

pub fn get_opt(&self, i: usize) -> Option<T>

Get element i as Option<T> by value (for Copy types).

Panics

Panics if i >= len.

pub fn first_opt(&self) -> Option<T>

Get the first element as Option<T>.

pub fn iter_opt(&self) -> impl Iterator<Item = Option<T>> + Clone + '_

Iterate yielding Option<T> by value (for Copy types). This is more convenient than iter() when you need owned values.

pub fn select_indices(&self, indices: &[usize]) -> NullableBuffer<T>

Collect indices, producing a new NullableBuffer. Out-of-bounds indices become NA.

Trait Implementations

impl<T: Clone + Clone + Default> Clone for NullableBuffer<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Clone + Default> Debug for NullableBuffer<T>

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

Formats the value using the given formatter.

impl<T: Clone + Default> From<NullableBuffer<T>> for Vec<Option<T>>

fn from(buf: NullableBuffer<T>) -> Self

Converts to this type from the input type.

impl<T: Clone + Default> From<Vec<Option<T>>> for NullableBuffer<T>

fn from(v: Vec<Option<T>>) -> Self

Converts to this type from the input type.

impl<T: Clone + Default> FromIterator<Option<T>> for NullableBuffer<T>

fn from_iter<I: IntoIterator<Item = Option<T>>>(iter: I) -> Self

Creates a value from an iterator.

impl<T: Clone + Default> IntoIterator for NullableBuffer<T>

type Item = Option<T>

The type of the elements being iterated over.

type IntoIter = NullableIntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: Clone + Default + PartialEq> PartialEq for NullableBuffer<T>

fn eq(&self, other: &Self) -> 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.