Struct key_node_list::KeyNodeList

pub struct KeyNodeList<K, N, M = HashMap<K, N>> { /* fields omitted */ }

A doubly-linked list that stores key-node pairs.

Implementations

impl<K, N, M> KeyNodeList<K, N, M> where
    M: Default, 

pub fn new() -> Self

Creates an empty linked list.

impl<K, N, M> KeyNodeList<K, N, M> where
    M: Map<K, N>, 

pub fn with_map(map: M) -> Self

Creates an linked list with the given hash map map.

pub fn front_key(&self) -> Option<&K>

Returns a reference to the front key, or None if the list is empty.

This operation should compute in O(1) time.

pub fn back_key(&self) -> Option<&K>

Returns a reference to the back key, or None if the list is empty.

This operation should compute in O(1) time.

pub fn len(&self) -> usize

Returns the number of key-node pairs in the list.

This operation should compute in O(1) time.

pub fn is_empty(&self) -> bool

Returns true if the list contains no key-node pairs.

This operation should compute in O(1) time.

pub fn clear(&mut self)

Removes all key-node pairs in the list.

pub fn iter(&self) -> Iter<'_, K, N, M>

Returns an iterator over all keys and nodes. The iterator element type is (&'a K, &'a N).

pub fn keys(&self) -> Keys<'_, K, N, M>

Returns an iterator over all keys. The iterator element type is &'a K.

pub fn nodes(&self) -> Nodes<'_, K, N, M>

Returns an iterator over all nodes. The iterator element type is &'a N.

impl<K, N, M> KeyNodeList<K, N, M> where
    K: Hash + Eq,
    M: Map<K, N>, 

pub fn contains_key<Q: ?Sized>(&self, key: &Q) -> bool where
    K: Borrow<Q>,
    Q: Hash + Eq, 

Returns true if the linked list contains a node for the specified key.

This operation should compute in O(1) time on average.

pub fn node<Q: ?Sized>(&self, key: &Q) -> Option<&N> where
    K: Borrow<Q>,
    Q: Hash + Eq, 

Returns a reference to the node corresponding to the key, or None if key does not exist.

This operation should compute in O(1) time on average.

pub fn node_mut<Q: ?Sized>(&mut self, key: &Q) -> Option<&mut N> where
    K: Borrow<Q>,
    Q: Hash + Eq, 

Returns a mutable reference to the node corresponding to the key, or None if key does not exist.

This operation should compute in O(1) time on average.

pub fn front_node(&self) -> Option<&N>

Returns a reference to the front node, or None if the list is empty.

This operation should compute in O(1) time on average.

pub fn front_node_mut(&mut self) -> Option<&mut N>

Returns a mutable reference to the front node, or None if the list is empty.

This operation should compute in O(1) time on average.

pub fn back_node(&self) -> Option<&N>

Returns a reference to the back node, or None if the list is empty.

This operation should compute in O(1) time on average.

pub fn back_node_mut(&mut self) -> Option<&mut N>

Returns a mutable reference to the back node, or None if the list is empty.

This operation should compute in O(1) time on average.

pub fn cursor(&self, key: K) -> Cursor<'_, K, N, M>

Provides a cursor at the specific key.

The cursor is pointing to the null pair if the key does not exist.

pub fn cursor_mut(&mut self, key: K) -> CursorMut<'_, K, N, M>

Provides a cursor with editing operations at the specific key.

The cursor is pointing to the null pair if the key does not exist.

impl<K, N, M> KeyNodeList<K, N, M> where
    K: Hash + Eq + Clone,
    M: Map<K, N>, 

pub fn cursor_front(&self) -> Cursor<'_, K, N, M>

Provides a cursor at the front key-node pair.

The cursor is pointing to the null pair if the list is empty.

pub fn cursor_front_mut(&mut self) -> CursorMut<'_, K, N, M>

Provides a cursor with editing operations at the front key-node pair.

The cursor is pointing to the null pair if the list is empty.

pub fn cursor_back(&self) -> Cursor<'_, K, N, M>

Provides a cursor at the back key-node pair.

The cursor is pointing to the null pair if the list is empty.

pub fn cursor_back_mut(&mut self) -> CursorMut<'_, K, N, M>

Provides a cursor with editing operations at the back key-node pair.

The cursor is pointing to the null pair if the list is empty.

impl<K, N, M> KeyNodeList<K, N, M> where
    K: Hash + Eq + Clone,
    N: Node<Key = K>,
    M: Map<K, N>, 

pub fn into_keys(self) -> IntoKeys<K, N, M>

Creates a consuming iterator over all keys. The list cannot be used after calling this. The iterator element type is K.

pub fn into_nodes(self) -> IntoNodes<K, N, M>

Creates a consuming iterator over all nodes. The list cannot be used after calling this. The iterator element type is N.

pub fn push_front<T: Into<N>>(&mut self, key: K, node: T) -> Result<(), (K, T)>

Adds a key-node pair first in the list.

If key already exists, returns an error containing key and node.

This operation should compute in O(1) time on average.

pub fn push_back<T: Into<N>>(&mut self, key: K, node: T) -> Result<(), (K, T)>

Adds a key-node pair back in the list.

If key already exists, returns an error containing key and node.

This operation should compute in O(1) time on average.

pub fn push_key_front(&mut self, key: K) -> Result<(), K> where
    (): Into<N>, 

Adds a key first in the list.

If key already exists, returns an error containing key.

This operation should compute in O(1) time on average.

pub fn push_key_back(&mut self, key: K) -> Result<(), K> where
    (): Into<N>, 

Adds a key back in the list.

If key already exists, returns an error containing key.

This operation should compute in O(1) time on average.

