Struct enum_vec::EnumVec

pub struct EnumVec<T: EnumLike> { /* fields omitted */ }

A vector which efficiently stores enum variants.

Methods

impl<T: EnumLike> EnumVec<T>

pub fn new() -> Self

pub fn with_capacity(n: usize) -> Self

pub fn capacity(&self) -> usize

Returns the number of elements that can be hold without allocating new memory.

use enum_vec::EnumVec;

let ev = EnumVec::<bool>::with_capacity(53);
assert!(ev.capacity() >= 53);

pub fn get(&self, i: usize) -> Option<T>

pub fn set(&mut self, i: usize, x: T)

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

Reserves capacity for at least additional more elements.

use enum_vec::EnumVec;

let mut ev: EnumVec<Option<()>> = vec![None, None, None].into();
ev.reserve(100);
assert!(ev.capacity() >= 100 + 3);

pub fn shrink_to_fit(&mut self)

Shrinks the capacity as much as possible.

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

pub fn swap_remove(&mut self, index: usize) -> T

Remove an element from an arbitrary position in O(1) time, but without preserving the ordering. This is accomplished by swapping the desired element with the last element, and then calling pop().

use enum_vec::EnumVec;

let mut ev: EnumVec<bool> = vec![true, true, true, false, false].into();
ev.swap_remove(0);
assert_eq!(&ev.to_vec(), &[false, true, true, false]);
ev.swap_remove(1);
assert_eq!(&ev.to_vec(), &[false, false, true]);

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

Insert and remove need a better implementation

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

pub fn retain<F>(&mut self, f: F) where     F: FnMut(&T) -> bool,

Retains only the elements specified by the predicate

use enum_vec::EnumVec;

let mut v: EnumVec<(bool, bool)> = vec![(true, true), (false, false), (true, false),
    (false, true)].into();
v.retain(|x| x.0 == true);
let a = v.to_vec();
assert_eq!(&a, &[(true, true), (true, false)]);

pub fn push(&mut self, x: T)

pub fn pop(&mut self) -> Option<T>

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

pub fn clear(&mut self)

Sets the length to zero, removing all the elements.

use enum_vec::EnumVec;

let mut ev = EnumVec::new();
ev.push(Some(false));
assert_eq!(ev.len(), 1);
ev.clear();
assert_eq!(ev.len(), 0);
assert!(ev.is_empty());

unsafe {
    ev.set_len(1);
    assert_eq!(ev.pop().unwrap(), Some(false));
}

pub fn len(&self) -> usize

Returns the length of the vector, the number of elements it holds.

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

pub fn is_empty(&self) -> bool

pub fn split_off(&mut self, at: usize) -> Self

pub fn resize(&mut self, new_len: usize, value: T) where     T: Clone,

pub unsafe fn get_raw_unchecked(&self, i: usize) -> usize

Get the raw discriminant without bounds checking

pub unsafe fn set_raw_unchecked(&mut self, i: usize, discr: usize)

Set the raw discriminant without bounds checking. It is assumed that the discriminant is lower than T::NUM_ELEMENTS.

pub fn swap(&mut self, ia: usize, ib: usize)

Swap two elements.

Important traits for EnumVecIter<'a, T>

impl<'a, T: EnumLike> Iterator for EnumVecIter<'a, T> type Item = T;

pub fn iter<'a>(&'a self) -> EnumVecIter<'a, T>

pub fn for_each<F>(&mut self, f: F) where     F: FnMut(&mut T),

Apply a function to each element in place, this is a substitute to for loops:

use enum_vec::EnumVec;

let mut v = vec![true, false, true];
for x in v.iter_mut() {
    *x = !*x;
}

// Is equivalent to
let mut ev: EnumVec<_> = vec![true, false, true].into();
ev.for_each(|x| {
    *x = !*x;
});

assert_eq!(v, ev.to_vec());
assert_eq!(&v, &[false, true, false]);

pub fn to_vec(&self) -> Vec<T>

Copies self into a plain Vec.

use enum_vec::EnumVec;

let mut ev = EnumVec::new();
ev.push(true);
ev.push(false);
let v = vec![true, false];
assert_eq!(ev.to_vec(), v);

pub fn from_elem(x: T, n: usize) -> Self where     T: Clone,

pub fn from_slice(x: &[T]) -> Self where     T: Clone,

Trait Implementations

impl<T: Clone + EnumLike> Clone for EnumVec<T>

fn clone(&self) -> EnumVec<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: EnumLike + Debug> Debug for EnumVec<T>

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

Formats the value using the given formatter.

impl<T: EnumLike> Default for EnumVec<T>

fn default() -> Self

Returns the "default value" for a type.

impl<T: EnumLike> Extend<T> for EnumVec<T>

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

Extends a collection with the contents of an iterator.

impl<T: EnumLike> FromIterator<T> for EnumVec<T>

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

Creates a value from an iterator.

impl<T: EnumLike> From<Vec<T>> for EnumVec<T>

fn from(v: Vec<T>) -> Self

Performs the conversion.

impl<T: EnumLike> Into<Vec<T>> for EnumVec<T>

fn into(self) -> Vec<T>

Performs the conversion.

impl<'a, T: EnumLike> IntoIterator for &'a EnumVec<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = EnumVecIter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: EnumLike> IntoIterator for EnumVec<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = EnumVecIntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: EnumLike> PartialEq for EnumVec<T>

fn eq(&self, other: &EnumVec<T>) -> bool

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T: EnumLike> Eq for EnumVec<T>

impl<T: EnumLike> Hash for EnumVec<T>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given [Hasher].

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

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