Struct FixedIndexVec 

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

A fixed-size indexed vector that maps indices to values.

It provides a fixed-size vector-like data structure that can store values based on its associated index. Each value is associated with a unique index in the map. The values can be accessed, inserted, and removed using the index as the identifier.

Examples

use fixed_index_vec::FixedIndexVec;

let mut vec = FixedIndexVec::new();

vec.insert("value1".to_string());
vec.insert("value2".to_string());

assert_eq!(vec.get(0), Some(&"value1".to_string()));
assert_eq!(vec.get(1), Some(&"value2".to_string()));

vec.remove(1);

assert_eq!(vec.get(1), None);

Notes

• The FixedIndexVec is backed by a BTreeMap, so it is not as fast as a Vec.
• Index notations are supported (eg. vec[0]), however, accessing an index that does not exist will panic.

Implementations

impl<T> FixedIndexVec<T>

pub fn new() -> FixedIndexVec<T>

Creates an empty FixedIndexVec.

The internal storage will not allocate until elements are pushed onto it.

Examples

use fixed_index_vec::FixedIndexVec;
let mut vec: FixedIndexVec<i32> = FixedIndexVec::new();

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

Inserts an element at the end of the FixedIndexVec.

Panics

Panics if the FixedIndexVec is at capacity.

Examples

use fixed_index_vec::FixedIndexVec;

let mut vec = FixedIndexVec::new();
vec.push(1);
vec.push(2);
assert_eq!(vec[0], 1);
assert_eq!(vec[1], 2);

pub fn insert(&mut self, value: T)

Alias for push. Inserts an element at the end of the FixedIndexVec.

Panics

Panics if the FixedIndexVec is at capacity.

Examples

use fixed_index_vec::FixedIndexVec;

let mut vec = FixedIndexVec::new();
vec.insert(1);
vec.insert(2);
assert_eq!(vec[0], 1);
assert_eq!(vec[1], 2);

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

Removes the element at the given index, if it exists, returning it or None if it does not exist.

Examples

use fixed_index_vec::FixedIndexVec;

let mut vec = FixedIndexVec::new();
vec.push(1);
vec.push(2);
assert_eq!(vec.remove(0), Some(1));
assert_eq!(vec.remove(0), None);

Notes

Unlike Vec::remove, this does not shift elements after the removed element. If index >= length, this returns None, the same as if the element did not exist.

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

Returns a reference to the element at the given index, if it exists, or None if it does not exist.

Examples

use fixed_index_vec::FixedIndexVec;

let mut vec = FixedIndexVec::new();
vec.push(1);
vec.push(2);
assert_eq!(vec.get(0), Some(&1));
assert_eq!(vec.get(2), None);

pub fn iter(&self) -> impl Iterator<Item = (usize, &T)>

An iterator visiting all elements in ascending order of their indices. The index is returned along with the value. The iterator skips indices that do not have a corresponding value.

Examples

use fixed_index_vec::FixedIndexVec;

let mut vec: FixedIndexVec<i32> = vec![1, 2, 3].into();
vec.remove(1);
let mut iter = vec.iter();
assert_eq!(iter.next(), Some((0, &1)));
assert_eq!(iter.next(), Some((2, &3)));
assert_eq!(iter.next(), None);

pub fn len(&self) -> usize

Returns the number of elements in the FixedIndexVec. This is not the same as the value of the largest index, unless no elements have been removed.

Examples

use fixed_index_vec::FixedIndexVec;

let mut vec: FixedIndexVec<i32> = vec![1, 2, 3].into();
vec.remove(1);
assert_eq!(vec.len(), 2);

pub fn is_empty(&self) -> bool

Returns true if the FixedIndexVec contains no elements.

Examples

use fixed_index_vec::FixedIndexVec;

let mut vec: FixedIndexVec<i32> = vec![1, 2, 3].into();
vec.remove(1);
assert_eq!(vec.is_empty(), false);

