146 lines
3.5 KiB
Rust
146 lines
3.5 KiB
Rust
//! Array-backed append-only vector type.
|
|
// TODO(tarcieri): use `core` impl of `ArrayVec`
|
|
// See: https://github.com/rust-lang/rfcs/pull/2990
|
|
|
|
use crate::{ErrorKind, Result};
|
|
|
|
/// Array-backed append-only vector type.
|
|
#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
|
|
pub(crate) struct ArrayVec<T, const N: usize> {
|
|
/// Elements of the set.
|
|
elements: [Option<T>; N],
|
|
|
|
/// Last populated element.
|
|
length: usize,
|
|
}
|
|
|
|
impl<T, const N: usize> ArrayVec<T, N> {
|
|
/// Create a new [`ArrayVec`].
|
|
pub fn new() -> Self {
|
|
Self {
|
|
elements: [(); N].map(|_| None),
|
|
length: 0,
|
|
}
|
|
}
|
|
|
|
/// Push an item into this [`ArrayVec`].
|
|
pub fn push(&mut self, item: T) -> Result<()> {
|
|
match self.length.checked_add(1) {
|
|
Some(n) if n <= N => {
|
|
self.elements[self.length] = Some(item);
|
|
self.length = n;
|
|
Ok(())
|
|
}
|
|
_ => Err(ErrorKind::Overlength.into()),
|
|
}
|
|
}
|
|
|
|
/// Get an element from this [`ArrayVec`].
|
|
pub fn get(&self, index: usize) -> Option<&T> {
|
|
match self.elements.get(index) {
|
|
Some(Some(ref item)) => Some(item),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
/// Iterate over the elements in this [`ArrayVec`].
|
|
pub fn iter(&self) -> Iter<'_, T> {
|
|
Iter::new(&self.elements)
|
|
}
|
|
|
|
/// Is this [`ArrayVec`] empty?
|
|
pub fn is_empty(&self) -> bool {
|
|
self.length == 0
|
|
}
|
|
|
|
/// Get the number of elements in this [`ArrayVec`].
|
|
pub fn len(&self) -> usize {
|
|
self.length
|
|
}
|
|
|
|
/// Get the last item from this [`ArrayVec`].
|
|
pub fn last(&self) -> Option<&T> {
|
|
self.length.checked_sub(1).and_then(|n| self.get(n))
|
|
}
|
|
|
|
/// Extract the inner array.
|
|
pub fn into_array(self) -> [Option<T>; N] {
|
|
self.elements
|
|
}
|
|
}
|
|
|
|
impl<T, const N: usize> AsRef<[Option<T>]> for ArrayVec<T, N> {
|
|
fn as_ref(&self) -> &[Option<T>] {
|
|
&self.elements[..self.length]
|
|
}
|
|
}
|
|
|
|
impl<T, const N: usize> AsMut<[Option<T>]> for ArrayVec<T, N> {
|
|
fn as_mut(&mut self) -> &mut [Option<T>] {
|
|
&mut self.elements[..self.length]
|
|
}
|
|
}
|
|
|
|
impl<T, const N: usize> Default for ArrayVec<T, N> {
|
|
fn default() -> Self {
|
|
Self::new()
|
|
}
|
|
}
|
|
|
|
/// Iterator over the elements of an [`ArrayVec`].
|
|
#[derive(Clone, Debug)]
|
|
pub struct Iter<'a, T> {
|
|
/// Decoder which iterates over the elements of the message.
|
|
elements: &'a [Option<T>],
|
|
|
|
/// Position within the iterator.
|
|
position: usize,
|
|
}
|
|
|
|
impl<'a, T> Iter<'a, T> {
|
|
pub(crate) fn new(elements: &'a [Option<T>]) -> Self {
|
|
Self {
|
|
elements,
|
|
position: 0,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'a, T> Iterator for Iter<'a, T> {
|
|
type Item = &'a T;
|
|
|
|
fn next(&mut self) -> Option<&'a T> {
|
|
match self.elements.get(self.position) {
|
|
Some(Some(res)) => {
|
|
self.position = self.position.checked_add(1)?;
|
|
Some(res)
|
|
}
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
fn size_hint(&self) -> (usize, Option<usize>) {
|
|
let len = self.elements.len().saturating_sub(self.position);
|
|
(len, Some(len))
|
|
}
|
|
}
|
|
|
|
impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::ArrayVec;
|
|
use crate::ErrorKind;
|
|
|
|
#[test]
|
|
fn add() {
|
|
let mut vec = ArrayVec::<u8, 3>::new();
|
|
vec.push(1).unwrap();
|
|
vec.push(2).unwrap();
|
|
vec.push(3).unwrap();
|
|
|
|
assert_eq!(vec.push(4).err().unwrap(), ErrorKind::Overlength.into());
|
|
assert_eq!(vec.len(), 3);
|
|
}
|
|
}
|