Struct OMap

Source

pub struct OMap<K, V> { /* private fields */ }

Expand description

Ephemeral ordered-map type using left-leaning-red-black tree.

Refer package level documentation for brief description.

Implementations§

Source §

pub fn len(&self) -> usize

Return number of entries in index.

Source

pub fn is_empty(&self) -> bool

Check whether this index is empty.

Source §

impl<K, V> OMap<K, V>

Source

pub fn set(&mut self, key: K, value: V) -> Option<V>
where K: Ord, V: Clone,

Set value for key. If there is an existing entry for key, overwrite the old value with new value and return the old value.

Source

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

Remove key from this instance and return its value. If key is not present, then delete is effectively a no-op.

Source

pub fn validate(&self) -> Result<()>
where K: Ord + Debug,

Validate OMap tree with following rules:

From root to any leaf, no consecutive reds allowed in its path.
Number of blacks should be same under left child and right child.
Make sure keys are in sorted order.

Source §

impl<K, V> OMap<K, V>

Source

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

Get value for key.

Source

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

Return an iterator over all entries in this instance.

use ppom::OMap;

let mut index: OMap<String,String> = OMap::new();
index.set("key1".to_string(), "value1".to_string());
index.set("key2".to_string(), "value2".to_string());

for (i, (key, value)) in index.iter().enumerate() {
    let refkey = format!("key{}", i+1);
    let refval = format!("value{}", i+1);
    assert_eq!(refkey, key);
    assert_eq!(refval, value);
}

Source

pub fn range<Q, R>(&self, range: R) -> Range<'_, K, V, R, Q>
where K: Borrow<Q>, R: RangeBounds<Q>, Q: Ord + ?Sized,

Range over all entries from low to high, specified by range.

use std::ops::Bound;
use ppom::OMap;

let mut index: OMap<String,String> = OMap::new();

index.set("key1".to_string(), "value1".to_string());
index.set("key2".to_string(), "value2".to_string());
index.set("key3".to_string(), "value3".to_string());

let low = Bound::Excluded("key1");
let high = Bound::Excluded("key2");
let item = index.range::<str, _>((low, high)).next();
assert_eq!(item, None);

let low = Bound::Excluded("key1");
let high = Bound::Excluded("key3");
let item = index.range::<str, _>((low, high)).next();
assert_eq!(item, Some(("key2".to_string(), "value2".to_string())));

let low = Bound::Included("key1");
let high = Bound::Included("key3");
let mut ranger = index.range::<str, _>((low, high));
let item = ranger.next();
assert_eq!(item, Some(("key1".to_string(), "value1".to_string())));
let item = ranger.last();
assert_eq!(item, Some(("key3".to_string(), "value3".to_string())));

Source

pub fn reverse<R, Q>(&self, range: R) -> Reverse<'_, K, V, R, Q>
where K: Borrow<Q>, R: RangeBounds<Q>, Q: Ord + ?Sized,

Reverse range over all entries from high to low, specified by range.

use std::ops::Bound;
use ppom::OMap;

let mut index: OMap<String,String> = OMap::new();

index.set("key1".to_string(), "value1".to_string());
index.set("key2".to_string(), "value2".to_string());
index.set("key3".to_string(), "value3".to_string());

let low = Bound::Included("key1");
let high = Bound::Included("key3");
let mut iter = index.reverse::<_, str>((low, high));

let item = iter.next();
assert_eq!(item, Some(("key3".to_string(), "value3".to_string())));
let item = iter.last();
assert_eq!(item, Some(("key1".to_string(), "value1".to_string())));