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 set_rebal_param(
    &mut self,
    alpha_num: f32,
    alpha_denom: f32
) -> Result<(), SGErr>

The original scapegoat tree paper’s alpha, a, can be chosen in the range 0.5 <= a < 1.0. a tunes how “aggressively” the data structure self-balances. It controls the trade-off between total rebuilding time and maximum height guarantees.

• As a approaches 0.5, the tree will rebalance more often. Ths means slower insertions, but faster lookups and deletions.

  • An a equal to 0.5 means a tree that always maintains a perfect balance (e.g.“complete” binary tree, at all times).

• As a approaches 1.0, the tree will rebalance less often. This means quicker insertions, but slower lookups and deletions.

  • If a reached 1.0, it’d mean a tree that never rebalances.

Returns Err if 0.5 <= alpha_num / alpha_denom < 1.0 isn’t true (invalid a, out of range).

Examples

use scapegoat::SGMap;

let mut map: SGMap<isize, isize> = SGMap::new();

// Set 2/3, e.g. `a = 0.666...` (it's default value).
assert!(map.set_rebal_param(2.0, 3.0).is_ok());

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: Clone + Ord, V: Clone> Clone for SGMap<K, V>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K, V> Debug for SGMap<K, V> where
    K: Ord + Debug,
    V: Debug, 

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

Formats the value using the given formatter.

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

fn default() -> SGMap<K, V>

Returns the “default value” for a type.

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

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, V> Extend<(K, V)> for SGMap<K, V> where
    K: Ord, 

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, V, const N: usize> From<[(K, V); N]> for SGMap<K, V> where
    K: Ord, 

fn from(arr: [(K, V); N]) -> Self

use scapegoat::SGMap;

let map1 = SGMap::from([(1, 2), (3, 4)]);
let map2: SGMap<_, _> = [(1, 2), (3, 4)].into();
assert_eq!(map1, map2);

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

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

Creates a value from an iterator.

impl<K: Hash + Ord, V: Hash> Hash for SGMap<K, V>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<K, V, Q> Index<&'_ Q> for SGMap<K, V> where
    K: Borrow<Q> + Ord,
    Q: Ord + ?Sized, 

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

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

Panics

Panics if the key is not present in the SGMap.

type Output = V

The returned type after indexing.

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.

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

fn cmp(&self, other: &SGMap<K, V>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<K: PartialEq + Ord, V: PartialEq> PartialEq<SGMap<K, V>> for SGMap<K, V>

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

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

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

This method tests for !=.

impl<K: PartialOrd + Ord, V: PartialOrd> PartialOrd<SGMap<K, V>> for SGMap<K, V>

fn partial_cmp(&self, other: &SGMap<K, V>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<K: Eq + Ord, V: Eq> Eq for SGMap<K, V>

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

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