Struct rustc_data_structures::small_vec::SmallVec

pub struct SmallVec<A: Array>(_);

Methods

impl<A: Array> SmallVec<A>

pub fn new() -> Self

pub fn with_capacity(cap: usize) -> Self

pub fn one(el: A::Element) -> Self

pub fn many<I: IntoIterator<Item = A::Element>>(els: I) -> Self

pub fn expect_one(self, err: &'static str) -> A::Element

pub fn push(&mut self, el: A::Element)

Will reallocate onto the heap if needed.

pub fn reserve(&mut self, n: usize)

pub unsafe fn set_len(&mut self, len: usize)

pub fn insert(&mut self, index: usize, element: A::Element)

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

Methods from Deref<Target = AccumulateVec<A>>

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

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

Important traits for Drain<'a, A>

impl<'a, A: Array> Iterator for Drain<'a, A> type Item = A::Element;

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

Trait Implementations

impl<A> Clone for SmallVec<A> where     A: Array,     A::Element: Clone,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A> Debug for SmallVec<A> where     A: Array + Debug,     A::Element: Debug,

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

Formats the value using the given formatter.

impl<A: Array> Deref for SmallVec<A>

type Target = AccumulateVec<A>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<A: Array> DerefMut for SmallVec<A>

fn deref_mut(&mut self) -> &mut AccumulateVec<A>

Mutably dereferences the value.

impl<A: Array> FromIterator<A::Element> for SmallVec<A>

fn from_iter<I>(iter: I) -> Self where     I: IntoIterator<Item = A::Element>,

Creates a value from an iterator.

impl<A: Array> Extend<A::Element> for SmallVec<A>

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

Extends a collection with the contents of an iterator.

impl<A: Array> IntoIterator for SmallVec<A>

type Item = A::Element

The type of the elements being iterated over.

type IntoIter = IntoIter<A>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<A: Array> Default for SmallVec<A>

fn default() -> SmallVec<A>

Returns the "default value" for a type.

impl<A> Encodable for SmallVec<A> where     A: Array,     A::Element: Encodable,

fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error>

impl<A> Decodable for SmallVec<A> where     A: Array,     A::Element: Decodable,

fn decode<D: Decoder>(d: &mut D) -> Result<SmallVec<A>, D::Error>