Struct arrow2::array::MutablePrimitiveArray

pub struct MutablePrimitiveArray<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: NativeType> MutablePrimitiveArray<T>

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

Returns an iterator over Option<T>

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

Returns an iterator of T

impl<T: NativeType> MutablePrimitiveArray<T>

pub fn new() -> Self

Creates a new empty MutablePrimitiveArray.

pub fn with_capacity(capacity: usize) -> Self

Creates a new MutablePrimitiveArray with a capacity.

pub fn try_new(
    data_type: DataType,
    values: Vec<T>,
    validity: Option<MutableBitmap>
) -> Result<Self, Error>

The canonical method to create a MutablePrimitiveArray out of its internal components.

Implementation

This function is O(1).

Errors

This function errors iff:

• The validity is not None and its length is different from values’s length
• The data_type’s crate::datatypes::PhysicalType is not equal to [crate::datatypes::PhysicalType::Primitive(T::PRIMITIVE)]

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

Extract the low-end APIs from the MutablePrimitiveArray.

pub fn apply_values<F: Fn(&mut [T])>(&mut self, f: F)

Applies a function f to the values of this array, cloning the values iff they are being shared with others

This is an API to use clone-on-write

Implementation

This function is O(f) if the data is not being shared, and O(N) + O(f) if it is being shared (since it results in a O(N) memcopy).

Panics

This function panics iff f panics

impl<T: NativeType> MutablePrimitiveArray<T>

pub fn with_capacity_from(capacity: usize, data_type: DataType) -> Self

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 pop(&mut self) -> Option<T>

Pop a value from the array. Note if the values is empty, this method will return None.

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) -> Self

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>

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: NativeType> MutablePrimitiveArray<T>

Accessors

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

Returns its values.

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

Returns a mutable slice of values.

impl<T: NativeType> MutablePrimitiveArray<T>

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>)

Sets values.

Panic

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

impl<T: NativeType> MutablePrimitiveArray<T>

pub fn from_slice<P: AsRef<[T]>>(slice: P) -> Self

Creates a MutablePrimitiveArray from a slice of values.

pub unsafe fn from_trusted_len_iter_unchecked<I, P>(iterator: I) -> Selfwhere
    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) -> Selfwhere
    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<Self, 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<Self, 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: TrustedLen<Item = T>>(iter: I) -> Self

Creates a new MutablePrimitiveArray out an iterator over values

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

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: Iterator<Item = T>>(
    iter: I
) -> Self

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: Clone + NativeType> Clone for MutablePrimitiveArray<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

fn default() -> Self

Returns the “default value” for a type.

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

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

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

fn from(data_type: DataType) -> Self

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

fn from(slice: P) -> Self

Converts to this type from the input type.

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

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

Creates a value from an iterator.

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

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>

Convert itself to an (immutable) Array.

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

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

Convert to Any, to enable dynamic casting.

fn as_mut_any(&mut self) -> &mut dyn Any

Convert to mutable Any, to enable dynamic casting.

fn push_null(&mut self)

Adds a new null element to the array.

fn reserve(&mut self, additional: usize)

Reserves additional slots to its capacity.

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: NativeType> PartialEq<MutablePrimitiveArray<T>> for MutablePrimitiveArray<T>

fn eq(&self, other: &Self) -> 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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

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

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

impl<T: NativeType> TryExtendFromSelf for MutablePrimitiveArray<T>

fn try_extend_from_self(&mut self, other: &Self) -> Result<(), Error>

Tries to extend itself with elements from other, failing only on overflow.

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

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

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