Struct abi_stable::std_types::RHashMap

#[repr(C)]
pub struct RHashMap<K, V, S = RandomState> { /* fields omitted */ }

An ffi-safe hashmap, which wraps std::collections::HashMap<K, V, S>, only requiring the K: Eq + Hash bounds when constructing it.

Most of the API in HashMap is implemented here, including the Entry API.

Example

This example demonstrates how one can use the RHashMap as a dictionary.

use abi_stable::std_types::{RHashMap, RSome, RString, Tuple2};

let mut map = RHashMap::new();

map.insert(
    "dictionary",
    "A book/document containing definitions of words",
);
map.insert("bibliophile", "Someone who loves books.");
map.insert("pictograph", "A picture representating of a word.");

assert_eq!(
    map["dictionary"],
    "A book/document containing definitions of words",
);

assert_eq!(map.remove("bibliophile"), RSome("Someone who loves books."),);

assert_eq!(
    map.get("pictograph"),
    Some(&"A picture representating of a word."),
);

for Tuple2(k, v) in map {
    assert!(k == "dictionary" || k == "pictograph");

    assert!(
        v == "A book/document containing definitions of words" ||
        v == "A picture representating of a word.",
        "{} => {}",
        k,
        v,
    );
}

Implementations

impl<K, V> RHashMap<K, V, RandomState>

pub fn new() -> RHashMap<K, V> where
    Self: Default, 

Constructs an empty RHashMap.

Example

use abi_stable::std_types::{RHashMap, RString};

let mut map = RHashMap::<RString, u32>::new();
assert!(map.is_empty());
map.insert("Hello".into(), 10);
assert_eq!(map.is_empty(), false);

pub fn with_capacity(capacity: usize) -> RHashMap<K, V> where
    Self: Default, 

Constructs an empty RHashMap with at least the passed capacity.

Example

use abi_stable::std_types::{RHashMap, RString};

let mut map = RHashMap::<RString, u32>::with_capacity(10);
assert!(map.capacity() >= 10);

impl<K, V, S> RHashMap<K, V, S>

pub fn with_hasher(hash_builder: S) -> RHashMap<K, V, S> where
    K: Eq + Hash,
    S: BuildHasher + Default, 

Constructs an empty RHashMap with the passed hash_builder to hash the keys.

Example

use abi_stable::std_types::{RHashMap, RString};
use std::collections::hash_map::RandomState;

let s = RandomState::new();
let mut map = RHashMap::<RString, u32, _>::with_hasher(s);
assert!(map.is_empty());
map.insert("Hello".into(), 10);
assert_eq!(map.is_empty(), false);

pub fn with_capacity_and_hasher(
    capacity: usize,
    hash_builder: S
) -> RHashMap<K, V, S> where
    K: Eq + Hash,
    S: BuildHasher + Default, 

Constructs an empty RHashMap with at least the passed capacity, and the passed hash_builder to hash the keys.

Example

use abi_stable::std_types::{RHashMap, RString};
use std::collections::hash_map::RandomState;

let s = RandomState::new();
let mut map = RHashMap::<RString, u32, _>::with_capacity_and_hasher(10, s);
assert!(map.capacity() >= 10);

impl<K, V, S> RHashMap<K, V, S>

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

Returns whether the map associates a value with the key.

Example

use abi_stable::std_types::{RHashMap, RString};

let mut map = RHashMap::<RString, u32>::new();
assert_eq!(map.contains_key("boo"), false);
map.insert("boo".into(), 0);
assert_eq!(map.contains_key("boo"), true);

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

Returns a reference to the value associated with the key.

Returns a None if there is no entry for the key.

Example

use abi_stable::std_types::{RHashMap, RString};

let mut map = RHashMap::<RString, u32>::new();
assert_eq!(map.get("boo"), None);
map.insert("boo".into(), 0);
assert_eq!(map.get("boo"), Some(&0));

pub fn get_mut<Q>(&mut self, query: &Q) -> Option<&mut V> where
    K: Borrow<Q>,
    Q: Hash + Eq + ?Sized, 

Returns a mutable reference to the value associated with the key.

Returns a None if there is no entry for the key.

Example

use abi_stable::std_types::{RHashMap, RString};

let mut map = RHashMap::<RString, u32>::new();
assert_eq!(map.get_mut("boo"), None);
map.insert("boo".into(), 0);
assert_eq!(map.get_mut("boo"), Some(&mut 0));

pub fn remove<Q>(&mut self, query: &Q) -> ROption<V> where
    K: Borrow<Q>,
    Q: Hash + Eq + ?Sized, 

