Enum PrimitiveVectorMut 

pub enum PrimitiveVectorMut {
    U8(PVectorMut<u8>),
    U16(PVectorMut<u16>),
    U32(PVectorMut<u32>),
    U64(PVectorMut<u64>),
    I8(PVectorMut<i8>),
    I16(PVectorMut<i16>),
    I32(PVectorMut<i32>),
    I64(PVectorMut<i64>),
    F16(PVectorMut<f16>),
    F32(PVectorMut<f32>),
    F64(PVectorMut<f64>),
}

A mutable vector of primitive values.

The immutable equivalent of this type is PrimitiveVector.

PrimitiveVector is represented by an enum over all possible PVectorMut types (which are templated by the types that implement NativePType).

See the documentation for PVectorMut for more information.

Variants

U8(PVectorMut<u8>)

U8

U16(PVectorMut<u16>)

U16

U32(PVectorMut<u32>)

U32

U64(PVectorMut<u64>)

U64

I8(PVectorMut<i8>)

I8

I16(PVectorMut<i16>)

I16

I32(PVectorMut<i32>)

I32

I64(PVectorMut<i64>)

I64

F16(PVectorMut<f16>)

F16

F32(PVectorMut<f32>)

F32

F64(PVectorMut<f64>)

F64

Implementations

impl PrimitiveVectorMut

pub fn upcast(self, target: PType) -> Self

Upcasts this integer vector to a wider integer type with matching signedness.

Returns self unchanged if the target type is the same or smaller in byte width.

pub fn extend_from_vector_with_upcast( &mut self, other: &PrimitiveVector, ) -> PType

Extends this vector from another, automatically upcasting if needed.

Unlike VectorMutOps::extend_from_vector, this does NOT panic on type mismatch. Instead, it upcasts self to the wider of the two types.

Returns the new PType after any upcasting.

impl PrimitiveVectorMut

pub fn ptype(&self) -> PType

Returns the PType of this PrimitiveVectorMut.

pub fn with_capacity(ptype: PType, capacity: usize) -> Self

Create a new mutable primitive vector with the given primitive type and capacity.

Trait Implementations

impl Clone for PrimitiveVectorMut

fn clone(&self) -> PrimitiveVectorMut

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PrimitiveVectorMut

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

Formats the value using the given formatter.

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

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

Converts to this type from the input type.

impl From<PrimitiveVectorMut> for VectorMut

fn from(v: PrimitiveVectorMut) -> Self

Converts to this type from the input type.

impl<'a> PTypeDowncast for &'a mut PrimitiveVectorMut

type Output<T: NativePType> = &'a mut PVectorMut<T>

fn into_u8(self) -> Self::Output<u8>

fn into_u16(self) -> Self::Output<u16>

fn into_u32(self) -> Self::Output<u32>

fn into_u64(self) -> Self::Output<u64>

fn into_i8(self) -> Self::Output<i8>

fn into_i16(self) -> Self::Output<i16>

fn into_i32(self) -> Self::Output<i32>

fn into_i64(self) -> Self::Output<i64>

fn into_f16(self) -> Self::Output<f16>

fn into_f32(self) -> Self::Output<f32>

fn into_f64(self) -> Self::Output<f64>

impl PTypeDowncast for PrimitiveVectorMut

type Output<T: NativePType> = PVectorMut<T>

fn into_u8(self) -> Self::Output<u8>

fn into_u16(self) -> Self::Output<u16>

fn into_u32(self) -> Self::Output<u32>

fn into_u64(self) -> Self::Output<u64>

fn into_i8(self) -> Self::Output<i8>

fn into_i16(self) -> Self::Output<i16>

fn into_i32(self) -> Self::Output<i32>

fn into_i64(self) -> Self::Output<i64>

fn into_f16(self) -> Self::Output<f16>

fn into_f32(self) -> Self::Output<f32>

fn into_f64(self) -> Self::Output<f64>

impl PTypeUpcast for PrimitiveVectorMut

type Input<T: NativePType> = PVectorMut<T>

fn from_u8(input: Self::Input<u8>) -> Self

fn from_u16(input: Self::Input<u16>) -> Self

fn from_u32(input: Self::Input<u32>) -> Self

fn from_u64(input: Self::Input<u64>) -> Self

fn from_i8(input: Self::Input<i8>) -> Self

fn from_i16(input: Self::Input<i16>) -> Self

fn from_i32(input: Self::Input<i32>) -> Self

fn from_i64(input: Self::Input<i64>) -> Self

fn from_f16(input: Self::Input<f16>) -> Self

fn from_f32(input: Self::Input<f32>) -> Self

fn from_f64(input: Self::Input<f64>) -> Self

impl VectorMutOps for PrimitiveVectorMut

type Immutable = PrimitiveVector

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: &PrimitiveVector)

Extends the vector by appending elements from another vector.

fn append_nulls(&mut self, n: usize)

Appends n null elements to the vector.

fn append_zeros(&mut self, n: usize)

Appends n zero elements to the vector.

fn append_scalars(&mut self, scalar: &PrimitiveScalar, n: usize)

Appends n scalar values to the vector.

fn freeze(self) -> PrimitiveVector

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.