Struct ZipList 

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

A ZipList can be thought of as a linked list with a hole punched in it to mark a single element that currently holds focus (though in practice it is implemented using a VecDeque for efficiency purposes). By convention, the main element is the first element in the stack (regardless of focus). Focusing operations do not reorder the elements of the stack or the resulting Vec that can be obtained from calling ZipList::flatten.

This is a zipper over a VecDeque. Many of the methods that mutate the structure of the ZipList return back a mutable reference so that they are able to be chained.

Implementations

impl<T> ZipList<T>

pub fn new<I, J>(up: I, focus: T, down: J) -> Self

where I: IntoIterator<Item = T>, J: IntoIterator<Item = T>,

Create a new ZipList specifying the focused element and and elements above and below it.

pub fn try_from_iter<I>(iter: I) -> Option<Self>

where I: IntoIterator<Item = T>,

For an iterator of at least one element, the first element will be focused and all remaining elements will be placed after it. For an empty iterator, return None.

pub fn len(&self) -> usize

The number of elements in this ZipList.

pub fn is_empty(&self) -> bool

Always false: a ZipList always has at least one focused element.

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

Provide an iterator over this stack iterating over up, focus and then down.

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

Provide an iterator over this stack iterating over up, focus and then down with mutable references.

pub fn unravel(&self) -> impl Iterator<Item = &T>

Iterate over the clients in this stack from the the focused element down through the stack.

pub fn flatten(self) -> Vec<T>

Flatten a ZipList into a Vector, losing the information of which element is focused.

pub fn head(&self) -> &T

Return a reference to the first element in this ZipList

pub fn focused(&self) -> &T

Return a reference to the focused element in this ZipList

pub fn last(&self) -> &T

Return a reference to the last element in this ZipList

pub fn last_mut(&mut self) -> &mut T

pub fn swap_focus_and_head(&mut self) -> &mut Self

Swap the current head element with the focused element in the stack order. Focus stays with the original focused element.

pub fn rotate_focus_to_head(&mut self) -> &mut Self

Rotate the ZipList until the current focused element is in the head position

pub fn focus_head(&mut self) -> &mut Self

Move focus to the element in the head position

pub fn focus_tail(&mut self) -> &mut Self

Move focus to the element in the head position

pub fn insert(&mut self, t: T) -> &mut Self

Insert the given element in place of the current focus, pushing the current focus down the ZipList.

pub fn insert_at(&mut self, pos: Position, t: T) -> &mut Self

Insert the given element at the requested position in the ZipList. See Position for the semantics of each case. For all cases, the existing elements in the ZipList are pushed down to make room for the new one.

pub fn remove_focused(self) -> (T, Option<Self>)

Remove the focused element of this ZipList. If this was the only element then the stack is dropped and None is returned.

pub fn remove_focused_unchecked(&mut self) -> T

Removed the focused element of this Ziplist.

Panics

Panics if the focus was the only element

pub fn remove_where_with_default( &mut self, pred: impl Fn(&T) -> bool, default: impl Fn() -> T, ) -> Option<T>

Remove the first element that matches the given predicate function. If doing so would remove the last element of the ZipList then default_focus is called to ensure that there is a single element remaining as the current focus.

pub fn map<F, U>(self, f: F) -> ZipList<U>

where F: Fn(T) -> U,

Map a function over all elements in this ZipList, returning a new one.

pub fn filter<F>(self, f: F) -> Option<Self>

where F: Fn(&T) -> bool,

Retain only elements which satisfy the given predicate. If the focused element is removed then focus shifts to the first remaining element after it, if there are no elements after then focus moves to the first remaining element before. If no elements satisfy the predicate then None is returned.

pub fn filter_unchecked<F>(&mut self, f: F)

where F: Fn(&T) -> bool,

pub fn reverse(&mut self) -> &mut Self

Reverse the ordering of a ZipList (up becomes down) while maintaining focus.

pub fn focus_up(&mut self) -> &mut Self

Move focus from the current element up the stack, wrapping to the bottom if focus is already at the top.

pub fn focus_down(&mut self) -> &mut Self

Move focus from the current element down the stack, wrapping to the top if focus is already at the bottom.

pub fn focus_element_by<F>(&mut self, f: F) -> bool

where F: Fn(&T) -> bool,

Focus the first element found matching the given predicate function.

Returns true if the focused element changed. If no matching elements are found, the ZipList will be left in its original state and false is returned.

pub fn focus_element_by_mut<F>(&mut self, f: F) -> bool

where F: Fn(&mut T) -> bool,

Focus the first element found matching the given predicate function.

If no matching elements are found, the ZipList will be left in its original state.

pub fn swap_up(&mut self) -> &mut Self

Swap the focused element with the one above, wrapping from top to bottom. The currently focused element is maintained by this operation.

pub fn swap_down(&mut self) -> &mut Self

Swap the focused element with the one below, wrapping from top to bottom. The currently focused element is maintained by this operation.

pub fn rotate_up(&mut self) -> &mut Self

Rotate all elements of the stack forward, wrapping from top to bottom. The currently focused element in the stack is maintained by this operation.

pub fn rotate_down(&mut self) -> &mut Self

Rotate all elements of the stack back, wrapping from bottom to top. The currently focused element in the stack is maintained by this operation.

impl<T: Clone> ZipList<T>

pub fn extract<F>(&self, f: F) -> (Option<Self>, Vec<T>)

where F: Fn(&T) -> bool,

Extract elements satisfying a predicate into a Vec, leaving remaining elements in their original stack position.

impl<T: PartialEq> ZipList<T>

pub fn contains(&self, t: &T) -> bool

Check whether a given element is in this ZipList

pub fn focus_element(&mut self, t: &T)

Attempt to focus a given element in the ZipList if it is present.

If the requested element is not found, the ZipList will be left in its original state.

pub fn remove(self, t: &T) -> (Option<T>, Option<Self>)

Remove an element from the stack.

If the element was present it is returned along with the rest of the ZipList. If this was the last element in the stack, the stack is dropped and None is returned.

Trait Implementations

impl<T: Clone> Clone for ZipList<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for ZipList<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for ZipList<T>

fn default() -> ZipList<T>

Returns the “default value” for a type.

impl<T: Display> Display for ZipList<T>

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

Formats the value using the given formatter.

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

type Item = (bool, &'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) -> Iter<'a, T>

Creates an iterator from a value.

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

type Item = (bool, &'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) -> IterMut<'a, T>

Creates an iterator from a value.

impl<T> IntoIterator for ZipList<T>

type Item = (bool, T)

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IntoIter<T>

Creates an iterator from a value.

impl<T: PartialEq> PartialEq for ZipList<T>

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

impl<T> StructuralPartialEq for ZipList<T>