Removes the value associated with the key.

Example

use abi_stable::std_types::{RHashMap, RSome, RNone};

let mut map = vec![(0, 1), (3, 4)].into_iter().collect::<RHashMap<u32, u32>>();

assert_eq!(map.remove(&0), RSome(1));
assert_eq!(map.remove(&0), RNone);

assert_eq!(map.remove(&3), RSome(4));
assert_eq!(map.remove(&3), RNone);

pub fn remove_entry<Q>(&mut self, query: &Q) -> ROption<Tuple2<K, V>> where
    K: Borrow<Q>,
    Q: Hash + Eq + ?Sized, 

Removes the entry for the key.

Example

use abi_stable::std_types::{RHashMap, RSome, RNone, Tuple2};

let mut map = vec![(0, 1), (3, 4)].into_iter().collect::<RHashMap<u32, u32>>();

assert_eq!(map.remove_entry(&0), RSome(Tuple2(0, 1)));
assert_eq!(map.remove_entry(&0), RNone);

assert_eq!(map.remove_entry(&3), RSome(Tuple2(3, 4)));
assert_eq!(map.remove_entry(&3), RNone);

impl<K, V, S> RHashMap<K, V, S>

pub fn contains_key_p(&self, key: &K) -> bool

Returns whether the map associates a value with the key.

Example

use abi_stable::std_types::RHashMap;

let mut map = RHashMap::<u32, u32>::new();
assert_eq!(map.contains_key(&11), false);
map.insert(11, 0);
assert_eq!(map.contains_key(&11), true);

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

Returns a reference to the value associated with the key.

Returns a None if there is no entry for the key.

Example

use abi_stable::std_types::RHashMap;

let mut map = RHashMap::<u32, u32>::new();
assert_eq!(map.get(&12), None);
map.insert(12, 0);
assert_eq!(map.get(&12), Some(&0));

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

Returns a mutable reference to the value associated with the key.

Returns a None if there is no entry for the key.

Example

use abi_stable::std_types::RHashMap;

let mut map = RHashMap::<u32, u32>::new();
assert_eq!(map.get_mut(&12), None);
map.insert(12, 0);
assert_eq!(map.get_mut(&12), Some(&mut 0));

pub fn remove_p(&mut self, key: &K) -> ROption<V>

Removes the value associated with the key.

Example

use abi_stable::std_types::{RHashMap, RSome, RNone};

let mut map = vec![(0, 1), (3, 4)].into_iter().collect::<RHashMap<u32, u32>>();

assert_eq!(map.remove_p(&0), RSome(1));
assert_eq!(map.remove_p(&0), RNone);

assert_eq!(map.remove_p(&3), RSome(4));
assert_eq!(map.remove_p(&3), RNone);

pub fn remove_entry_p(&mut self, key: &K) -> ROption<Tuple2<K, V>>

Removes the entry for the key.

Example

use abi_stable::std_types::{RHashMap, RSome, RNone, Tuple2};

let mut map = vec![(0, 1), (3, 4)].into_iter().collect::<RHashMap<u32, u32>>();

assert_eq!(map.remove_entry_p(&0), RSome(Tuple2(0, 1)));
assert_eq!(map.remove_entry_p(&0), RNone);

assert_eq!(map.remove_entry_p(&3), RSome(Tuple2(3, 4)));
assert_eq!(map.remove_entry_p(&3), RNone);

pub fn index_p(&self, key: &K) -> &V

Returns a reference to the value associated with the key.

Panics

Panics if the key is not associated with a value.

Example

use abi_stable::std_types::RHashMap;

let mut map = vec![(0, 1), (3, 4)].into_iter().collect::<RHashMap<u32, u32>>();

assert_eq!(map.index_p(&0), &1);
assert_eq!(map.index_p(&3), &4);

use abi_stable::std_types::RHashMap;

let mut map = RHashMap::<u32, u32>::new();

assert_eq!(map.index_p(&0), &1);

pub fn index_mut_p(&mut self, key: &K) -> &mut V

Returns a mutable reference to the value associated with the key.

Panics

Panics if the key is not associated with a value.

Example

use abi_stable::std_types::RHashMap;

let mut map = vec![(0, 1), (3, 4)].into_iter().collect::<RHashMap<u32, u32>>();

assert_eq!(map.index_mut_p(&0), &mut 1);
assert_eq!(map.index_mut_p(&3), &mut 4);

use abi_stable::std_types::RHashMap;

let mut map = RHashMap::<u32, u32>::new();

assert_eq!(map.index_mut_p(&0), &mut 1);

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

