Struct tinyvec::ArrayishVec

#[repr(C)]
pub struct ArrayishVec<A: Arrayish> { /* fields omitted */ }

Methods

impl<A: Arrayish> ArrayishVec<A>

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

#[must_use] pub fn as_mut_ptr(&mut self) -> *mut A::Item

#[must_use] pub fn as_mut_slice(&mut self) -> &mut [A::Item]

#[must_use] pub fn as_ptr(&self) -> *const A::Item

#[must_use] pub fn as_slice(&self) -> &[A::Item]

#[must_use] pub fn capacity(&self) -> usize

pub fn clear(&mut self)

pub fn dedup(&mut self) where
    A::Item: PartialEq, 

pub fn dedup_by<F>(&mut self, same_bucket: F) where
    F: FnMut(&mut A::Item, &mut A::Item) -> bool, 

pub fn dedup_by_key<F, K>(&mut self, key: F) where
    F: FnMut(&mut A::Item) -> K,
    K: PartialEq, 

Important traits for ArrayishVecDrain<'p, A>

impl<'p, A: Arrayish> Iterator for ArrayishVecDrain<'p, A> type Item = A::Item;

pub fn drain<R: RangeBounds<usize>>(&mut self, range: R) -> ArrayishVecDrain<A>

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 = arr_vec!([i32; 4], 1, 2, 3);
let av2: ArrayishVec<[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, 

#[must_use] pub fn from_array_len(data: A, len: usize) -> Self

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)

Inserts an item at the position given, moving all following elements +1 index.

Panics

• If index > len

Example

use tinyvec::*;
let mut av = arr_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

#[must_use] pub fn len(&self) -> usize

#[must_use] pub fn new() -> Self where
    A: Default, 

pub fn pop(&mut self) -> Option<A::Item>

pub fn push(&mut self, val: A::Item)

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

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 = arr_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, 

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 = arr_vec!([&str; 10], "hello");
av.resize(3, "world");
assert_eq!(av.as_slice(), &["hello", "world", "world"][..]);

let mut av = arr_vec!([i32; 10], 1, 2, 3, 4);
av.resize(2, 0);
assert_eq!(av.as_slice(), &[1, 2][..]);

pub fn resize_default(&mut self, new_len: usize)

Resize the vec to the new size.

If it needs to be longer the length is simply increased (in constant time), if it needs to be shorter then it's truncated.

Example

use tinyvec::*;

let mut av = arr_vec!([i32; 10], 1, 2, 3);
av.resize_default(5);
assert_eq!(av.as_slice(), &[1, 2, 3, 0, 0][..]);

let mut av = arr_vec!([i32; 10], 1, 2, 3, 4);
av.resize_default(2);
assert_eq!(av.as_slice(), &[1, 2][..]);

pub fn resize_with<F: FnMut() -> A::Item>(&mut self, new_len: usize, f: F)

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

Walk the vec and keep only the elements that pass the predicate given.

Example

use tinyvec::*;

let mut av = arr_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, 

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 = arr_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

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

pub fn try_from_array_len(data: A, len: usize) -> Result<Self, A>

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>

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: Arrayish> AsMut<[<A as Arrayish>::Item]> for ArrayishVec<A>

#[must_use] fn as_mut(&mut self) -> &mut [A::Item]

Performs the conversion.

impl<A: Arrayish> AsRef<[<A as Arrayish>::Item]> for ArrayishVec<A>

#[must_use] fn as_ref(&self) -> &[A::Item]

Performs the conversion.

impl<A: Arrayish> Binary for ArrayishVec<A> where
    A::Item: Binary, 

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

Formats the value using the given formatter.

impl<A: Arrayish> Borrow<[<A as Arrayish>::Item]> for ArrayishVec<A>

#[must_use] fn borrow(&self) -> &[A::Item]

Immutably borrows from an owned value.

impl<A: Arrayish> BorrowMut<[<A as Arrayish>::Item]> for ArrayishVec<A>

#[must_use] fn borrow_mut(&mut self) -> &mut [A::Item]

Mutably borrows from an owned value.

impl<A: Clone + Arrayish> Clone for ArrayishVec<A>

