indextreemap

IndexTreeMap is an ordered tree map based on the rust standard library BTreeMap, that allows for items to be accessed by key, value, or position in the tree.

This library is meant to serve niche use cases where the deterministic ordering of key-value items is required, with the ability to index items by position or key in logarithmic time.

IndexTreeMap::new()

Makes a new, empty IndexTreeMap.

Does not allocate anything on its own.

Example

Basic usage: ```rust use indextreemap::IndexTreeMap;

let mut map = IndexTreeMap::new(); map.insert(1, "a".to_string()); ```

IndexTreeMap::insert()

Inserts a key-value pair into the map.

### Example

Basic usage: ```rust use indextreemap::IndexTreeMap;

let mut tree = IndexTreeMap::new(); tree.insert(1, "a".tostring()); assert!(!tree.isempty()); ```

IndexTreeMap::clear()

Clears the map, removing all elements. Does not allocate anything on its own.

Example

Basic usage: ```rust use indextreemap::IndexTreeMap;

let mut map = IndexTreeMap::new(); map.insert(1, "a".tostring()); map.clear(); assert!(map.isempty()); ```

IndexTreeMap::len()

Returns the size of the map.

Example

Basic usage: ```rust use indextreemap::IndexTreeMap;

let mut map = IndexTreeMap::new(); map.insert(1, "a".tostring()); asserteq!(map.len(), 1); ```

IndexTreeMap::is_empty()

Returns true if the map contains no elements.

Example

Basic usage: ```rust use indextreemap::IndexTreeMap;

let mut map = IndexTreeMap::new(); assert!(map.isempty()); map.insert(1, "a".tostring()); assert!(!map.is_empty()); ```

IndexTreeMap::contains_key()

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.

Example

Basic usage: ```rust use indextreemap::IndexTreeMap;

let mut tree = IndexTreeMap::new(); tree.insert(1, "a".tostring()); asserteq!(tree.containskey(&1), true); asserteq!(tree.contains_key(&2), false); ```

IndexTreeMap::contains_index()

Returns true if the map contains an item in the index position.

Example

Basic usage: ```rust use indextreemap::IndexTreeMap;

let mut tree = IndexTreeMap::new(); tree.insert(1, "a".tostring()); asserteq!(tree.containsindex(0), true); asserteq!(tree.contains_index(1), false); ```

IndexTreeMap::get()

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.

Example

Basic usage: ```rust use indextreemap::IndexTreeMap;

let mut tree = IndexTreeMap::new(); tree.insert(1, "a".tostring()); asserteq!(tree.get(&1), Some(&"a".tostring())); asserteq!(tree.get(&2), None); ```

IndexTreeMap::getkeyvalue()

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.

Example

Basic usage: ```rust use indextreemap::IndexTreeMap;

let mut tree = IndexTreeMap::new(); tree.insert(1, "a".tostring()); asserteq!(tree.getkeyvalue(&1), (Some(&1), Some(&"a".tostring()))); asserteq!(tree.getkeyvalue(&2), (None, None)); ```

IndexTreeMap::getfromindex()

Returns a reference to the value corresponding to the index.

Example

Basic usage: ```rust use indextreemap::IndexTreeMap;

let mut tree = IndexTreeMap::new(); tree.insert(1, "a".tostring()); asserteq!(tree.getfromindex(0), Some(&"a".tostring())); asserteq!(tree.getfromindex(1), None); ```

IndexTreeMap::getkeyfrom_index()

Returns a reference to the key corresponding to the index.

Example

Basic usage: ```rust use indextreemap::IndexTreeMap;

let mut tree = IndexTreeMap::new(); tree.insert(1, "a".tostring()); asserteq!(tree.getkeyfromindex(0), Some(&1)); asserteq!(tree.getkeyfrom_index(1), None); ```

IndexTreeMap::getkeyvaluefromindex()

Returns a reference to the key-value pair corresponding to the index.

Example

Basic usage: ```rust use indextreemap::IndexTreeMap;

let mut tree = IndexTreeMap::new(); tree.insert(1, "a".tostring()); asserteq!(tree.getkeyvaluefromindex(0), (Some(&1), Some(&"a".tostring()))); asserteq!(tree.getkeyvaluefromindex(1), (None, None)); ```

IndexTreeMap::getfirstkey()