Inserts a value into the map, associating it with a key, returning the previous value.

Example

use abi_stable::std_types::RHashMap;

let mut map = RHashMap::<u32, u32>::new();

map.insert(0, 1);
map.insert(2, 3);

assert_eq!(map[&0], 1);
assert_eq!(map[&2], 3);

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

Reserves enough space to insert reserved extra elements without reallocating.

Example

use abi_stable::std_types::RHashMap;

let mut map = RHashMap::<u32, u32>::new();
map.reserve(10);

pub fn clear(&mut self)

Removes all the entries in the map.

Example

use abi_stable::std_types::RHashMap;

let mut map = vec![(0, 1), (3, 4)].into_iter().collect::<RHashMap<u32, u32>>();

assert_eq!(map.contains_key(&0), true);
assert_eq!(map.contains_key(&3), true);

map.clear();

assert_eq!(map.contains_key(&0), false);
assert_eq!(map.contains_key(&3), false);

pub fn len(&self) -> usize

Returns the amount of entries in the map.

Example

use abi_stable::std_types::RHashMap;

let mut map = RHashMap::<u32, u32>::new();

assert_eq!(map.len(), 0);
map.insert(0, 1);
assert_eq!(map.len(), 1);
map.insert(2, 3);
assert_eq!(map.len(), 2);

pub fn capacity(&self) -> usize

Returns the capacity of the map, the amount of elements it can store without reallocating.

Note that this is a lower bound, since hash maps don’t necessarily have an exact capacity.

Example

use abi_stable::std_types::RHashMap;

let mut map = RHashMap::<u32, u32>::with_capacity(4);

assert!(map.capacity() >= 4);

pub fn is_empty(&self) -> bool

Returns whether the map contains any entries.

Example

use abi_stable::std_types::RHashMap;

let mut map = RHashMap::<u32, u32>::new();

assert_eq!(map.is_empty(), true);
map.insert(0, 1);
assert_eq!(map.is_empty(), false);

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

Iterates over the entries in the map, with references to the values in the map.

This returns a type that implements Iterator<Item= Tuple2< &K, &V > > + !Send + !Sync + Clone

Example

use abi_stable::std_types::{RHashMap, Tuple2};

let mut map = RHashMap::<u32, u32>::new();

map.insert(0, 1);
map.insert(3, 4);

let mut list = map.iter().collect::<Vec<_>>();
list.sort();
assert_eq!( list, vec![Tuple2(&0, &1), Tuple2(&3, &4)] );

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

Iterates over the entries in the map, with mutable references to the values in the map.

This returns a type that implements Iterator<Item= Tuple2< &K, &mut V > > + !Send + !Sync

Example

use abi_stable::std_types::{RHashMap, Tuple2};

let mut map = RHashMap::<u32, u32>::new();

map.insert(0, 1);
map.insert(3, 4);

let mut list = map.iter_mut().collect::<Vec<_>>();
list.sort();
assert_eq!( list, vec![Tuple2(&0, &mut 1), Tuple2(&3, &mut  4)] );

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

Clears the map, returning an iterator over all the entries that were removed.

This returns a type that implements Iterator<Item= Tuple2< K, V > > + !Send + !Sync

Example

use abi_stable::std_types::{RHashMap, Tuple2};

let mut map = RHashMap::<u32, u32>::new();

map.insert(0, 1);
map.insert(3, 4);

let mut list = map.drain().collect::<Vec<_>>();
list.sort();
assert_eq!( list, vec![Tuple2(0, 1), Tuple2(3, 4)] );

assert!(map.is_empty());

pub fn entry(&mut self, key: K) -> REntry<'_, K, V>

Gets a handle into the entry in the map for the key, that allows operating directly on the entry.

Example

use abi_stable::std_types::RHashMap;

let mut map = RHashMap::<u32, u32>::new();

// Inserting an entry that wasn't there before.
{
    let mut entry = map.entry(0);
    assert_eq!(entry.get(), None);
    assert_eq!(entry.or_insert(3), &mut 3);
    assert_eq!(map.get(&0), Some(&3));
}

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

An iterator visiting all keys in arbitrary order. The iterator element type is &'a K.

Examples

use abi_stable::std_types::RHashMap;

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

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

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

An iterator visiting all values in arbitrary order. The iterator element type is &'a V.

Examples

use abi_stable::std_types::RHashMap;

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

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

Trait Implementations

impl<K, V, S> Clone for RHashMap<K, V, S> where
    K: Clone,
    V: Clone,
    Self: Default, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K, V, S> Debug for RHashMap<K, V, S> where
    K: Debug,
    V: Debug, 

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

