[][src]Struct smallvec::SmallVec

pub struct SmallVec<A: Array> { /* fields omitted */ }

A Vec-like container that can store a small number of elements inline.

SmallVec acts like a vector, but can store a limited amount of data inline within the SmallVec struct rather than in a separate allocation. If the data exceeds this limit, the SmallVec will "spill" its data onto the heap, allocating a new buffer to hold it.

The amount of data that a SmallVec can store inline depends on its backing store. The backing store can be any type that implements the Array trait; usually it is a small fixed-sized array. For example a SmallVec<[u64; 8]> can hold up to eight 64-bit integers inline.

Example

use smallvec::SmallVec;
let mut v = SmallVec::<[u8; 4]>::new(); // initialize an empty vector

// The vector can hold up to 4 items without spilling onto the heap.
v.extend(0..4);
assert_eq!(v.len(), 4);
assert!(!v.spilled());

// Pushing another element will force the buffer to spill:
v.push(4);
assert_eq!(v.len(), 5);
assert!(v.spilled());

Methods

impl<A: Array> SmallVec<A>[src]

Important traits for SmallVec<A>
pub fn new() -> SmallVec<A>[src]

Construct an empty vector

pub fn with_capacity(n: usize) -> Self[src]

Construct an empty vector with enough capacity pre-allocated to store at least n elements.

Will create a heap allocation only if n is larger than the inline capacity.

let v: SmallVec<[u8; 3]> = SmallVec::with_capacity(100);

assert!(v.is_empty());
assert!(v.capacity() >= 100);

Important traits for SmallVec<A>
pub fn from_vec(vec: Vec<A::Item>) -> SmallVec<A>[src]

Construct a new SmallVec from a Vec<A::Item>.

Elements will be copied to the inline buffer if vec.capacity() <= A::size().

use smallvec::SmallVec;

let vec = vec![1, 2, 3, 4, 5];
let small_vec: SmallVec<[_; 3]> = SmallVec::from_vec(vec);

assert_eq!(&*small_vec, &[1, 2, 3, 4, 5]);

Important traits for SmallVec<A>
pub fn from_buf(buf: A) -> SmallVec<A>[src]

Constructs a new SmallVec on the stack from an A without copying elements.

use smallvec::SmallVec;

let buf = [1, 2, 3, 4, 5];
let small_vec: SmallVec<_> = SmallVec::from_buf(buf);

assert_eq!(&*small_vec, &[1, 2, 3, 4, 5]);

Important traits for SmallVec<A>
pub fn from_buf_and_len(buf: A, len: usize) -> SmallVec<A>[src]

Constructs a new SmallVec on the stack from an A without copying elements. Also sets the length, which must be less or equal to the size of buf.

use smallvec::SmallVec;

let buf = [1, 2, 3, 4, 5, 0, 0, 0];
let small_vec: SmallVec<_> = SmallVec::from_buf_and_len(buf, 5);

assert_eq!(&*small_vec, &[1, 2, 3, 4, 5]);

Important traits for SmallVec<A>
pub unsafe fn from_buf_and_len_unchecked(buf: A, len: usize) -> SmallVec<A>[src]

Constructs a new SmallVec on the stack from an A without copying elements. Also sets the length. The user is responsible for ensuring that len <= A::size().

use smallvec::SmallVec;

let buf = [1, 2, 3, 4, 5, 0, 0, 0];
let small_vec: SmallVec<_> = unsafe {
    SmallVec::from_buf_and_len_unchecked(buf, 5)
};

assert_eq!(&*small_vec, &[1, 2, 3, 4, 5]);

pub unsafe fn set_len(&mut self, new_len: usize)[src]

Sets the length of a vector.

This will explicitly set the size of the vector, without actually modifying its buffers, so it is up to the caller to ensure that the vector is actually the specified size.

pub fn inline_size(&self) -> usize[src]

The maximum number of elements this vector can hold inline

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

The number of elements stored in the vector

