Struct IndexMap

pub struct IndexMap<K, V, Node = Vec<Pair<K, V>>>
where
    K: Send + Ord + Clone + 'static,
    V: Send + Clone + 'static,
    Node: NodeLike<Pair<K, V>>,
{ /* private fields */ }

Implementations

impl<K, V, Node> BTreeMap<K, V, Node>

where K: Send + Ord + Clone + 'static, V: Send + Clone + 'static, Node: NodeLike<Pair<K, V>> + Send + 'static,

pub fn new() -> BTreeMap<K, V, Node>

Makes a new, empty, persistent BTreeMap.

Examples

Basic usage:

use indexset::concurrent::map::BTreeMap;

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

// entries can now be inserted into the empty map
map.insert(1, "a");

pub fn with_maximum_node_size(node_capacity: usize) -> BTreeMap<K, V, Node>

Makes a new, empty BTreeMap with the given maximum node size. Allocates one vec with the capacity set to be the specified node size.

Examples

use indexset::concurrent::map::BTreeMap;

let map = BTreeMap::<i32, i32>::with_maximum_node_size(128);

pub fn attach_node(&self, node: Node)

Adds full [Node] to this set. [Node] should be correct node with values sorted.

pub fn iter_nodes(&self) -> impl Iterator<Item = Arc<Mutex<RawMutex, Node>>>

Returns iterator over this set’s [Node]’s.

pub fn contains_key<Q>(&self, key: &Q) -> bool

where Pair<K, V>: 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

Basic usage:

use indexset::concurrent::map::BTreeMap;

let mut map = BTreeMap::<usize, &str>::new();
map.insert(1, "a");
assert_eq!(map.contains_key(&1), true);
assert_eq!(map.contains_key(&2), false);

pub fn get<Q>(&self, key: &Q) -> Option<Ref<Pair<K, V>, Node>>

where Pair<K, V>: Borrow<Q> + Ord, Q: Ord + ?Sized,

Returns a reference to a pair whose key corresponds to the input.

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

Basic usage:

use indexset::concurrent::map::BTreeMap;

let mut map = BTreeMap::<usize, &str>::new();
map.insert(1, "a");
assert_eq!(map.get(&1).and_then(|e| Some(e.get().value)), Some("a"));
assert_eq!(map.get(&2).and_then(|e| Some(e.get().value)), None);

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

Inserts a key-value pair into the map.

If the map did not have this key present, it will be inserted.

Otherwise, the value is updated.

Examples

Basic usage:

use indexset::concurrent::map::BTreeMap;

let mut map = BTreeMap::<usize, &str>::new();
assert_eq!(map.insert(37, "a"), None);
assert_eq!(map.len() == 0, false);

map.insert(37, "b");
assert_eq!(map.insert(37, "c"), Some("b"));
assert_eq!(map.get(&37).and_then(|e| Some(e.get().value)), Some("c"));

pub fn insert_cdc( &self, key: K, value: V, ) -> (Option<V>, Vec<ChangeEvent<Pair<K, V>>>)

Inserts a key-value pair into the map and returns old value (if it was already in set) with ChangeEvent’s that describes this insert action.

pub fn remove<Q>(&self, key: &Q) -> Option<(K, V)>

where Pair<K, V>: Borrow<Q> + Ord, Q: Ord + ?Sized,

Removes a key from the map, returning the key and the 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

Basic usage:

use indexset::concurrent::map::BTreeMap;

let map = BTreeMap::<usize, &str>::new();
map.insert(1, "a");
assert_eq!(map.remove(&1), Some((1, "a")));
assert_eq!(map.remove(&1), None);

pub fn remove_cdc<Q>( &self, key: &Q, ) -> (Option<(K, V)>, Vec<ChangeEvent<Pair<K, V>>>)

where Pair<K, V>: Borrow<Q> + Ord, Q: Ord + ?Sized,

