Struct PVectorMut 

pub struct PVectorMut<T> { /* private fields */ }

A mutable vector of generic primitive values.

T is expected to be bound by NativePType, which templates an internal BufferMut<T> that stores the elements of the vector.

Implementations

impl<T> PVectorMut<T>

pub fn new(elements: BufferMut<T>, validity: MaskMut) -> Self

Creates a new PVectorMut<T> from the given elements buffer and validity mask.

Panics

Panics if the length of the validity mask does not match the length of the elements buffer.

pub fn try_new(elements: BufferMut<T>, validity: MaskMut) -> VortexResult<Self>

Tries to create a new PVectorMut<T> from the given elements buffer and validity mask.

Errors

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

pub unsafe fn new_unchecked(elements: BufferMut<T>, validity: MaskMut) -> Self

Creates a new PVectorMut<T> from the given elements buffer and validity mask without validation.

Safety

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

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

Create a new mutable primitive vector with the given capacity.

pub unsafe fn set_len(&mut self, new_len: usize)

Set the length of the vector.

Safety

• new_len must be less than or equal to capacity().
• The elements at old_len..new_len must be initialized.

pub unsafe fn elements_mut(&mut self) -> &mut BufferMut<T>

Returns a mutable reference to the elements buffer.

Safety

The caller must ensure that any mutations to the elements do not violate the invariants of the vector (e.g., the length must remain consistent with the elements buffer).

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

Returns a mutable reference to the validity mask.

Safety

The caller must ensure that any mutations to the validity mask do not violate the invariants of the vector (e.g., the length must remain consistent with the elements buffer).

pub fn into_parts(self) -> (BufferMut<T>, MaskMut)

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

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

where T: Copy,

Append n values to the vector.

impl<T: NativePType> PVectorMut<T>

Point operations for PVectorMut.

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

Gets a nullable element at the given index, panicking on out-of-bounds.

If the element at the given index is null, returns None. Otherwise, returns Some(x), where x: T.

Note that this get method is different from the standard library slice::get, which returns None if the index is out of bounds. This method will panic if the index is out of bounds, and return None if the elements is null.

Panics

Panics if the index is out of bounds.

pub fn push(&mut self, value: T)

Pushes an element to the back of the vector.

The element is treated as non-null.

pub unsafe fn push_unchecked(&mut self, value: T)

Pushes an element without bounds checking.

The element is treated as non-null.

Safety

The caller must ensure that there is sufficient capacity in both elements and validity buffers.

pub fn push_opt(&mut self, value: Option<T>)

Appends an optional element to the back of the vector, where None represents a null element.

impl<T: NativePType> PVectorMut<T>

Batch operations for PVectorMut.

pub fn elements(&self) -> &BufferMut<T>

Returns the internal BufferMut of the PVectorMut.

Note that the internal buffer may hold garbage data in place of nulls. That information is tracked by the validity().

pub fn resize(&mut self, new_len: usize, value: Option<T>)

Resizes the Vec in-place so that len is equal to new_len.

If new_len is greater than len, the Vec is extended by the difference, with each additional slot filled with value, where None represent a null.

If new_len is less than len, the Vec is simply truncated.

Trait Implementations

impl<T: NativePType> AsMut<[T]> for PVectorMut<T>

fn as_mut(&mut self) -> &mut [T]

Returns a mutable slice over the internal mutable buffer with elements of type T.

Note that this slice may contain garbage data where the validity() mask from the frozen PVector type states that an element is invalid.

The caller should check the frozen validity() before performing any operations.

impl<T: NativePType> AsRef<[T]> for PVectorMut<T>

fn as_ref(&self) -> &[T]

Returns an immutable slice over the internal mutable buffer with elements of type T.

Note that this slice may contain garbage data where the validity() mask from the frozen PVector type states that an element is invalid.

The caller should check the frozen validity() before performing any operations.

impl<T: Clone> Clone for PVectorMut<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for PVectorMut<T>

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

Formats the value using the given formatter.

impl<T: NativePType> Extend<Option<T>> for PVectorMut<T>

fn extend<I: IntoIterator<Item = Option<T>>>(&mut self, iter: I)

Extends the vector from an iterator of optional values.

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

Examples

use vortex_vector::primitive::PVectorMut;
use vortex_vector::{VectorMutOps, VectorOps};

let mut vec = PVectorMut::from_iter([Some(1i32), None]);
vec.extend([Some(3), None, Some(5)]);
assert_eq!(vec.len(), 5);

let frozen = vec.freeze();
assert_eq!(frozen.validity().true_count(), 3); // Only 3 non-null values.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<T: NativePType> Extend<T> for PVectorMut<T>

fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)

Extends the vector from an iterator of values.

All values from the iterator will be marked as non-null in the validity mask.

Internally, this uses the Extend<T> trait implementation.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<T: NativePType> From<PVectorMut<T>> for PrimitiveVectorMut

fn from(v: PVectorMut<T>) -> Self

Converts to this type from the input type.

impl<T: NativePType> From<PVectorMut<T>> for VectorMut

fn from(val: PVectorMut<T>) -> Self

Converts to this type from the input type.

impl<T: NativePType> FromIterator<Option<T>> for PVectorMut<T>

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

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

Creates a new PVectorMut<T> from an iterator of Option<T> values.

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

Internally, this uses the Extend<Option<T>> trait implementation.

impl<T: NativePType> FromIterator<T> for PVectorMut<T>

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

where I: IntoIterator<Item = T>,

Creates a new PVectorMut<T> from an iterator of T values.

All values will be treated as non-null.

Examples

use vortex_vector::primitive::PVectorMut;
use vortex_vector::VectorMutOps;

let mut vec = PVectorMut::from_iter([1i32, 2, 3, 4]);
assert_eq!(vec.len(), 4);

impl<T: NativePType> IntoIterator for PVectorMut<T>

fn into_iter(self) -> Self::IntoIter

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

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

Examples

use vortex_vector::primitive::PVectorMut;

let vec = PVectorMut::<i32>::from_iter([Some(1), None, Some(3), Some(4)]);
let collected: Vec<_> = vec.into_iter().collect();
assert_eq!(collected, vec![Some(1), None, Some(3), Some(4)]);

type Item = Option<T>

The type of the elements being iterated over.

type IntoIter = PVectorMutIterator<T>

Which kind of iterator are we turning this into?

impl<T: NativePType> VectorMutOps for PVectorMut<T>

fn extend_from_vector(&mut self, other: &PVector<T>)

Extends the vector by appending elements from another vector.

fn freeze(self) -> PVector<T>

Freeze the vector into an immutable one.

type Immutable = PVector<T>

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 append_nulls(&mut self, n: usize)

Appends n null elements to the 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.