pub fn is_empty(&self) -> bool[src]

Returns true if the vector is empty

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

The number of items the vector can hold without reallocating

pub fn spilled(&self) -> bool[src]

Returns true if the data has spilled into a separate heap-allocated buffer.

Important traits for Drain<'a, T>
pub fn drain(&mut self) -> Drain<A::Item>[src]

Empty the vector and return an iterator over its former contents.

pub fn push(&mut self, value: A::Item)[src]

Append an item to the vector.

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

Remove an item from the end of the vector and return it, or None if empty.

pub fn grow(&mut self, new_cap: usize)[src]

Re-allocate to set the capacity to max(new_cap, inline_size()).

Panics if new_cap is less than the vector's length.

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

Reserve capacity for additional more elements to be inserted.

May reserve more space to avoid frequent reallocations.

If the new capacity would overflow usize then it will be set to usize::max_value() instead. (This means that inserting additional new elements is not guaranteed to be possible after calling this function.)

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

Reserve the minimum capacity for additional more elements to be inserted.

Panics if the new capacity overflows usize.

pub fn shrink_to_fit(&mut self)[src]

Shrink the capacity of the vector as much as possible.

When possible, this will move data from an external heap buffer to the vector's inline storage.

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

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

If len is greater than or equal to the vector's current length, this has no effect.

This does not re-allocate. If you want the vector's capacity to shrink, call shrink_to_fit after truncating.

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

Extracts a slice containing the entire vector.

Equivalent to &s[..].

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

Extracts a mutable slice of the entire vector.

Equivalent to &mut s[..].

pub fn swap_remove(&mut self, index: usize) -> A::Item[src]

Remove the element at position index, replacing it with the last element.

This does not preserve ordering, but is O(1).

Panics if index is out of bounds.

pub fn clear(&mut self)[src]

Remove all elements from the vector.

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

Remove and return the element at position index, shifting all elements after it to the left.

Panics if index is out of bounds.

pub fn insert(&mut self, index: usize, element: A::Item)[src]

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

Panics if index is out of bounds.

pub fn insert_many<I: IntoIterator<Item = A::Item>>(
    &mut self,
    index: usize,
    iterable: I
)
[src]

Insert multiple elements at position index, shifting all following elements toward the back.

pub fn into_vec(self) -> Vec<A::Item>[src]

Convert a SmallVec to a Vec, without reallocating if the SmallVec has already spilled onto the heap.

pub fn into_inner(self) -> Result<A, Self>[src]

Convert the SmallVec into an A if possible. Otherwise return Err(Self).

This method returns Err(Self) if the SmallVec is too short (and the A contains uninitialized elements), or if the SmallVec is too long (and all the elements were spilled to the heap).

pub fn retain<F: FnMut(&mut A::Item) -> bool>(&mut self, f: F)[src]

Retains only the elements specified by the predicate.

In other words, remove all elements e such that f(&e) returns false. This method operates in place and preserves the order of the retained elements.

pub fn dedup(&mut self) where
    A::Item: PartialEq<A::Item>, 
[src]

Removes consecutive duplicate elements.

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

Removes consecutive duplicate elements using the given equality relation.

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

Removes consecutive elements that map to the same key.

Important traits for SmallVec<A>
pub unsafe fn from_raw_parts(
    ptr: *mut A::Item,
    length: usize,
    capacity: usize
) -> SmallVec<A>
[src]

Creates a SmallVec directly from the raw components of another SmallVec.

Safety

This is highly unsafe, due to the number of invariants that aren't checked:

  • ptr needs to have been previously allocated via SmallVec for its spilled storage (at least, it's highly likely to be incorrect if it wasn't).
  • ptr's A::Item type needs to be the same size and alignment that it was allocated with
  • length needs to be less than or equal to capacity.
  • capacity needs to be the capacity that the pointer was allocated with.

Violating these may cause problems like corrupting the allocator's internal data structures.