Returns a reference to the first key in the map.

Example

Basic usage: ```rust use indextreemap::IndexTreeMap;

let mut tree = IndexTreeMap::new(); tree.insert(1, "a".tostring()); asserteq!(tree.getfirstkey(), Some(&1)); ```

IndexTreeMap::getfirstvalue()

Returns a reference to the first value in the map.

Example

Basic usage: ```rust use indextreemap::IndexTreeMap;

let mut tree = IndexTreeMap::new(); tree.insert(1, "a".tostring()); asserteq!(tree.getfirstvalue(), Some(&"a".to_string())); ```

IndexTreeMap::getfirstkey_value()

Returns a reference to the first key-value pair in the map.

Example

Basic usage: ```rust use indextreemap::IndexTreeMap;

let mut tree = IndexTreeMap::new(); tree.insert(1, "a".tostring()); asserteq!(tree.getfirstkeyvalue(), (Some(&1),Some(&"a".tostring()))); ```

IndexTreeMap::getlastkey()

Returns a reference to the last key in the map.

Example

Basic usage: ```rust use indextreemap::IndexTreeMap; let mut tree = IndexTreeMap::new();

tree.insert(1, "a".tostring()); tree.insert(2, "b".tostring()); asserteq!(tree.getlast_key(), Some(&2)); ```

IndexTreeMap::getlastvalue()

Returns a reference to the first value in the map.

Example

Basic usage: ```rust use indextreemap::IndexTreeMap;

let mut tree = IndexTreeMap::new(); tree.insert(1, "a".tostring()); tree.insert(2, "b".tostring()); asserteq!(tree.getlastvalue(), Some(&"b".tostring())); ```

IndexTreeMap::getlastkey_value()

Returns a reference to the last key-value pair in the map.

Example

Basic usage: ```rust use indextreemap::IndexTreeMap;

let mut tree = IndexTreeMap::new(); tree.insert(1, "a".tostring()); tree.insert(2, "b".tostring()); asserteq!(tree.getlastkeyvalue(), (Some(&2),Some(&"b".to_string()))); ```

IndexTreeMap::iter()

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

Example

Basic usage: ```rust use std::collections::BTreeMap;

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

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

let (firstkey, firstvalue) = map.iter().next().unwrap(); asserteq!((*firstkey, *first_value), (1, "a")); ```

IndexTreeMap::into_iter()

Creates a consuming iterator visiting all the keys, in sorted order. The map cannot be used after calling this.

Example

Basic usage: ```rust use std::collections::BTreeMap;

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

let items: Vec<(i32, &str)> = map.intoiter().collect(); asserteq!(items, [(1, "a"), (2, "b")]); ```

IndexTreeMap::remove()

Removes an item from the map from its corresponding key, returning the key-value pair that was previously in the map.

Example

Basic usage: ```rust use indextreemap::IndexTreeMap;

let mut tree = IndexTreeMap::new(); tree.insert(1, "a".tostring()); asserteq!(tree.remove(&1), (Some(1), Some("a".tostring()))); asserteq!(tree.remove(&2), (None, None)); ```

IndexTreeMap::removefromindex()

Removes an item from the map from its corresponding index, returning the key-value pair that was previously in the map.

Example

Basic usage: rust use indextreemap::IndexTreeMap; let mut tree = IndexTreeMap::new(); tree.insert(1, "a".to_string()); assert_eq!(tree.remove_from_index(0), (Some(1), Some("a".to_string()))); assert_eq!(tree.remove_from_index(1), (None, None));

IndexTreeMap::replace()

Replaces an item from the map from its corresponding key, returning the key-value pair that was previously in the map.

Example

Basic usage: ```rust use indextreemap::IndexTreeMap;

let mut tree = IndexTreeMap::new(); tree.insert(1, "a".tostring()); tree.replace(1, "b".tostring()); asserteq!(tree.get(&1), Some(&"b".tostring())); ```

IndexTreeMap::replace_index()

Replaces an item from the map from its corresponding index, returning the key-value pair that was previously in the map.

Example

Basic usage: ```rust use indextreemap::IndexTreeMap;

let mut tree = IndexTreeMap::new(); tree.insert(1, "a".tostring()); tree.replaceindex(0, "b".tostring()); asserteq!(tree.get(&1), Some(&"b".to_string())); ```