Struct DynamicArray 

pub struct DynamicArray<T, TAllocator>
where
    TAllocator: Allocator,
{ /* private fields */ }

A #[repr(C)] variant of the standard vec struct.

Functionally similar, and implements [ReprC] for T: ReprC. However, unlike vec this struct multiplies capacity by 3/2 when resizing is needed.

Implementations

impl<T, TAllocator> DynamicArray<T, TAllocator>

where TAllocator: Allocator,

pub fn new() -> Self

where TAllocator: Default,

Creates a new, empty DynamicArray.

pub const fn with_allocator(allocator: TAllocator) -> Self

Creates a new, empty DynamicArray with an allocator.

pub fn with_capacity_and_allocator( capacity: Length, allocator: TAllocator, ) -> Result<Self, ArrayError>

Creates a new DynamicArray with capacity and allocator. This allocates memory only when capacity > 0.

Errors

For details see ArrayError.

pub fn with_capacity(capacity: Length) -> Result<Self, ArrayError>

where TAllocator: Default,

Creates a new DynamicArray with capacity and the default allocator. This allocates memory only when capacity > 0.

Errors

For details see ArrayError.

pub fn with_factory<Factory: FnMut(usize) -> T>( size: Length, factory: Factory, ) -> Result<Self, ArrayError>

where TAllocator: Default,

Creates a new DynamicArray with a given size, generated through a given factory. This allocates memory only when size > 0.

Notes

This method is functionally equivalent to initializing an empty vector and running factory one by one in a loop, and passing it to push. This way, however, is more efficient, even if you preallocate the vector with capacity. Because this method gives the compiler an opportunity to vectorize the construction, unlike sequential push calls.

Errors

For details see ArrayError.

pub fn with_factory_and_allocator<Factory: FnMut(usize) -> T>( size: Length, factory: Factory, allocator: TAllocator, ) -> Result<Self, ArrayError>

Creates a new DynamicArray with a given size, generated through a given factory, with a custom allocator. This allocates memory only when size > 0.

Notes

This method is functionally equivalent to initializing an empty vector and running factory one by one in a loop, and passing it to push. This way, however, is more efficient, even if you preallocate the vector with capacity. Because this method gives the compiler an opportunity to vectorize the construction, unlike sequential push calls.

Errors

For details see ArrayError.

pub unsafe fn with_size_uninitialized(size: Length) -> Result<Self, ArrayError>

where TAllocator: Default,

Creates a new DynamicArray with a given size, but uninitialized.

Safety

The underlying array is uninitialized and reading the data is UB, unless initialized first.

Errors

For details see ArrayError.

pub unsafe fn with_size_and_allocator_uninitialized( size: Length, allocator: TAllocator, ) -> Result<Self, ArrayError>

Creates a new DynamicArray with a given size and allocator, but uninitialized.

Safety

The underlying array is uninitialized and reading the data is UB, unless initialized first.

Errors

For details see ArrayError.

Trait Implementations

impl<T, TAllocator> AsMut<[T]> for DynamicArray<T, TAllocator>

where TAllocator: Allocator,

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

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T, TAllocator> AsRef<[T]> for DynamicArray<T, TAllocator>

where TAllocator: Allocator,

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

Converts this type into a shared reference of the (usually inferred) input type.

impl<T, TAllocator> Borrow<[T]> for DynamicArray<T, TAllocator>

where TAllocator: Allocator,

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

Immutably borrows from an owned value.

impl<T, TAllocator> BorrowMut<[T]> for DynamicArray<T, TAllocator>

where TAllocator: Allocator,

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

Mutably borrows from an owned value.

impl<T, TAllocator> Clone for DynamicArray<T, TAllocator>

where T: TryClone + Clone, TAllocator: Allocator + TryClone + Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug, TAllocator> Debug for DynamicArray<T, TAllocator>

where TAllocator: Allocator + Debug,

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

Formats the value using the given formatter.

impl<T, TAllocator> Default for DynamicArray<T, TAllocator>

where TAllocator: Allocator + Default,

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T: Deserialize<'de>, TAllocator: Allocator + Default> Deserialize<'de> for DynamicArray<T, TAllocator>

Available on crate feature serde only.

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T, TAllocator> Drop for DynamicArray<T, TAllocator>

where TAllocator: Allocator,

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

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

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<T, TAllocator> Eq for DynamicArray<T, TAllocator>

where T: Eq, TAllocator: Allocator,

impl<T, TAllocator> Hash for DynamicArray<T, TAllocator>

where T: Hash, TAllocator: Allocator,

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, TAllocator> ImmutableArray<T> for DynamicArray<T, TAllocator>

where TAllocator: Allocator,

fn length(&self) -> Length

Returns array’s length as [Length].

fn capacity(&self) -> Length

Returns the current capacity for holding items in the array.

fn is_empty(&self) -> bool

Returns true if array is empty, false otherwise. Should be consistent with self.length() == Length::ZERO check.

impl<T, TAllocator> MutableArray<T> for DynamicArray<T, TAllocator>

where TAllocator: Allocator,

fn try_push_array<const TSIZE: usize>( &mut self, arr: [T; TSIZE], ) -> Result<(), ArrayError>

Tries to push raw array to the array.

fn try_push_slice(&mut self, slice: &[T]) -> Result<(), ArrayTryCloneError>

where T: TryClone,

Tries to push slice to the array. This method requires Clone trait on T.

fn try_pop(&mut self) -> Result<T, ArrayIsEmptyError>

Removes element from the top of the array.

fn pop(&mut self) -> T

Removes element from the top of the array.

fn try_push(&mut self, value: T) -> Result<(), ArrayError>

Pushes a single element to the array.

fn push_array<const TSIZE: usize>(&mut self, arr: [T; TSIZE])

Pushes raw array to the array.

fn push_slice(&mut self, slice: &[T])

where T: TryClone,

Pushes raw slice to the array. This method requires Clone trait on T.

fn push(&mut self, value: T)

Pushes a single element to the array.

impl<T, TAllocator, Rhs> PartialEq<Rhs> for DynamicArray<T, TAllocator>

where T: PartialEq, TAllocator: Allocator, Rhs: AsRef<[T]>,

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, TAllocator> ReprC for DynamicArray<T, TAllocator>

where T: ReprC, TAllocator: Allocator,

const CHECK: ()

This field is used for const checks only.

impl<T: Serialize, TAllocator: Allocator> Serialize for DynamicArray<T, TAllocator>

Available on crate feature serde only.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T, TAllocator> TryClone for DynamicArray<T, TAllocator>

where T: TryClone, TAllocator: Allocator + TryClone,

type Error = ArrayTryCloneError

fn try_clone(&self) -> Result<Self, Self::Error>

Tries to clone the type.