[−][src]Struct tinyvec::ArrayVec
An array-backed vector-like data structure.
- Fixed capacity (based on array size)
- Variable length
- All of the array memory is always initialized.
Methods
impl<A: Array> ArrayVec<A>
[src]
pub fn append(&mut self, other: &mut Self)
[src]
Move all values from other
into this vec.
#[must_use]
pub fn as_mut_ptr(&mut self) -> *mut A::Item
[src]
A mutable pointer to the backing array.
Safety
This pointer has provenance over the entire backing array.
#[must_use]
pub fn as_mut_slice(&mut self) -> &mut [A::Item]
[src]
Helper for getting the mut slice.
#[must_use]
pub fn as_ptr(&self) -> *const A::Item
[src]
A const pointer to the backing array.
Safety
This pointer has provenance over the entire backing array.
#[must_use]
pub fn as_slice(&self) -> &[A::Item]
[src]
Helper for getting the shared slice.
#[must_use]
pub fn capacity(&self) -> usize
[src]
The capacity of the ArrayVec
.
This is fixed based on the array type.
pub fn clear(&mut self)
[src]
Removes all elements from the vec.
pub fn dedup(&mut self) where
A::Item: PartialEq,
[src]
A::Item: PartialEq,
De-duplicates the vec.
pub fn dedup_by<F>(&mut self, same_bucket: F) where
F: FnMut(&mut A::Item, &mut A::Item) -> bool,
[src]
F: FnMut(&mut A::Item, &mut A::Item) -> bool,
De-duplicates the vec according to the predicate given.
pub fn dedup_by_key<F, K>(&mut self, key: F) where
F: FnMut(&mut A::Item) -> K,
K: PartialEq,
[src]
F: FnMut(&mut A::Item) -> K,
K: PartialEq,
De-duplicates the vec according to the key selector given.
ⓘImportant traits for ArrayVecDrain<'p, A>pub fn drain<R: RangeBounds<usize>>(&mut self, range: R) -> ArrayVecDrain<A>
[src]
Creates a draining iterator that removes the specified range in the vector and yields the removed items.
Panics
- If the start is greater than the end
- If the end is past the edge of the vec.
Example
use tinyvec::*; let mut av = array_vec!([i32; 4], 1, 2, 3); let av2: ArrayVec<[i32; 4]> = av.drain(1..).collect(); assert_eq!(av.as_slice(), &[1][..]); assert_eq!(av2.as_slice(), &[2, 3][..]); av.drain(..); assert_eq!(av.as_slice(), &[]);
pub fn extend_from_slice(&mut self, sli: &[A::Item]) where
A::Item: Clone,
[src]
A::Item: Clone,
Clone each element of the slice into this vec.
#[must_use]
pub fn from_array_len(data: A, len: usize) -> Self
[src]
Wraps up an array and uses the given length as the initial length.
Note that the From
impl for arrays assumes the full length is used.
Panics
The length must be less than or equal to the capacity of the array.
pub fn insert(&mut self, index: usize, item: A::Item)
[src]
Inserts an item at the position given, moving all following elements +1 index.
Panics
- If
index
>len
Example
use tinyvec::*; let mut av = array_vec!([i32; 10], 1, 2, 3); av.insert(1, 4); assert_eq!(av.as_slice(), &[1, 4, 2, 3]); av.insert(4, 5); assert_eq!(av.as_slice(), &[1, 4, 2, 3, 5]);
#[must_use]
pub fn is_empty(&self) -> bool
[src]
If the vec is empty.
#[must_use]
pub fn len(&self) -> usize
[src]
The length of the vec (in elements).
#[must_use]
pub fn new() -> Self where
A: Default,
[src]
A: Default,
Makes a new, empty vec.
pub fn pop(&mut self) -> Option<A::Item>
[src]
Remove and return the last element of the vec, if there is one.
Failure
- If the vec is empty you get
None
.
pub fn push(&mut self, val: A::Item)
[src]
Place an element onto the end of the vec.
See also, try_push
Panics
- If the length of the vec would overflow the capacity.
pub fn remove(&mut self, index: usize) -> A::Item
[src]
Removes the item at index
, shifting all others down by one index.
Returns the removed element.
Panics
If the index is out of bounds.
Example
use tinyvec::*; let mut av = array_vec!([i32; 4], 1, 2, 3); assert_eq!(av.remove(1), 2); assert_eq!(av.as_slice(), &[1, 3][..]);
pub fn resize(&mut self, new_len: usize, new_val: A::Item) where
A::Item: Clone,
[src]
A::Item: Clone,
Resize the vec to the new length.
If it needs to be longer, it's filled with clones of the provided value. If it needs to be shorter, it's truncated.
Example
use tinyvec::*; let mut av = array_vec!([&str; 10], "hello"); av.resize(3, "world"); assert_eq!(av.as_slice(), &["hello", "world", "world"][..]); let mut av = array_vec!([i32; 10], 1, 2, 3, 4); av.resize(2, 0); assert_eq!(av.as_slice(), &[1, 2][..]);
pub fn resize_with<F: FnMut() -> A::Item>(&mut self, new_len: usize, f: F)
[src]
Resize the vec to the new length.
If it needs to be longer, it's filled with repeated calls to the provided function. If it needs to be shorter, it's truncated.
Example
use tinyvec::*; let mut av = array_vec!([i32; 10], 1, 2, 3); av.resize_with(5, Default::default); assert_eq!(av.as_slice(), &[1, 2, 3, 0, 0][..]); let mut av = array_vec!([i32; 10]); let mut p = 1; av.resize_with(4, || { p *= 2; p }); assert_eq!(av.as_slice(), &[2, 4, 8, 16][..]);
pub fn retain<F: FnMut(&A::Item) -> bool>(&mut self, acceptable: F)
[src]
Walk the vec and keep only the elements that pass the predicate given.
Example
use tinyvec::*; let mut av = array_vec!([i32; 10], 1, 2, 3, 4); av.retain(|&x| x % 2 == 0); assert_eq!(av.as_slice(), &[2, 4][..]);
pub fn split_off(&mut self, at: usize) -> Self where
Self: Default,
[src]
Self: Default,
Splits the collection at the point given.
[0, at)
stays in this vec[at, len)
ends up in the new vec.
Panics
- if at > len
Example
use tinyvec::*; let mut av = array_vec!([i32; 4], 1, 2, 3); let av2 = av.split_off(1); assert_eq!(av.as_slice(), &[1][..]); assert_eq!(av2.as_slice(), &[2, 3][..]);
pub fn swap_remove(&mut self, index: usize) -> A::Item
[src]
Remove an element, swapping the end of the vec into its place.
Panics
- If the index is out of bounds.
Example
use tinyvec::*; let mut av = array_vec!([&str; 4], "foo", "bar", "quack", "zap"); assert_eq!(av.swap_remove(1), "bar"); assert_eq!(av.as_slice(), &["foo", "zap", "quack"][..]); assert_eq!(av.swap_remove(0), "foo"); assert_eq!(av.as_slice(), &["quack", "zap"][..]);
pub fn truncate(&mut self, new_len: usize)
[src]
Reduces the vec's length to the given value.
If the vec is already shorter than the input, nothing happens.
pub fn try_from_array_len(data: A, len: usize) -> Result<Self, A>
[src]
Wraps an array, using the given length as the starting length.
If you want to use the whole length of the array, you can just use the
From
impl.
Failure
If the given length is greater than the capacity of the array this will
error, and you'll get the array back in the Err
.
pub fn try_push(&mut self, val: A::Item) -> Result<(), A::Item>
[src]
Pushes an item if there's room.
Failure
If there's no more capacity the vec is unchanged, and you get the item
back in the Err
.
Trait Implementations
impl<A: Array> AsMut<[<A as Array>::Item]> for ArrayVec<A>
[src]
impl<A: Array> AsRef<[<A as Array>::Item]> for ArrayVec<A>
[src]
impl<A: Array> Binary for ArrayVec<A> where
A::Item: Binary,
[src]
A::Item: Binary,
impl<A: Array> Borrow<[<A as Array>::Item]> for ArrayVec<A>
[src]
impl<A: Array> BorrowMut<[<A as Array>::Item]> for ArrayVec<A>
[src]
#[must_use]
fn borrow_mut(&mut self) -> &mut [A::Item]
[src]
impl<A: Clone + Array> Clone for ArrayVec<A>
[src]
fn clone(&self) -> ArrayVec<A>
[src]
fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl<A: Copy + Array> Copy for ArrayVec<A>
[src]
impl<A: Array> Debug for ArrayVec<A> where
A::Item: Debug,
[src]
A::Item: Debug,
impl<A: Default + Array> Default for ArrayVec<A>
[src]
impl<A: Array> Deref for ArrayVec<A>
[src]
type Target = [A::Item]
The resulting type after dereferencing.
#[must_use]
fn deref(&self) -> &Self::Target
[src]
impl<A: Array> DerefMut for ArrayVec<A>
[src]
impl<A: Array> Display for ArrayVec<A> where
A::Item: Display,
[src]
A::Item: Display,
impl<A: Array> Eq for ArrayVec<A> where
A::Item: Eq,
[src]
A::Item: Eq,
impl<A: Array> Extend<<A as Array>::Item> for ArrayVec<A>
[src]
fn extend<T: IntoIterator<Item = A::Item>>(&mut self, iter: T)
[src]
impl<A: Array> From<A> for ArrayVec<A>
[src]
#[must_use]
fn from(data: A) -> Self
[src]
The output has a length equal to the full array.
If you want to select a length, use
from_array_len
impl<A: Array> From<ArrayVec<A>> for TinyVec<A>
[src]
impl<A: Array + Default> FromIterator<<A as Array>::Item> for ArrayVec<A>
[src]
#[must_use]
fn from_iter<T: IntoIterator<Item = A::Item>>(iter: T) -> Self
[src]
impl<A: Array, I: SliceIndex<[A::Item]>> Index<I> for ArrayVec<A>
[src]
type Output = <I as SliceIndex<[A::Item]>>::Output
The returned type after indexing.
#[must_use]
fn index(&self, index: I) -> &Self::Output
[src]
impl<A: Array, I: SliceIndex<[A::Item]>> IndexMut<I> for ArrayVec<A>
[src]
impl<A: Array> IntoIterator for ArrayVec<A>
[src]
type Item = A::Item
The type of the elements being iterated over.
type IntoIter = ArrayVecIterator<A>
Which kind of iterator are we turning this into?
#[must_use]
fn into_iter(self) -> Self::IntoIter
[src]
impl<A: Array> LowerExp for ArrayVec<A> where
A::Item: LowerExp,
[src]
A::Item: LowerExp,
impl<A: Array> LowerHex for ArrayVec<A> where
A::Item: LowerHex,
[src]
A::Item: LowerHex,
impl<A: Array> Octal for ArrayVec<A> where
A::Item: Octal,
[src]
A::Item: Octal,
impl<A: Array> Ord for ArrayVec<A> where
A::Item: Ord,
[src]
A::Item: Ord,
#[must_use]
fn cmp(&self, other: &Self) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<'_, A: Array> PartialEq<&'_ [<A as Array>::Item]> for ArrayVec<A> where
A::Item: PartialEq,
[src]
A::Item: PartialEq,
#[must_use]
fn eq(&self, other: &&[A::Item]) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'_, A: Array> PartialEq<&'_ A> for ArrayVec<A> where
A::Item: PartialEq,
[src]
A::Item: PartialEq,
#[must_use]
fn eq(&self, other: &&A) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<A: Array> PartialEq<ArrayVec<A>> for ArrayVec<A> where
A::Item: PartialEq,
[src]
A::Item: PartialEq,
#[must_use]
fn eq(&self, other: &Self) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<A: Array> PartialOrd<ArrayVec<A>> for ArrayVec<A> where
A::Item: PartialOrd,
[src]
A::Item: PartialOrd,
#[must_use]
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
impl<A: Array> Pointer for ArrayVec<A> where
A::Item: Pointer,
[src]
A::Item: Pointer,
impl<A: Array> UpperExp for ArrayVec<A> where
A::Item: UpperExp,
[src]
A::Item: UpperExp,
impl<A: Array> UpperHex for ArrayVec<A> where
A::Item: UpperHex,
[src]
A::Item: UpperHex,
Auto Trait Implementations
impl<A> Send for ArrayVec<A> where
A: Send,
A: Send,
impl<A> Sync for ArrayVec<A> where
A: Sync,
A: Sync,
impl<A> Unpin for ArrayVec<A> where
A: Unpin,
A: Unpin,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<!> for T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<I> IntoIterator for I where
I: Iterator,
[src]
I: Iterator,
type Item = <I as Iterator>::Item
The type of the elements being iterated over.
type IntoIter = I
Which kind of iterator are we turning this into?
fn into_iter(self) -> I
[src]
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T> ToString for T where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,