pub fn pop_front(&mut self) -> Option<(K, N)>

Removes the first key-node pair and returns it, or None if the list is empty.

This operation should compute in O(1) time on average.

pub fn pop_back(&mut self) -> Option<(K, N)>

Removes the last key-node pair and returns it, or None if the list is empty.

This operation should compute in O(1) time on average.

pub fn remove<Q: ?Sized>(&mut self, key: &Q) -> Option<(K, N)> where
    K: Borrow<Q>,
    Q: Hash + Eq, 

Removes the key-node pair at the given key and returns it, or returns None if key does not exists.

Trait Implementations

impl<K: Clone, N: Clone, M: Clone> Clone for KeyNodeList<K, N, M>

fn clone(&self) -> KeyNodeList<K, N, M>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K, N, M> Debug for KeyNodeList<K, N, M> where
    K: Hash + Eq + Debug,
    N: Node<Key = K> + Debug,
    M: Map<K, N>, 

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

Formats the value using the given formatter.

impl<K, N, M> Default for KeyNodeList<K, N, M> where
    M: Default, 

fn default() -> Self

Returns the “default value” for a type.

impl<'a, K: 'a, N, M> Extend<&'a K> for KeyNodeList<K, N, M> where
    K: Eq + Hash + Copy,
    (): Into<N>,
    N: Node<Key = K> + Copy,
    M: Map<K, N>, 

fn extend<I: IntoIterator<Item = &'a K>>(&mut self, iter: I)

Extends a KeyNodeList with an key iterator if the node can be built with a ().

Example

use key_node_list::KeyValueList;

let mut list: KeyValueList<i32, ()> = KeyValueList::new();
list.extend(&[1, 2, 3]);
assert_eq!(list.front_key(), Some(&1));
assert_eq!(list.back_key(), Some(&3));

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<'a, K, T, N, M> Extend<(&'a K, &'a T)> for KeyNodeList<K, N, M> where
    K: Eq + Hash + Copy,
    T: Into<N> + Copy,
    N: Node<Key = K> + Copy,
    M: Map<K, N>, 

fn extend<I: IntoIterator<Item = (&'a K, &'a 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<K, T, N, M> Extend<(K, T)> for KeyNodeList<K, N, M> where
    K: Eq + Hash + Clone,
    T: Into<N>,
    N: Node<Key = K>,
    M: Map<K, N>, 

fn extend<I: IntoIterator<Item = (K, 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<K, N, M> Extend<K> for KeyNodeList<K, N, M> where
    K: Eq + Hash + Clone,
    (): Into<N>,
    N: Node<Key = K>,
    M: Map<K, N>, 

fn extend<I: IntoIterator<Item = K>>(&mut self, iter: I)

Extends a KeyNodeList with an key iterator if the node can be built with a ().

Example

use key_node_list::KeyValueList;

let mut list: KeyValueList<i32, ()> = KeyValueList::new();
list.extend([1, 2, 3]);
assert_eq!(list.front_key(), Some(&1));
assert_eq!(list.back_key(), Some(&3));

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<K, T, N, M, const LEN: usize> From<[(K, T); LEN]> for KeyNodeList<K, N, M> where
    K: Eq + Hash + Clone,
    T: Into<N>,
    N: Node<Key = K>,
    M: Map<K, N> + Default, 

fn from(arr: [(K, T); LEN]) -> Self

Performs the conversion.

impl<K, T, N, M> FromIterator<(K, T)> for KeyNodeList<K, N, M> where
    K: Eq + Hash + Clone,
    T: Into<N>,
    N: Node<Key = K>,
    M: Map<K, N> + Default, 

fn from_iter<I: IntoIterator<Item = (K, T)>>(iter: I) -> Self

Creates a value from an iterator.

impl<K, N, M> FromIterator<K> for KeyNodeList<K, N, M> where
    K: Eq + Hash + Clone,
    (): Into<N>,
    N: Node<Key = K>,
    M: Map<K, N> + Default, 

fn from_iter<I: IntoIterator<Item = K>>(iter: I) -> Self

Creates a KeyNodeList from an key iterator if the node can be built with a ().

Example

use key_node_list::KeyValueList;

let list: KeyValueList<i32, ()> = [1, 2, 3].into_iter().collect();
assert_eq!(list.front_key(), Some(&1));
assert_eq!(list.back_key(), Some(&3));

impl<'a, K, Q, N, M> Index<&'a Q> for KeyNodeList<K, N, M> where
    K: Hash + Eq + Borrow<Q>,
    Q: ?Sized + Hash + Eq,
    M: Map<K, N>, 

fn index(&self, key: &'a Q) -> &Self::Output

Returns a reference to the value corresponding to the supplied key.

Panics

Panics if the key is not present in the KeyNodeList.

type Output = N

The returned type after indexing.

impl<K, N, M> IntoIterator for KeyNodeList<K, N, M> where
    K: Hash + Eq + Clone,
    N: Node<Key = K>,
    M: Map<K, N>, 

type Item = (K, N)

The type of the elements being iterated over.

type IntoIter = IntoIter<K, N, M>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, K, N, M> IntoIterator for &'a KeyNodeList<K, N, M> where
    K: Hash + Eq,
    N: Node<Key = K>,
    M: Map<K, N>, 

type Item = (&'a K, &'a N)

The type of the elements being iterated over.

type IntoIter = Iter<'a, K, N, M>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K, N, M> PartialEq<KeyNodeList<K, N, M>> for KeyNodeList<K, N, M> where
    M: PartialEq, 

fn eq(&self, other: &KeyNodeList<K, N, M>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl<K, N, M> Eq for KeyNodeList<K, N, M> where
    M: PartialEq,