Struct Map

Source

pub struct Map<K = Key, V = Value>where
    K: Eq + Hash,
{ /* private fields */ }

Expand description

A hash map implementation with consistent ordering.

Implementations§

Source §

impl<K, V> Map<K, V>
where K: Eq + Hash,

Source

pub fn new() -> Self

Creates an empty Map.

§Example

use json_api::value::{Key, Map, Value};
let mut map = Map::<Key, Value>::new();

Source

pub fn with_capacity(capacity: usize) -> Self

Creates a new empty Map, with specified capacity.

§Example

let mut map = Map::with_capacity(2);

map.insert("x", 1);
map.insert("y", 2);

// The next insert will likely require reallocation...
map.insert("z", 3);

Source

pub fn capacity(&self) -> usize

Returns the number of key-value pairs the map can hold without reallocating.

§Example

let map = Map::<Key, Value>::with_capacity(2);
assert!(map.capacity() >= 2);

Source

pub fn clear(&mut self)

Clears the map, removing all key-value pairs. Keeps the allocated memory for reuse.

§Example

let mut map = Map::new();

map.insert("x", 1);
map.clear();
assert!(map.is_empty());

Source

pub fn contains_key<Q>(&self, key: &Q) -> bool
where Q: Equivalent<K> + Hash + ?Sized,

Returns true if the map contains a value for the specified key.

§Example

let mut map = Map::new();

map.insert(1, "a");
assert_eq!(map.contains_key(&1), true);
assert_eq!(map.contains_key(&2), false);

Source

pub fn drain(&mut self, range: RangeFull) -> Drain<'_, K, V> ⓘ

Clears the map, returning all key-value pairs as an iterator. Keeps the allocated memory for reuse.

§Example

let mut map = Map::new();

map.insert("x", 1);
map.insert("y", 2);

for (key, value) in map.drain(..) {
    assert!(key == "x" || key == "y");
    assert!(value == 1 || value == 2);
}

assert!(map.is_empty());

Source

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

Returns a reference to the value corresponding to the key.

§Example

let mut map = Map::new();

map.insert("x", 1);

assert_eq!(map.get("x"), Some(&1));
assert_eq!(map.get("y"), None);

Source

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

Inserts a key-value pair into the map.

If a value already existed for key, that old value is returned in Some; otherwise, None is returned.

§Example

let mut map = Map::new();

assert_eq!(map.insert("x", 1), None);
assert_eq!(map.insert("x", 2), Some(1));

Source

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

Return an iterator visiting all the key-value pairs of the map in the order in which they were inserted.

§Example

let mut map = Map::new();

map.insert("a", 1);
map.insert("b", 2);
map.insert("c", 3);

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

Source

pub fn iter_mut(&mut self) -> IterMut<'_, K, V> ⓘ

Return an iterator visiting all the key-value pairs of the map in the order in which they were inserted, with mutable references to the values.

§Example

let mut map = Map::new();

map.insert("a", 1);
map.insert("b", 2);
map.insert("c", 3);

for (_, value) in map.iter_mut() {
    *value += 1;
}

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

Source

pub fn keys(&self) -> Keys<'_, K, V> ⓘ

Return an iterator visiting all keys in the order in which they were inserted.

§Example

let mut map = Map::new();

map.insert("a", 1);
map.insert("b", 2);
map.insert("c", 3);

for key in map.keys() {
    println!("{}", key);
}

Source

pub fn len(&self) -> usize

Return the number of key-value pairs in the map.

§Example

let mut map = Map::new();
assert_eq!(map.len(), 0);

map.insert("x", 1);
assert_eq!(map.len(), 1);

Source

pub fn is_empty(&self) -> bool

Returns true if the map contains no elements.

§Example

let mut map = Map::new();
assert!(map.is_empty());

map.insert("x", 1);
assert!(!map.is_empty());

Source

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

Removes a key from the map, returning the value at the key if the key was previously in the map.

§Example

let mut map = Map::new();

map.insert("x", 1);

assert_eq!(map.remove("x"), Some(1));
assert_eq!(map.remove("x"), None);

Source

pub fn reserve(&mut self, additional: usize)

Reserves capacity for at least additional more elements to be inserted in the Map. The collection may reserve more space to avoid frequent reallocations.

§Note

This method has yet to be fully implemented in the ordermap crate.

§Example

let mut map = Map::<Key, Value>::new();
map.reserve(10);

Source

pub fn values(&self) -> Values<'_, K, V> ⓘ

Return an iterator visiting all values in the order in which they were inserted.

§Example

let mut map = Map::new();

map.insert("a", 1);
map.insert("b", 2);
map.insert("c", 3);

for value in map.values() {
    println!("{}", value);
}

Source

pub fn values_mut(&mut self) -> ValuesMut<'_, K, V> ⓘ

Return an iterator visiting all values mutably in the order in which they were inserted.

§Example

let mut map = Map::new();

map.insert("a", 1);
map.insert("b", 2);
map.insert("c", 3);

for value in map.values_mut() {
    *value += 1;
}

for value in map.values() {
    println!("{}", value);
}