Struct perseus::state::rx_collections::RxHashMapNested
source · pub struct RxHashMapNested<K, V>(_)
where
K: Clone + Eq + Hash,
V: MakeRx + 'static,
V::Rx: MakeUnrx<Unrx = V> + Freeze + Clone;
Expand description
A reactive version of HashMap
that uses nested reactivity on its
elements. That means the type inside the vector must implement MakeRx
(usually derived with the ReactiveState
macro). If you want to store
simple types inside the vector, without nested reactivity (e.g. String
s),
you should use super::RxHashMap
.
Methods from Deref<Target = HashMap<K, V>>§
1.0.0 · sourcepub fn capacity(&self) -> usize
pub fn capacity(&self) -> usize
Returns the number of elements the map can hold without reallocating.
This number is a lower bound; the HashMap<K, V>
might be able to hold
more, but is guaranteed to be able to hold at least this many.
Examples
use std::collections::HashMap;
let map: HashMap<i32, i32> = HashMap::with_capacity(100);
assert!(map.capacity() >= 100);
1.0.0 · sourcepub fn keys(&self) -> Keys<'_, K, V>
pub fn keys(&self) -> Keys<'_, K, V>
An iterator visiting all keys in arbitrary order.
The iterator element type is &'a K
.
Examples
use std::collections::HashMap;
let map = HashMap::from([
("a", 1),
("b", 2),
("c", 3),
]);
for key in map.keys() {
println!("{key}");
}
Performance
In the current implementation, iterating over keys takes O(capacity) time instead of O(len) because it internally visits empty buckets too.
1.0.0 · sourcepub fn values(&self) -> Values<'_, K, V>
pub fn values(&self) -> Values<'_, K, V>
An iterator visiting all values in arbitrary order.
The iterator element type is &'a V
.
Examples
use std::collections::HashMap;
let map = HashMap::from([
("a", 1),
("b", 2),
("c", 3),
]);
for val in map.values() {
println!("{val}");
}
Performance
In the current implementation, iterating over values takes O(capacity) time instead of O(len) because it internally visits empty buckets too.
1.0.0 · sourcepub fn iter(&self) -> Iter<'_, K, V>
pub fn iter(&self) -> Iter<'_, K, V>
An iterator visiting all key-value pairs in arbitrary order.
The iterator element type is (&'a K, &'a V)
.
Examples
use std::collections::HashMap;
let map = HashMap::from([
("a", 1),
("b", 2),
("c", 3),
]);
for (key, val) in map.iter() {
println!("key: {key} val: {val}");
}
Performance
In the current implementation, iterating over map takes O(capacity) time instead of O(len) because it internally visits empty buckets too.
1.0.0 · sourcepub fn len(&self) -> usize
pub fn len(&self) -> usize
Returns the number of elements in the map.
Examples
use std::collections::HashMap;
let mut a = HashMap::new();
assert_eq!(a.len(), 0);
a.insert(1, "a");
assert_eq!(a.len(), 1);
1.0.0 · sourcepub fn is_empty(&self) -> bool
pub fn is_empty(&self) -> bool
Returns true
if the map contains no elements.
Examples
use std::collections::HashMap;
let mut a = HashMap::new();
assert!(a.is_empty());
a.insert(1, "a");
assert!(!a.is_empty());
1.9.0 · sourcepub fn hasher(&self) -> &S
pub fn hasher(&self) -> &S
Returns a reference to the map’s BuildHasher
.
Examples
use std::collections::HashMap;
use std::collections::hash_map::RandomState;
let hasher = RandomState::new();
let map: HashMap<i32, i32> = HashMap::with_hasher(hasher);
let hasher: &RandomState = map.hasher();
1.0.0 · sourcepub fn get<Q>(&self, k: &Q) -> Option<&V>where
K: Borrow<Q>,
Q: Hash + Eq + ?Sized,
pub fn get<Q>(&self, k: &Q) -> Option<&V>where K: Borrow<Q>, Q: Hash + Eq + ?Sized,
Returns a reference to the value corresponding to the key.
The key may be any borrowed form of the map’s key type, but
Hash
and Eq
on the borrowed form must match those for
the key type.
Examples
use std::collections::HashMap;
let mut map = HashMap::new();
map.insert(1, "a");
assert_eq!(map.get(&1), Some(&"a"));
assert_eq!(map.get(&2), None);
1.40.0 · sourcepub fn get_key_value<Q>(&self, k: &Q) -> Option<(&K, &V)>where
K: Borrow<Q>,
Q: Hash + Eq + ?Sized,
pub fn get_key_value<Q>(&self, k: &Q) -> Option<(&K, &V)>where K: Borrow<Q>, Q: Hash + Eq + ?Sized,
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
Hash
and Eq
on the borrowed form must match those for
the key type.
Examples
use std::collections::HashMap;
let mut map = HashMap::new();
map.insert(1, "a");
assert_eq!(map.get_key_value(&1), Some((&1, &"a")));
assert_eq!(map.get_key_value(&2), None);
1.0.0 · sourcepub fn contains_key<Q>(&self, k: &Q) -> boolwhere
K: Borrow<Q>,
Q: Hash + Eq + ?Sized,
pub fn contains_key<Q>(&self, k: &Q) -> boolwhere K: Borrow<Q>, Q: Hash + Eq + ?Sized,
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
Hash
and Eq
on the borrowed form must match those for
the key type.
Examples
use std::collections::HashMap;
let mut map = HashMap::new();
map.insert(1, "a");
assert_eq!(map.contains_key(&1), true);
assert_eq!(map.contains_key(&2), false);
sourcepub fn raw_entry(&self) -> RawEntryBuilder<'_, K, V, S>
🔬This is a nightly-only experimental API. (hash_raw_entry
)
pub fn raw_entry(&self) -> RawEntryBuilder<'_, K, V, S>
hash_raw_entry
)Creates a raw immutable entry builder for the HashMap.
Raw entries provide the lowest level of control for searching and manipulating a map. They must be manually initialized with a hash and then manually searched.
This is useful for
- Hash memoization
- Using a search key that doesn’t work with the Borrow trait
- Using custom comparison logic without newtype wrappers
Unless you are in such a situation, higher-level and more foolproof APIs like
get
should be preferred.
Immutable raw entries have very limited use; you might instead want raw_entry_mut
.
Trait Implementations§
source§impl<K, V> Clone for RxHashMapNested<K, V>where
K: Clone + Eq + Hash + Clone,
V: MakeRx + 'static + Clone,
V::Rx: MakeUnrx<Unrx = V> + Freeze + Clone,
impl<K, V> Clone for RxHashMapNested<K, V>where K: Clone + Eq + Hash + Clone, V: MakeRx + 'static + Clone, V::Rx: MakeUnrx<Unrx = V> + Freeze + Clone,
source§fn clone(&self) -> RxHashMapNested<K, V>
fn clone(&self) -> RxHashMapNested<K, V>
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read moresource§impl<K, V> Debug for RxHashMapNested<K, V>where
K: Clone + Eq + Hash + Debug,
V: MakeRx + 'static + Debug,
V::Rx: MakeUnrx<Unrx = V> + Freeze + Clone,
impl<K, V> Debug for RxHashMapNested<K, V>where K: Clone + Eq + Hash + Debug, V: MakeRx + 'static + Debug, V::Rx: MakeUnrx<Unrx = V> + Freeze + Clone,
source§impl<K, V> Deref for RxHashMapNested<K, V>where
K: Clone + Serialize + DeserializeOwned + Eq + Hash,
V: MakeRx + Serialize + DeserializeOwned + 'static,
V::Rx: MakeUnrx<Unrx = V> + Freeze + Clone,
impl<K, V> Deref for RxHashMapNested<K, V>where K: Clone + Serialize + DeserializeOwned + Eq + Hash, V: MakeRx + Serialize + DeserializeOwned + 'static, V::Rx: MakeUnrx<Unrx = V> + Freeze + Clone,
source§impl<'de, K, V> Deserialize<'de> for RxHashMapNested<K, V>where
K: Clone + Eq + Hash + Deserialize<'de>,
V: MakeRx + 'static + Deserialize<'de>,
V::Rx: MakeUnrx<Unrx = V> + Freeze + Clone,
impl<'de, K, V> Deserialize<'de> for RxHashMapNested<K, V>where K: Clone + Eq + Hash + Deserialize<'de>, V: MakeRx + 'static + Deserialize<'de>, V::Rx: MakeUnrx<Unrx = V> + Freeze + Clone,
source§fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
__D: Deserializer<'de>,
fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,
source§impl<K, V> From<HashMap<K, V, RandomState>> for RxHashMapNested<K, V>where
K: Clone + Serialize + DeserializeOwned + Eq + Hash,
V: MakeRx + Serialize + DeserializeOwned + 'static,
V::Rx: MakeUnrx<Unrx = V> + Freeze + Clone,
impl<K, V> From<HashMap<K, V, RandomState>> for RxHashMapNested<K, V>where K: Clone + Serialize + DeserializeOwned + Eq + Hash, V: MakeRx + Serialize + DeserializeOwned + 'static, V::Rx: MakeUnrx<Unrx = V> + Freeze + Clone,
source§impl<K, V> MakeRx for RxHashMapNested<K, V>where
K: Clone + Serialize + DeserializeOwned + Eq + Hash,
V: MakeRx + Serialize + DeserializeOwned + 'static,
V::Rx: MakeUnrx<Unrx = V> + Freeze + Clone,
impl<K, V> MakeRx for RxHashMapNested<K, V>where K: Clone + Serialize + DeserializeOwned + Eq + Hash, V: MakeRx + Serialize + DeserializeOwned + 'static, V::Rx: MakeUnrx<Unrx = V> + Freeze + Clone,
§type Rx = RxHashMapNestedRx<K, V>
type Rx = RxHashMapNestedRx<K, V>
source§const HSR_IGNORE: bool = false
const HSR_IGNORE: bool = false
true
to have this type be ignored by the hot
state reloading system, which can be useful when working with state
that you will regularly update in development. Read moresource§impl<K, V> PartialEq<RxHashMapNested<K, V>> for RxHashMapNested<K, V>where
K: Clone + Eq + Hash + PartialEq,
V: MakeRx + 'static + PartialEq,
V::Rx: MakeUnrx<Unrx = V> + Freeze + Clone,
impl<K, V> PartialEq<RxHashMapNested<K, V>> for RxHashMapNested<K, V>where K: Clone + Eq + Hash + PartialEq, V: MakeRx + 'static + PartialEq, V::Rx: MakeUnrx<Unrx = V> + Freeze + Clone,
source§fn eq(&self, other: &RxHashMapNested<K, V>) -> bool
fn eq(&self, other: &RxHashMapNested<K, V>) -> bool
self
and other
values to be equal, and is used
by ==
.source§impl<K, V> Serialize for RxHashMapNested<K, V>where
K: Clone + Eq + Hash + Serialize,
V: MakeRx + 'static + Serialize,
V::Rx: MakeUnrx<Unrx = V> + Freeze + Clone,
impl<K, V> Serialize for RxHashMapNested<K, V>where K: Clone + Eq + Hash + Serialize, V: MakeRx + 'static + Serialize, V::Rx: MakeUnrx<Unrx = V> + Freeze + Clone,
impl<K, V> Eq for RxHashMapNested<K, V>where K: Clone + Eq + Hash + Eq, V: MakeRx + 'static + Eq, V::Rx: MakeUnrx<Unrx = V> + Freeze + Clone,
impl<K, V> StructuralEq for RxHashMapNested<K, V>where K: Clone + Eq + Hash, V: MakeRx + 'static, V::Rx: MakeUnrx<Unrx = V> + Freeze + Clone,
impl<K, V> StructuralPartialEq for RxHashMapNested<K, V>where K: Clone + Eq + Hash, V: MakeRx + 'static, V::Rx: MakeUnrx<Unrx = V> + Freeze + Clone,
Auto Trait Implementations§
impl<K, V> RefUnwindSafe for RxHashMapNested<K, V>where K: RefUnwindSafe, V: RefUnwindSafe,
impl<K, V> Send for RxHashMapNested<K, V>where K: Send, V: Send,
impl<K, V> Sync for RxHashMapNested<K, V>where K: Sync, V: Sync,
impl<K, V> Unpin for RxHashMapNested<K, V>where K: Unpin, V: Unpin,
impl<K, V> UnwindSafe for RxHashMapNested<K, V>where K: UnwindSafe, V: UnwindSafe,
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<Q, K> Equivalent<K> for Qwhere
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,
impl<Q, K> Equivalent<K> for Qwhere Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,
source§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key
and return true
if they are equal.