Formats the value using the given formatter.

impl<K, V, S> Default for RHashMap<K, V, S> where
    K: Eq + Hash,
    S: BuildHasher + Default, 

fn default() -> Self

Returns the “default value” for a type.

impl<'de, K, V, S> Deserialize<'de> for RHashMap<K, V, S> where
    K: Deserialize<'de>,
    V: Deserialize<'de>,
    Self: Default, 

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<K, V, S> Extend<(K, V)> for RHashMap<K, V, S>

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.

impl<K, V, S> Extend<Tuple2<K, V>> for RHashMap<K, V, S>

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

impl<K, V, S> From<HashMap<K, V, S>> for RHashMap<K, V, S> where
    Self: Default, 

fn from(map: HashMap<K, V, S>) -> Self

Performs the conversion.

impl<K, V, S> From<RHashMap<K, V, S>> for HashMap<K, V, S> where
    K: Eq + Hash,
    S: BuildHasher + Default, 

fn from(this: RHashMap<K, V, S>) -> HashMap<K, V, S>

Performs the conversion.

impl<K, V, S> FromIterator<(K, V)> for RHashMap<K, V, S> where
    Self: Default, 

fn from_iter<I>(iter: I) -> Self where
    I: IntoIterator<Item = (K, V)>, 

Creates a value from an iterator.

impl<K, V, S> FromIterator<Tuple2<K, V>> for RHashMap<K, V, S> where
    Self: Default, 

fn from_iter<I>(iter: I) -> Self where
    I: IntoIterator<Item = Tuple2<K, V>>, 

Creates a value from an iterator.

impl<K, V, S> GetStaticEquivalent_ for RHashMap<K, V, S> where
    K: __StableAbi,
    V: __StableAbi, 

type StaticEquivalent = _static_RHashMap<__GetStaticEquivalent<K>, __GetStaticEquivalent<V>, ()>

impl<K, Q, V, S> Index<&'_ Q> for RHashMap<K, V, S> where
    K: Borrow<Q>,
    Q: Eq + Hash + ?Sized, 

type Output = V

The returned type after indexing.

fn index(&self, query: &Q) -> &V

Performs the indexing (container[index]) operation.

impl<K, Q, V, S> IndexMut<&'_ Q> for RHashMap<K, V, S> where
    K: Borrow<Q>,
    Q: Eq + Hash + ?Sized, 

fn index_mut(&mut self, query: &Q) -> &mut V

Performs the mutable indexing (container[index]) operation.

impl<K, V, S> IntoIterator for RHashMap<K, V, S>

This returns an Iterator<Item= Tuple2< K, V > >+!Send+!Sync

type Item = Tuple2<K, V>

The type of the elements being iterated over.

type IntoIter = IntoIter<K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IntoIter<K, V>

Creates an iterator from a value.

impl<'a, K, V, S> IntoIterator for &'a RHashMap<K, V, S>

This returns an Iterator<Item= Tuple2< &K, &V > > + !Send + !Sync + Clone

type Item = Tuple2<&'a K, &'a V>

The type of the elements being iterated over.

type IntoIter = Iter<'a, K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, K, V, S> IntoIterator for &'a mut RHashMap<K, V, S>

This returns a type that implements Iterator<Item= Tuple2< &K, &mut V > > + !Send + !Sync

type Item = Tuple2<&'a K, &'a mut V>

The type of the elements being iterated over.

type IntoIter = IterMut<'a, K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K, V, S> PartialEq<RHashMap<K, V, S>> for RHashMap<K, V, S> where
    K: PartialEq,
    V: PartialEq, 

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<K, V, S> Serialize for RHashMap<K, V, S> where
    K: Serialize,
    V: Serialize, 

fn serialize<Z>(&self, serializer: Z) -> Result<Z::Ok, Z::Error> where
    Z: Serializer, 

Serialize this value into the given Serde serializer.

impl<K, V, S> StableAbi for RHashMap<K, V, S> where
    K: __StableAbi,
    V: __StableAbi, 

type IsNonZeroType = False

Whether this type has a single invalid bit-pattern.

const LAYOUT: &'static TypeLayout

The layout of the type provided by implementors.

const ABI_CONSTS: AbiConsts

const-equivalents of the associated types.

impl<K, V, S> Eq for RHashMap<K, V, S> where
    K: Eq,
    V: Eq, 

impl<K, V, S> Send for RHashMap<K, V, S> where
    HashMap<K, V, S>: Send, 

impl<K, V, S> Sync for RHashMap<K, V, S> where
    HashMap<K, V, S>: Sync,