[−][src]Struct smallvec::SmallVec
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());
Implementations
impl<A: Array> SmallVec<A>
[src]
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);
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() <= Self::inline_capacity().
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]);
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]);
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]);
pub unsafe fn from_buf_and_len_unchecked(
buf: MaybeUninit<A>,
len: usize
) -> SmallVec<A>
[src]
buf: MaybeUninit<A>,
len: usize
) -> SmallVec<A>
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; use std::mem::MaybeUninit; let buf = [1, 2, 3, 4, 5, 0, 0, 0]; let small_vec: SmallVec<_> = unsafe { SmallVec::from_buf_and_len_unchecked(MaybeUninit::new(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.
pub fn drain<R>(&mut self, range: R) -> Drain<'_, A>ⓘ where
R: RangeBounds<usize>,
[src]
R: RangeBounds<usize>,
Creates a draining iterator that removes the specified range in the vector and yields the removed items.
Note 1: The element range is removed even if the iterator is only partially consumed or not consumed at all.
Note 2: It is unspecified how many elements are removed from the vector
if the Drain
value is leaked.
Panics
Panics if the starting point is greater than the end point or if the end point is greater than the length of the vector.
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 append<B>(&mut self, other: &mut SmallVec<B>) where
B: Array<Item = A::Item>,
[src]
B: Array<Item = A::Item>,
Moves all the elements of other
into self
, leaving other
empty.
Example
let mut v0: SmallVec<[u8; 16]> = smallvec![1, 2, 3]; let mut v1: SmallVec<[u8; 32]> = smallvec![4, 5, 6]; v0.append(&mut v1); assert_eq!(*v0, [1, 2, 3, 4, 5, 6]); assert_eq!(*v1, []);
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
or if the capacity computation overflows usize
.
pub fn try_grow(&mut self, new_cap: usize) -> Result<(), CollectionAllocErr>
[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.
Panics if the capacity computation overflows usize
.
pub fn try_reserve(
&mut self,
additional: usize
) -> Result<(), CollectionAllocErr>
[src]
&mut self,
additional: usize
) -> Result<(), CollectionAllocErr>
Reserve capacity for additional
more elements to be inserted.
May reserve more space to avoid frequent reallocations.
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 try_reserve_exact(
&mut self,
additional: usize
) -> Result<(), CollectionAllocErr>
[src]
&mut self,
additional: usize
) -> Result<(), CollectionAllocErr>
Reserve the minimum capacity for additional
more elements to be inserted.
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]
&mut self,
index: usize,
iterable: I
)
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_boxed_slice(self) -> Box<[A::Item]>
[src]
Converts a SmallVec
into a Box<[T]>
without reallocating if the SmallVec
has already spilled
onto the heap.
Note that this will drop any excess capacity.
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]
A::Item: PartialEq<A::Item>,
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]
F: FnMut(&mut A::Item, &mut A::Item) -> bool,
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]
F: FnMut(&mut A::Item) -> K,
K: PartialEq<K>,
Removes consecutive elements that map to the same key.
pub fn resize_with<F>(&mut self, new_len: usize, f: F) where
F: FnMut() -> A::Item,
[src]
F: FnMut() -> A::Item,
Resizes the SmallVec
in-place so that len
is equal to new_len
.
If new_len
is greater than len
, the SmallVec
is extended by the difference, with each
additional slot filled with the result of calling the closure f
. The return values from f
If new_len
is less than len
, the SmallVec
is simply truncated.
This method uses a closure to create new values on every push. If you'd rather Clone
a given
value, use resize
. If you want to use the Default
trait to generate values, you can pass
Default::default()
as the second argument.
Added for std::vec::Vec compatibility (added in Rust 1.33.0)
let mut vec : SmallVec<[_; 4]> = smallvec![1, 2, 3]; vec.resize_with(5, Default::default); assert_eq!(&*vec, &[1, 2, 3, 0, 0]); let mut vec : SmallVec<[_; 4]> = smallvec![]; let mut p = 1; vec.resize_with(4, || { p *= 2; p }); assert_eq!(&*vec, &[2, 4, 8, 16]);
pub unsafe fn from_raw_parts(
ptr: *mut A::Item,
length: usize,
capacity: usize
) -> SmallVec<A>
[src]
ptr: *mut A::Item,
length: usize,
capacity: usize
) -> SmallVec<A>
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 viaSmallVec
for its spilled storage (at least, it's highly likely to be incorrect if it wasn't).ptr
'sA::Item
type needs to be the same size and alignment that it was allocated withlength
needs to be less than or equal tocapacity
.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 { ptr::write(p.add(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]); } }
pub fn as_ptr(&self) -> *const A::Item
[src]
Returns a raw pointer to the vector's buffer.
pub fn as_mut_ptr(&mut self) -> *mut A::Item
[src]
Returns a raw mutable pointer to the vector's buffer.
impl<A: Array> SmallVec<A> where
A::Item: Copy,
[src]
A::Item: Copy,
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]
A::Item: Clone,
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> AsMut<[<A as Array>::Item]> for SmallVec<A>
[src]
impl<A: Array> AsRef<[<A as Array>::Item]> for SmallVec<A>
[src]
impl<A: Array> Borrow<[<A as Array>::Item]> for SmallVec<A>
[src]
impl<A: Array> BorrowMut<[<A as Array>::Item]> for SmallVec<A>
[src]
pub fn borrow_mut(&mut self) -> &mut [A::Item]
[src]
impl<A: Array> Clone for SmallVec<A> where
A::Item: Clone,
[src]
A::Item: Clone,
pub fn clone(&self) -> SmallVec<A>
[src]
pub fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl<A: Array> Debug for SmallVec<A> where
A::Item: Debug,
[src]
A::Item: Debug,
impl<A: Array> Default for SmallVec<A>
[src]
impl<A: Array> Deref for SmallVec<A>
[src]
type Target = [A::Item]
The resulting type after dereferencing.
pub fn deref(&self) -> &[A::Item]
[src]
impl<A: Array> DerefMut for SmallVec<A>
[src]
impl<A: Array> Drop for SmallVec<A>
[src]
impl<A: Array> Eq for SmallVec<A> where
A::Item: Eq,
[src]
A::Item: Eq,
impl<A: Array> Extend<<A as Array>::Item> for SmallVec<A>
[src]
pub fn extend<I: IntoIterator<Item = A::Item>>(&mut self, iterable: I)
[src]
pub fn extend_one(&mut self, item: A)
[src]
pub fn extend_reserve(&mut self, additional: usize)
[src]
impl<'a, A: Array> From<&'a [<A as Array>::Item]> for SmallVec<A> where
A::Item: Clone,
[src]
A::Item: Clone,
impl<A: Array> From<A> for SmallVec<A>
[src]
impl<A: Array> From<Vec<<A as Array>::Item, Global>> for SmallVec<A>
[src]
impl<A: Array> FromIterator<<A as Array>::Item> for SmallVec<A>
[src]
pub fn from_iter<I: IntoIterator<Item = A::Item>>(iterable: I) -> SmallVec<A>
[src]
impl<A: Array> Hash for SmallVec<A> where
A::Item: Hash,
[src]
A::Item: Hash,
pub fn hash<H: Hasher>(&self, state: &mut H)
[src]
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<A: Array, I: SliceIndex<[A::Item]>> Index<I> for SmallVec<A>
[src]
type Output = I::Output
The returned type after indexing.
pub fn index(&self, index: I) -> &I::Output
[src]
impl<A: Array, I: SliceIndex<[A::Item]>> IndexMut<I> 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.
pub fn into_iter(self) -> Self::IntoIter
[src]
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.
pub fn into_iter(self) -> Self::IntoIter
[src]
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.
pub fn into_iter(self) -> Self::IntoIter
[src]
impl<A: Array> Ord for SmallVec<A> where
A::Item: Ord,
[src]
A::Item: Ord,
pub fn cmp(&self, other: &SmallVec<A>) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<A: Array, B: Array> PartialEq<SmallVec<B>> for SmallVec<A> where
A::Item: PartialEq<B::Item>,
[src]
A::Item: PartialEq<B::Item>,
pub fn eq(&self, other: &SmallVec<B>) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<A: Array> PartialOrd<SmallVec<A>> for SmallVec<A> where
A::Item: PartialOrd,
[src]
A::Item: PartialOrd,
pub fn partial_cmp(&self, other: &SmallVec<A>) -> Option<Ordering>
[src]
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
impl<A: Array> Send for SmallVec<A> where
A::Item: Send,
[src]
A::Item: Send,
Auto Trait Implementations
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,
pub 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<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
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.
pub 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>,