Struct litemap::LiteMap

pub struct LiteMap<K, V> { /* fields omitted */ }

A simple “flat” map based on a sorted vector

See the module level documentation for why one should use this.

The API is roughly similar to that of std::collections::HashMap, though it requires Ord instead of Hash.

Implementations

impl<K, V> LiteMap<K, V>

pub fn new() -> Self

Construct a new LiteMap

pub fn with_capacity(capacity: usize) -> Self

Construct a new LiteMap with a given capacity

pub fn len(&self) -> usize

The number of elements in the LiteMap

pub fn is_empty(&self) -> bool

Whether the LiteMap is empty

pub fn clear(&mut self)

Remove all elements from the LiteMap

pub fn reserve(&mut self, additional: usize)

Reserve capacity for additional more elements to be inserted into the LiteMap to avoid frequent reallocations.

See Vec::reserve() for more information.

impl<K: Ord, V> LiteMap<K, V>

pub fn get<Q: ?Sized>(&self, key: &Q) -> Option<&V> where
    K: Borrow<Q>,
    Q: Ord, 

Get the value associated with key, if it exists.

use litemap::LiteMap;

let mut map = LiteMap::new();
map.insert(1, "one");
map.insert(2, "two");
assert_eq!(map.get(&1), Some(&"one"));
assert_eq!(map.get(&3), None);

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

Returns whether key is contained in this map

use litemap::LiteMap;

let mut map = LiteMap::new();
map.insert(1, "one");
map.insert(2, "two");
assert_eq!(map.contains_key(&1), true);
assert_eq!(map.contains_key(&3), false);

pub fn get_mut<Q: ?Sized>(&mut self, key: &Q) -> Option<&mut V> where
    K: Borrow<Q>,
    Q: Ord, 

Get the value associated with key, if it exists, as a mutable reference.

use litemap::LiteMap;

let mut map = LiteMap::new();
map.insert(1, "one");
map.insert(2, "two");
if let Some(mut v) = map.get_mut(&1) {
    *v = "uno";
}
assert_eq!(map.get(&1), Some(&"uno"));

#[must_use]

pub fn try_append(&mut self, key: K, value: V) -> Option<(K, V)>

Appends value with key to the end of the underlying vector, returning key and value if it failed. Useful for extending with an existing sorted list.

use litemap::LiteMap;

let mut map = LiteMap::new();
assert!(map.try_append(1, "uno").is_none());
assert!(map.try_append(3, "tres").is_none());

assert!(
    matches!(map.try_append(3, "tres-updated"), Some((3, "tres-updated"))),
    "append duplicate of last key",
);

assert!(
    matches!(map.try_append(2, "dos"), Some((2, "dos"))),
    "append out of order"
);

assert_eq!(map.get(&1), Some(&"uno"));

// contains the original value for the key: 3
assert_eq!(map.get(&3), Some(&"tres"));

// not appended since it wasn't in order
assert_eq!(map.get(&2), None);

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

Insert value with key, returning the existing value if it exists.

use litemap::LiteMap;

let mut map = LiteMap::new();
map.insert(1, "one");
map.insert(2, "two");
assert_eq!(map.get(&1), Some(&"one"));
assert_eq!(map.get(&3), None);

pub fn remove<Q: ?Sized>(&mut self, key: &Q) -> Option<V> where
    K: Borrow<Q>,
    Q: Ord, 

Remove the value at key, returning it if it exists.

use litemap::LiteMap;

let mut map = LiteMap::new();
map.insert(1, "one");
map.insert(2, "two");
assert_eq!(map.remove(&1), Some("one"));
assert_eq!(map.get(&1), None);

impl<K, V> LiteMap<K, V>

pub fn iter(&self) -> impl Iterator<Item = (&K, &V)>

Produce an ordered iterator over key-value pairs

pub fn iter_keys(&self) -> impl Iterator<Item = &K>

Produce an ordered iterator over keys

pub fn iter_values(&self) -> impl Iterator<Item = &V>

Produce an iterator over values, ordered by their keys

pub fn iter_mut(&mut self) -> impl Iterator<Item = (&K, &mut V)>

Produce an ordered mutable iterator over key-value pairs

Trait Implementations

impl<K: Clone, V: Clone> Clone for LiteMap<K, V>

fn clone(&self) -> LiteMap<K, V>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K: Debug, V: Debug> Debug for LiteMap<K, V>

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

Formats the value using the given formatter.

impl<K, V> Default for LiteMap<K, V>

fn default() -> Self

Returns the “default value” for a type.

impl<K: Ord, V> FromIterator<(K, V)> for LiteMap<K, V>

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

Creates a value from an iterator.

impl<K: Ord, V> Index<&'_ K> for LiteMap<K, V>

type Output = V

The returned type after indexing.

fn index(&self, key: &K) -> &V

Performs the indexing (container[index]) operation.

impl<K: Ord, V> IndexMut<&'_ K> for LiteMap<K, V>

fn index_mut(&mut self, key: &K) -> &mut V

Performs the mutable indexing (container[index]) operation.

impl<K: PartialEq, V: PartialEq> PartialEq<LiteMap<K, V>> for LiteMap<K, V>

fn eq(&self, other: &LiteMap<K, V>) -> bool

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

fn ne(&self, other: &LiteMap<K, V>) -> bool

This method tests for !=.

impl<K, V> StructuralPartialEq for LiteMap<K, V>