Removes a key from the map, returning the key and the value if the key was previously in the map and ChangeEvents describing changes caused by this action.

pub fn len(&self) -> usize

Returns the number of elements in the map.

Examples

Basic usage:

use indexset::concurrent::map::BTreeMap;

let mut a = BTreeMap::<usize, &str>::new();
assert_eq!(a.len(), 0);
a.insert(1, "a");
assert_eq!(a.len(), 1);

pub fn capacity(&self) -> usize

Returns the total number of allocated slots across all internal nodes.

This represents the number of key-value pairs the map can hold without reallocating memory in its internal vectors.

Examples

Basic usage:

use indexset::concurrent::map::BTreeMap;

let mut a = BTreeMap::<usize, &str>::with_maximum_node_size(16);

a.insert(1, "a");
a.insert(2, "b");

// Capacity remains the same until node is split or reallocated
assert_eq!(a.capacity(), 16);

pub fn node_count(&self) -> usize

Returns the total number of nodes.

Examples

Basic usage:

use indexset::concurrent::map::BTreeMap;

let mut a = BTreeMap::<usize, &str>::with_maximum_node_size(16);

a.insert(1, "a");
a.insert(2, "b");

assert_eq!(a.node_count(), 1);

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

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

Examples

Basic usage:

use indexset::concurrent::map::BTreeMap;

let mut map = BTreeMap::<usize, &str>::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 range<Q, R>(&self, range: R) -> Range<'_, K, V, Node>

where Pair<K, V>: Borrow<Q>, Q: Ord + ?Sized, R: RangeBounds<Q>,

Constructs a double-ended iterator over a sub-range of elements in the map. The simplest way is to use the range syntax min..max, thus range(min..max) will yield elements from min (inclusive) to max (exclusive). The range may also be entered as (Bound<T>, Bound<T>), so for example range((Excluded(4), Included(10))) will yield a left-exclusive, right-inclusive range from 4 to 10.

Panics

Panics if range start > end. Panics if range start == end and both bounds are Excluded.

Examples

Basic usage:

use indexset::concurrent::map::BTreeMap;
use std::ops::Bound::Included;

let mut map = BTreeMap::<i32, &str>::new();
map.insert(3, "a");
map.insert(5, "b");
map.insert(8, "c");
for (&key, &value) in map.range::<i32, _>((Included(&4), Included(&8))) {
    println!("{key}: {value}");
}
assert_eq!(Some((&5, &"b")), map.range(4..).next());

Trait Implementations

impl<K, V, Node> Debug for BTreeMap<K, V, Node>

where K: Debug + Send + Ord + Clone + 'static, V: Debug + Send + Clone + 'static, Node: Debug + NodeLike<Pair<K, V>>,

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

Formats the value using the given formatter.

impl<K, V, Node> Default for BTreeMap<K, V, Node>

where K: Send + Ord + Clone, V: Send + Clone + 'static, Node: NodeLike<Pair<K, V>> + Send + 'static,

fn default() -> BTreeMap<K, V, Node>

Returns the “default value” for a type.

impl<T, Node> TableIndex<T> for IndexMap<T, Link, Node>

where T: Eq + Hash + Clone + Send + Ord, Node: NodeLike<Pair<T, Link>> + Send + 'static,

fn insert(&self, value: T, link: Link) -> Option<Link>

fn remove(&self, value: T, _: Link) -> Option<(T, Link)>

impl<T, Node> TableIndexCdc<T> for IndexMap<T, Link, Node>

where T: Eq + Hash + Clone + Send + Ord, Node: NodeLike<Pair<T, Link>> + Send + 'static,

fn insert_cdc( &self, value: T, link: Link, ) -> (Option<Link>, Vec<ChangeEvent<Pair<T, Link>>>)

fn remove_cdc( &self, value: T, _: Link, ) -> (Option<(T, Link)>, Vec<ChangeEvent<Pair<T, Link>>>)