Struct scapegoat::SGMap

pub struct SGMap<K: Ord, V> { /* fields omitted */ }

Ordered map. A wrapper interface for SGTree. API examples and descriptions are all adapted or directly copied from the standard library’s BTreeMap.

Implementations

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

pub fn new() -> Self

Makes a new, empty SGMap.

Examples

use scapegoat::SGMap;

let mut map = SGMap::new();

map.insert(1, "a");

pub fn capacity(&self) -> usize

#![no_std]: total capacity, e.g. maximum number of map pairs. Attempting to insert pairs beyond capacity will panic, unless the high_assurance feature is enabled.

If using std: fast capacity, e.g. number of map pairs stored on the stack. Pairs inserted beyond capacity will be stored on the heap.

Examples

use scapegoat::SGMap;

let mut map = SGMap::<usize, &str>::new();

assert!(map.capacity() > 0)

pub fn append(&mut self, other: &mut SGMap<K, V>)

Moves all elements from other into self, leaving other empty.

Examples

use scapegoat::SGMap;

let mut a = SGMap::new();
a.insert(1, "a");
a.insert(2, "b");
a.insert(3, "c");

let mut b = SGMap::new();
b.insert(3, "d");
b.insert(4, "e");
b.insert(5, "f");

a.append(&mut b);

assert_eq!(a.len(), 5);
assert_eq!(b.len(), 0);

assert_eq!(a[&1], "a");
assert_eq!(a[&2], "b");
assert_eq!(a[&3], "d");
assert_eq!(a[&4], "e");
assert_eq!(a[&5], "f");

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

Insert a key-value pair into the map. If the map did not have this key present, None is returned. If the map did have this key present, the value is updated, the old value is returned, and the key is updated. This accommodates types that can be == without being identical.

Examples

use scapegoat::SGMap;

let mut map = SGMap::new();
assert_eq!(map.insert(37, "a"), None);
assert_eq!(map.is_empty(), false);

map.insert(37, "b");
assert_eq!(map.insert(37, "c"), Some("b"));
assert_eq!(map[&37], "c");

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

Gets an iterator over the entries of the map, sorted by key.

Examples

Basic usage:

use scapegoat::SGMap;

let mut map = SGMap::new();
map.insert(3, "c");
map.insert(2, "b");
map.insert(1, "a");

for (key, value) in map.iter() {
    println!("{}: {}", key, value);
}

let (first_key, first_value) = map.iter().next().unwrap();
assert_eq!((*first_key, *first_value), (1, "a"));

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

Gets a mutable iterator over the entries of the map, sorted by key.

Examples

Basic usage:

use scapegoat::SGMap;

let mut map = SGMap::new();
map.insert("a", 1);
map.insert("b", 2);
map.insert("c", 3);

// Add 10 to the value if the key isn't "a"
for (key, value) in map.iter_mut() {
    if key != &"a" {
        *value += 10;
    }
}

let (second_key, second_value) = map.iter().skip(1).next().unwrap();
assert_eq!((*second_key, *second_value), ("b", 12));

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

Removes a key from the map, returning the stored key and value if the key was previously in the map.

The key may be any borrowed form of the map’s key type, but the ordering on the borrowed form must match the ordering on the key type.

Examples

use scapegoat::SGMap;

let mut map = SGMap::new();
map.insert(1, "a");
assert_eq!(map.remove_entry(&1), Some((1, "a")));
assert_eq!(map.remove_entry(&1), None);

pub fn retain<F>(&mut self, f: F) where
    K: Ord,
    F: FnMut(&K, &mut V) -> bool, 

Retains only the elements specified by the predicate.

In other words, remove all pairs (k, v) such that f(&k, &mut v) returns false. The elements are visited in ascending key order.

Examples

use scapegoat::SGMap;

let mut map: SGMap<i32, i32> = (0..8).map(|x| (x, x*10)).collect();
// Keep only the elements with even-numbered keys.
map.retain(|&k, _| k % 2 == 0);
assert!(map.into_iter().eq(vec![(0, 0), (2, 20), (4, 40), (6, 60)]));

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

Splits the collection into two at the given key. Returns everything after the given key, including the key.

Examples

Basic usage:

use scapegoat::SGMap;

let mut a = SGMap::new();
a.insert(1, "a");
a.insert(2, "b");
a.insert(3, "c");
a.insert(17, "d");
a.insert(41, "e");

let b = a.split_off(&3);

assert_eq!(a.len(), 2);
assert_eq!(b.len(), 3);

assert_eq!(a[&1], "a");
assert_eq!(a[&2], "b");

assert_eq!(b[&3], "c");
assert_eq!(b[&17], "d");
assert_eq!(b[&41], "e");

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

Removes a key from the map, returning the value at the key if the key was previously in the map.

The key may be any borrowed form of the map’s key type, but the ordering on the borrowed form must match the ordering on the key type.

Examples

use scapegoat::SGMap;

let mut map = SGMap::new();
map.insert(1, "a");
assert_eq!(map.remove(&1), Some("a"));
assert_eq!(map.remove(&1), None);

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

Returns the key-value pair corresponding to the supplied key.

The supplied key may be any borrowed form of the map’s key type, but the ordering on the borrowed form must match the ordering on the key type.

Examples

use scapegoat::SGMap;

