Struct abi_stable::std_types::RHashMap

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

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

Converts to this type from the input type.

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>

Converts to this type from the input type.

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<<K as GetStaticEquivalent_>::StaticEquivalent, <V as GetStaticEquivalent_>::StaticEquivalent, ()>

The 'static equivalent of Self

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<'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 = DynTrait<'a, RBox<()>, RefIterInterface<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 = DynTrait<'a, RBox<()>, MutIterInterface<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> 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<K, V, S> PartialEq for RHashMap<K, V, S>

where K: PartialEq, V: PartialEq,

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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,