Struct abi_stable::std_types::map::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,Tuple2,RString,RSome};

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: ?Sized>(&self, query: &Q) -> bool where
    K: Borrow<Q>,
    Q: Hash + Eq, 

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: ?Sized>(&self, query: &Q) -> Option<&V> where
    K: Borrow<Q>,
    Q: Hash + Eq, 

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: ?Sized>(&mut self, query: &Q) -> Option<&mut V> where
    K: Borrow<Q>,
    Q: Hash + Eq, 

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: ?Sized>(&mut self, query: &Q) -> ROption<V> where
    K: Borrow<Q>,
    Q: Hash + Eq, 

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: ?Sized>(&mut self, query: &Q) -> ROption<Tuple2<K, V>> where
    K: Borrow<Q>,
    Q: Hash + Eq, 

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));
}

Trait Implementations

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

pub fn clone(&self) -> Self

Returns a copy of the value.

pub 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, 

pub 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, 

pub 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, 

pub 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> Eq for RHashMap<K, V, S> where
    K: Eq,
    V: Eq, 

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

pub fn extend<I>(&mut self, iter: I) where
    I: IntoIterator<Item = (K, V)>, 

Extends a collection with the contents of an iterator.

pub fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

pub 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>

pub fn extend<I>(&mut self, iter: I) where
    I: IntoIterator<Item = Tuple2<K, V>>, 

Extends a collection with the contents of an iterator.

pub fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

pub 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, 

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

Performs the conversion.

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

pub 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, 

pub 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: ?Sized, V, S, '_> Index<&'_ Q> for RHashMap<K, V, S> where
    K: Borrow<Q>,
    Q: Eq + Hash, 

type Output = V

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

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

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

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

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

pub fn into(self) -> HashMap<K, V, S>

Performs the conversion.

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?

pub 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?

pub 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?

pub 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, 

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

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

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

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

pub 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.

pub const LAYOUT: &'static TypeLayout

The layout of the type provided by implementors.

pub const ABI_CONSTS: AbiConsts

const-equivalents of the associated types.

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