Struct cursed_collections::AppendOnlyVec

pub struct AppendOnlyVec<T> { /* fields omitted */ }

A collection onto which new values can be appended, while still keeping references to previous values valid.

Example

This is useful as a buffer on the side of another data structure that is built incrementally. For example, let's imagine we want to parse a JSON-like data format that contains only arrays and strings.

The advantage of having slices and strs instead of Vecs and Strings is that you'd then be to directly pattern match against values of this type.

enum MyData<'buffers> {
  Array(&'buffers [MyData<'buffers>]),
  String(&'buffers str),
}

fn main() {
  let string_buf = AppendOnlyVec::<String>::new();
  let array_buf = AppendOnlyVec::<Vec<MyData>>::new();

  let my_key = MyData::String(string_buf.push("name".into()));
  let my_name = MyData::String(string_buf.push("Simon".into()));
  let my_array = MyData::Array(array_buf.push(vec![my_key, my_name]));

  match my_array {
    MyData::Array(&[MyData::String("name"), MyData::String(name)]) => {
      println!("Hello, {}", name)
    }
    _ => println!("Hello!"),
  }
}

Implementations

impl<T> AppendOnlyVec<T>

pub fn new() -> AppendOnlyVec<T>

Creates an empty AppendOnlyVec.

pub fn push(&self, element: T) -> &T

Consumes a T, appends it to the end of the vector, and returns a reference to the newly appended element.

pub fn len(&self) -> usize

Returns the number of elements in the vector.

Trait Implementations

impl<T> Default for AppendOnlyVec<T>

fn default() -> Self

Returns the "default value" for a type.

impl<T> Index<usize> for AppendOnlyVec<T>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.