Struct polars::export::arrow::array::MutablePrimitiveArray

pub struct MutablePrimitiveArray<T> where
    T: NativeType,  { /* private fields */ }

The Arrow’s equivalent to Vec<Option<T>> where T is byte-size (e.g. i32). Converting a MutablePrimitiveArray into a PrimitiveArray is O(1).

Implementations

impl<'a, T> MutablePrimitiveArray<T> where
    T: NativeType, 

pub fn iter(&'a self) -> ZipValidity<'a, &'a T, Iter<'a, T>>

Returns an iterator over Option<T>

pub fn values_iter(&'a self) -> Iter<'a, T>

Returns an iterator of bool

impl<T> MutablePrimitiveArray<T> where
    T: NativeType, 

pub fn new() -> MutablePrimitiveArray<T>

Creates a new empty MutablePrimitiveArray.

pub fn with_capacity(capacity: usize) -> MutablePrimitiveArray<T>

Creates a new MutablePrimitiveArray with a capacity.

pub fn from_data(
    data_type: DataType,
    values: Vec<T, Global>,
    validity: Option<MutableBitmap>
) -> MutablePrimitiveArray<T>

Create a MutablePrimitiveArray out of low-end APIs.

Panics

This function panics iff:

• data_type is not supported by the physical type
• The validity is not None and its length is different from the values’s length

pub fn into_data(self) -> (DataType, Vec<T, Global>, Option<MutableBitmap>)

Extract the low-end APIs from the MutablePrimitiveArray.

impl<T> MutablePrimitiveArray<T> where
    T: NativeType, 

pub fn with_capacity_from(
    capacity: usize,
    data_type: DataType
) -> MutablePrimitiveArray<T>

Creates a new MutablePrimitiveArray from a capacity and DataType.

pub fn reserve(&mut self, additional: usize)

Reserves additional entries.

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

Adds a new value to the array.

pub fn extend_constant(&mut self, additional: usize, value: Option<T>)

Extends the MutablePrimitiveArray with a constant

pub fn extend_trusted_len<P, I>(&mut self, iterator: I) where
    P: Borrow<T>,
    I: TrustedLen<Item = Option<P>>, 

Extends the MutablePrimitiveArray from an iterator of trusted len.

pub unsafe fn extend_trusted_len_unchecked<P, I>(&mut self, iterator: I) where
    P: Borrow<T>,
    I: Iterator<Item = Option<P>>, 

Extends the MutablePrimitiveArray from an iterator of trusted len.

Safety

The iterator must be trusted len.

pub fn extend_trusted_len_values<I>(&mut self, iterator: I) where
    I: TrustedLen<Item = T>, 

Extends the MutablePrimitiveArray from an iterator of values of trusted len. This differs from extend_trusted_len which accepts in iterator of optional values.

pub unsafe fn extend_trusted_len_values_unchecked<I>(&mut self, iterator: I) where
    I: Iterator<Item = T>, 

Extends the MutablePrimitiveArray from an iterator of values of trusted len. This differs from extend_trusted_len_unchecked which accepts in iterator of optional values.

Safety

The iterator must be trusted len.

pub fn extend_from_slice(&mut self, items: &[T])

Extends the MutablePrimitiveArray from a slice

pub fn to(self, data_type: DataType) -> MutablePrimitiveArray<T>

Changes the arrays’ DataType, returning a new MutablePrimitiveArray. Use to change the logical type without changing the corresponding physical Type.

Implementation

This operation is O(1).

pub fn into_arc(self) -> Arc<dyn Array + 'static>

Converts itself into an Array.

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the MutablePrimitiveArray to fit its current length.

pub fn capacity(&self) -> usize

Returns the capacity of this MutablePrimitiveArray.

impl<T> MutablePrimitiveArray<T> where
    T: NativeType, 

Accessors

pub fn values(&self) -> &Vec<T, Global>

Returns its values.

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

Returns a mutable slice of values.

impl<T> MutablePrimitiveArray<T> where
    T: NativeType, 

Setters

pub fn set(&mut self, index: usize, value: Option<T>)

Sets position index to value. Note that if it is the first time a null appears in this array, this initializes the validity bitmap (O(N)).

Panic

Panics iff index is larger than self.len().

pub unsafe fn set_unchecked(&mut self, index: usize, value: Option<T>)

Sets position index to value. Note that if it is the first time a null appears in this array, this initializes the validity bitmap (O(N)).

Safety

Caller must ensure index < self.len()

pub fn set_validity(&mut self, validity: Option<MutableBitmap>)

Sets the validity.

Panic

Panics iff the validity’s len is not equal to the existing values’ length.

pub fn set_values(&mut self, values: Vec<T, Global>)

Sets values.

Panic

Panics iff the values’ length is not equal to the existing validity’s len.

impl<T> MutablePrimitiveArray<T> where
    T: NativeType, 

pub fn from_slice<P>(slice: P) -> MutablePrimitiveArray<T> where
    P: AsRef<[T]>, 

Creates a MutablePrimitiveArray from a slice of values.

pub unsafe fn from_trusted_len_iter_unchecked<I, P>(
    iterator: I
) -> MutablePrimitiveArray<T> where
    P: Borrow<T>,
    I: Iterator<Item = Option<P>>, 

Creates a MutablePrimitiveArray from an iterator of trusted length.

Safety

The iterator must be TrustedLen. I.e. size_hint().1 correctly reports its length.

pub fn from_trusted_len_iter<I, P>(iterator: I) -> MutablePrimitiveArray<T> where
    P: Borrow<T>,
    I: TrustedLen<Item = Option<P>>, 

Creates a MutablePrimitiveArray from a TrustedLen.

pub unsafe fn try_from_trusted_len_iter_unchecked<E, I, P>(
    iter: I
) -> Result<MutablePrimitiveArray<T>, E> where
    P: Borrow<T>,
    I: IntoIterator<Item = Result<Option<P>, E>>, 

Creates a MutablePrimitiveArray from an fallible iterator of trusted length.

Safety

The iterator must be TrustedLen. I.e. that size_hint().1 correctly reports its length.

pub fn try_from_trusted_len_iter<E, I, P>(
    iterator: I
) -> Result<MutablePrimitiveArray<T>, E> where
    P: Borrow<T>,
    I: TrustedLen<Item = Result<Option<P>, E>>, 

Creates a MutablePrimitiveArray from an fallible iterator of trusted length.

pub fn from_trusted_len_values_iter<I>(iter: I) -> MutablePrimitiveArray<T> where
    I: TrustedLen<Item = T>, 

Creates a new MutablePrimitiveArray out an iterator over values

pub fn from_vec(values: Vec<T, Global>) -> MutablePrimitiveArray<T>

Creates a (non-null) MutablePrimitiveArray from a vector of values. This does not have memcopy and is the fastest way to create a PrimitiveArray.

pub unsafe fn from_trusted_len_values_iter_unchecked<I>(
    iter: I
) -> MutablePrimitiveArray<T> where
    I: Iterator<Item = T>, 

Creates a new MutablePrimitiveArray from an iterator over values

Safety

The iterator must be TrustedLen. I.e. that size_hint().1 correctly reports its length.

Trait Implementations

impl<T> Debug for MutablePrimitiveArray<T> where
    T: Debug + NativeType, 

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

Formats the value using the given formatter.

impl<T> Default for MutablePrimitiveArray<T> where
    T: NativeType, 

fn default() -> MutablePrimitiveArray<T>

Returns the “default value” for a type.

impl<T> Extend<Option<T>> for MutablePrimitiveArray<T> where
    T: NativeType, 

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

Extends a collection with the contents of an iterator.

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> From<DataType> for MutablePrimitiveArray<T> where
    T: NativeType, 

fn from(data_type: DataType) -> MutablePrimitiveArray<T>

Performs the conversion.

impl<T> From<MutablePrimitiveArray<T>> for PrimitiveArray<T> where
    T: NativeType, 

fn from(other: MutablePrimitiveArray<T>) -> PrimitiveArray<T>

Performs the conversion.

impl<T, P> From<P> for MutablePrimitiveArray<T> where
    T: NativeType,
    P: AsRef<[Option<T>]>, 

fn from(slice: P) -> MutablePrimitiveArray<T>

Performs the conversion.

impl<T, Ptr> FromIterator<Ptr> for MutablePrimitiveArray<T> where
    T: NativeType,
    Ptr: Borrow<Option<T>>, 

fn from_iter<I>(iter: I) -> MutablePrimitiveArray<T> where
    I: IntoIterator<Item = Ptr>, 

Creates a value from an iterator.

impl<T> MutableArray for MutablePrimitiveArray<T> where
    T: NativeType, 

fn len(&self) -> usize

The length of the array.

fn validity(&self) -> Option<&MutableBitmap>

The optional validity of the array.

fn as_box(&mut self) -> Box<dyn Array + 'static, Global>

Convert itself to an (immutable) [‘Array’].

fn as_arc(&mut self) -> Arc<dyn Array + 'static>

Convert itself to an (immutable) atomically reference counted Array.

fn data_type(&self) -> &DataType

The DataType of the array.

fn as_any(&self) -> &(dyn Any + 'static)

Convert to Any, to enable dynamic casting.

fn as_mut_any(&mut self) -> &mut (dyn Any + 'static)

Convert to mutable Any, to enable dynamic casting.

fn push_null(&mut self)

Adds a new null element to the array.

fn shrink_to_fit(&mut self)

Shrink the array to fit its length.

fn is_empty(&self) -> bool

Whether the array is empty.

fn is_valid(&self, index: usize) -> bool

Whether index is valid / set.

impl<T> PartialEq<MutablePrimitiveArray<T>> for MutablePrimitiveArray<T> where
    T: NativeType, 

fn eq(&self, other: &MutablePrimitiveArray<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T> TryExtend<Option<T>> for MutablePrimitiveArray<T> where
    T: NativeType, 

fn try_extend<I>(&mut self, iter: I) -> Result<(), ArrowError> where
    I: IntoIterator<Item = Option<T>>, 

This is infalible and is implemented for consistency with all other types

impl<T> TryPush<Option<T>> for MutablePrimitiveArray<T> where
    T: NativeType, 

fn try_push(&mut self, item: Option<T>) -> Result<(), ArrowError>

This is infalible and is implemented for consistency with all other types