Struct soapy::Soa

pub struct Soa<T>
where
    T: Soapy,
{ /* private fields */ }

Implementations

impl<T> Soa<T>

where T: Soapy,

pub fn new() -> Self

Constructs a new, empty Soa<T>.

The container will not allocate until elements are pushed onto it.

pub fn with_capacity(capacity: usize) -> Self

Construct a new, empty Soa<T> with at least the specified capacity.

The container will be able to hold capacity elements without reallocating. If the capacity is 0, the container will not allocate. Note that although the returned vector has the minimum capacity specified, the vector will have a zero length. The capacity will be as specified unless T is zero-sized, in which case the capacity will be usize::MAX.

pub fn len(&self) -> usize

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

pub fn is_empty(&self) -> bool

Returns true if the container contains no elements.

pub fn capacity(&self) -> usize

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

pub fn into_raw_parts(self) -> (*mut u8, usize, usize)

Decomposes a Soa<T> into its raw components.

Returns the raw pointer to the underlying data, the length of the vector (in elements), and the allocated capacity of the data (in elements). These are the same arguments in the same order as the arguments to Soa::from_raw_parts.

After calling this function, the caller is responsible for the memory previously managed by the Soa. The only way to do this is to convert the raw pointer, length, and capacity back into a Vec with the Soa::from_raw_parts function, allowing the destructor to perform the cleanup.

pub unsafe fn from_raw_parts( ptr: *mut u8, length: usize, capacity: usize ) -> Self

Creates a Soa<T> from a pointer, a length, and a capacity.

Safety

This is highly unsafe due to the number of invariants that aren’t checked. Given that many of these invariants are private implementation details of RawSoa, it is better not to uphold them manually. Rather, it only valid to call this method with the output of a previous call to Soa::into_raw_parts.

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

Appends an element to the back of a collection.

pub fn pop(&mut self) -> Option<T>

Removes the last element from a vector and returns it, or None if it is empty.

pub fn insert(&mut self, index: usize, element: T)

Inserts an element at position index, shifting all elements after it to the right.

Panics

Panics if index > len

pub fn remove(&mut self, index: usize) -> T

Removes and returns the element at position index within the vector, shifting all elements after it to the left.

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

Reserves capacity for at least additional more elements to be inserted in the given Soa<T>. The collection may reserve more space to speculatively avoid frequent reallocations. After calling reserve, capacity will be greater than or equal to self.len() + additional. Does nothing if capacity is already sufficient.

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

Reserves the minimum capacity for at least additional more elements to be inserted in the given Soa<T>. Unlike Soa::reserve, this will not deliberately over-allocate to speculatively avoid frequent allocations. After calling reserve_exact, capacity will be greater than or equal to self.len() + additional. Does nothing if the capacity is already sufficient.

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the container as much as possible.

pub fn shrink_to(&mut self, min_capacity: usize)

Shrinks the capacity of the vector with a lower bound.

The capacity will remain at least as large as both the length and the supplied value. If the current capacity is less than the lower limit, this is a no-op.

pub fn truncate(&mut self, len: usize)

Shortens the vector, keeping the first len elements and dropping the rest.

If len is greater or equal to the vector’s current length, this has no effect. Note that this method has no effect on the allocated capacity of the vector.

pub fn swap_remove(&mut self, index: usize) -> T

Removes an element from the vector and returns it.

The removed element is replaced by the last element of the vector. This does not preserve ordering, but is O(1). If you need to preserve the element order, use remove instead.

Panics

Panics if index is out of bounds.

pub fn append(&mut self, other: &mut Self)

Moves all the elements of other into self, leaving other empty.

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

Returns an iterator over the elements.

The iterator yields all items from start to end.

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator over the elements that allows modifying each value.

The iterator yields all items from start to end.

pub fn try_fold<F, B>(&self, init: B, f: F) -> B

where F: FnMut(B, &T) -> ControlFlow<B, B>,

pub fn try_fold_zip<F, B, O>(&self, other: &Soa<O>, init: B, f: F) -> B