Additionally, capacity must be greater than the amount of inline storage A has; that is, the new SmallVec must need to spill over into heap allocated storage. This condition is asserted against.

The ownership of ptr is effectively transferred to the SmallVec which may then deallocate, reallocate or change the contents of memory pointed to by the pointer at will. Ensure that nothing else uses the pointer after calling this function.

Examples

use std::mem;
use std::ptr;

fn main() {
    let mut v: SmallVec<[_; 1]> = smallvec![1, 2, 3];

    // Pull out the important parts of `v`.
    let p = v.as_mut_ptr();
    let len = v.len();
    let cap = v.capacity();
    let spilled = v.spilled();

    unsafe {
        // Forget all about `v`. The heap allocation that stored the
        // three values won't be deallocated.
        mem::forget(v);

        // Overwrite memory with [4, 5, 6].
        //
        // This is only safe if `spilled` is true! Otherwise, we are
        // writing into the old `SmallVec`'s inline storage on the
        // stack.
        assert!(spilled);
        for i in 0..len as isize {
            ptr::write(p.offset(i), 4 + i);
        }

        // Put everything back together into a SmallVec with a different
        // amount of inline storage, but which is still less than `cap`.
        let rebuilt = SmallVec::<[_; 2]>::from_raw_parts(p, len, cap);
        assert_eq!(&*rebuilt, &[4, 5, 6]);
    }
}

impl<A: Array> SmallVec<A> where
    A::Item: Copy
[src]

pub fn from_slice(slice: &[A::Item]) -> Self[src]

Copy the elements from a slice into a new SmallVec.

For slices of Copy types, this is more efficient than SmallVec::from(slice).

pub fn insert_from_slice(&mut self, index: usize, slice: &[A::Item])[src]

Copy elements from a slice into the vector at position index, shifting any following elements toward the back.

For slices of Copy types, this is more efficient than insert.

pub fn extend_from_slice(&mut self, slice: &[A::Item])[src]

Copy elements from a slice and append them to the vector.

For slices of Copy types, this is more efficient than extend.

impl<A: Array> SmallVec<A> where
    A::Item: Clone
[src]

pub fn resize(&mut self, len: usize, value: A::Item)[src]

Resizes the vector so that its length is equal to len.

If len is less than the current length, the vector simply truncated.

If len is greater than the current length, value is appended to the vector until its length equals len.

pub fn from_elem(elem: A::Item, n: usize) -> Self[src]

Creates a SmallVec with n copies of elem.

use smallvec::SmallVec;

let v = SmallVec::<[char; 128]>::from_elem('d', 2);
assert_eq!(v, SmallVec::from_buf(['d', 'd']));

Trait Implementations

impl<A: Array> VecLike<<A as Array>::Item> for SmallVec<A>[src]

impl<A: Array> ExtendFromSlice<<A as Array>::Item> for SmallVec<A> where
    A::Item: Copy
[src]

impl<A: Array> Eq for SmallVec<A> where
    A::Item: Eq
[src]

impl<A: Array> Extend<<A as Array>::Item> for SmallVec<A>[src]

impl<A: Array> Ord for SmallVec<A> where
    A::Item: Ord
[src]

fn max(self, other: Self) -> Self1.21.0[src]

Compares and returns the maximum of two values. Read more

fn min(self, other: Self) -> Self1.21.0[src]

Compares and returns the minimum of two values. Read more

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

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

Restrict a value to a certain interval. Read more

impl<A: Array> Send for SmallVec<A> where
    A::Item: Send
[src]

impl<A: Array> AsMut<[<A as Array>::Item]> for SmallVec<A>[src]

impl<A: Array, B: Array> PartialEq<SmallVec<B>> for SmallVec<A> where
    A::Item: PartialEq<B::Item>, 
[src]

impl<A: Array> Drop for SmallVec<A>[src]

impl<A: Array> Clone for SmallVec<A> where
    A::Item: Clone
[src]

fn clone_from(&mut self, source: &Self)1.0.0[src]

Performs copy-assignment from source. Read more

