Struct SortedList

pub struct SortedList<K: Ord, V: PartialEq> { /* private fields */ }

SortedList stores multiple (K, V) tuples ordered by K, then in the order of insertion for V. Implmented using two Vec this should be fast for in-order inserts and quite bad in the worst-case of reverse insertion order.

Example

use sorted_list::SortedList;

let mut list: SortedList<u32, u8> = SortedList::new();
list.insert(0, 0);
list.insert(1, 1);
list.insert(0, 2);

assert_eq!(
    list.iter().collect::<Vec<_>>(),
    vec![(&0, &0), (&0, &2), (&1, &1)]);

Implementations

impl<K: Ord, V: PartialEq> SortedList<K, V>

pub fn new() -> Self

Creates a new as small as possible SortedList

pub fn len(&self) -> usize

Returns the number of tuples

pub fn insert(&mut self, key: K, value: V) -> bool

Returns true if the (key, value) did not exist in the sorted list before and it exists now, false otherwise.

pub fn values_of(&self, key: &K) -> &[V]

Returns the values of a specific key as a slice

pub fn iter(&self) -> Tuples<'_, K, V>

Iterate all stored tuples, keys in order, values in insertion order

pub fn keys(&self) -> Iter<'_, K>

Iterate over all keys, can contain duplicates

pub fn values(&self) -> Iter<'_, V>

Iterate over all values

pub fn first_value_of(&self, key: &K) -> Option<&V>

Returns the first (in insertion order) value of key

pub fn last_value_of(&self, key: &K) -> Option<&V>

Returns the last (in insertion order) value of key

Trait Implementations

impl<K: Ord + Clone, V: PartialEq + Clone> Clone for SortedList<K, V>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K: Ord + Debug, V: PartialEq + Debug> Debug for SortedList<K, V>

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

Formats the value using the given formatter.

impl<K: Clone + Ord, V: PartialEq> Extend<(K, V)> for SortedList<K, V>

fn extend<T>(&mut self, iter: T)

where T: IntoIterator<Item = (K, V)>,

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: Ord, V: PartialEq> IntoIterator for SortedList<K, V>

type Item = (K, V)

The type of the elements being iterated over.

type IntoIter = IntoTuples<K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.