Struct orga::collections::Deque

pub struct Deque<S: Read, T: Encode + Decode> { /* fields omitted */ }

A double-ended queue data structure.

Implementations

impl<S: Read, T: Encode + Decode> Deque<S, T>

pub fn len(&self) -> u64

Gets the length of the deque.

This method does not read from the state since the head and tail indices are kept in memory, so it is a cheap operation.

pub fn get(&self, index: u64) -> Result<T>

Gets the element with the given index.

If the index is out of bounds, this method will panic. If getting from the store or decoding the store value returns an error, this method will return the error.

pub fn fixed_index(&self, index: u64) -> u64

Calculates the current fixed index of the given index.

An element's fixed index remains constant even as elements are pushed or popped from the front of the deque. This is useful when storing data which references other elements of the deque, using the index as a pseudo-pointer.

For example, if we have a deque with 2 elements, "foo" and "bar", index 0 will be "foo" and index 1 will be "bar". But if we pop "foo", now index 0 will be "bar", but its fixed index will still be 1.

pub fn get_fixed(&self, index: u64) -> Result<T>

Gets an element by its fixed index.

See [#method.fixed_index] for more info about fixed indices.

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

Creates an iterator over the deque's elements.

Iteration happens in order by index.

pub fn is_empty(&self) -> bool

Returns true if the deque has length 0, false otherwise.

This method does not read from the state since the head and tail indices are kept in memory, so it is a cheap operation.

pub fn back(&self) -> Result<Option<T>>

Gets the last element of the deque, or None if the deque is empty.

impl<S: Store, T: Encode + Decode> Deque<S, T>

pub fn push_back(&mut self, value: T) -> Result<()>

Appends an element to the back of the deque.

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

Pops an element off the front of the deque and deletes it, then returns the popped value.

pub fn set(&mut self, index: u64, value: T) -> Result<()>

Replaces the element at the given index.

pub fn clear(&mut self) -> Result<()>

Removes all elements.

This operation will be expensive for large deques, since each element is individually deleted.

pub fn drain_into<S2: Store>(&mut self, other: &mut Deque<S2, T>) -> Result<()>

Removes all elements and appends them to the given deque in order.

This operation will be expensive for large deques, since each element is individually deleted then pushed.

Trait Implementations

impl<S: Read, T: Encode + Decode> State<S> for Deque<S, T>

fn wrap_store(store: S) -> Result<Self>

Wraps the store to allow reading from and writing to the deque.

This wrap_store implementation will also read the Meta value (containing the head and tail indices) and store its contents in memory.