impl<A: Array> PartialOrd<SmallVec<A>> for SmallVec<A> where
    A::Item: PartialOrd
[src]

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

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

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

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

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

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

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

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

impl<A: Array> AsRef<[<A as Array>::Item]> for SmallVec<A>[src]

impl<'a, A: Array> From<&'a [<A as Array>::Item]> for SmallVec<A> where
    A::Item: Clone
[src]

impl<A: Array> From<Vec<<A as Array>::Item>> for SmallVec<A>[src]

impl<A: Array> From<A> for SmallVec<A>[src]

impl<A: Array> Default for SmallVec<A>[src]

impl<A: Array> IntoIterator for SmallVec<A>[src]

type IntoIter = IntoIter<A>

Which kind of iterator are we turning this into?

type Item = A::Item

The type of the elements being iterated over.

impl<'a, A: Array> IntoIterator for &'a SmallVec<A>[src]

type IntoIter = Iter<'a, A::Item>

Which kind of iterator are we turning this into?

type Item = &'a A::Item

The type of the elements being iterated over.

impl<'a, A: Array> IntoIterator for &'a mut SmallVec<A>[src]

type IntoIter = IterMut<'a, A::Item>

Which kind of iterator are we turning this into?

type Item = &'a mut A::Item

The type of the elements being iterated over.

impl<A: Array> DerefMut for SmallVec<A>[src]

impl<A: Array> Deref for SmallVec<A>[src]

type Target = [A::Item]

The resulting type after dereferencing.

impl<A: Array> Debug for SmallVec<A> where
    A::Item: Debug
[src]

impl<A: Array> Index<usize> for SmallVec<A>[src]

type Output = A::Item

The returned type after indexing.

impl<A: Array> Index<Range<usize>> for SmallVec<A>[src]

type Output = [A::Item]

The returned type after indexing.

impl<A: Array> Index<RangeFrom<usize>> for SmallVec<A>[src]

type Output = [A::Item]

The returned type after indexing.

impl<A: Array> Index<RangeTo<usize>> for SmallVec<A>[src]

type Output = [A::Item]

The returned type after indexing.

impl<A: Array> Index<RangeFull> for SmallVec<A>[src]

type Output = [A::Item]

The returned type after indexing.

impl<A: Array> IndexMut<usize> for SmallVec<A>[src]

impl<A: Array> IndexMut<Range<usize>> for SmallVec<A>[src]

impl<A: Array> IndexMut<RangeFrom<usize>> for SmallVec<A>[src]

impl<A: Array> IndexMut<RangeTo<usize>> for SmallVec<A>[src]

impl<A: Array> IndexMut<RangeFull> for SmallVec<A>[src]

impl<A: Array> Hash for SmallVec<A> where
    A::Item: Hash
[src]

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

Feeds a slice of this type into the given [Hasher]. Read more

impl<A: Array> FromIterator<<A as Array>::Item> for SmallVec<A>[src]

impl<A: Array> BorrowMut<[<A as Array>::Item]> for SmallVec<A>[src]

impl<A: Array> Borrow<[<A as Array>::Item]> for SmallVec<A>[src]

impl<A: Array<Item = u8>> Write for SmallVec<A>[src]

fn write_vectored(&mut self, bufs: &[IoSlice]) -> Result<usize, Error>1.36.0[src]

Like write, except that it writes from a slice of buffers. Read more

fn write_fmt(&mut self, fmt: Arguments) -> Result<(), Error>1.0.0[src]

Writes a formatted string into this writer, returning any error encountered. Read more

fn by_ref(&mut self) -> &mut Self1.0.0[src]

Creates a "by reference" adaptor for this instance of Write. Read more

Auto Trait Implementations

impl<A> Sync for SmallVec<A> where
    A: Sync

Blanket Implementations

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T> From<T> for T[src]

impl<I> IntoIterator for I where
    I: Iterator
[src]

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?

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> Any for T where
    T: 'static + ?Sized
[src]