Struct BoolVectorMut 

pub struct BoolVectorMut { /* private fields */ }

A mutable vector of boolean values.

Internally, this BoolVectorMut is a wrapper around a BitBufferMut and a validity mask.

Implementations

impl BoolVectorMut

pub fn new(bits: BitBufferMut, validity: MaskMut) -> Self

Creates a new BoolVectorMut from the given bits and validity mask.

Panics

Panics if the length of the validity mask does not match the length of the bits.

pub fn try_new(bits: BitBufferMut, validity: MaskMut) -> VortexResult<Self>

Tries to create a new BoolVectorMut from the given bits and validity mask.

Errors

Returns an error if the length of the validity mask does not match the length of the bits.

pub unsafe fn new_unchecked(bits: BitBufferMut, validity: MaskMut) -> Self

Creates a new BoolVectorMut from the given bits and validity mask without validation.

Safety

The caller must ensure that the validity mask has the same length as the bits.

Ideally, they are taken from into_parts, mutated in a way that doesn’t re-allocate, and then passed back to this function.

pub fn with_capacity(capacity: usize) -> Self

Creates a new mutable boolean vector with the given capacity.

pub fn into_parts(self) -> (BitBufferMut, MaskMut)

Decomposes the boolean vector into its constituent parts (bit buffer and validity).

pub fn append_values(&mut self, value: bool, n: usize)

Append n values to the vector.

pub fn bits(&self) -> &BitBufferMut

Returns a readonly handle to the bits backing the vector.

pub unsafe fn bits_mut(&mut self) -> &mut BitBufferMut

Returns a mutable handle to the bits backing the vector.

Safety

Caller must ensure that bits and validity always have same length.

pub unsafe fn validity_mut(&mut self) -> &mut MaskMut

Get a mutable handle to the validity mask of the vector.

Safety

Caller must ensure that length of the validity always matches length of the bits.

Trait Implementations

impl Clone for BoolVectorMut

fn clone(&self) -> BoolVectorMut

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BoolVectorMut

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

Formats the value using the given formatter.

impl From<BoolVectorMut> for VectorMut

fn from(v: BoolVectorMut) -> Self

Converts to this type from the input type.

impl FromIterator<Option<bool>> for BoolVectorMut

fn from_iter<I>(iter: I) -> Self

where I: IntoIterator<Item = Option<bool>>,

Creates a new BoolVectorMut from an iterator of Option<bool> values.

None values will be marked as invalid in the validity mask.

Examples

use vortex_vector::bool::BoolVectorMut;
use vortex_vector::VectorMutOps;

let mut vec = BoolVectorMut::from_iter([Some(true), None, Some(false)]);
assert_eq!(vec.len(), 3);

impl FromIterator<bool> for BoolVectorMut

fn from_iter<I>(iter: I) -> Self

where I: IntoIterator<Item = bool>,

Creates a new BoolVectorMut from an iterator of bool values.

All values will be treated as non-null.

Examples

use vortex_vector::bool::BoolVectorMut;
use vortex_vector::VectorMutOps;

let mut vec = BoolVectorMut::from_iter([true, false, false, true]);
assert_eq!(vec.len(), 4);

impl IntoIterator for BoolVectorMut

fn into_iter(self) -> Self::IntoIter

Converts the mutable vector into an iterator over Option<bool> values.

This method consumes the BoolVectorMut and returns an iterator that yields None for null values and Some(value) for valid values.

Examples

use vortex_vector::bool::BoolVectorMut;

let vec = BoolVectorMut::from_iter([Some(true), None, Some(false), Some(true)]);
let collected: Vec<_> = vec.into_iter().collect();
assert_eq!(collected, vec![Some(true), None, Some(false), Some(true)]);

type Item = Option<bool>

The type of the elements being iterated over.

type IntoIter = BoolVectorMutIterator

Which kind of iterator are we turning this into?

impl VectorMutOps for BoolVectorMut

type Immutable = BoolVector

The immutable equivalent of this mutable vector.

fn len(&self) -> usize

Returns the number of elements in the vector, also referred to as its “length”.

fn validity(&self) -> &MaskMut

Returns the validity mask of the vector, where true represents a valid element and false represents a null element.

fn capacity(&self) -> usize

Returns the total number of elements the vector can hold without reallocating.

fn reserve(&mut self, additional: usize)

Reserves capacity for at least additional more elements to be inserted in the given vector.

fn clear(&mut self)

Clears the buffer, removing all data. Existing capacity is preserved.

fn truncate(&mut self, len: usize)

Shortens the buffer, keeping the first len bytes and dropping the rest.

fn extend_from_vector(&mut self, other: &BoolVector)

Extends the vector by appending elements from another vector.

fn append_nulls(&mut self, n: usize)

Appends n null elements to the vector.

fn freeze(self) -> BoolVector

Converts self into an immutable vector.

fn split_off(&mut self, at: usize) -> Self

Splits the vector into two at the given index.

fn unsplit(&mut self, other: Self)

Absorbs a mutable vector that was previously split off.

fn is_empty(&self) -> bool

Returns true if the vector contains no elements.