Struct ppom::OMap

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

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

Refer package level documentation for brief description.

Implementations

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

pub fn new() -> OMap<K, V>

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

pub fn len(&self) -> usize

Return number of entries in index.

pub fn is_empty(&self) -> bool

Check whether this index is empty.

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

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.

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.

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.

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

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

Get value for key.

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);
}

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())));

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())));

pub fn random<R>(&self, rng: &mut R) -> Option<(K, V)> where
    K: Clone,
    V: Clone,
    R: Rng, 

Return a random entry from this index.

Trait Implementations

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K: Default, V: Default> Default for OMap<K, V>

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

Returns the “default value” for a type.

impl<K, V> Extend<(K, V)> for OMap<K, V> where
    K: Ord,
    V: Clone, 

fn extend<I>(&mut self, iter: I) where
    I: 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.