let mut map = SGMap::new();
map.insert(1, "a");
assert_eq!(map.get_key_value(&1), Some((&1, &"a")));
assert_eq!(map.get_key_value(&2), None);

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

Returns a reference to the value corresponding to the key.

The key may be any borrowed form of the map’s key type, but the ordering on the borrowed form must match the ordering on the key type.

Examples

use scapegoat::SGMap;

let mut map = SGMap::new();
map.insert(1, "a");
assert_eq!(map.get(&1), Some(&"a"));
assert_eq!(map.get(&2), None);

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

The key may be any borrowed form of the map’s key type, but the ordering on the borrowed form must match the ordering on the key type.

Examples

use scapegoat::SGMap;

let mut map = SGMap::new();
map.insert(1, "a");
if let Some(x) = map.get_mut(&1) {
    *x = "b";
}
assert_eq!(map[&1], "b");

pub fn clear(&mut self)

Clears the map, removing all elements.

Examples

use scapegoat::SGMap;

let mut a = SGMap::new();
a.insert(1, "a");
a.clear();
assert!(a.is_empty());

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

Returns true if the map contains a value for the specified key.

The key may be any borrowed form of the map’s key type, but the ordering on the borrowed form must match the ordering on the key type.

Examples

use scapegoat::SGMap;

let mut map = SGMap::new();
map.insert(1, "a");
assert_eq!(map.contains_key(&1), true);
assert_eq!(map.contains_key(&2), false);

pub fn is_empty(&self) -> bool

Returns true if the map contains no elements.

Examples

use scapegoat::SGMap;

let mut a = SGMap::new();
assert!(a.is_empty());
a.insert(1, "a");
assert!(!a.is_empty());

pub fn first_key_value(&self) -> Option<(&K, &V)> where
    K: Ord, 

Returns a reference to the first key-value pair in the map. The key in this pair is the minimum key in the map.

Examples

use scapegoat::SGMap;

let mut map = SGMap::new();
assert_eq!(map.first_key_value(), None);
map.insert(1, "b");
map.insert(2, "a");
assert_eq!(map.first_key_value(), Some((&1, &"b")));

pub fn first_key(&self) -> Option<&K> where
    K: Ord, 

Returns a reference to the first/minium key in the map, if any.

Examples

use scapegoat::SGMap;

let mut map = SGMap::new();
assert_eq!(map.first_key_value(), None);
map.insert(1, "b");
map.insert(2, "a");
assert_eq!(map.first_key(), Some(&1));

pub fn pop_first(&mut self) -> Option<(K, V)> where
    K: Ord, 

Removes and returns the first element in the map. The key of this element is the minimum key that was in the map.

Examples

Draining elements in ascending order, while keeping a usable map each iteration.

use scapegoat::SGMap;

let mut map = SGMap::new();
map.insert(1, "a");
map.insert(2, "b");
while let Some((key, _val)) = map.pop_first() {
    assert!((&map).into_iter().all(|(k, _v)| *k > key));
}
assert!(map.is_empty());

pub fn last_key_value(&self) -> Option<(&K, &V)> where
    K: Ord, 

Returns a reference to the last key-value pair in the map. The key in this pair is the maximum key in the map.

Examples

use scapegoat::SGMap;

let mut map = SGMap::new();
map.insert(1, "b");
map.insert(2, "a");
assert_eq!(map.last_key_value(), Some((&2, &"a")));

pub fn last_key(&self) -> Option<&K> where
    K: Ord, 

Returns a reference to the last/maximum key in the map, if any.

Examples

use scapegoat::SGMap;

let mut map = SGMap::new();
map.insert(1, "b");
map.insert(2, "a");
assert_eq!(map.last_key(), Some(&2));

pub fn pop_last(&mut self) -> Option<(K, V)> where
    K: Ord, 

Removes and returns the last element in the map. The key of this element is the maximum key that was in the map.

Examples

Draining elements in descending order, while keeping a usable map each iteration.

use scapegoat::SGMap;

let mut map = SGMap::new();
map.insert(1, "a");
map.insert(2, "b");
while let Some((key, _val)) = map.pop_last() {
    assert!((&map).into_iter().all(|(k, _v)| *k < key));
}
assert!(map.is_empty());

pub fn len(&self) -> usize

Returns the number of elements in the map.

Examples

use scapegoat::SGMap;

let mut a = SGMap::new();
assert_eq!(a.len(), 0);
a.insert(1, "a");
assert_eq!(a.len(), 1);

Trait Implementations

impl<K: Ord, V> Default for SGMap<K, V>

fn default() -> Self

Returns the “default value” for a type.

impl<'a, K: Ord + Copy, V: Copy> Extend<(&'a K, &'a V)> for SGMap<K, V>

fn extend<I: IntoIterator<Item = (&'a K, &'a V)>>(&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: Ord, V> Extend<(K, V)> for SGMap<K, V>

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

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> FromIterator<(K, V)> for SGMap<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 SGMap<K, V>

type Output = V

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<'a, K: Ord, V> IntoIterator for &'a SGMap<K, V>

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

The type of the elements being iterated over.

type IntoIter = Iter<'a, K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K: Ord, V> IntoIterator for SGMap<K, V>

type Item = (K, V)

The type of the elements being iterated over.

type IntoIter = ConsumingIter<K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.