Struct OptionVec 

pub struct OptionVec<T> { /* private fields */ }

A vector that can contain unused indices.

Implementations

impl<T> OptionVec<T>

pub fn new() -> Self

Create a new OptionVec with no elements.

pub fn len(&self) -> usize

pub fn size(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn contains(&self, index: usize) -> bool

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

pub fn get_mut(&mut self, index: usize) -> Option<&mut T>

pub fn capacity(&self) -> usize

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

pub fn clear(&mut self)

pub fn iter(&self) -> Iter<'_, T>

pub fn iter_mut(&mut self) -> IterMut<'_, T>

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

Write the element at the given index. If there is already an element at the given index, it will be overwritten. If there isn’t, a new element will be added at that index.

pub fn try_remove(&mut self, index: usize) -> Result<T, String>

Remove the element at the given index and return it. If the OptionVec is not big enough to contain this index, this will throw an error. If there isn’t an element at that index, this will throw an error.

pub fn option_remove(&mut self, index: usize) -> Option<T>

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

Remove the element at the given index and return it. If the OptionVec is not big enough to contain this index, this will panic. If there isn’t an element at that index, this will panic.

Trait Implementations

impl<T: Clone> Clone for OptionVec<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for OptionVec<T>

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

Formats the value using the given formatter.

impl<T> Default for OptionVec<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for OptionVec<T>

where T: Deserialize<'de>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T> Deserialize<'de> for OptionVec<T>

where T: Deserialize<'de>,

fn deserialize<D>(deserializer: D) -> Result<Self, DeError>

where D: DeserializerTrait<'de>,

Deserialize this value from the given deserializer.

impl<T> Extend<(usize, T)> for OptionVec<T>

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

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

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

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

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

Reserves capacity in a collection for the given number of additional elements.

impl<T> FromIterator<(usize, T)> for OptionVec<T>

fn from_iter<I: IntoIterator<Item = (usize, T)>>(iterable: I) -> Self

Creates a value from an iterator.

impl<T> Index<usize> for OptionVec<T>

type Output = T

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T> IndexMut<usize> for OptionVec<T>

fn index_mut(&mut self, index: usize) -> &mut Self::Output

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

impl<'a, T> IntoIterator for &'a OptionVec<T>

type Item = (usize, &'a T)

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut OptionVec<T>

type Item = (usize, &'a mut T)

The type of the elements being iterated over.

type IntoIter = IterMut<'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: PartialEq> PartialEq for OptionVec<T>

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Serialize for OptionVec<T>

where T: Serialize,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Serialize for OptionVec<T>

where T: Serialize,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, SerError>

where S: SerializerTrait,

Serialize this value into the given serializer.

impl<T: Eq> Eq for OptionVec<T>

impl<T> StructuralPartialEq for OptionVec<T>