where O: Soapy, F: FnMut(B, &T, &O) -> ControlFlow<B, B>,

pub fn for_each<F>(&self, f: F)

where F: FnMut(&T),

Calls a closure on each element of the collection.

pub fn for_each_zip<F, O>(&self, other: &Soa<O>, f: F)

where O: Soapy, F: FnMut(&T, &O),

Calls a closure on each element of the collection.

pub fn clear(&mut self)

Clears the vector, removing all values.

Note that this method has no effect on the allocated capacity of the vector.

pub fn get<I>(&self, index: I) -> Option<I::Output<'_>>

where I: SoaIndex<T>,

Returns a reference to an element or subslice depending on the type of index.

pub fn nth_cloned(&self, index: usize) -> T

where T: Clone,

Returns a clone of the element at the given index.

Panics

Panics if index >= len.

pub fn nth(&self, index: usize) -> <T::RawSoa as RawSoa<T>>::Ref<'_>

Returns a reference to the element at the given index.

Panics

Panics if index >= len.

pub fn slices(&self) -> <T::RawSoa as RawSoa<T>>::Slices<'_>

Returns slices for each of the SoA fields.

pub fn get_mut<I>(&mut self, index: I) -> Option<I::OutputMut<'_>>

where I: SoaIndex<T>,

Returns a mutable reference to an element or subslice depending on the type of index.

pub fn nth_mut(&mut self, index: usize) -> <T::RawSoa as RawSoa<T>>::RefMut<'_>

Returns a reference to the element at the given index.

Panics

Panics if index >= len.

pub fn slices_mut(&mut self) -> <T::RawSoa as RawSoa<T>>::SlicesMut<'_>

Returns mutable slices for each of the SoA fields.

pub fn swap(&mut self, a: usize, b: usize)

Swaps the position of two elements.

Panics

Panics if a or b is out of bounds.

Trait Implementations

impl<T> Clone for Soa<T>

where T: Soapy + Clone,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Soa<T>

where T: Soapy + Debug,

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

Formats the value using the given formatter.

impl<T> Default for Soa<T>

where T: Soapy,

fn default() -> Self

Returns the “default value” for a type.

impl<T> Drop for Soa<T>

where T: Soapy,

fn drop(&mut self)

Executes the destructor for this type.

impl<T> Extend<T> for Soa<T>

where T: Soapy,

fn extend<I: IntoIterator<Item = 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> From<&[T]> for Soa<T>

where T: Soapy + Clone,

fn from(value: &[T]) -> Self

Allocate a Soa<T> and fill it by cloning value’s items.

impl<T, const N: usize> From<&[T; N]> for Soa<T>

where T: Soapy + Clone,

fn from(value: &[T; N]) -> Self

Allocate a Soa<T> and fill it by cloning value’s items.

impl<T> From<&mut [T]> for Soa<T>

where T: Soapy + Clone,

fn from(value: &mut [T]) -> Self

Allocate a Soa<T> and fill it by cloning value’s items.

impl<T, const N: usize> From<&mut [T; N]> for Soa<T>

where T: Soapy + Clone,

fn from(value: &mut [T; N]) -> Self

Allocate a Soa<T> and fill it by cloning value’s items.

impl<T, const N: usize> From<[T; N]> for Soa<T>

where T: Soapy,

fn from(value: [T; N]) -> Self

Allocate a Soa<T> and move value’s items into it.

impl<T> FromIterator<T> for Soa<T>

where T: Soapy,

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

Creates a value from an iterator.

impl<T> Hash for Soa<T>

where T: Soapy + Hash,

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> IntoIterator for Soa<T>

where T: Soapy,

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> Ord for Soa<T>

where T: Soapy + Ord,

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl<T> PartialEq for Soa<T>

where T: Soapy + PartialEq,

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> PartialOrd for Soa<T>

where T: Soapy + PartialOrd,

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> Eq for Soa<T>

where T: Soapy + Eq,

impl<T> Send for Soa<T>

where T: Send + Soapy,

impl<T> Sync for Soa<T>

where T: Sync + Soapy,