fn clone(&self) -> ArrayishVec<A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Copy + Arrayish> Copy for ArrayishVec<A>

impl<A: Arrayish> Debug for ArrayishVec<A> where
    A::Item: Debug, 

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

Formats the value using the given formatter.

impl<A: Default + Arrayish> Default for ArrayishVec<A>

fn default() -> ArrayishVec<A>

Returns the "default value" for a type.

impl<A: Arrayish> Deref for ArrayishVec<A>

type Target = [A::Item]

The resulting type after dereferencing.

#[must_use] fn deref(&self) -> &Self::Target

Dereferences the value.

impl<A: Arrayish> DerefMut for ArrayishVec<A>

#[must_use] fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<A: Arrayish> Display for ArrayishVec<A> where
    A::Item: Display, 

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

Formats the value using the given formatter.

impl<A: Arrayish> Eq for ArrayishVec<A> where
    A::Item: Eq, 

impl<A: Arrayish> Extend<<A as Arrayish>::Item> for ArrayishVec<A>

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

Extends a collection with the contents of an iterator.

impl<A: Arrayish> From<A> for ArrayishVec<A>

#[must_use] fn from(data: A) -> Self

The output has a length equal to the full array.

If you want to select a length, use [from_array_len]

impl<A: Arrayish + Default> FromIterator<<A as Arrayish>::Item> for ArrayishVec<A>

#[must_use] fn from_iter<T: IntoIterator<Item = A::Item>>(iter: T) -> Self

Creates a value from an iterator.

impl<A: Arrayish, I: SliceIndex<[A::Item]>> Index<I> for ArrayishVec<A>

type Output = <I as SliceIndex<[A::Item]>>::Output

The returned type after indexing.

#[must_use] fn index(&self, index: I) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<A: Arrayish, I: SliceIndex<[A::Item]>> IndexMut<I> for ArrayishVec<A>

#[must_use] fn index_mut(&mut self, index: I) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<A: Arrayish> IntoIterator for ArrayishVec<A>

type Item = A::Item

The type of the elements being iterated over.

type IntoIter = ArrayishVecIterator<A>

Which kind of iterator are we turning this into?

#[must_use] fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<A: Arrayish> LowerExp for ArrayishVec<A> where
    A::Item: LowerExp, 

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

Formats the value using the given formatter.

impl<A: Arrayish> LowerHex for ArrayishVec<A> where
    A::Item: LowerHex, 

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

Formats the value using the given formatter.

impl<A: Arrayish> Octal for ArrayishVec<A> where
    A::Item: Octal, 

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

Formats the value using the given formatter.

impl<A: Arrayish> Ord for ArrayishVec<A> where
    A::Item: Ord, 

#[must_use] fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

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

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

Restrict a value to a certain interval.

impl<'_, A: Arrayish> PartialEq<&'_ [<A as Arrayish>::Item]> for ArrayishVec<A> where
    A::Item: PartialEq, 

#[must_use] fn eq(&self, other: &&[A::Item]) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'_, A: Arrayish> PartialEq<&'_ A> for ArrayishVec<A> where
    A::Item: PartialEq, 

#[must_use] fn eq(&self, other: &&A) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<A: Arrayish> PartialEq<ArrayishVec<A>> for ArrayishVec<A> where
    A::Item: PartialEq, 

#[must_use] fn eq(&self, other: &Self) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<A: Arrayish> PartialOrd<ArrayishVec<A>> for ArrayishVec<A> where
    A::Item: PartialOrd, 

#[must_use] fn partial_cmp(&self, other: &Self) -> Option<Ordering>

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

#[must_use] fn lt(&self, other: &Rhs) -> bool

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

#[must_use] fn le(&self, other: &Rhs) -> bool

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

#[must_use] fn gt(&self, other: &Rhs) -> bool

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

#[must_use] 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<A: Arrayish> Pointer for ArrayishVec<A> where
    A::Item: Pointer, 

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

Formats the value using the given formatter.

impl<A: Arrayish> UpperExp for ArrayishVec<A> where
    A::Item: UpperExp, 

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

Formats the value using the given formatter.

impl<A: Arrayish> UpperHex for ArrayishVec<A> where
    A::Item: UpperHex, 

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

Formats the value using the given formatter.