use fixed_index_vec::FixedIndexVec;
let vec: FixedIndexVec<i32> = FixedIndexVec::new();
assert_eq!(vec.is_empty(), true);

pub fn clear(&mut self)

Clears the FixedIndexVec, removing all values. Keeps the allocated memory for reuse. This is equivalent to calling remove on every index. The next index will not be reset to 0.

Examples

use fixed_index_vec::FixedIndexVec;

let mut vec: FixedIndexVec<i32> = vec![1, 2, 3].into();
vec.clear();
assert_eq!(vec.len(), 0);
assert_eq!(vec.next_index(), 3);

pub fn reset(&mut self)

Clears the FixedIndexVec, removing all values and resetting the next index to 0. Keeps the allocated memory for reuse.

Examples

use fixed_index_vec::FixedIndexVec;

let mut vec: FixedIndexVec<i32> = vec![1, 2, 3].into();
vec.reset();
assert_eq!(vec.len(), 0);
assert_eq!(vec.next_index(), 0);

pub fn next_index(&self) -> usize

Returns the next index that will be used when inserting an element.

Examples

use fixed_index_vec::FixedIndexVec;

let mut vec: FixedIndexVec<i32> = vec![1, 2, 3].into();
vec.remove(1);
assert_eq!(vec.next_index(), 3);

pub fn first(&self) -> Option<(usize, &T)>

Returns the index and a reference to the element at the smallest populated index, or None if the FixedIndexVec is empty.

Examples

use fixed_index_vec::FixedIndexVec;

let mut vec: FixedIndexVec<i32> = vec![1, 2, 3].into();
vec.remove(0);
assert_eq!(vec.first(), Some((1, &2)));

use fixed_index_vec::FixedIndexVec;

let vec: FixedIndexVec<i32> = FixedIndexVec::new();
assert_eq!(vec.first(), None);

pub fn last(&self) -> Option<(usize, &T)>

Returns the index and a reference to the element at the largest populated index, or None if the FixedIndexVec is empty.

Examples

use fixed_index_vec::FixedIndexVec;

let mut vec: FixedIndexVec<i32> = vec![1, 2, 3].into();
vec.remove(2);
assert_eq!(vec.last(), Some((1, &2)));

use fixed_index_vec::FixedIndexVec;

let vec: FixedIndexVec<i32> = FixedIndexVec::new();
assert_eq!(vec.last(), None);

Trait Implementations

impl<T: Clone> Clone for FixedIndexVec<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for FixedIndexVec<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for FixedIndexVec<T>

fn default() -> FixedIndexVec<T>

Returns the “default value” for a type.

impl<T: Display> Display for FixedIndexVec<T>

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

Formats the value using the given formatter.

impl<T> Extend<T> for FixedIndexVec<T>

fn extend<I: IntoIterator<Item = T>>(&mut self, iter: 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, A> From<BTreeMap<A, T>> for FixedIndexVec<T>

fn from(map: BTreeMap<A, T>) -> FixedIndexVec<T>

Converts to this type from the input type.

impl<T, A> From<HashMap<A, T>> for FixedIndexVec<T>

fn from(map: HashMap<A, T>) -> FixedIndexVec<T>

Converts to this type from the input type.

impl<T> From<Vec<T>> for FixedIndexVec<T>

fn from(vec: Vec<T>) -> FixedIndexVec<T>

Converts to this type from the input type.

impl<T> FromIterator<T> for FixedIndexVec<T>

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

Creates a value from an iterator.

impl<T: Hash> Hash for FixedIndexVec<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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> Index<usize> for FixedIndexVec<T>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T: Ord> Ord for FixedIndexVec<T>

fn cmp(&self, other: &FixedIndexVec<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq> PartialEq for FixedIndexVec<T>

fn eq(&self, other: &FixedIndexVec<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: PartialOrd> PartialOrd for FixedIndexVec<T>

fn partial_cmp(&self, other: &FixedIndexVec<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Eq> Eq for FixedIndexVec<T>

impl<T> StructuralPartialEq for FixedIndexVec<T>