请立即保存此密钥，关闭后将无法再次查看：
-{r.key_path} },
- {
- title: '当前值',
- dataIndex: 'current_value',
- width: 250,
- render: (_, record) => {
- if (editingId === record.id) {
- return (
- {r.target_id.substring(0, 8)}... : '-' },
- {
- title: '详情',
- dataIndex: 'details',
- width: 250,
- ellipsis: true,
- render: (_, r) => {
- if (!r.details) return '-'
- if (typeof r.details === 'string') return r.details
- return JSON.stringify(r.details)
- },
- },
- { title: 'IP 地址', dataIndex: 'ip_address', width: 130, render: (_, r) => {r.ip_address || '-'} },
- {
- title: '时间',
- dataIndex: 'created_at',
- width: 180,
- render: (_, r) => new Date(r.created_at).toLocaleString('zh-CN'),
- },
- ]
-
- return (
- {r.model_id} },
- { title: '别名', dataIndex: 'alias', width: 140 },
- {
- title: '服务商',
- dataIndex: 'provider_id',
- width: 140,
- render: (_, r) => {
- const provider = providersData?.items?.find((p) => p.id === r.provider_id)
- return provider?.display_name || r.provider_id.substring(0, 8)
- },
- },
- { title: '上下文窗口', dataIndex: 'context_window', width: 110, render: (_, r) => r.context_window?.toLocaleString() },
- { title: '最大输出', dataIndex: 'max_output_tokens', width: 100, render: (_, r) => r.max_output_tokens?.toLocaleString() },
- {
- title: '流式',
- dataIndex: 'supports_streaming',
- width: 70,
- render: (_, r) => r.supports_streaming ? {r.id.substring(0, 8)}... },
- {
- title: '状态',
- dataIndex: 'status',
- width: 100,
- render: (_, r) => pub use mapref::entry::Entry;pub use mapref::entry::OccupiedEntry;pub use mapref::entry::VacantEntry;DashMap using () as the value type. It uses
+methods and types which are more convenient to work with on a set.DashMap. Allows to obtain raw references to the stored values.pub struct Iter<'a, K, V, S = RandomState, M = DashMap<K, V, S>> { /* private fields */ }Iterator over a DashMap yielding immutable references.
+use dashmap::DashMap;
+
+let map = DashMap::new();
+map.insert("hello", "world");
+assert_eq!(map.iter().count(), 1);iter_next_chunk)N values. Read moreiter_advance_by)n elements. Read morenth element of the iterator. Read moreiter_intersperse)separator
+between adjacent items of the original iterator. Read moren elements. Read moren elements, or fewer
+if the underlying iterator ends sooner. Read moreiter_map_windows)f for each contiguous window of size N over
+self and returns an iterator over the outputs of f. Like slice::windows(),
+the windows during mapping overlap as well. Read moreIterator. Read moreiter_collect_into)iter_is_partitioned)true precede all those that return false. Read moreiterator_try_reduce)try_find)iter_array_chunks)N elements of the iterator at a time. Read moreiter_order_by)Iterator with those
+of another with respect to the specified comparison function. Read morePartialOrd elements of
+this Iterator with those of another. The comparison works like short-circuit
+evaluation, returning a result without comparing the remaining elements.
+As soon as an order can be determined, the evaluation stops and a result is returned. Read moreiter_order_by)Iterator with those
+of another with respect to the specified comparison function. Read moreiter_order_by)Iterator are lexicographically
+less than those of another. Read moreIterator are lexicographically
+less or equal to those of another. Read moreIterator are lexicographically
+greater than those of another. Read moreIterator are lexicographically
+greater than or equal to those of another. Read morepub struct IterMut<'a, K, V, S = RandomState, M = DashMap<K, V, S>> { /* private fields */ }Iterator over a DashMap yielding mutable references.
+use dashmap::DashMap;
+
+let map = DashMap::new();
+map.insert("Johnny", 21);
+map.iter_mut().for_each(|mut r| *r += 1);
+assert_eq!(*map.get("Johnny").unwrap(), 22);iter_next_chunk)N values. Read moreiter_advance_by)n elements. Read morenth element of the iterator. Read moreiter_intersperse)separator
+between adjacent items of the original iterator. Read moren elements. Read moren elements, or fewer
+if the underlying iterator ends sooner. Read moreiter_map_windows)f for each contiguous window of size N over
+self and returns an iterator over the outputs of f. Like slice::windows(),
+the windows during mapping overlap as well. Read moreIterator. Read moreiter_collect_into)iter_is_partitioned)true precede all those that return false. Read moreiterator_try_reduce)try_find)iter_array_chunks)N elements of the iterator at a time. Read moreiter_order_by)Iterator with those
+of another with respect to the specified comparison function. Read morePartialOrd elements of
+this Iterator with those of another. The comparison works like short-circuit
+evaluation, returning a result without comparing the remaining elements.
+As soon as an order can be determined, the evaluation stops and a result is returned. Read moreiter_order_by)Iterator with those
+of another with respect to the specified comparison function. Read moreiter_order_by)Iterator are lexicographically
+less than those of another. Read moreIterator are lexicographically
+less or equal to those of another. Read moreIterator are lexicographically
+greater than those of another. Read moreIterator are lexicographically
+greater than or equal to those of another. Read morepub struct OwningIter<K, V, S = RandomState> { /* private fields */ }Iterator over a DashMap yielding key value pairs.
+use dashmap::DashMap;
+
+let map = DashMap::new();
+map.insert("hello", "world");
+map.insert("alex", "steve");
+let pairs: Vec<(&'static str, &'static str)> = map.into_iter().collect();
+assert_eq!(pairs.len(), 2);iter_next_chunk)N values. Read moreiter_advance_by)n elements. Read morenth element of the iterator. Read moreiter_intersperse)separator between adjacent
+items of the original iterator. Read moreiter_intersperse)separator
+between adjacent items of the original iterator. Read moren elements. Read moren elements, or fewer
+if the underlying iterator ends sooner. Read moreiter_map_windows)f for each contiguous window of size N over
+self and returns an iterator over the outputs of f. Like slice::windows(),
+the windows during mapping overlap as well. Read moreIterator. Read moreiterator_try_collect)iter_collect_into)iter_is_partitioned)true precede all those that return false. Read moreiterator_try_reduce)try_find)iter_array_chunks)N elements of the iterator at a time. Read moreiter_order_by)Iterator with those
+of another with respect to the specified comparison function. Read morePartialOrd elements of
+this Iterator with those of another. The comparison works like short-circuit
+evaluation, returning a result without comparing the remaining elements.
+As soon as an order can be determined, the evaluation stops and a result is returned. Read moreiter_order_by)Iterator with those
+of another with respect to the specified comparison function. Read moreiter_order_by)Iterator are lexicographically
+less than those of another. Read moreIterator are lexicographically
+less or equal to those of another. Read moreIterator are lexicographically
+greater than those of another. Read moreIterator are lexicographically
+greater than or equal to those of another. Read morepub struct Iter<'a, K, S, M> { /* private fields */ }iter_next_chunk)N values. Read moreiter_advance_by)n elements. Read morenth element of the iterator. Read moreiter_intersperse)separator
+between adjacent items of the original iterator. Read moren elements. Read moren elements, or fewer
+if the underlying iterator ends sooner. Read moreiter_map_windows)f for each contiguous window of size N over
+self and returns an iterator over the outputs of f. Like slice::windows(),
+the windows during mapping overlap as well. Read moreIterator. Read moreiter_collect_into)iter_is_partitioned)true precede all those that return false. Read moreiterator_try_reduce)try_find)iter_array_chunks)N elements of the iterator at a time. Read moreiter_order_by)Iterator with those
+of another with respect to the specified comparison function. Read morePartialOrd elements of
+this Iterator with those of another. The comparison works like short-circuit
+evaluation, returning a result without comparing the remaining elements.
+As soon as an order can be determined, the evaluation stops and a result is returned. Read moreiter_order_by)Iterator with those
+of another with respect to the specified comparison function. Read moreiter_order_by)Iterator are lexicographically
+less than those of another. Read moreIterator are lexicographically
+less or equal to those of another. Read moreIterator are lexicographically
+greater than those of another. Read moreIterator are lexicographically
+greater than or equal to those of another. Read morepub struct OwningIter<K, S> { /* private fields */ }iter_next_chunk)N values. Read moreiter_advance_by)n elements. Read morenth element of the iterator. Read moreiter_intersperse)separator between adjacent
+items of the original iterator. Read moreiter_intersperse)separator
+between adjacent items of the original iterator. Read moren elements. Read moren elements, or fewer
+if the underlying iterator ends sooner. Read moreiter_map_windows)f for each contiguous window of size N over
+self and returns an iterator over the outputs of f. Like slice::windows(),
+the windows during mapping overlap as well. Read moreIterator. Read moreiterator_try_collect)iter_collect_into)iter_is_partitioned)true precede all those that return false. Read moreiterator_try_reduce)try_find)iter_array_chunks)N elements of the iterator at a time. Read moreiter_order_by)Iterator with those
+of another with respect to the specified comparison function. Read morePartialOrd elements of
+this Iterator with those of another. The comparison works like short-circuit
+evaluation, returning a result without comparing the remaining elements.
+As soon as an order can be determined, the evaluation stops and a result is returned. Read moreiter_order_by)Iterator with those
+of another with respect to the specified comparison function. Read moreiter_order_by)Iterator are lexicographically
+less than those of another. Read moreIterator are lexicographically
+less or equal to those of another. Read moreIterator are lexicographically
+greater than those of another. Read moreIterator are lexicographically
+greater than or equal to those of another. Read morepub enum Entry<'a, K, V> {
+ Occupied(OccupiedEntry<'a, K, V>),
+ Vacant(VacantEntry<'a, K, V>),
+}Apply a function to the stored value if it exists.
+Return a mutable reference to the element if it exists, +otherwise insert the default and return a mutable reference to that.
+Return a mutable reference to the element if it exists, +otherwise a provided value and return a mutable reference to that.
+Return a mutable reference to the element if it exists, +otherwise insert the result of a provided function and return a mutable reference to that.
+Sets the value of the entry, and returns a reference to the inserted value.
+Sets the value of the entry, and returns an OccupiedEntry.
+If you are not interested in the occupied entry,
+consider insert as it doesn’t need to clone the key.
pub struct OccupiedEntry<'a, K, V> { /* private fields */ }pub struct VacantEntry<'a, K, V> { /* private fields */ }pub struct RefMulti<'a, K, V> { /* private fields */ }pub struct RefMutMulti<'a, K, V> { /* private fields */ }pub struct MappedRef<'a, K, V, T> { /* private fields */ }pub struct MappedRefMut<'a, K, V, T> { /* private fields */ }pub struct Ref<'a, K, V> { /* private fields */ }pub struct RefMut<'a, K, V> { /* private fields */ }Redirecting to ../../dashmap/struct.ReadOnlyView.html...
+ + + \ No newline at end of file diff --git a/target/doc/dashmap/set/struct.DashSet.html b/target/doc/dashmap/set/struct.DashSet.html new file mode 100644 index 0000000..cb863a1 --- /dev/null +++ b/target/doc/dashmap/set/struct.DashSet.html @@ -0,0 +1,11 @@ + + + + +Redirecting to ../../dashmap/struct.DashSet.html...
+ + + \ No newline at end of file diff --git a/target/doc/dashmap/setref/index.html b/target/doc/dashmap/setref/index.html new file mode 100644 index 0000000..e928026 --- /dev/null +++ b/target/doc/dashmap/setref/index.html @@ -0,0 +1 @@ +pub struct RefMulti<'a, K> { /* private fields */ }pub struct Ref<'a, K> { /* private fields */ }pub struct DashMap<K, V, S = RandomState> { /* private fields */ }DashMap is an implementation of a concurrent associative array/hashmap in Rust.
+DashMap tries to implement an easy to use API similar to std::collections::HashMap
+with some slight changes to handle concurrency.
DashMap tries to be very simple to use and to be a direct replacement for RwLock<HashMap<K, V>>.
+To accomplish this, all methods take &self instead of modifying methods taking &mut self.
+This allows you to put a DashMap in an Arc<T> and share it between threads while being able to modify it.
Documentation mentioning locking behaviour acts in the reference frame of the calling thread. +This means that it is safe to ignore it across multiple threads.
+Creates a new DashMap with a capacity of 0.
+use dashmap::DashMap;
+
+let reviews = DashMap::new();
+reviews.insert("Veloren", "What a fantastic game!");Creates a new DashMap with a specified starting capacity.
+use dashmap::DashMap;
+
+let mappings = DashMap::with_capacity(2);
+mappings.insert(2, 4);
+mappings.insert(8, 16);Creates a new DashMap with a specified shard amount
+shard_amount should greater than 0 and be a power of two. +If a shard_amount which is not a power of two is provided, the function will panic.
+use dashmap::DashMap;
+
+let mappings = DashMap::with_shard_amount(32);
+mappings.insert(2, 4);
+mappings.insert(8, 16);Creates a new DashMap with a specified capacity and shard amount.
+shard_amount should greater than 0 and be a power of two. +If a shard_amount which is not a power of two is provided, the function will panic.
+use dashmap::DashMap;
+
+let mappings = DashMap::with_capacity_and_shard_amount(32, 32);
+mappings.insert(2, 4);
+mappings.insert(8, 16);Wraps this DashMap into a read-only view. This view allows to obtain raw references to the stored values.
Creates a new DashMap with a capacity of 0 and the provided hasher.
+use dashmap::DashMap;
+use std::collections::hash_map::RandomState;
+
+let s = RandomState::new();
+let reviews = DashMap::with_hasher(s);
+reviews.insert("Veloren", "What a fantastic game!");Creates a new DashMap with a specified starting capacity and hasher.
+use dashmap::DashMap;
+use std::collections::hash_map::RandomState;
+
+let s = RandomState::new();
+let mappings = DashMap::with_capacity_and_hasher(2, s);
+mappings.insert(2, 4);
+mappings.insert(8, 16);Creates a new DashMap with a specified hasher and shard amount
+shard_amount should be greater than 0 and a power of two. +If a shard_amount which is not a power of two is provided, the function will panic.
+use dashmap::DashMap;
+use std::collections::hash_map::RandomState;
+
+let s = RandomState::new();
+let mappings = DashMap::with_hasher_and_shard_amount(s, 32);
+mappings.insert(2, 4);
+mappings.insert(8, 16);Creates a new DashMap with a specified starting capacity, hasher and shard_amount.
+shard_amount should greater than 0 and be a power of two. +If a shard_amount which is not a power of two is provided, the function will panic.
+use dashmap::DashMap;
+use std::collections::hash_map::RandomState;
+
+let s = RandomState::new();
+let mappings = DashMap::with_capacity_and_hasher_and_shard_amount(2, s, 32);
+mappings.insert(2, 4);
+mappings.insert(8, 16);Hash a given item to produce a usize. +Uses the provided or default HashBuilder.
+Returns a reference to the map’s BuildHasher.
use dashmap::DashMap;
+use std::collections::hash_map::RandomState;
+
+let hasher = RandomState::new();
+let map: DashMap<i32, i32> = DashMap::new();
+let hasher: &RandomState = map.hasher();Inserts a key and a value into the map. Returns the old value associated with the key if there was one.
+Locking behaviour: May deadlock if called when holding any sort of reference into the map.
+use dashmap::DashMap;
+
+let map = DashMap::new();
+map.insert("I am the key!", "And I am the value!");Removes an entry from the map, returning the key and value if they existed in the map.
+Locking behaviour: May deadlock if called when holding any sort of reference into the map.
+use dashmap::DashMap;
+
+let soccer_team = DashMap::new();
+soccer_team.insert("Jack", "Goalie");
+assert_eq!(soccer_team.remove("Jack").unwrap().1, "Goalie");Removes an entry from the map, returning the key and value +if the entry existed and the provided conditional function returned true.
+Locking behaviour: May deadlock if called when holding any sort of reference into the map.
+ +use dashmap::DashMap;
+
+let soccer_team = DashMap::new();
+soccer_team.insert("Sam", "Forward");
+soccer_team.remove_if("Sam", |_, position| position == &"Goalie");
+assert!(soccer_team.contains_key("Sam"));use dashmap::DashMap;
+
+let soccer_team = DashMap::new();
+soccer_team.insert("Sam", "Forward");
+soccer_team.remove_if("Sam", |_, position| position == &"Forward");
+assert!(!soccer_team.contains_key("Sam"));Creates an iterator over a DashMap yielding immutable references.
+Locking behaviour: May deadlock if called when holding a mutable reference into the map.
+use dashmap::DashMap;
+
+let words = DashMap::new();
+words.insert("hello", "world");
+assert_eq!(words.iter().count(), 1);Iterator over a DashMap yielding mutable references.
+Locking behaviour: May deadlock if called when holding any sort of reference into the map.
+use dashmap::DashMap;
+
+let map = DashMap::new();
+map.insert("Johnny", 21);
+map.iter_mut().for_each(|mut r| *r += 1);
+assert_eq!(*map.get("Johnny").unwrap(), 22);Get an immutable reference to an entry in the map
+Locking behaviour: May deadlock if called when holding a mutable reference into the map.
+use dashmap::DashMap;
+
+let youtubers = DashMap::new();
+youtubers.insert("Bosnian Bill", 457000);
+assert_eq!(*youtubers.get("Bosnian Bill").unwrap(), 457000);Get a mutable reference to an entry in the map
+Locking behaviour: May deadlock if called when holding any sort of reference into the map.
+use dashmap::DashMap;
+
+let class = DashMap::new();
+class.insert("Albin", 15);
+*class.get_mut("Albin").unwrap() -= 1;
+assert_eq!(*class.get("Albin").unwrap(), 14);Get an immutable reference to an entry in the map, if the shard is not locked. +If the shard is locked, the function will return TryResult::Locked.
+use dashmap::DashMap;
+use dashmap::try_result::TryResult;
+
+let map = DashMap::new();
+map.insert("Johnny", 21);
+
+assert_eq!(*map.try_get("Johnny").unwrap(), 21);
+
+let _result1_locking = map.get_mut("Johnny");
+
+let result2 = map.try_get("Johnny");
+assert!(result2.is_locked());Get a mutable reference to an entry in the map, if the shard is not locked. +If the shard is locked, the function will return TryResult::Locked.
+use dashmap::DashMap;
+use dashmap::try_result::TryResult;
+
+let map = DashMap::new();
+map.insert("Johnny", 21);
+
+*map.try_get_mut("Johnny").unwrap() += 1;
+assert_eq!(*map.get("Johnny").unwrap(), 22);
+
+let _result1_locking = map.get("Johnny");
+
+let result2 = map.try_get_mut("Johnny");
+assert!(result2.is_locked());Remove excess capacity to reduce memory usage.
+Locking behaviour: May deadlock if called when holding any sort of reference into the map.
+use dashmap::DashMap;
+use dashmap::try_result::TryResult;
+
+let map = DashMap::new();
+map.insert("Johnny", 21);
+assert!(map.capacity() > 0);
+map.remove("Johnny");
+map.shrink_to_fit();
+assert_eq!(map.capacity(), 0);Retain elements that whose predicates return true +and discard elements whose predicates return false.
+Locking behaviour: May deadlock if called when holding any sort of reference into the map.
+use dashmap::DashMap;
+
+let people = DashMap::new();
+people.insert("Albin", 15);
+people.insert("Jones", 22);
+people.insert("Charlie", 27);
+people.retain(|_, v| *v > 20);
+assert_eq!(people.len(), 2);Fetches the total number of key-value pairs stored in the map.
+Locking behaviour: May deadlock if called when holding a mutable reference into the map.
+use dashmap::DashMap;
+
+let people = DashMap::new();
+people.insert("Albin", 15);
+people.insert("Jones", 22);
+people.insert("Charlie", 27);
+assert_eq!(people.len(), 3);Checks if the map is empty or not.
+Locking behaviour: May deadlock if called when holding a mutable reference into the map.
+use dashmap::DashMap;
+
+let map = DashMap::<(), ()>::new();
+assert!(map.is_empty());Removes all key-value pairs in the map.
+Locking behaviour: May deadlock if called when holding any sort of reference into the map.
+use dashmap::DashMap;
+
+let stats = DashMap::new();
+stats.insert("Goals", 4);
+assert!(!stats.is_empty());
+stats.clear();
+assert!(stats.is_empty());Returns how many key-value pairs the map can store without reallocating.
+Locking behaviour: May deadlock if called when holding a mutable reference into the map.
+Modify a specific value according to a function.
+Locking behaviour: May deadlock if called when holding any sort of reference into the map.
+use dashmap::DashMap;
+
+let stats = DashMap::new();
+stats.insert("Goals", 4);
+stats.alter("Goals", |_, v| v * 2);
+assert_eq!(*stats.get("Goals").unwrap(), 8);If the given closure panics, then alter will abort the process
Modify every value in the map according to a function.
+Locking behaviour: May deadlock if called when holding any sort of reference into the map.
+use dashmap::DashMap;
+
+let stats = DashMap::new();
+stats.insert("Wins", 4);
+stats.insert("Losses", 2);
+stats.alter_all(|_, v| v + 1);
+assert_eq!(*stats.get("Wins").unwrap(), 5);
+assert_eq!(*stats.get("Losses").unwrap(), 3);If the given closure panics, then alter_all will abort the process
Scoped access into an item of the map according to a function.
+Locking behaviour: May deadlock if called when holding any sort of reference into the map.
+use dashmap::DashMap;
+
+let warehouse = DashMap::new();
+warehouse.insert(4267, ("Banana", 100));
+warehouse.insert(2359, ("Pear", 120));
+let fruit = warehouse.view(&4267, |_k, v| *v);
+assert_eq!(fruit, Some(("Banana", 100)));If the given closure panics, then view will abort the process
Checks if the map contains a specific key.
+Locking behaviour: May deadlock if called when holding a mutable reference into the map.
+use dashmap::DashMap;
+
+let team_sizes = DashMap::new();
+team_sizes.insert("Dakota Cherries", 23);
+assert!(team_sizes.contains_key("Dakota Cherries"));Advanced entry API that tries to mimic std::collections::HashMap.
+See the documentation on dashmap::mapref::entry for more details.
Locking behaviour: May deadlock if called when holding any sort of reference into the map.
+Advanced entry API that tries to mimic std::collections::HashMap.
+See the documentation on dashmap::mapref::entry for more details.
Returns None if the shard is currently locked.
+Advanced entry API that tries to mimic std::collections::HashMap::try_reserve.
+Tries to reserve capacity for at least shard * additional
+and may reserve more space to avoid frequent reallocations.
If the capacity overflows, or the allocator reports a failure, then an error is returned.
+extend_one)extend_one)pub struct DashSet<K, S = RandomState> { /* private fields */ }DashSet is a thin wrapper around DashMap using () as the value type. It uses
+methods and types which are more convenient to work with on a set.
Creates a new DashSet with a capacity of 0.
+use dashmap::DashSet;
+
+let games = DashSet::new();
+games.insert("Veloren");Creates a new DashMap with a specified starting capacity.
+use dashmap::DashSet;
+
+let numbers = DashSet::with_capacity(2);
+numbers.insert(2);
+numbers.insert(8);Creates a new DashMap with a capacity of 0 and the provided hasher.
+use dashmap::DashSet;
+use std::collections::hash_map::RandomState;
+
+let s = RandomState::new();
+let games = DashSet::with_hasher(s);
+games.insert("Veloren");Creates a new DashMap with a specified starting capacity and hasher.
+use dashmap::DashSet;
+use std::collections::hash_map::RandomState;
+
+let s = RandomState::new();
+let numbers = DashSet::with_capacity_and_hasher(2, s);
+numbers.insert(2);
+numbers.insert(8);Hash a given item to produce a usize. +Uses the provided or default HashBuilder.
+Inserts a key into the set. Returns true if the key was not already in the set.
+use dashmap::DashSet;
+
+let set = DashSet::new();
+set.insert("I am the key!");Removes an entry from the map, returning the key if it existed in the map.
+use dashmap::DashSet;
+
+let soccer_team = DashSet::new();
+soccer_team.insert("Jack");
+assert_eq!(soccer_team.remove("Jack").unwrap(), "Jack");Removes an entry from the set, returning the key +if the entry existed and the provided conditional function returned true.
+ +use dashmap::DashSet;
+
+let soccer_team = DashSet::new();
+soccer_team.insert("Sam");
+soccer_team.remove_if("Sam", |player| player.starts_with("Ja"));
+assert!(soccer_team.contains("Sam"));use dashmap::DashSet;
+
+let soccer_team = DashSet::new();
+soccer_team.insert("Sam");
+soccer_team.remove_if("Jacob", |player| player.starts_with("Ja"));
+assert!(!soccer_team.contains("Jacob"));Creates an iterator over a DashMap yielding immutable references.
+use dashmap::DashSet;
+
+let words = DashSet::new();
+words.insert("hello");
+assert_eq!(words.iter().count(), 1);Get a reference to an entry in the set
+use dashmap::DashSet;
+
+let youtubers = DashSet::new();
+youtubers.insert("Bosnian Bill");
+assert_eq!(*youtubers.get("Bosnian Bill").unwrap(), "Bosnian Bill");Remove excess capacity to reduce memory usage.
+Retain elements that whose predicates return true +and discard elements whose predicates return false.
+use dashmap::DashSet;
+
+let people = DashSet::new();
+people.insert("Albin");
+people.insert("Jones");
+people.insert("Charlie");
+people.retain(|name| name.contains('i'));
+assert_eq!(people.len(), 2);Fetches the total number of keys stored in the set.
+use dashmap::DashSet;
+
+let people = DashSet::new();
+people.insert("Albin");
+people.insert("Jones");
+people.insert("Charlie");
+assert_eq!(people.len(), 3);Checks if the set is empty or not.
+use dashmap::DashSet;
+
+let map = DashSet::<()>::new();
+assert!(map.is_empty());Removes all keys in the set.
+use dashmap::DashSet;
+
+let people = DashSet::new();
+people.insert("Albin");
+assert!(!people.is_empty());
+people.clear();
+assert!(people.is_empty());extend_one)extend_one)pub struct ReadOnlyView<K, V, S = RandomState> { /* private fields */ }A read-only view into a DashMap. Allows to obtain raw references to the stored values.
Consumes this ReadOnlyView, returning the underlying DashMap.
Returns the number of elements the map can hold without reallocating.
+Returns true if the map contains a value for the specified key.
Returns a reference to the value corresponding to the key.
+Returns the key-value pair corresponding to the supplied key.
+An iterator visiting all key-value pairs in arbitrary order. The iterator element type is (&'a K, &'a V).
#[non_exhaustive]pub struct TryReserveError {}source. Read moreRedirecting to ../../dashmap/trait.Map.html...
+ + + \ No newline at end of file diff --git a/target/doc/dashmap/trait.Map.html b/target/doc/dashmap/trait.Map.html new file mode 100644 index 0000000..d73bbea --- /dev/null +++ b/target/doc/dashmap/trait.Map.html @@ -0,0 +1,135 @@ +pub trait Map<'a, K: 'a + Eq + Hash, V: 'a, S: 'a + Clone + BuildHasher> {
+Show 29 methods
// Required methods
+ fn _shard_count(&self) -> usize;
+ unsafe fn _get_read_shard(
+ &'a self,
+ i: usize,
+ ) -> &'a RawTable<(K, SharedValue<V>)>;
+ unsafe fn _yield_read_shard(
+ &'a self,
+ i: usize,
+ ) -> RwLockReadGuard<'a, RawRwLock, RawTable<(K, SharedValue<V>)>>;
+ unsafe fn _yield_write_shard(
+ &'a self,
+ i: usize,
+ ) -> RwLockWriteGuard<'a, RawRwLock, RawTable<(K, SharedValue<V>)>>;
+ unsafe fn _try_yield_read_shard(
+ &'a self,
+ i: usize,
+ ) -> Option<RwLockReadGuard<'a, RawRwLock, RawTable<(K, SharedValue<V>)>>>;
+ unsafe fn _try_yield_write_shard(
+ &'a self,
+ i: usize,
+ ) -> Option<RwLockWriteGuard<'a, RawRwLock, RawTable<(K, SharedValue<V>)>>>;
+ fn _insert(&self, key: K, value: V) -> Option<V>;
+ fn _remove<Q>(&self, key: &Q) -> Option<(K, V)>
+ where K: Borrow<Q>,
+ Q: Hash + Eq + ?Sized;
+ fn _remove_if<Q>(
+ &self,
+ key: &Q,
+ f: impl FnOnce(&K, &V) -> bool,
+ ) -> Option<(K, V)>
+ where K: Borrow<Q>,
+ Q: Hash + Eq + ?Sized;
+ fn _remove_if_mut<Q>(
+ &self,
+ key: &Q,
+ f: impl FnOnce(&K, &mut V) -> bool,
+ ) -> Option<(K, V)>
+ where K: Borrow<Q>,
+ Q: Hash + Eq + ?Sized;
+ fn _iter(&'a self) -> Iter<'a, K, V, S, Self> ⓘ
+ where Self: Sized;
+ fn _iter_mut(&'a self) -> IterMut<'a, K, V, S, Self> ⓘ
+ where Self: Sized;
+ fn _get<Q>(&'a self, key: &Q) -> Option<Ref<'a, K, V>>
+ where K: Borrow<Q>,
+ Q: Hash + Eq + ?Sized;
+ fn _get_mut<Q>(&'a self, key: &Q) -> Option<RefMut<'a, K, V>>
+ where K: Borrow<Q>,
+ Q: Hash + Eq + ?Sized;
+ fn _try_get<Q>(&'a self, key: &Q) -> TryResult<Ref<'a, K, V>>
+ where K: Borrow<Q>,
+ Q: Hash + Eq + ?Sized;
+ fn _try_get_mut<Q>(&'a self, key: &Q) -> TryResult<RefMut<'a, K, V>>
+ where K: Borrow<Q>,
+ Q: Hash + Eq + ?Sized;
+ fn _shrink_to_fit(&self);
+ fn _retain(&self, f: impl FnMut(&K, &mut V) -> bool);
+ fn _len(&self) -> usize;
+ fn _capacity(&self) -> usize;
+ fn _alter<Q>(&self, key: &Q, f: impl FnOnce(&K, V) -> V)
+ where K: Borrow<Q>,
+ Q: Hash + Eq + ?Sized;
+ fn _alter_all(&self, f: impl FnMut(&K, V) -> V);
+ fn _view<Q, R>(&self, key: &Q, f: impl FnOnce(&K, &V) -> R) -> Option<R>
+ where K: Borrow<Q>,
+ Q: Hash + Eq + ?Sized;
+ fn _entry(&'a self, key: K) -> Entry<'a, K, V>;
+ fn _try_entry(&'a self, key: K) -> Option<Entry<'a, K, V>>;
+ fn _hasher(&self) -> S;
+
+ // Provided methods
+ fn _clear(&self) { ... }
+ fn _contains_key<Q>(&'a self, key: &Q) -> bool
+ where K: Borrow<Q>,
+ Q: Hash + Eq + ?Sized { ... }
+ fn _is_empty(&self) -> bool { ... }
+}Implementation detail that is exposed due to generic constraints in public types.
+The index must not be out of bounds.
+The index must not be out of bounds.
+The index must not be out of bounds.
+The index must not be out of bounds.
+The index must not be out of bounds.
+This trait is not dyn compatible.
In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.
pub enum TryResult<R> {
+ Present(R),
+ Absent,
+ Locked,
+}Represents the result of a non-blocking read from a DashMap.
+The value was present in the map, and the lock for the shard was successfully obtained.
+The shard wasn’t locked, and the value wasn’t present in the map.
+The shard was locked.
+Returns true if the value was present in the map, and the lock for the shard was successfully obtained.
Returns true if the shard wasn’t locked, and the value wasn’t present in the map.
U::from(self).00000000000000000000000000CiAn iterator visiting all key-value pairs in arbitrary \xe2\x80\xa6CiCreates an iterator over a DashMap yielding immutable \xe2\x80\xa60CdReturns an iterator over the parameters in the list.CiAn iterator visiting all keys in arbitrary order. The \xe2\x80\xa6ChScoped access into an item of the map according to a \xe2\x80\xa6CjThe existing route that the insertion is conflicting with.CmA successful match consisting of the registered value and \xe2\x80\xa6C`Modify a specific value according to a function.AlRemoves all keys in the set.BgRemoves all key-value pairs in the map.BjAdvanced entry API that tries to mimic \xe2\x80\xa6BhThe value stored under the matched node.CmThe shard wasn\xe2\x80\x99t locked, and the value wasn\xe2\x80\x99t present \xe2\x80\xa6AeThe shard was locked.BoA list of parameters returned by a route match.mA URL router.CjTries to find a value in the router matching the given \xe2\x80\xa6ClReturns a reference to the map\xe2\x80\x99s BuildHasher.CkInserts a key into the set. Returns true if the key was \xe2\x80\xa6CkInserts a key and a value into the map. Returns the old \xe2\x80\xa6CkSets the value of the entry, and returns a reference to \xe2\x80\xa6oInsert a route.CfThe route parameters. See parameters for more details.CjRemoves an entry from the map, returning the key if it \xe2\x80\xa6CnRemoves an entry from the map, returning the key and value \xe2\x80\xa6CiRetain elements that whose predicates return true and \xe2\x80\xa60DjIf self is Present, returns the reference to the value in \xe2\x80\xa6CkAn iterator visiting all values in arbitrary order. The \xe2\x80\xa6ClDashMap is an implementation of a concurrent associative \xe2\x80\xa6EfDashSet is a thin wrapper around DashMap using () as the \xe2\x80\xa6CdIterator over a DashMap yielding mutable references.CjThe value was present in the map, and the lock for the \xe2\x80\xa6BnGet a mutable reference to an entry in the mapAdmatchitCmGet an immutable reference to an entry in the map, if the \xe2\x80\xa6CnAttempted to insert a path that conflicts with an existing \xe2\x80\xa6AlNo matching route was found.CkReturns the number of elements the map can hold without \xe2\x80\xa6CcReturns how many keys the set can store without \xe2\x80\xa6CnReturns how many key-value pairs the map can store without \xe2\x80\xa6BjChecks if the set contains a specific key.AjInto the key of the entry.CjReturns true if the map contains no elements.BbChecks if the set is empty or not.BbChecks if the map is empty or not.DaReturns true if there are no parameters in the list.?CnRepresents the result of a non-blocking read from a DashMap\xe2\x80\xa6CfModify every value in the map according to a function.DiReturns true if the shard wasn\xe2\x80\x99t locked, and the value \xe2\x80\xa6CbReturns true if the shard was locked.CkReturn a mutable reference to the element if it exists, \xe2\x80\xa6CkRemoves an entry from the set, returning the key if the \xe2\x80\xa6CnRemoves an entry from the map, returning the key and value \xe2\x80\xa6BjAdvanced entry API that tries to mimic \xe2\x80\xa6AgA failed match attempt.CaIterator over a DashMap yielding key value pairs.CgAn iterator over the keys and values of a route\xe2\x80\x99s \xe2\x80\xa6CbApply a function to the stored value if it exists.CnHash a given item to produce a usize. Uses the provided or \xe2\x80\xa60DeConsumes this ReadOnlyView, returning the underlying \xe2\x80\xa6DjReturns true if the value was present in the map, and the \xe2\x80\xa6:DjIf self is Present, returns the reference to the value in \xe2\x80\xa6CiRepresents errors that can occur when inserting a new \xe2\x80\xa6CjGet a mutable reference to an entry in the map, if the \xe2\x80\xa6:CfCreates a new DashMap with a capacity of 0 and the \xe2\x80\xa60DfA read-only view into a DashMap. Allows to obtain raw \xe2\x80\xa6BjParameters must be registered with a name.DkReturns true if the map contains a value for the specified \xe2\x80\xa6BjChecks if the map contains a specific key.CjSets the value of the entry, and returns an OccupiedEntry.CmSets the value of the entry with the VacantEntry\xe2\x80\x99s key, \xe2\x80\xa6C`Only one parameter per route segment is allowed.ClReturns the key-value pair corresponding to the supplied \xe2\x80\xa6BnRemove excess capacity to reduce memory usage.0CiCreates a new DashMap with a specified starting capacity.0DkWraps this DashMap into a read-only view. This view allows \xe2\x80\xa6CkReturn a mutable reference to the element if it exists, \xe2\x80\xa6CkCatch-all parameters are only allowed at the end of a path.fSafety0CcCreates a new DashMap with a specified shard amountBeThe path had an extra trailing slash.2BfThe path was missing a trailing slash.33ClCreates a new DashMap with a specified starting capacity \xe2\x80\xa60CkCreates a new DashMap with a specified hasher and shard \xe2\x80\xa6CmCreates a new DashMap with a specified capacity and shard \xe2\x80\xa6CmCreates a new DashMap with a specified starting capacity, \xe2\x80\xa6")
\ No newline at end of file
diff --git a/target/doc/search.index/desc/e4d1511a12ae.js b/target/doc/search.index/desc/e4d1511a12ae.js
deleted file mode 100644
index 1c8f6d5..0000000
--- a/target/doc/search.index/desc/e4d1511a12ae.js
+++ /dev/null
@@ -1 +0,0 @@
-rd_("CjTries to find a value in the router matching the given \xe2\x80\xa6CmReturns the value of the first parameter registered under \xe2\x80\xa6BaReturns the number of parameters.AgConstruct a new router.AoReturns the argument unchanged.00000BaCalls U::from(self).00000CdReturns an iterator over the parameters in the list.CjThe existing route that the insertion is conflicting with.CmA successful match consisting of the registered value and \xe2\x80\xa6BhThe value stored under the matched node.BoA list of parameters returned by a route match.mA URL router.;oInsert a route.CfThe route parameters. See parameters for more details.AdmatchitCnAttempted to insert a path that conflicts with an existing \xe2\x80\xa6AlNo matching route was found.DaReturns true if there are no parameters in the list.AgA failed match attempt.CgAn iterator over the keys and values of a route\xe2\x80\x99s \xe2\x80\xa6CiRepresents errors that can occur when inserting a new \xe2\x80\xa6BjParameters must be registered with a name.C`Only one parameter per route segment is allowed.CkCatch-all parameters are only allowed at the end of a path.BeThe path had an extra trailing slash.BfThe path was missing a trailing slash.")
\ No newline at end of file
diff --git a/target/doc/search.index/entry/2fa75484f6ba.js b/target/doc/search.index/entry/2fa75484f6ba.js
new file mode 100644
index 0000000..19779c3
--- /dev/null
+++ b/target/doc/search.index/entry/2fa75484f6ba.js
@@ -0,0 +1 @@
+rd_("Ah[307,13,308,280,222,0,0]Aj[301,13,302,302,591,445,0]Aj[307,13,308,199,545,445,0]Aj[307,13,308,199,484,445,0]Aj[307,13,308,273,218,445,0]Ad[301,10,302,1,0,0,0]Ab[301,5,65,0,0,0,0]Ab[301,5,66,0,0,0,0]Ai[307,13,308,199,545,13,0]Ai[307,13,308,273,218,13,0]Aj[301,13,302,472,559,165,0]Ai[301,13,302,69,286,165,0]Aj[301,13,302,302,285,165,0]Aj[301,13,302,302,591,165,0]Ag[301,13,65,65,14,165,0]Ah[301,13,65,65,219,165,0]Dd[301,13,65,65,444,165,0,\"impl-Debug-for-MappedRef%3C\'a,+K,+V,+T%3E\"]Df[301,13,65,65,444,288,0,\"impl-Display-for-MappedRef%3C\'a,+K,+V,+T%3E\"]Ah[301,13,65,65,558,165,0]Aj[301,13,540,540,446,165,0]Cg[307,13,308,199,545,165,0,\"impl-Debug-for-InsertError\"]Ci[307,13,308,199,545,288,0,\"impl-Display-for-InsertError\"]Cf[307,13,308,199,484,165,0,\"impl-Debug-for-MatchError\"]Ch[307,13,308,199,484,288,0,\"impl-Display-for-MatchError\"]Aj[307,13,308,273,218,165,0]Aj[307,13,308,280,170,165,0]Ah[301,13,302,472,559,0,0]Ag[301,13,302,69,286,0,0]Ah[301,13,302,302,285,0,0]Ah[301,13,198,198,572,0,0]Ah[307,13,308,273,218,0,0]Ah[301,13,198,198,168,0,0]Ah[301,13,198,198,549,0,0]3Ah[301,13,372,372,350,0,0]Ah[301,13,372,372,547,0,0]Ae[301,13,65,65,14,0,0]Af[301,13,65,65,219,0,0]Af[301,13,65,65,444,0,0]Af[301,13,65,65,558,0,0]Ah[301,13,373,373,351,0,0]Ae[301,13,66,66,15,0,0]>=<:5432=1use super::mapref::multiple::{RefMulti, RefMutMulti};
+2use crate::lock::{RwLockReadGuard, RwLockWriteGuard};
+3use crate::t::Map;
+4use crate::util::SharedValue;
+5use crate::{DashMap, HashMap};
+6use core::hash::{BuildHasher, Hash};
+7use core::mem;
+8use std::collections::hash_map::RandomState;
+9use std::marker::PhantomData;
+10use std::sync::Arc;
+11
+12/// Iterator over a DashMap yielding key value pairs.
+13///
+14/// # Examples
+15///
+16/// ```
+17/// use dashmap::DashMap;
+18///
+19/// let map = DashMap::new();
+20/// map.insert("hello", "world");
+21/// map.insert("alex", "steve");
+22/// let pairs: Vec<(&'static str, &'static str)> = map.into_iter().collect();
+23/// assert_eq!(pairs.len(), 2);
+24/// ```
+25pub struct OwningIter<K, V, S = RandomState> {
+26 map: DashMap<K, V, S>,
+27 shard_i: usize,
+28 current: Option<GuardOwningIter<K, V>>,
+29}
+30
+31impl<K: Eq + Hash, V, S: BuildHasher + Clone> OwningIter<K, V, S> {
+32 pub(crate) fn new(map: DashMap<K, V, S>) -> Self {
+33 Self {
+34 map,
+35 shard_i: 0,
+36 current: None,
+37 }
+38 }
+39}
+40
+41type GuardOwningIter<K, V> = hashbrown::raw::RawIntoIter<(K, SharedValue<V>)>;
+42
+43impl<K: Eq + Hash, V, S: BuildHasher + Clone> Iterator for OwningIter<K, V, S> {
+44 type Item = (K, V);
+45
+46 fn next(&mut self) -> Option<Self::Item> {
+47 loop {
+48 if let Some(current) = self.current.as_mut() {
+49 if let Some((k, v)) = current.next() {
+50 return Some((k, v.into_inner()));
+51 }
+52 }
+53
+54 if self.shard_i == self.map._shard_count() {
+55 return None;
+56 }
+57
+58 //let guard = unsafe { self.map._yield_read_shard(self.shard_i) };
+59 let mut shard_wl = unsafe { self.map._yield_write_shard(self.shard_i) };
+60
+61 let map = mem::take(&mut *shard_wl);
+62
+63 drop(shard_wl);
+64
+65 let iter = map.into_iter();
+66
+67 //unsafe { ptr::write(&mut self.current, Some((arcee, iter))); }
+68 self.current = Some(iter);
+69
+70 self.shard_i += 1;
+71 }
+72 }
+73}
+74
+75unsafe impl<K, V, S> Send for OwningIter<K, V, S>
+76where
+77 K: Eq + Hash + Send,
+78 V: Send,
+79 S: BuildHasher + Clone + Send,
+80{
+81}
+82
+83unsafe impl<K, V, S> Sync for OwningIter<K, V, S>
+84where
+85 K: Eq + Hash + Sync,
+86 V: Sync,
+87 S: BuildHasher + Clone + Sync,
+88{
+89}
+90
+91type GuardIter<'a, K, V> = (
+92 Arc<RwLockReadGuard<'a, HashMap<K, V>>>,
+93 hashbrown::raw::RawIter<(K, SharedValue<V>)>,
+94);
+95
+96type GuardIterMut<'a, K, V> = (
+97 Arc<RwLockWriteGuard<'a, HashMap<K, V>>>,
+98 hashbrown::raw::RawIter<(K, SharedValue<V>)>,
+99);
+100
+101/// Iterator over a DashMap yielding immutable references.
+102///
+103/// # Examples
+104///
+105/// ```
+106/// use dashmap::DashMap;
+107///
+108/// let map = DashMap::new();
+109/// map.insert("hello", "world");
+110/// assert_eq!(map.iter().count(), 1);
+111/// ```
+112pub struct Iter<'a, K, V, S = RandomState, M = DashMap<K, V, S>> {
+113 map: &'a M,
+114 shard_i: usize,
+115 current: Option<GuardIter<'a, K, V>>,
+116 marker: PhantomData<S>,
+117}
+118
+119impl<'i, K: Clone + Hash + Eq, V: Clone, S: Clone + BuildHasher> Clone for Iter<'i, K, V, S> {
+120 fn clone(&self) -> Self {
+121 Iter::new(self.map)
+122 }
+123}
+124
+125unsafe impl<'a, 'i, K, V, S, M> Send for Iter<'i, K, V, S, M>
+126where
+127 K: 'a + Eq + Hash + Send,
+128 V: 'a + Send,
+129 S: 'a + BuildHasher + Clone,
+130 M: Map<'a, K, V, S>,
+131{
+132}
+133
+134unsafe impl<'a, 'i, K, V, S, M> Sync for Iter<'i, K, V, S, M>
+135where
+136 K: 'a + Eq + Hash + Sync,
+137 V: 'a + Sync,
+138 S: 'a + BuildHasher + Clone,
+139 M: Map<'a, K, V, S>,
+140{
+141}
+142
+143impl<'a, K: Eq + Hash, V, S: 'a + BuildHasher + Clone, M: Map<'a, K, V, S>> Iter<'a, K, V, S, M> {
+144 pub(crate) fn new(map: &'a M) -> Self {
+145 Self {
+146 map,
+147 shard_i: 0,
+148 current: None,
+149 marker: PhantomData,
+150 }
+151 }
+152}
+153
+154impl<'a, K: Eq + Hash, V, S: 'a + BuildHasher + Clone, M: Map<'a, K, V, S>> Iterator
+155 for Iter<'a, K, V, S, M>
+156{
+157 type Item = RefMulti<'a, K, V>;
+158
+159 fn next(&mut self) -> Option<Self::Item> {
+160 loop {
+161 if let Some(current) = self.current.as_mut() {
+162 if let Some(b) = current.1.next() {
+163 return unsafe {
+164 let (k, v) = b.as_ref();
+165 let guard = current.0.clone();
+166 Some(RefMulti::new(guard, k, v.get()))
+167 };
+168 }
+169 }
+170
+171 if self.shard_i == self.map._shard_count() {
+172 return None;
+173 }
+174
+175 let guard = unsafe { self.map._yield_read_shard(self.shard_i) };
+176
+177 let iter = unsafe { guard.iter() };
+178
+179 self.current = Some((Arc::new(guard), iter));
+180
+181 self.shard_i += 1;
+182 }
+183 }
+184}
+185
+186/// Iterator over a DashMap yielding mutable references.
+187///
+188/// # Examples
+189///
+190/// ```
+191/// use dashmap::DashMap;
+192///
+193/// let map = DashMap::new();
+194/// map.insert("Johnny", 21);
+195/// map.iter_mut().for_each(|mut r| *r += 1);
+196/// assert_eq!(*map.get("Johnny").unwrap(), 22);
+197/// ```
+198pub struct IterMut<'a, K, V, S = RandomState, M = DashMap<K, V, S>> {
+199 map: &'a M,
+200 shard_i: usize,
+201 current: Option<GuardIterMut<'a, K, V>>,
+202 marker: PhantomData<S>,
+203}
+204
+205unsafe impl<'a, 'i, K, V, S, M> Send for IterMut<'i, K, V, S, M>
+206where
+207 K: 'a + Eq + Hash + Send,
+208 V: 'a + Send,
+209 S: 'a + BuildHasher + Clone,
+210 M: Map<'a, K, V, S>,
+211{
+212}
+213
+214unsafe impl<'a, 'i, K, V, S, M> Sync for IterMut<'i, K, V, S, M>
+215where
+216 K: 'a + Eq + Hash + Sync,
+217 V: 'a + Sync,
+218 S: 'a + BuildHasher + Clone,
+219 M: Map<'a, K, V, S>,
+220{
+221}
+222
+223impl<'a, K: Eq + Hash, V, S: 'a + BuildHasher + Clone, M: Map<'a, K, V, S>>
+224 IterMut<'a, K, V, S, M>
+225{
+226 pub(crate) fn new(map: &'a M) -> Self {
+227 Self {
+228 map,
+229 shard_i: 0,
+230 current: None,
+231 marker: PhantomData,
+232 }
+233 }
+234}
+235
+236impl<'a, K: Eq + Hash, V, S: 'a + BuildHasher + Clone, M: Map<'a, K, V, S>> Iterator
+237 for IterMut<'a, K, V, S, M>
+238{
+239 type Item = RefMutMulti<'a, K, V>;
+240
+241 fn next(&mut self) -> Option<Self::Item> {
+242 loop {
+243 if let Some(current) = self.current.as_mut() {
+244 if let Some(b) = current.1.next() {
+245 return unsafe {
+246 let (k, v) = b.as_mut();
+247 let guard = current.0.clone();
+248 Some(RefMutMulti::new(guard, k, v.get_mut()))
+249 };
+250 }
+251 }
+252
+253 if self.shard_i == self.map._shard_count() {
+254 return None;
+255 }
+256
+257 let guard = unsafe { self.map._yield_write_shard(self.shard_i) };
+258
+259 let iter = unsafe { guard.iter() };
+260
+261 self.current = Some((Arc::new(guard), iter));
+262
+263 self.shard_i += 1;
+264 }
+265 }
+266}
+267
+268#[cfg(test)]
+269mod tests {
+270 use crate::DashMap;
+271
+272 #[test]
+273 fn iter_mut_manual_count() {
+274 let map = DashMap::new();
+275
+276 map.insert("Johnny", 21);
+277
+278 assert_eq!(map.len(), 1);
+279
+280 let mut c = 0;
+281
+282 for shard in map.shards() {
+283 c += unsafe { shard.write().iter().count() };
+284 }
+285
+286 assert_eq!(c, 1);
+287 }
+288
+289 #[test]
+290 fn iter_mut_count() {
+291 let map = DashMap::new();
+292
+293 map.insert("Johnny", 21);
+294
+295 assert_eq!(map.len(), 1);
+296
+297 assert_eq!(map.iter_mut().count(), 1);
+298 }
+299
+300 #[test]
+301 fn iter_count() {
+302 let map = DashMap::new();
+303
+304 map.insert("Johnny", 21);
+305
+306 assert_eq!(map.len(), 1);
+307
+308 assert_eq!(map.iter().count(), 1);
+309 }
+310}
+1use crate::setref::multiple::RefMulti;
+2use crate::t::Map;
+3use core::hash::{BuildHasher, Hash};
+4
+5pub struct OwningIter<K, S> {
+6 inner: crate::iter::OwningIter<K, (), S>,
+7}
+8
+9impl<K: Eq + Hash, S: BuildHasher + Clone> OwningIter<K, S> {
+10 pub(crate) fn new(inner: crate::iter::OwningIter<K, (), S>) -> Self {
+11 Self { inner }
+12 }
+13}
+14
+15impl<K: Eq + Hash, S: BuildHasher + Clone> Iterator for OwningIter<K, S> {
+16 type Item = K;
+17
+18 fn next(&mut self) -> Option<Self::Item> {
+19 self.inner.next().map(|(k, _)| k)
+20 }
+21}
+22
+23unsafe impl<K, S> Send for OwningIter<K, S>
+24where
+25 K: Eq + Hash + Send,
+26 S: BuildHasher + Clone + Send,
+27{
+28}
+29
+30unsafe impl<K, S> Sync for OwningIter<K, S>
+31where
+32 K: Eq + Hash + Sync,
+33 S: BuildHasher + Clone + Sync,
+34{
+35}
+36
+37pub struct Iter<'a, K, S, M> {
+38 inner: crate::iter::Iter<'a, K, (), S, M>,
+39}
+40
+41unsafe impl<'a, 'i, K, S, M> Send for Iter<'i, K, S, M>
+42where
+43 K: 'a + Eq + Hash + Send,
+44 S: 'a + BuildHasher + Clone,
+45 M: Map<'a, K, (), S>,
+46{
+47}
+48
+49unsafe impl<'a, 'i, K, S, M> Sync for Iter<'i, K, S, M>
+50where
+51 K: 'a + Eq + Hash + Sync,
+52 S: 'a + BuildHasher + Clone,
+53 M: Map<'a, K, (), S>,
+54{
+55}
+56
+57impl<'a, K: Eq + Hash, S: 'a + BuildHasher + Clone, M: Map<'a, K, (), S>> Iter<'a, K, S, M> {
+58 pub(crate) fn new(inner: crate::iter::Iter<'a, K, (), S, M>) -> Self {
+59 Self { inner }
+60 }
+61}
+62
+63impl<'a, K: Eq + Hash, S: 'a + BuildHasher + Clone, M: Map<'a, K, (), S>> Iterator
+64 for Iter<'a, K, S, M>
+65{
+66 type Item = RefMulti<'a, K>;
+67
+68 fn next(&mut self) -> Option<Self::Item> {
+69 self.inner.next().map(RefMulti::new)
+70 }
+71}
+1#![allow(clippy::type_complexity)]
+2
+3#[cfg(feature = "arbitrary")]
+4mod arbitrary;
+5pub mod iter;
+6pub mod iter_set;
+7mod lock;
+8pub mod mapref;
+9mod read_only;
+10#[cfg(feature = "serde")]
+11mod serde;
+12mod set;
+13pub mod setref;
+14mod t;
+15pub mod try_result;
+16mod util;
+17
+18#[cfg(feature = "rayon")]
+19pub mod rayon {
+20 pub mod map;
+21 pub mod read_only;
+22 pub mod set;
+23}
+24
+25#[cfg(not(feature = "raw-api"))]
+26use crate::lock::{RwLock, RwLockReadGuard, RwLockWriteGuard};
+27
+28#[cfg(feature = "raw-api")]
+29pub use crate::lock::{RawRwLock, RwLock, RwLockReadGuard, RwLockWriteGuard};
+30
+31use cfg_if::cfg_if;
+32use core::borrow::Borrow;
+33use core::fmt;
+34use core::hash::{BuildHasher, Hash, Hasher};
+35use core::iter::FromIterator;
+36use core::ops::{BitAnd, BitOr, Shl, Shr, Sub};
+37use crossbeam_utils::CachePadded;
+38use iter::{Iter, IterMut, OwningIter};
+39pub use mapref::entry::{Entry, OccupiedEntry, VacantEntry};
+40use mapref::multiple::RefMulti;
+41use mapref::one::{Ref, RefMut};
+42use once_cell::sync::OnceCell;
+43pub use read_only::ReadOnlyView;
+44pub use set::DashSet;
+45use std::collections::hash_map::RandomState;
+46pub use t::Map;
+47use try_result::TryResult;
+48
+49cfg_if! {
+50 if #[cfg(feature = "raw-api")] {
+51 pub use util::SharedValue;
+52 } else {
+53 use util::SharedValue;
+54 }
+55}
+56
+57pub(crate) type HashMap<K, V> = hashbrown::raw::RawTable<(K, SharedValue<V>)>;
+58
+59// Temporary reimplementation of [`std::collections::TryReserveError`]
+60// util [`std::collections::TryReserveError`] stabilises.
+61// We cannot easily create `std::collections` error type from `hashbrown` error type
+62// without access to `TryReserveError::kind` method.
+63#[non_exhaustive]
+64#[derive(Clone, PartialEq, Eq, Debug)]
+65pub struct TryReserveError {}
+66
+67fn default_shard_amount() -> usize {
+68 static DEFAULT_SHARD_AMOUNT: OnceCell<usize> = OnceCell::new();
+69 *DEFAULT_SHARD_AMOUNT.get_or_init(|| {
+70 (std::thread::available_parallelism().map_or(1, usize::from) * 4).next_power_of_two()
+71 })
+72}
+73
+74fn ncb(shard_amount: usize) -> usize {
+75 shard_amount.trailing_zeros() as usize
+76}
+77
+78/// DashMap is an implementation of a concurrent associative array/hashmap in Rust.
+79///
+80/// DashMap tries to implement an easy to use API similar to `std::collections::HashMap`
+81/// with some slight changes to handle concurrency.
+82///
+83/// DashMap tries to be very simple to use and to be a direct replacement for `RwLock<HashMap<K, V>>`.
+84/// To accomplish this, all methods take `&self` instead of modifying methods taking `&mut self`.
+85/// This allows you to put a DashMap in an `Arc<T>` and share it between threads while being able to modify it.
+86///
+87/// Documentation mentioning locking behaviour acts in the reference frame of the calling thread.
+88/// This means that it is safe to ignore it across multiple threads.
+89pub struct DashMap<K, V, S = RandomState> {
+90 shift: usize,
+91 shards: Box<[CachePadded<RwLock<HashMap<K, V>>>]>,
+92 hasher: S,
+93}
+94
+95impl<K: Eq + Hash + Clone, V: Clone, S: Clone> Clone for DashMap<K, V, S> {
+96 fn clone(&self) -> Self {
+97 let mut inner_shards = Vec::new();
+98
+99 for shard in self.shards.iter() {
+100 let shard = shard.read();
+101
+102 inner_shards.push(CachePadded::new(RwLock::new((*shard).clone())));
+103 }
+104
+105 Self {
+106 shift: self.shift,
+107 shards: inner_shards.into_boxed_slice(),
+108 hasher: self.hasher.clone(),
+109 }
+110 }
+111}
+112
+113impl<K, V, S> Default for DashMap<K, V, S>
+114where
+115 K: Eq + Hash,
+116 S: Default + BuildHasher + Clone,
+117{
+118 fn default() -> Self {
+119 Self::with_hasher(Default::default())
+120 }
+121}
+122
+123impl<'a, K: 'a + Eq + Hash, V: 'a> DashMap<K, V, RandomState> {
+124 /// Creates a new DashMap with a capacity of 0.
+125 ///
+126 /// # Examples
+127 ///
+128 /// ```
+129 /// use dashmap::DashMap;
+130 ///
+131 /// let reviews = DashMap::new();
+132 /// reviews.insert("Veloren", "What a fantastic game!");
+133 /// ```
+134 pub fn new() -> Self {
+135 DashMap::with_hasher(RandomState::default())
+136 }
+137
+138 /// Creates a new DashMap with a specified starting capacity.
+139 ///
+140 /// # Examples
+141 ///
+142 /// ```
+143 /// use dashmap::DashMap;
+144 ///
+145 /// let mappings = DashMap::with_capacity(2);
+146 /// mappings.insert(2, 4);
+147 /// mappings.insert(8, 16);
+148 /// ```
+149 pub fn with_capacity(capacity: usize) -> Self {
+150 DashMap::with_capacity_and_hasher(capacity, RandomState::default())
+151 }
+152
+153 /// Creates a new DashMap with a specified shard amount
+154 ///
+155 /// shard_amount should greater than 0 and be a power of two.
+156 /// If a shard_amount which is not a power of two is provided, the function will panic.
+157 ///
+158 /// # Examples
+159 ///
+160 /// ```
+161 /// use dashmap::DashMap;
+162 ///
+163 /// let mappings = DashMap::with_shard_amount(32);
+164 /// mappings.insert(2, 4);
+165 /// mappings.insert(8, 16);
+166 /// ```
+167 pub fn with_shard_amount(shard_amount: usize) -> Self {
+168 Self::with_capacity_and_hasher_and_shard_amount(0, RandomState::default(), shard_amount)
+169 }
+170
+171 /// Creates a new DashMap with a specified capacity and shard amount.
+172 ///
+173 /// shard_amount should greater than 0 and be a power of two.
+174 /// If a shard_amount which is not a power of two is provided, the function will panic.
+175 ///
+176 /// # Examples
+177 ///
+178 /// ```
+179 /// use dashmap::DashMap;
+180 ///
+181 /// let mappings = DashMap::with_capacity_and_shard_amount(32, 32);
+182 /// mappings.insert(2, 4);
+183 /// mappings.insert(8, 16);
+184 /// ```
+185 pub fn with_capacity_and_shard_amount(capacity: usize, shard_amount: usize) -> Self {
+186 Self::with_capacity_and_hasher_and_shard_amount(
+187 capacity,
+188 RandomState::default(),
+189 shard_amount,
+190 )
+191 }
+192}
+193
+194impl<'a, K: 'a + Eq + Hash, V: 'a, S: BuildHasher + Clone> DashMap<K, V, S> {
+195 /// Wraps this `DashMap` into a read-only view. This view allows to obtain raw references to the stored values.
+196 pub fn into_read_only(self) -> ReadOnlyView<K, V, S> {
+197 ReadOnlyView::new(self)
+198 }
+199
+200 /// Creates a new DashMap with a capacity of 0 and the provided hasher.
+201 ///
+202 /// # Examples
+203 ///
+204 /// ```
+205 /// use dashmap::DashMap;
+206 /// use std::collections::hash_map::RandomState;
+207 ///
+208 /// let s = RandomState::new();
+209 /// let reviews = DashMap::with_hasher(s);
+210 /// reviews.insert("Veloren", "What a fantastic game!");
+211 /// ```
+212 pub fn with_hasher(hasher: S) -> Self {
+213 Self::with_capacity_and_hasher(0, hasher)
+214 }
+215
+216 /// Creates a new DashMap with a specified starting capacity and hasher.
+217 ///
+218 /// # Examples
+219 ///
+220 /// ```
+221 /// use dashmap::DashMap;
+222 /// use std::collections::hash_map::RandomState;
+223 ///
+224 /// let s = RandomState::new();
+225 /// let mappings = DashMap::with_capacity_and_hasher(2, s);
+226 /// mappings.insert(2, 4);
+227 /// mappings.insert(8, 16);
+228 /// ```
+229 pub fn with_capacity_and_hasher(capacity: usize, hasher: S) -> Self {
+230 Self::with_capacity_and_hasher_and_shard_amount(capacity, hasher, default_shard_amount())
+231 }
+232
+233 /// Creates a new DashMap with a specified hasher and shard amount
+234 ///
+235 /// shard_amount should be greater than 0 and a power of two.
+236 /// If a shard_amount which is not a power of two is provided, the function will panic.
+237 ///
+238 /// # Examples
+239 ///
+240 /// ```
+241 /// use dashmap::DashMap;
+242 /// use std::collections::hash_map::RandomState;
+243 ///
+244 /// let s = RandomState::new();
+245 /// let mappings = DashMap::with_hasher_and_shard_amount(s, 32);
+246 /// mappings.insert(2, 4);
+247 /// mappings.insert(8, 16);
+248 /// ```
+249 pub fn with_hasher_and_shard_amount(hasher: S, shard_amount: usize) -> Self {
+250 Self::with_capacity_and_hasher_and_shard_amount(0, hasher, shard_amount)
+251 }
+252
+253 /// Creates a new DashMap with a specified starting capacity, hasher and shard_amount.
+254 ///
+255 /// shard_amount should greater than 0 and be a power of two.
+256 /// If a shard_amount which is not a power of two is provided, the function will panic.
+257 ///
+258 /// # Examples
+259 ///
+260 /// ```
+261 /// use dashmap::DashMap;
+262 /// use std::collections::hash_map::RandomState;
+263 ///
+264 /// let s = RandomState::new();
+265 /// let mappings = DashMap::with_capacity_and_hasher_and_shard_amount(2, s, 32);
+266 /// mappings.insert(2, 4);
+267 /// mappings.insert(8, 16);
+268 /// ```
+269 pub fn with_capacity_and_hasher_and_shard_amount(
+270 mut capacity: usize,
+271 hasher: S,
+272 shard_amount: usize,
+273 ) -> Self {
+274 assert!(shard_amount > 1);
+275 assert!(shard_amount.is_power_of_two());
+276
+277 let shift = util::ptr_size_bits() - ncb(shard_amount);
+278
+279 if capacity != 0 {
+280 capacity = (capacity + (shard_amount - 1)) & !(shard_amount - 1);
+281 }
+282
+283 let cps = capacity / shard_amount;
+284
+285 let shards = (0..shard_amount)
+286 .map(|_| CachePadded::new(RwLock::new(HashMap::with_capacity(cps))))
+287 .collect();
+288
+289 Self {
+290 shift,
+291 shards,
+292 hasher,
+293 }
+294 }
+295
+296 /// Hash a given item to produce a usize.
+297 /// Uses the provided or default HashBuilder.
+298 pub fn hash_usize<T: Hash>(&self, item: &T) -> usize {
+299 self.hash_u64(item) as usize
+300 }
+301
+302 fn hash_u64<T: Hash>(&self, item: &T) -> u64 {
+303 let mut hasher = self.hasher.build_hasher();
+304
+305 item.hash(&mut hasher);
+306
+307 hasher.finish()
+308 }
+309
+310 cfg_if! {
+311 if #[cfg(feature = "raw-api")] {
+312 /// Allows you to peek at the inner shards that store your data.
+313 /// You should probably not use this unless you know what you are doing.
+314 ///
+315 /// Requires the `raw-api` feature to be enabled.
+316 ///
+317 /// # Examples
+318 ///
+319 /// ```
+320 /// use dashmap::DashMap;
+321 ///
+322 /// let map = DashMap::<(), ()>::new();
+323 /// println!("Amount of shards: {}", map.shards().len());
+324 /// ```
+325 pub fn shards(&self) -> &[CachePadded<RwLock<HashMap<K, V>>>] {
+326 &self.shards
+327 }
+328
+329 /// Provides mutable access to the inner shards that store your data.
+330 /// You should probably not use this unless you know what you are doing.
+331 ///
+332 /// Requires the `raw-api` feature to be enabled.
+333 ///
+334 /// # Examples
+335 ///
+336 /// ```
+337 /// use dashmap::DashMap;
+338 /// use dashmap::SharedValue;
+339 /// use std::hash::{Hash, Hasher, BuildHasher};
+340 ///
+341 /// let mut map = DashMap::<i32, &'static str>::new();
+342 /// let shard_ind = map.determine_map(&42);
+343 /// let mut factory = map.hasher().clone();
+344 /// let hasher = |tuple: &(i32, SharedValue<&'static str>)| {
+345 /// let mut hasher = factory.build_hasher();
+346 /// tuple.0.hash(&mut hasher);
+347 /// hasher.finish()
+348 /// };
+349 /// let data = (42, SharedValue::new("forty two"));
+350 /// let hash = hasher(&data);
+351 /// map.shards_mut()[shard_ind].get_mut().insert(hash, data, hasher);
+352 /// assert_eq!(*map.get(&42).unwrap(), "forty two");
+353 /// ```
+354 pub fn shards_mut(&mut self) -> &mut [CachePadded<RwLock<HashMap<K, V>>>] {
+355 &mut self.shards
+356 }
+357
+358 /// Consumes this `DashMap` and returns the inner shards.
+359 /// You should probably not use this unless you know what you are doing.
+360 ///
+361 /// Requires the `raw-api` feature to be enabled.
+362 ///
+363 /// See [`DashMap::shards()`] and [`DashMap::shards_mut()`] for more information.
+364 pub fn into_shards(self) -> Box<[CachePadded<RwLock<HashMap<K, V>>>]> {
+365 self.shards
+366 }
+367 } else {
+368 #[allow(dead_code)]
+369 pub(crate) fn shards(&self) -> &[CachePadded<RwLock<HashMap<K, V>>>] {
+370 &self.shards
+371 }
+372
+373 #[allow(dead_code)]
+374 pub(crate) fn shards_mut(&mut self) -> &mut [CachePadded<RwLock<HashMap<K, V>>>] {
+375 &mut self.shards
+376 }
+377
+378 #[allow(dead_code)]
+379 pub(crate) fn into_shards(self) -> Box<[CachePadded<RwLock<HashMap<K, V>>>]> {
+380 self.shards
+381 }
+382 }
+383 }
+384
+385 cfg_if! {
+386 if #[cfg(feature = "raw-api")] {
+387 /// Finds which shard a certain key is stored in.
+388 /// You should probably not use this unless you know what you are doing.
+389 /// Note that shard selection is dependent on the default or provided HashBuilder.
+390 ///
+391 /// Requires the `raw-api` feature to be enabled.
+392 ///
+393 /// # Examples
+394 ///
+395 /// ```
+396 /// use dashmap::DashMap;
+397 ///
+398 /// let map = DashMap::new();
+399 /// map.insert("coca-cola", 1.4);
+400 /// println!("coca-cola is stored in shard: {}", map.determine_map("coca-cola"));
+401 /// ```
+402 pub fn determine_map<Q>(&self, key: &Q) -> usize
+403 where
+404 K: Borrow<Q>,
+405 Q: Hash + Eq + ?Sized,
+406 {
+407 let hash = self.hash_usize(&key);
+408 self.determine_shard(hash)
+409 }
+410 }
+411 }
+412
+413 cfg_if! {
+414 if #[cfg(feature = "raw-api")] {
+415 /// Finds which shard a certain hash is stored in.
+416 ///
+417 /// Requires the `raw-api` feature to be enabled.
+418 ///
+419 /// # Examples
+420 ///
+421 /// ```
+422 /// use dashmap::DashMap;
+423 ///
+424 /// let map: DashMap<i32, i32> = DashMap::new();
+425 /// let key = "key";
+426 /// let hash = map.hash_usize(&key);
+427 /// println!("hash is stored in shard: {}", map.determine_shard(hash));
+428 /// ```
+429 pub fn determine_shard(&self, hash: usize) -> usize {
+430 // Leave the high 7 bits for the HashBrown SIMD tag.
+431 (hash << 7) >> self.shift
+432 }
+433 } else {
+434
+435 pub(crate) fn determine_shard(&self, hash: usize) -> usize {
+436 // Leave the high 7 bits for the HashBrown SIMD tag.
+437 (hash << 7) >> self.shift
+438 }
+439 }
+440 }
+441
+442 /// Returns a reference to the map's [`BuildHasher`].
+443 ///
+444 /// # Examples
+445 ///
+446 /// ```rust
+447 /// use dashmap::DashMap;
+448 /// use std::collections::hash_map::RandomState;
+449 ///
+450 /// let hasher = RandomState::new();
+451 /// let map: DashMap<i32, i32> = DashMap::new();
+452 /// let hasher: &RandomState = map.hasher();
+453 /// ```
+454 ///
+455 /// [`BuildHasher`]: https://doc.rust-lang.org/std/hash/trait.BuildHasher.html
+456 pub fn hasher(&self) -> &S {
+457 &self.hasher
+458 }
+459
+460 /// Inserts a key and a value into the map. Returns the old value associated with the key if there was one.
+461 ///
+462 /// **Locking behaviour:** May deadlock if called when holding any sort of reference into the map.
+463 ///
+464 /// # Examples
+465 ///
+466 /// ```
+467 /// use dashmap::DashMap;
+468 ///
+469 /// let map = DashMap::new();
+470 /// map.insert("I am the key!", "And I am the value!");
+471 /// ```
+472 pub fn insert(&self, key: K, value: V) -> Option<V> {
+473 self._insert(key, value)
+474 }
+475
+476 /// Removes an entry from the map, returning the key and value if they existed in the map.
+477 ///
+478 /// **Locking behaviour:** May deadlock if called when holding any sort of reference into the map.
+479 ///
+480 /// # Examples
+481 ///
+482 /// ```
+483 /// use dashmap::DashMap;
+484 ///
+485 /// let soccer_team = DashMap::new();
+486 /// soccer_team.insert("Jack", "Goalie");
+487 /// assert_eq!(soccer_team.remove("Jack").unwrap().1, "Goalie");
+488 /// ```
+489 pub fn remove<Q>(&self, key: &Q) -> Option<(K, V)>
+490 where
+491 K: Borrow<Q>,
+492 Q: Hash + Eq + ?Sized,
+493 {
+494 self._remove(key)
+495 }
+496
+497 /// Removes an entry from the map, returning the key and value
+498 /// if the entry existed and the provided conditional function returned true.
+499 ///
+500 /// **Locking behaviour:** May deadlock if called when holding any sort of reference into the map.
+501 ///
+502 /// ```
+503 /// use dashmap::DashMap;
+504 ///
+505 /// let soccer_team = DashMap::new();
+506 /// soccer_team.insert("Sam", "Forward");
+507 /// soccer_team.remove_if("Sam", |_, position| position == &"Goalie");
+508 /// assert!(soccer_team.contains_key("Sam"));
+509 /// ```
+510 /// ```
+511 /// use dashmap::DashMap;
+512 ///
+513 /// let soccer_team = DashMap::new();
+514 /// soccer_team.insert("Sam", "Forward");
+515 /// soccer_team.remove_if("Sam", |_, position| position == &"Forward");
+516 /// assert!(!soccer_team.contains_key("Sam"));
+517 /// ```
+518 pub fn remove_if<Q>(&self, key: &Q, f: impl FnOnce(&K, &V) -> bool) -> Option<(K, V)>
+519 where
+520 K: Borrow<Q>,
+521 Q: Hash + Eq + ?Sized,
+522 {
+523 self._remove_if(key, f)
+524 }
+525
+526 pub fn remove_if_mut<Q>(&self, key: &Q, f: impl FnOnce(&K, &mut V) -> bool) -> Option<(K, V)>
+527 where
+528 K: Borrow<Q>,
+529 Q: Hash + Eq + ?Sized,
+530 {
+531 self._remove_if_mut(key, f)
+532 }
+533
+534 /// Creates an iterator over a DashMap yielding immutable references.
+535 ///
+536 /// **Locking behaviour:** May deadlock if called when holding a mutable reference into the map.
+537 ///
+538 /// # Examples
+539 ///
+540 /// ```
+541 /// use dashmap::DashMap;
+542 ///
+543 /// let words = DashMap::new();
+544 /// words.insert("hello", "world");
+545 /// assert_eq!(words.iter().count(), 1);
+546 /// ```
+547 pub fn iter(&'a self) -> Iter<'a, K, V, S, DashMap<K, V, S>> {
+548 self._iter()
+549 }
+550
+551 /// Iterator over a DashMap yielding mutable references.
+552 ///
+553 /// **Locking behaviour:** May deadlock if called when holding any sort of reference into the map.
+554 ///
+555 /// # Examples
+556 ///
+557 /// ```
+558 /// use dashmap::DashMap;
+559 ///
+560 /// let map = DashMap::new();
+561 /// map.insert("Johnny", 21);
+562 /// map.iter_mut().for_each(|mut r| *r += 1);
+563 /// assert_eq!(*map.get("Johnny").unwrap(), 22);
+564 /// ```
+565 pub fn iter_mut(&'a self) -> IterMut<'a, K, V, S, DashMap<K, V, S>> {
+566 self._iter_mut()
+567 }
+568
+569 /// Get an immutable reference to an entry in the map
+570 ///
+571 /// **Locking behaviour:** May deadlock if called when holding a mutable reference into the map.
+572 ///
+573 /// # Examples
+574 ///
+575 /// ```
+576 /// use dashmap::DashMap;
+577 ///
+578 /// let youtubers = DashMap::new();
+579 /// youtubers.insert("Bosnian Bill", 457000);
+580 /// assert_eq!(*youtubers.get("Bosnian Bill").unwrap(), 457000);
+581 /// ```
+582 pub fn get<Q>(&'a self, key: &Q) -> Option<Ref<'a, K, V>>
+583 where
+584 K: Borrow<Q>,
+585 Q: Hash + Eq + ?Sized,
+586 {
+587 self._get(key)
+588 }
+589
+590 /// Get a mutable reference to an entry in the map
+591 ///
+592 /// **Locking behaviour:** May deadlock if called when holding any sort of reference into the map.
+593 ///
+594 /// # Examples
+595 ///
+596 /// ```
+597 /// use dashmap::DashMap;
+598 ///
+599 /// let class = DashMap::new();
+600 /// class.insert("Albin", 15);
+601 /// *class.get_mut("Albin").unwrap() -= 1;
+602 /// assert_eq!(*class.get("Albin").unwrap(), 14);
+603 /// ```
+604 pub fn get_mut<Q>(&'a self, key: &Q) -> Option<RefMut<'a, K, V>>
+605 where
+606 K: Borrow<Q>,
+607 Q: Hash + Eq + ?Sized,
+608 {
+609 self._get_mut(key)
+610 }
+611
+612 /// Get an immutable reference to an entry in the map, if the shard is not locked.
+613 /// If the shard is locked, the function will return [TryResult::Locked].
+614 ///
+615 /// # Examples
+616 ///
+617 /// ```
+618 /// use dashmap::DashMap;
+619 /// use dashmap::try_result::TryResult;
+620 ///
+621 /// let map = DashMap::new();
+622 /// map.insert("Johnny", 21);
+623 ///
+624 /// assert_eq!(*map.try_get("Johnny").unwrap(), 21);
+625 ///
+626 /// let _result1_locking = map.get_mut("Johnny");
+627 ///
+628 /// let result2 = map.try_get("Johnny");
+629 /// assert!(result2.is_locked());
+630 /// ```
+631 pub fn try_get<Q>(&'a self, key: &Q) -> TryResult<Ref<'a, K, V>>
+632 where
+633 K: Borrow<Q>,
+634 Q: Hash + Eq + ?Sized,
+635 {
+636 self._try_get(key)
+637 }
+638
+639 /// Get a mutable reference to an entry in the map, if the shard is not locked.
+640 /// If the shard is locked, the function will return [TryResult::Locked].
+641 ///
+642 /// # Examples
+643 ///
+644 /// ```
+645 /// use dashmap::DashMap;
+646 /// use dashmap::try_result::TryResult;
+647 ///
+648 /// let map = DashMap::new();
+649 /// map.insert("Johnny", 21);
+650 ///
+651 /// *map.try_get_mut("Johnny").unwrap() += 1;
+652 /// assert_eq!(*map.get("Johnny").unwrap(), 22);
+653 ///
+654 /// let _result1_locking = map.get("Johnny");
+655 ///
+656 /// let result2 = map.try_get_mut("Johnny");
+657 /// assert!(result2.is_locked());
+658 /// ```
+659 pub fn try_get_mut<Q>(&'a self, key: &Q) -> TryResult<RefMut<'a, K, V>>
+660 where
+661 K: Borrow<Q>,
+662 Q: Hash + Eq + ?Sized,
+663 {
+664 self._try_get_mut(key)
+665 }
+666
+667 /// Remove excess capacity to reduce memory usage.
+668 ///
+669 /// **Locking behaviour:** May deadlock if called when holding any sort of reference into the map.
+670 /// # Examples
+671 ///
+672 /// ```
+673 /// use dashmap::DashMap;
+674 /// use dashmap::try_result::TryResult;
+675 ///
+676 /// let map = DashMap::new();
+677 /// map.insert("Johnny", 21);
+678 /// assert!(map.capacity() > 0);
+679 /// map.remove("Johnny");
+680 /// map.shrink_to_fit();
+681 /// assert_eq!(map.capacity(), 0);
+682 /// ```
+683 pub fn shrink_to_fit(&self) {
+684 self._shrink_to_fit();
+685 }
+686
+687 /// Retain elements that whose predicates return true
+688 /// and discard elements whose predicates return false.
+689 ///
+690 /// **Locking behaviour:** May deadlock if called when holding any sort of reference into the map.
+691 ///
+692 /// # Examples
+693 ///
+694 /// ```
+695 /// use dashmap::DashMap;
+696 ///
+697 /// let people = DashMap::new();
+698 /// people.insert("Albin", 15);
+699 /// people.insert("Jones", 22);
+700 /// people.insert("Charlie", 27);
+701 /// people.retain(|_, v| *v > 20);
+702 /// assert_eq!(people.len(), 2);
+703 /// ```
+704 pub fn retain(&self, f: impl FnMut(&K, &mut V) -> bool) {
+705 self._retain(f);
+706 }
+707
+708 /// Fetches the total number of key-value pairs stored in the map.
+709 ///
+710 /// **Locking behaviour:** May deadlock if called when holding a mutable reference into the map.
+711 ///
+712 /// # Examples
+713 ///
+714 /// ```
+715 /// use dashmap::DashMap;
+716 ///
+717 /// let people = DashMap::new();
+718 /// people.insert("Albin", 15);
+719 /// people.insert("Jones", 22);
+720 /// people.insert("Charlie", 27);
+721 /// assert_eq!(people.len(), 3);
+722 /// ```
+723 pub fn len(&self) -> usize {
+724 self._len()
+725 }
+726
+727 /// Checks if the map is empty or not.
+728 ///
+729 /// **Locking behaviour:** May deadlock if called when holding a mutable reference into the map.
+730 ///
+731 /// # Examples
+732 ///
+733 /// ```
+734 /// use dashmap::DashMap;
+735 ///
+736 /// let map = DashMap::<(), ()>::new();
+737 /// assert!(map.is_empty());
+738 /// ```
+739 pub fn is_empty(&self) -> bool {
+740 self._is_empty()
+741 }
+742
+743 /// Removes all key-value pairs in the map.
+744 ///
+745 /// **Locking behaviour:** May deadlock if called when holding any sort of reference into the map.
+746 ///
+747 /// # Examples
+748 ///
+749 /// ```
+750 /// use dashmap::DashMap;
+751 ///
+752 /// let stats = DashMap::new();
+753 /// stats.insert("Goals", 4);
+754 /// assert!(!stats.is_empty());
+755 /// stats.clear();
+756 /// assert!(stats.is_empty());
+757 /// ```
+758 pub fn clear(&self) {
+759 self._clear();
+760 }
+761
+762 /// Returns how many key-value pairs the map can store without reallocating.
+763 ///
+764 /// **Locking behaviour:** May deadlock if called when holding a mutable reference into the map.
+765 pub fn capacity(&self) -> usize {
+766 self._capacity()
+767 }
+768
+769 /// Modify a specific value according to a function.
+770 ///
+771 /// **Locking behaviour:** May deadlock if called when holding any sort of reference into the map.
+772 ///
+773 /// # Examples
+774 ///
+775 /// ```
+776 /// use dashmap::DashMap;
+777 ///
+778 /// let stats = DashMap::new();
+779 /// stats.insert("Goals", 4);
+780 /// stats.alter("Goals", |_, v| v * 2);
+781 /// assert_eq!(*stats.get("Goals").unwrap(), 8);
+782 /// ```
+783 ///
+784 /// # Panics
+785 ///
+786 /// If the given closure panics, then `alter` will abort the process
+787 pub fn alter<Q>(&self, key: &Q, f: impl FnOnce(&K, V) -> V)
+788 where
+789 K: Borrow<Q>,
+790 Q: Hash + Eq + ?Sized,
+791 {
+792 self._alter(key, f);
+793 }
+794
+795 /// Modify every value in the map according to a function.
+796 ///
+797 /// **Locking behaviour:** May deadlock if called when holding any sort of reference into the map.
+798 ///
+799 /// # Examples
+800 ///
+801 /// ```
+802 /// use dashmap::DashMap;
+803 ///
+804 /// let stats = DashMap::new();
+805 /// stats.insert("Wins", 4);
+806 /// stats.insert("Losses", 2);
+807 /// stats.alter_all(|_, v| v + 1);
+808 /// assert_eq!(*stats.get("Wins").unwrap(), 5);
+809 /// assert_eq!(*stats.get("Losses").unwrap(), 3);
+810 /// ```
+811 ///
+812 /// # Panics
+813 ///
+814 /// If the given closure panics, then `alter_all` will abort the process
+815 pub fn alter_all(&self, f: impl FnMut(&K, V) -> V) {
+816 self._alter_all(f);
+817 }
+818
+819 /// Scoped access into an item of the map according to a function.
+820 ///
+821 /// **Locking behaviour:** May deadlock if called when holding any sort of reference into the map.
+822 ///
+823 /// # Examples
+824 ///
+825 /// ```
+826 /// use dashmap::DashMap;
+827 ///
+828 /// let warehouse = DashMap::new();
+829 /// warehouse.insert(4267, ("Banana", 100));
+830 /// warehouse.insert(2359, ("Pear", 120));
+831 /// let fruit = warehouse.view(&4267, |_k, v| *v);
+832 /// assert_eq!(fruit, Some(("Banana", 100)));
+833 /// ```
+834 ///
+835 /// # Panics
+836 ///
+837 /// If the given closure panics, then `view` will abort the process
+838 pub fn view<Q, R>(&self, key: &Q, f: impl FnOnce(&K, &V) -> R) -> Option<R>
+839 where
+840 K: Borrow<Q>,
+841 Q: Hash + Eq + ?Sized,
+842 {
+843 self._view(key, f)
+844 }
+845
+846 /// Checks if the map contains a specific key.
+847 ///
+848 /// **Locking behaviour:** May deadlock if called when holding a mutable reference into the map.
+849 ///
+850 /// # Examples
+851 ///
+852 /// ```
+853 /// use dashmap::DashMap;
+854 ///
+855 /// let team_sizes = DashMap::new();
+856 /// team_sizes.insert("Dakota Cherries", 23);
+857 /// assert!(team_sizes.contains_key("Dakota Cherries"));
+858 /// ```
+859 pub fn contains_key<Q>(&self, key: &Q) -> bool
+860 where
+861 K: Borrow<Q>,
+862 Q: Hash + Eq + ?Sized,
+863 {
+864 self._contains_key(key)
+865 }
+866
+867 /// Advanced entry API that tries to mimic `std::collections::HashMap`.
+868 /// See the documentation on `dashmap::mapref::entry` for more details.
+869 ///
+870 /// **Locking behaviour:** May deadlock if called when holding any sort of reference into the map.
+871 pub fn entry(&'a self, key: K) -> Entry<'a, K, V> {
+872 self._entry(key)
+873 }
+874
+875 /// Advanced entry API that tries to mimic `std::collections::HashMap`.
+876 /// See the documentation on `dashmap::mapref::entry` for more details.
+877 ///
+878 /// Returns None if the shard is currently locked.
+879 pub fn try_entry(&'a self, key: K) -> Option<Entry<'a, K, V>> {
+880 self._try_entry(key)
+881 }
+882
+883 /// Advanced entry API that tries to mimic `std::collections::HashMap::try_reserve`.
+884 /// Tries to reserve capacity for at least `shard * additional`
+885 /// and may reserve more space to avoid frequent reallocations.
+886 ///
+887 /// # Errors
+888 ///
+889 /// If the capacity overflows, or the allocator reports a failure, then an error is returned.
+890 // TODO: return std::collections::TryReserveError once std::collections::TryReserveErrorKind stabilises.
+891 pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError> {
+892 for shard in self.shards.iter() {
+893 shard
+894 .write()
+895 .try_reserve(additional, |(k, _v)| {
+896 let mut hasher = self.hasher.build_hasher();
+897 k.hash(&mut hasher);
+898 hasher.finish()
+899 })
+900 .map_err(|_| TryReserveError {})?;
+901 }
+902 Ok(())
+903 }
+904}
+905
+906impl<'a, K: 'a + Eq + Hash, V: 'a, S: 'a + BuildHasher + Clone> Map<'a, K, V, S>
+907 for DashMap<K, V, S>
+908{
+909 fn _shard_count(&self) -> usize {
+910 self.shards.len()
+911 }
+912
+913 unsafe fn _get_read_shard(&'a self, i: usize) -> &'a HashMap<K, V> {
+914 debug_assert!(i < self.shards.len());
+915
+916 &*self.shards.get_unchecked(i).data_ptr()
+917 }
+918
+919 unsafe fn _yield_read_shard(&'a self, i: usize) -> RwLockReadGuard<'a, HashMap<K, V>> {
+920 debug_assert!(i < self.shards.len());
+921
+922 self.shards.get_unchecked(i).read()
+923 }
+924
+925 unsafe fn _yield_write_shard(&'a self, i: usize) -> RwLockWriteGuard<'a, HashMap<K, V>> {
+926 debug_assert!(i < self.shards.len());
+927
+928 self.shards.get_unchecked(i).write()
+929 }
+930
+931 unsafe fn _try_yield_read_shard(
+932 &'a self,
+933 i: usize,
+934 ) -> Option<RwLockReadGuard<'a, HashMap<K, V>>> {
+935 debug_assert!(i < self.shards.len());
+936
+937 self.shards.get_unchecked(i).try_read()
+938 }
+939
+940 unsafe fn _try_yield_write_shard(
+941 &'a self,
+942 i: usize,
+943 ) -> Option<RwLockWriteGuard<'a, HashMap<K, V>>> {
+944 debug_assert!(i < self.shards.len());
+945
+946 self.shards.get_unchecked(i).try_write()
+947 }
+948
+949 fn _insert(&self, key: K, value: V) -> Option<V> {
+950 match self.entry(key) {
+951 Entry::Occupied(mut o) => Some(o.insert(value)),
+952 Entry::Vacant(v) => {
+953 v.insert(value);
+954 None
+955 }
+956 }
+957 }
+958
+959 fn _remove<Q>(&self, key: &Q) -> Option<(K, V)>
+960 where
+961 K: Borrow<Q>,
+962 Q: Hash + Eq + ?Sized,
+963 {
+964 let hash = self.hash_u64(&key);
+965
+966 let idx = self.determine_shard(hash as usize);
+967
+968 let mut shard = unsafe { self._yield_write_shard(idx) };
+969
+970 if let Some(bucket) = shard.find(hash, |(k, _v)| key == k.borrow()) {
+971 let ((k, v), _) = unsafe { shard.remove(bucket) };
+972 Some((k, v.into_inner()))
+973 } else {
+974 None
+975 }
+976 }
+977
+978 fn _remove_if<Q>(&self, key: &Q, f: impl FnOnce(&K, &V) -> bool) -> Option<(K, V)>
+979 where
+980 K: Borrow<Q>,
+981 Q: Hash + Eq + ?Sized,
+982 {
+983 let hash = self.hash_u64(&key);
+984
+985 let idx = self.determine_shard(hash as usize);
+986
+987 let mut shard = unsafe { self._yield_write_shard(idx) };
+988
+989 if let Some(bucket) = shard.find(hash, |(k, _v)| key == k.borrow()) {
+990 let (k, v) = unsafe { bucket.as_ref() };
+991 if f(k, v.get()) {
+992 let ((k, v), _) = unsafe { shard.remove(bucket) };
+993 Some((k, v.into_inner()))
+994 } else {
+995 None
+996 }
+997 } else {
+998 None
+999 }
+1000 }
+1001
+1002 fn _remove_if_mut<Q>(&self, key: &Q, f: impl FnOnce(&K, &mut V) -> bool) -> Option<(K, V)>
+1003 where
+1004 K: Borrow<Q>,
+1005 Q: Hash + Eq + ?Sized,
+1006 {
+1007 let hash = self.hash_u64(&key);
+1008
+1009 let idx = self.determine_shard(hash as usize);
+1010
+1011 let mut shard = unsafe { self._yield_write_shard(idx) };
+1012
+1013 if let Some(bucket) = shard.find(hash, |(k, _v)| key == k.borrow()) {
+1014 let (k, v) = unsafe { bucket.as_mut() };
+1015 if f(k, v.get_mut()) {
+1016 let ((k, v), _) = unsafe { shard.remove(bucket) };
+1017 Some((k, v.into_inner()))
+1018 } else {
+1019 None
+1020 }
+1021 } else {
+1022 None
+1023 }
+1024 }
+1025
+1026 fn _iter(&'a self) -> Iter<'a, K, V, S, DashMap<K, V, S>> {
+1027 Iter::new(self)
+1028 }
+1029
+1030 fn _iter_mut(&'a self) -> IterMut<'a, K, V, S, DashMap<K, V, S>> {
+1031 IterMut::new(self)
+1032 }
+1033
+1034 fn _get<Q>(&'a self, key: &Q) -> Option<Ref<'a, K, V>>
+1035 where
+1036 K: Borrow<Q>,
+1037 Q: Hash + Eq + ?Sized,
+1038 {
+1039 let hash = self.hash_u64(&key);
+1040
+1041 let idx = self.determine_shard(hash as usize);
+1042
+1043 let shard = unsafe { self._yield_read_shard(idx) };
+1044
+1045 if let Some(bucket) = shard.find(hash, |(k, _v)| key == k.borrow()) {
+1046 unsafe {
+1047 let (k, v) = bucket.as_ref();
+1048 Some(Ref::new(shard, k, v.as_ptr()))
+1049 }
+1050 } else {
+1051 None
+1052 }
+1053 }
+1054
+1055 fn _get_mut<Q>(&'a self, key: &Q) -> Option<RefMut<'a, K, V>>
+1056 where
+1057 K: Borrow<Q>,
+1058 Q: Hash + Eq + ?Sized,
+1059 {
+1060 let hash = self.hash_u64(&key);
+1061
+1062 let idx = self.determine_shard(hash as usize);
+1063
+1064 let shard = unsafe { self._yield_write_shard(idx) };
+1065
+1066 if let Some(bucket) = shard.find(hash, |(k, _v)| key == k.borrow()) {
+1067 unsafe {
+1068 let (k, v) = bucket.as_ref();
+1069 Some(RefMut::new(shard, k, v.as_ptr()))
+1070 }
+1071 } else {
+1072 None
+1073 }
+1074 }
+1075
+1076 fn _try_get<Q>(&'a self, key: &Q) -> TryResult<Ref<'a, K, V>>
+1077 where
+1078 K: Borrow<Q>,
+1079 Q: Hash + Eq + ?Sized,
+1080 {
+1081 let hash = self.hash_u64(&key);
+1082
+1083 let idx = self.determine_shard(hash as usize);
+1084
+1085 let shard = match unsafe { self._try_yield_read_shard(idx) } {
+1086 Some(shard) => shard,
+1087 None => return TryResult::Locked,
+1088 };
+1089
+1090 if let Some(bucket) = shard.find(hash, |(k, _v)| key == k.borrow()) {
+1091 unsafe {
+1092 let (k, v) = bucket.as_ref();
+1093 TryResult::Present(Ref::new(shard, k, v.as_ptr()))
+1094 }
+1095 } else {
+1096 TryResult::Absent
+1097 }
+1098 }
+1099
+1100 fn _try_get_mut<Q>(&'a self, key: &Q) -> TryResult<RefMut<'a, K, V>>
+1101 where
+1102 K: Borrow<Q>,
+1103 Q: Hash + Eq + ?Sized,
+1104 {
+1105 let hash = self.hash_u64(&key);
+1106
+1107 let idx = self.determine_shard(hash as usize);
+1108
+1109 let shard = match unsafe { self._try_yield_write_shard(idx) } {
+1110 Some(shard) => shard,
+1111 None => return TryResult::Locked,
+1112 };
+1113
+1114 if let Some(bucket) = shard.find(hash, |(k, _v)| key == k.borrow()) {
+1115 unsafe {
+1116 let (k, v) = bucket.as_ref();
+1117 TryResult::Present(RefMut::new(shard, k, v.as_ptr()))
+1118 }
+1119 } else {
+1120 TryResult::Absent
+1121 }
+1122 }
+1123
+1124 fn _shrink_to_fit(&self) {
+1125 self.shards.iter().for_each(|s| {
+1126 let mut shard = s.write();
+1127 let size = shard.len();
+1128 shard.shrink_to(size, |(k, _v)| {
+1129 let mut hasher = self.hasher.build_hasher();
+1130 k.hash(&mut hasher);
+1131 hasher.finish()
+1132 })
+1133 });
+1134 }
+1135
+1136 fn _retain(&self, mut f: impl FnMut(&K, &mut V) -> bool) {
+1137 self.shards.iter().for_each(|s| {
+1138 unsafe {
+1139 let mut shard = s.write();
+1140 // Here we only use `iter` as a temporary, preventing use-after-free
+1141 for bucket in shard.iter() {
+1142 let (k, v) = bucket.as_mut();
+1143 if !f(&*k, v.get_mut()) {
+1144 shard.erase(bucket);
+1145 }
+1146 }
+1147 }
+1148 });
+1149 }
+1150
+1151 fn _len(&self) -> usize {
+1152 self.shards.iter().map(|s| s.read().len()).sum()
+1153 }
+1154
+1155 fn _capacity(&self) -> usize {
+1156 self.shards.iter().map(|s| s.read().capacity()).sum()
+1157 }
+1158
+1159 fn _alter<Q>(&self, key: &Q, f: impl FnOnce(&K, V) -> V)
+1160 where
+1161 K: Borrow<Q>,
+1162 Q: Hash + Eq + ?Sized,
+1163 {
+1164 if let Some(mut r) = self.get_mut(key) {
+1165 util::map_in_place_2(r.pair_mut(), f);
+1166 }
+1167 }
+1168
+1169 fn _alter_all(&self, mut f: impl FnMut(&K, V) -> V) {
+1170 self.iter_mut()
+1171 .for_each(|mut m| util::map_in_place_2(m.pair_mut(), &mut f));
+1172 }
+1173
+1174 fn _view<Q, R>(&self, key: &Q, f: impl FnOnce(&K, &V) -> R) -> Option<R>
+1175 where
+1176 K: Borrow<Q>,
+1177 Q: Hash + Eq + ?Sized,
+1178 {
+1179 self.get(key).map(|r| {
+1180 let (k, v) = r.pair();
+1181 f(k, v)
+1182 })
+1183 }
+1184
+1185 fn _entry(&'a self, key: K) -> Entry<'a, K, V> {
+1186 let hash = self.hash_u64(&key);
+1187
+1188 let idx = self.determine_shard(hash as usize);
+1189
+1190 let mut shard = unsafe { self._yield_write_shard(idx) };
+1191
+1192 match shard.find_or_find_insert_slot(
+1193 hash,
+1194 |(k, _v)| k == &key,
+1195 |(k, _v)| {
+1196 let mut hasher = self.hasher.build_hasher();
+1197 k.hash(&mut hasher);
+1198 hasher.finish()
+1199 },
+1200 ) {
+1201 Ok(elem) => Entry::Occupied(unsafe { OccupiedEntry::new(shard, key, elem) }),
+1202 Err(slot) => Entry::Vacant(unsafe { VacantEntry::new(shard, key, hash, slot) }),
+1203 }
+1204 }
+1205
+1206 fn _try_entry(&'a self, key: K) -> Option<Entry<'a, K, V>> {
+1207 let hash = self.hash_u64(&key);
+1208
+1209 let idx = self.determine_shard(hash as usize);
+1210
+1211 let mut shard = match unsafe { self._try_yield_write_shard(idx) } {
+1212 Some(shard) => shard,
+1213 None => return None,
+1214 };
+1215
+1216 match shard.find_or_find_insert_slot(
+1217 hash,
+1218 |(k, _v)| k == &key,
+1219 |(k, _v)| {
+1220 let mut hasher = self.hasher.build_hasher();
+1221 k.hash(&mut hasher);
+1222 hasher.finish()
+1223 },
+1224 ) {
+1225 Ok(elem) => Some(Entry::Occupied(unsafe {
+1226 OccupiedEntry::new(shard, key, elem)
+1227 })),
+1228 Err(slot) => Some(Entry::Vacant(unsafe {
+1229 VacantEntry::new(shard, key, hash, slot)
+1230 })),
+1231 }
+1232 }
+1233
+1234 fn _hasher(&self) -> S {
+1235 self.hasher.clone()
+1236 }
+1237}
+1238
+1239impl<K: Eq + Hash + fmt::Debug, V: fmt::Debug, S: BuildHasher + Clone> fmt::Debug
+1240 for DashMap<K, V, S>
+1241{
+1242 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+1243 let mut pmap = f.debug_map();
+1244
+1245 for r in self {
+1246 let (k, v) = r.pair();
+1247
+1248 pmap.entry(k, v);
+1249 }
+1250
+1251 pmap.finish()
+1252 }
+1253}
+1254
+1255impl<'a, K: 'a + Eq + Hash, V: 'a, S: BuildHasher + Clone> Shl<(K, V)> for &'a DashMap<K, V, S> {
+1256 type Output = Option<V>;
+1257
+1258 fn shl(self, pair: (K, V)) -> Self::Output {
+1259 self.insert(pair.0, pair.1)
+1260 }
+1261}
+1262
+1263impl<'a, K: 'a + Eq + Hash, V: 'a, S: BuildHasher + Clone, Q> Shr<&Q> for &'a DashMap<K, V, S>
+1264where
+1265 K: Borrow<Q>,
+1266 Q: Hash + Eq + ?Sized,
+1267{
+1268 type Output = Ref<'a, K, V>;
+1269
+1270 fn shr(self, key: &Q) -> Self::Output {
+1271 self.get(key).unwrap()
+1272 }
+1273}
+1274
+1275impl<'a, K: 'a + Eq + Hash, V: 'a, S: BuildHasher + Clone, Q> BitOr<&Q> for &'a DashMap<K, V, S>
+1276where
+1277 K: Borrow<Q>,
+1278 Q: Hash + Eq + ?Sized,
+1279{
+1280 type Output = RefMut<'a, K, V>;
+1281
+1282 fn bitor(self, key: &Q) -> Self::Output {
+1283 self.get_mut(key).unwrap()
+1284 }
+1285}
+1286
+1287impl<'a, K: 'a + Eq + Hash, V: 'a, S: BuildHasher + Clone, Q> Sub<&Q> for &'a DashMap<K, V, S>
+1288where
+1289 K: Borrow<Q>,
+1290 Q: Hash + Eq + ?Sized,
+1291{
+1292 type Output = Option<(K, V)>;
+1293
+1294 fn sub(self, key: &Q) -> Self::Output {
+1295 self.remove(key)
+1296 }
+1297}
+1298
+1299impl<'a, K: 'a + Eq + Hash, V: 'a, S: BuildHasher + Clone, Q> BitAnd<&Q> for &'a DashMap<K, V, S>
+1300where
+1301 K: Borrow<Q>,
+1302 Q: Hash + Eq + ?Sized,
+1303{
+1304 type Output = bool;
+1305
+1306 fn bitand(self, key: &Q) -> Self::Output {
+1307 self.contains_key(key)
+1308 }
+1309}
+1310
+1311impl<K: Eq + Hash, V, S: BuildHasher + Clone> IntoIterator for DashMap<K, V, S> {
+1312 type Item = (K, V);
+1313
+1314 type IntoIter = OwningIter<K, V, S>;
+1315
+1316 fn into_iter(self) -> Self::IntoIter {
+1317 OwningIter::new(self)
+1318 }
+1319}
+1320
+1321impl<'a, K: Eq + Hash, V, S: BuildHasher + Clone> IntoIterator for &'a DashMap<K, V, S> {
+1322 type Item = RefMulti<'a, K, V>;
+1323
+1324 type IntoIter = Iter<'a, K, V, S, DashMap<K, V, S>>;
+1325
+1326 fn into_iter(self) -> Self::IntoIter {
+1327 self.iter()
+1328 }
+1329}
+1330
+1331impl<K: Eq + Hash, V, S: BuildHasher + Clone> Extend<(K, V)> for DashMap<K, V, S> {
+1332 fn extend<I: IntoIterator<Item = (K, V)>>(&mut self, intoiter: I) {
+1333 for pair in intoiter.into_iter() {
+1334 self.insert(pair.0, pair.1);
+1335 }
+1336 }
+1337}
+1338
+1339impl<K: Eq + Hash, V, S: BuildHasher + Clone + Default> FromIterator<(K, V)> for DashMap<K, V, S> {
+1340 fn from_iter<I: IntoIterator<Item = (K, V)>>(intoiter: I) -> Self {
+1341 let mut map = DashMap::default();
+1342
+1343 map.extend(intoiter);
+1344
+1345 map
+1346 }
+1347}
+1348
+1349#[cfg(feature = "typesize")]
+1350impl<K, V, S> typesize::TypeSize for DashMap<K, V, S>
+1351where
+1352 K: typesize::TypeSize + Eq + Hash,
+1353 V: typesize::TypeSize,
+1354 S: typesize::TypeSize + Clone + BuildHasher,
+1355{
+1356 fn extra_size(&self) -> usize {
+1357 let shards_extra_size: usize = self
+1358 .shards
+1359 .iter()
+1360 .map(|shard_lock| {
+1361 let shard = shard_lock.read();
+1362 let hashtable_size = shard.allocation_info().1.size();
+1363
+1364 // Safety: The iterator is dropped before the HashTable
+1365 let iter = unsafe { shard.iter() };
+1366 let entry_size_iter = iter.map(|bucket| {
+1367 // Safety: The iterator returns buckets with valid pointers to entries
+1368 let (key, value) = unsafe { bucket.as_ref() };
+1369 key.extra_size() + value.get().extra_size()
+1370 });
+1371
+1372 core::mem::size_of::<CachePadded<RwLock<HashMap<K, V>>>>()
+1373 + hashtable_size
+1374 + entry_size_iter.sum::<usize>()
+1375 })
+1376 .sum();
+1377
+1378 self.hasher.extra_size() + shards_extra_size
+1379 }
+1380
+1381 typesize::if_typesize_details! {
+1382 fn get_collection_item_count(&self) -> Option<usize> {
+1383 Some(self.len())
+1384 }
+1385 }
+1386}
+1387
+1388#[cfg(test)]
+1389mod tests {
+1390 use crate::DashMap;
+1391 use std::collections::hash_map::RandomState;
+1392
+1393 #[test]
+1394 fn test_basic() {
+1395 let dm = DashMap::new();
+1396
+1397 dm.insert(0, 0);
+1398
+1399 assert_eq!(dm.get(&0).unwrap().value(), &0);
+1400 }
+1401
+1402 #[test]
+1403 fn test_default() {
+1404 let dm: DashMap<u32, u32> = DashMap::default();
+1405
+1406 dm.insert(0, 0);
+1407
+1408 assert_eq!(dm.get(&0).unwrap().value(), &0);
+1409 }
+1410
+1411 #[test]
+1412 fn test_multiple_hashes() {
+1413 let dm: DashMap<u32, u32> = DashMap::default();
+1414
+1415 for i in 0..100 {
+1416 dm.insert(0, i);
+1417
+1418 dm.insert(i, i);
+1419 }
+1420
+1421 for i in 1..100 {
+1422 let r = dm.get(&i).unwrap();
+1423
+1424 assert_eq!(i, *r.value());
+1425
+1426 assert_eq!(i, *r.key());
+1427 }
+1428
+1429 let r = dm.get(&0).unwrap();
+1430
+1431 assert_eq!(99, *r.value());
+1432 }
+1433
+1434 #[test]
+1435 fn test_more_complex_values() {
+1436 #[derive(Hash, PartialEq, Debug, Clone)]
+1437
+1438 struct T0 {
+1439 s: String,
+1440 u: u8,
+1441 }
+1442
+1443 let dm = DashMap::new();
+1444
+1445 let range = 0..10;
+1446
+1447 for i in range {
+1448 let t = T0 {
+1449 s: i.to_string(),
+1450 u: i as u8,
+1451 };
+1452
+1453 dm.insert(i, t.clone());
+1454
+1455 assert_eq!(&t, dm.get(&i).unwrap().value());
+1456 }
+1457 }
+1458
+1459 #[test]
+1460 fn test_different_hashers_randomstate() {
+1461 let dm_hm_default: DashMap<u32, u32, RandomState> =
+1462 DashMap::with_hasher(RandomState::new());
+1463
+1464 for i in 0..10 {
+1465 dm_hm_default.insert(i, i);
+1466
+1467 assert_eq!(i, *dm_hm_default.get(&i).unwrap().value());
+1468 }
+1469 }
+1470
+1471 #[test]
+1472 fn test_map_view() {
+1473 let dm = DashMap::new();
+1474
+1475 let vegetables: [String; 4] = [
+1476 "Salad".to_string(),
+1477 "Beans".to_string(),
+1478 "Potato".to_string(),
+1479 "Tomato".to_string(),
+1480 ];
+1481
+1482 // Give it some values
+1483 dm.insert(0, "Banana".to_string());
+1484 dm.insert(4, "Pear".to_string());
+1485 dm.insert(9, "Potato".to_string());
+1486 dm.insert(12, "Chicken".to_string());
+1487
+1488 let potato_vegetableness = dm.view(&9, |_, v| vegetables.contains(v));
+1489 assert_eq!(potato_vegetableness, Some(true));
+1490
+1491 let chicken_vegetableness = dm.view(&12, |_, v| vegetables.contains(v));
+1492 assert_eq!(chicken_vegetableness, Some(false));
+1493
+1494 let not_in_map = dm.view(&30, |_k, _v| false);
+1495 assert_eq!(not_in_map, None);
+1496 }
+1497
+1498 #[test]
+1499 fn test_try_get() {
+1500 {
+1501 let map = DashMap::new();
+1502 map.insert("Johnny", 21);
+1503
+1504 assert_eq!(*map.try_get("Johnny").unwrap(), 21);
+1505
+1506 let _result1_locking = map.get_mut("Johnny");
+1507
+1508 let result2 = map.try_get("Johnny");
+1509 assert!(result2.is_locked());
+1510 }
+1511
+1512 {
+1513 let map = DashMap::new();
+1514 map.insert("Johnny", 21);
+1515
+1516 *map.try_get_mut("Johnny").unwrap() += 1;
+1517 assert_eq!(*map.get("Johnny").unwrap(), 22);
+1518
+1519 let _result1_locking = map.get("Johnny");
+1520
+1521 let result2 = map.try_get_mut("Johnny");
+1522 assert!(result2.is_locked());
+1523 }
+1524 }
+1525
+1526 #[test]
+1527 fn test_try_reserve() {
+1528 let mut map: DashMap<i32, i32> = DashMap::new();
+1529 // DashMap is empty and doesn't allocate memory
+1530 assert_eq!(map.capacity(), 0);
+1531
+1532 map.try_reserve(10).unwrap();
+1533
+1534 // And now map can hold at least 10 elements
+1535 assert!(map.capacity() >= 10);
+1536 }
+1537
+1538 #[test]
+1539 fn test_try_reserve_errors() {
+1540 let mut map: DashMap<i32, i32> = DashMap::new();
+1541
+1542 match map.try_reserve(usize::MAX) {
+1543 Err(_) => {}
+1544 _ => panic!("should have raised CapacityOverflow error"),
+1545 }
+1546 }
+1547}
+1use core::sync::atomic::{AtomicUsize, Ordering};
+2use parking_lot_core::{ParkToken, SpinWait, UnparkToken};
+3
+4pub type RwLock<T> = lock_api::RwLock<RawRwLock, T>;
+5pub type RwLockReadGuard<'a, T> = lock_api::RwLockReadGuard<'a, RawRwLock, T>;
+6pub type RwLockWriteGuard<'a, T> = lock_api::RwLockWriteGuard<'a, RawRwLock, T>;
+7
+8const READERS_PARKED: usize = 0b0001;
+9const WRITERS_PARKED: usize = 0b0010;
+10const ONE_READER: usize = 0b0100;
+11const ONE_WRITER: usize = !(READERS_PARKED | WRITERS_PARKED);
+12
+13pub struct RawRwLock {
+14 state: AtomicUsize,
+15}
+16
+17unsafe impl lock_api::RawRwLock for RawRwLock {
+18 #[allow(clippy::declare_interior_mutable_const)]
+19 const INIT: Self = Self {
+20 state: AtomicUsize::new(0),
+21 };
+22
+23 type GuardMarker = lock_api::GuardNoSend;
+24
+25 #[inline]
+26 fn try_lock_exclusive(&self) -> bool {
+27 self.state
+28 .compare_exchange(0, ONE_WRITER, Ordering::Acquire, Ordering::Relaxed)
+29 .is_ok()
+30 }
+31
+32 #[inline]
+33 fn lock_exclusive(&self) {
+34 if self
+35 .state
+36 .compare_exchange_weak(0, ONE_WRITER, Ordering::Acquire, Ordering::Relaxed)
+37 .is_err()
+38 {
+39 self.lock_exclusive_slow();
+40 }
+41 }
+42
+43 #[inline]
+44 unsafe fn unlock_exclusive(&self) {
+45 if self
+46 .state
+47 .compare_exchange(ONE_WRITER, 0, Ordering::Release, Ordering::Relaxed)
+48 .is_err()
+49 {
+50 self.unlock_exclusive_slow();
+51 }
+52 }
+53
+54 #[inline]
+55 fn try_lock_shared(&self) -> bool {
+56 self.try_lock_shared_fast() || self.try_lock_shared_slow()
+57 }
+58
+59 #[inline]
+60 fn lock_shared(&self) {
+61 if !self.try_lock_shared_fast() {
+62 self.lock_shared_slow();
+63 }
+64 }
+65
+66 #[inline]
+67 unsafe fn unlock_shared(&self) {
+68 let state = self.state.fetch_sub(ONE_READER, Ordering::Release);
+69
+70 if state == (ONE_READER | WRITERS_PARKED) {
+71 self.unlock_shared_slow();
+72 }
+73 }
+74}
+75
+76unsafe impl lock_api::RawRwLockDowngrade for RawRwLock {
+77 #[inline]
+78 unsafe fn downgrade(&self) {
+79 let state = self
+80 .state
+81 .fetch_and(ONE_READER | WRITERS_PARKED, Ordering::Release);
+82 if state & READERS_PARKED != 0 {
+83 parking_lot_core::unpark_all((self as *const _ as usize) + 1, UnparkToken(0));
+84 }
+85 }
+86}
+87
+88impl RawRwLock {
+89 #[cold]
+90 fn lock_exclusive_slow(&self) {
+91 let mut acquire_with = 0;
+92 loop {
+93 let mut spin = SpinWait::new();
+94 let mut state = self.state.load(Ordering::Relaxed);
+95
+96 loop {
+97 while state & ONE_WRITER == 0 {
+98 match self.state.compare_exchange_weak(
+99 state,
+100 state | ONE_WRITER | acquire_with,
+101 Ordering::Acquire,
+102 Ordering::Relaxed,
+103 ) {
+104 Ok(_) => return,
+105 Err(e) => state = e,
+106 }
+107 }
+108
+109 if state & WRITERS_PARKED == 0 {
+110 if spin.spin() {
+111 state = self.state.load(Ordering::Relaxed);
+112 continue;
+113 }
+114
+115 if let Err(e) = self.state.compare_exchange_weak(
+116 state,
+117 state | WRITERS_PARKED,
+118 Ordering::Relaxed,
+119 Ordering::Relaxed,
+120 ) {
+121 state = e;
+122 continue;
+123 }
+124 }
+125
+126 let _ = unsafe {
+127 parking_lot_core::park(
+128 self as *const _ as usize,
+129 || {
+130 let state = self.state.load(Ordering::Relaxed);
+131 (state & ONE_WRITER != 0) && (state & WRITERS_PARKED != 0)
+132 },
+133 || {},
+134 |_, _| {},
+135 ParkToken(0),
+136 None,
+137 )
+138 };
+139
+140 acquire_with = WRITERS_PARKED;
+141 break;
+142 }
+143 }
+144 }
+145
+146 #[cold]
+147 fn unlock_exclusive_slow(&self) {
+148 let state = self.state.load(Ordering::Relaxed);
+149 assert_eq!(state & ONE_WRITER, ONE_WRITER);
+150
+151 let mut parked = state & (READERS_PARKED | WRITERS_PARKED);
+152 assert_ne!(parked, 0);
+153
+154 if parked != (READERS_PARKED | WRITERS_PARKED) {
+155 if let Err(new_state) =
+156 self.state
+157 .compare_exchange(state, 0, Ordering::Release, Ordering::Relaxed)
+158 {
+159 assert_eq!(new_state, ONE_WRITER | READERS_PARKED | WRITERS_PARKED);
+160 parked = READERS_PARKED | WRITERS_PARKED;
+161 }
+162 }
+163
+164 if parked == (READERS_PARKED | WRITERS_PARKED) {
+165 self.state.store(WRITERS_PARKED, Ordering::Release);
+166 parked = READERS_PARKED;
+167 }
+168
+169 if parked == READERS_PARKED {
+170 return unsafe {
+171 parking_lot_core::unpark_all((self as *const _ as usize) + 1, UnparkToken(0));
+172 };
+173 }
+174
+175 assert_eq!(parked, WRITERS_PARKED);
+176 unsafe {
+177 parking_lot_core::unpark_one(self as *const _ as usize, |_| UnparkToken(0));
+178 }
+179 }
+180
+181 #[inline(always)]
+182 fn try_lock_shared_fast(&self) -> bool {
+183 let state = self.state.load(Ordering::Relaxed);
+184
+185 if let Some(new_state) = state.checked_add(ONE_READER) {
+186 if new_state & ONE_WRITER != ONE_WRITER {
+187 return self
+188 .state
+189 .compare_exchange_weak(state, new_state, Ordering::Acquire, Ordering::Relaxed)
+190 .is_ok();
+191 }
+192 }
+193
+194 false
+195 }
+196
+197 #[cold]
+198 fn try_lock_shared_slow(&self) -> bool {
+199 let mut state = self.state.load(Ordering::Relaxed);
+200
+201 while let Some(new_state) = state.checked_add(ONE_READER) {
+202 if new_state & ONE_WRITER == ONE_WRITER {
+203 break;
+204 }
+205
+206 match self.state.compare_exchange_weak(
+207 state,
+208 new_state,
+209 Ordering::Acquire,
+210 Ordering::Relaxed,
+211 ) {
+212 Ok(_) => return true,
+213 Err(e) => state = e,
+214 }
+215 }
+216
+217 false
+218 }
+219
+220 #[cold]
+221 fn lock_shared_slow(&self) {
+222 loop {
+223 let mut spin = SpinWait::new();
+224 let mut state = self.state.load(Ordering::Relaxed);
+225
+226 loop {
+227 let mut backoff = SpinWait::new();
+228 while let Some(new_state) = state.checked_add(ONE_READER) {
+229 assert_ne!(
+230 new_state & ONE_WRITER,
+231 ONE_WRITER,
+232 "reader count overflowed",
+233 );
+234
+235 if self
+236 .state
+237 .compare_exchange_weak(
+238 state,
+239 new_state,
+240 Ordering::Acquire,
+241 Ordering::Relaxed,
+242 )
+243 .is_ok()
+244 {
+245 return;
+246 }
+247
+248 backoff.spin_no_yield();
+249 state = self.state.load(Ordering::Relaxed);
+250 }
+251
+252 if state & READERS_PARKED == 0 {
+253 if spin.spin() {
+254 state = self.state.load(Ordering::Relaxed);
+255 continue;
+256 }
+257
+258 if let Err(e) = self.state.compare_exchange_weak(
+259 state,
+260 state | READERS_PARKED,
+261 Ordering::Relaxed,
+262 Ordering::Relaxed,
+263 ) {
+264 state = e;
+265 continue;
+266 }
+267 }
+268
+269 let _ = unsafe {
+270 parking_lot_core::park(
+271 (self as *const _ as usize) + 1,
+272 || {
+273 let state = self.state.load(Ordering::Relaxed);
+274 (state & ONE_WRITER == ONE_WRITER) && (state & READERS_PARKED != 0)
+275 },
+276 || {},
+277 |_, _| {},
+278 ParkToken(0),
+279 None,
+280 )
+281 };
+282
+283 break;
+284 }
+285 }
+286 }
+287
+288 #[cold]
+289 fn unlock_shared_slow(&self) {
+290 if self
+291 .state
+292 .compare_exchange(WRITERS_PARKED, 0, Ordering::Relaxed, Ordering::Relaxed)
+293 .is_ok()
+294 {
+295 unsafe {
+296 parking_lot_core::unpark_one(self as *const _ as usize, |_| UnparkToken(0));
+297 }
+298 }
+299 }
+300}
+1use super::one::RefMut;
+2use crate::lock::RwLockWriteGuard;
+3use crate::util::SharedValue;
+4use crate::HashMap;
+5use core::hash::Hash;
+6use core::mem;
+7
+8pub enum Entry<'a, K, V> {
+9 Occupied(OccupiedEntry<'a, K, V>),
+10 Vacant(VacantEntry<'a, K, V>),
+11}
+12
+13impl<'a, K: Eq + Hash, V> Entry<'a, K, V> {
+14 /// Apply a function to the stored value if it exists.
+15 pub fn and_modify(self, f: impl FnOnce(&mut V)) -> Self {
+16 match self {
+17 Entry::Occupied(mut entry) => {
+18 f(entry.get_mut());
+19
+20 Entry::Occupied(entry)
+21 }
+22
+23 Entry::Vacant(entry) => Entry::Vacant(entry),
+24 }
+25 }
+26
+27 /// Get the key of the entry.
+28 pub fn key(&self) -> &K {
+29 match *self {
+30 Entry::Occupied(ref entry) => entry.key(),
+31 Entry::Vacant(ref entry) => entry.key(),
+32 }
+33 }
+34
+35 /// Into the key of the entry.
+36 pub fn into_key(self) -> K {
+37 match self {
+38 Entry::Occupied(entry) => entry.into_key(),
+39 Entry::Vacant(entry) => entry.into_key(),
+40 }
+41 }
+42
+43 /// Return a mutable reference to the element if it exists,
+44 /// otherwise insert the default and return a mutable reference to that.
+45 pub fn or_default(self) -> RefMut<'a, K, V>
+46 where
+47 V: Default,
+48 {
+49 match self {
+50 Entry::Occupied(entry) => entry.into_ref(),
+51 Entry::Vacant(entry) => entry.insert(V::default()),
+52 }
+53 }
+54
+55 /// Return a mutable reference to the element if it exists,
+56 /// otherwise a provided value and return a mutable reference to that.
+57 pub fn or_insert(self, value: V) -> RefMut<'a, K, V> {
+58 match self {
+59 Entry::Occupied(entry) => entry.into_ref(),
+60 Entry::Vacant(entry) => entry.insert(value),
+61 }
+62 }
+63
+64 /// Return a mutable reference to the element if it exists,
+65 /// otherwise insert the result of a provided function and return a mutable reference to that.
+66 pub fn or_insert_with(self, value: impl FnOnce() -> V) -> RefMut<'a, K, V> {
+67 match self {
+68 Entry::Occupied(entry) => entry.into_ref(),
+69 Entry::Vacant(entry) => entry.insert(value()),
+70 }
+71 }
+72
+73 pub fn or_try_insert_with<E>(
+74 self,
+75 value: impl FnOnce() -> Result<V, E>,
+76 ) -> Result<RefMut<'a, K, V>, E> {
+77 match self {
+78 Entry::Occupied(entry) => Ok(entry.into_ref()),
+79 Entry::Vacant(entry) => Ok(entry.insert(value()?)),
+80 }
+81 }
+82
+83 /// Sets the value of the entry, and returns a reference to the inserted value.
+84 pub fn insert(self, value: V) -> RefMut<'a, K, V> {
+85 match self {
+86 Entry::Occupied(mut entry) => {
+87 entry.insert(value);
+88 entry.into_ref()
+89 }
+90 Entry::Vacant(entry) => entry.insert(value),
+91 }
+92 }
+93
+94 /// Sets the value of the entry, and returns an OccupiedEntry.
+95 ///
+96 /// If you are not interested in the occupied entry,
+97 /// consider [`insert`] as it doesn't need to clone the key.
+98 ///
+99 /// [`insert`]: Entry::insert
+100 pub fn insert_entry(self, value: V) -> OccupiedEntry<'a, K, V>
+101 where
+102 K: Clone,
+103 {
+104 match self {
+105 Entry::Occupied(mut entry) => {
+106 entry.insert(value);
+107 entry
+108 }
+109 Entry::Vacant(entry) => entry.insert_entry(value),
+110 }
+111 }
+112}
+113
+114pub struct VacantEntry<'a, K, V> {
+115 shard: RwLockWriteGuard<'a, HashMap<K, V>>,
+116 key: K,
+117 hash: u64,
+118 slot: hashbrown::raw::InsertSlot,
+119}
+120
+121unsafe impl<'a, K: Eq + Hash + Sync, V: Sync> Send for VacantEntry<'a, K, V> {}
+122unsafe impl<'a, K: Eq + Hash + Sync, V: Sync> Sync for VacantEntry<'a, K, V> {}
+123
+124impl<'a, K: Eq + Hash, V> VacantEntry<'a, K, V> {
+125 pub(crate) unsafe fn new(
+126 shard: RwLockWriteGuard<'a, HashMap<K, V>>,
+127 key: K,
+128 hash: u64,
+129 slot: hashbrown::raw::InsertSlot,
+130 ) -> Self {
+131 Self {
+132 shard,
+133 key,
+134 hash,
+135 slot,
+136 }
+137 }
+138
+139 pub fn insert(mut self, value: V) -> RefMut<'a, K, V> {
+140 unsafe {
+141 let occupied = self.shard.insert_in_slot(
+142 self.hash,
+143 self.slot,
+144 (self.key, SharedValue::new(value)),
+145 );
+146
+147 let (k, v) = occupied.as_ref();
+148
+149 RefMut::new(self.shard, k, v.as_ptr())
+150 }
+151 }
+152
+153 /// Sets the value of the entry with the VacantEntry’s key, and returns an OccupiedEntry.
+154 pub fn insert_entry(mut self, value: V) -> OccupiedEntry<'a, K, V>
+155 where
+156 K: Clone,
+157 {
+158 unsafe {
+159 let bucket = self.shard.insert_in_slot(
+160 self.hash,
+161 self.slot,
+162 (self.key.clone(), SharedValue::new(value)),
+163 );
+164
+165 OccupiedEntry::new(self.shard, self.key, bucket)
+166 }
+167 }
+168
+169 pub fn into_key(self) -> K {
+170 self.key
+171 }
+172
+173 pub fn key(&self) -> &K {
+174 &self.key
+175 }
+176}
+177
+178pub struct OccupiedEntry<'a, K, V> {
+179 shard: RwLockWriteGuard<'a, HashMap<K, V>>,
+180 bucket: hashbrown::raw::Bucket<(K, SharedValue<V>)>,
+181 key: K,
+182}
+183
+184unsafe impl<'a, K: Eq + Hash + Sync, V: Sync> Send for OccupiedEntry<'a, K, V> {}
+185unsafe impl<'a, K: Eq + Hash + Sync, V: Sync> Sync for OccupiedEntry<'a, K, V> {}
+186
+187impl<'a, K: Eq + Hash, V> OccupiedEntry<'a, K, V> {
+188 pub(crate) unsafe fn new(
+189 shard: RwLockWriteGuard<'a, HashMap<K, V>>,
+190 key: K,
+191 bucket: hashbrown::raw::Bucket<(K, SharedValue<V>)>,
+192 ) -> Self {
+193 Self { shard, bucket, key }
+194 }
+195
+196 pub fn get(&self) -> &V {
+197 unsafe { self.bucket.as_ref().1.get() }
+198 }
+199
+200 pub fn get_mut(&mut self) -> &mut V {
+201 unsafe { self.bucket.as_mut().1.get_mut() }
+202 }
+203
+204 pub fn insert(&mut self, value: V) -> V {
+205 mem::replace(self.get_mut(), value)
+206 }
+207
+208 pub fn into_ref(self) -> RefMut<'a, K, V> {
+209 unsafe {
+210 let (k, v) = self.bucket.as_ref();
+211 RefMut::new(self.shard, k, v.as_ptr())
+212 }
+213 }
+214
+215 pub fn into_key(self) -> K {
+216 self.key
+217 }
+218
+219 pub fn key(&self) -> &K {
+220 unsafe { &self.bucket.as_ref().0 }
+221 }
+222
+223 pub fn remove(mut self) -> V {
+224 let ((_k, v), _) = unsafe { self.shard.remove(self.bucket) };
+225 v.into_inner()
+226 }
+227
+228 pub fn remove_entry(mut self) -> (K, V) {
+229 let ((k, v), _) = unsafe { self.shard.remove(self.bucket) };
+230 (k, v.into_inner())
+231 }
+232
+233 pub fn replace_entry(self, value: V) -> (K, V) {
+234 let (k, v) = mem::replace(
+235 unsafe { self.bucket.as_mut() },
+236 (self.key, SharedValue::new(value)),
+237 );
+238 (k, v.into_inner())
+239 }
+240}
+241
+242#[cfg(test)]
+243mod tests {
+244 use crate::DashMap;
+245
+246 use super::*;
+247
+248 #[test]
+249 fn test_insert_entry_into_vacant() {
+250 let map: DashMap<u32, u32> = DashMap::new();
+251
+252 let entry = map.entry(1);
+253
+254 assert!(matches!(entry, Entry::Vacant(_)));
+255
+256 let entry = entry.insert_entry(2);
+257
+258 assert_eq!(*entry.get(), 2);
+259
+260 drop(entry);
+261
+262 assert_eq!(*map.get(&1).unwrap(), 2);
+263 }
+264
+265 #[test]
+266 fn test_insert_entry_into_occupied() {
+267 let map: DashMap<u32, u32> = DashMap::new();
+268
+269 map.insert(1, 1000);
+270
+271 let entry = map.entry(1);
+272
+273 assert!(matches!(&entry, Entry::Occupied(entry) if *entry.get() == 1000));
+274
+275 let entry = entry.insert_entry(2);
+276
+277 assert_eq!(*entry.get(), 2);
+278
+279 drop(entry);
+280
+281 assert_eq!(*map.get(&1).unwrap(), 2);
+282 }
+283}
+1use crate::lock::{RwLockReadGuard, RwLockWriteGuard};
+2use crate::HashMap;
+3use core::hash::Hash;
+4use core::ops::{Deref, DerefMut};
+5use std::sync::Arc;
+6
+7pub struct RefMulti<'a, K, V> {
+8 _guard: Arc<RwLockReadGuard<'a, HashMap<K, V>>>,
+9 k: *const K,
+10 v: *const V,
+11}
+12
+13unsafe impl<'a, K: Eq + Hash + Sync, V: Sync> Send for RefMulti<'a, K, V> {}
+14unsafe impl<'a, K: Eq + Hash + Sync, V: Sync> Sync for RefMulti<'a, K, V> {}
+15
+16impl<'a, K: Eq + Hash, V> RefMulti<'a, K, V> {
+17 pub(crate) unsafe fn new(
+18 guard: Arc<RwLockReadGuard<'a, HashMap<K, V>>>,
+19 k: *const K,
+20 v: *const V,
+21 ) -> Self {
+22 Self {
+23 _guard: guard,
+24 k,
+25 v,
+26 }
+27 }
+28
+29 pub fn key(&self) -> &K {
+30 self.pair().0
+31 }
+32
+33 pub fn value(&self) -> &V {
+34 self.pair().1
+35 }
+36
+37 pub fn pair(&self) -> (&K, &V) {
+38 unsafe { (&*self.k, &*self.v) }
+39 }
+40}
+41
+42impl<'a, K: Eq + Hash, V> Deref for RefMulti<'a, K, V> {
+43 type Target = V;
+44
+45 fn deref(&self) -> &V {
+46 self.value()
+47 }
+48}
+49
+50pub struct RefMutMulti<'a, K, V> {
+51 _guard: Arc<RwLockWriteGuard<'a, HashMap<K, V>>>,
+52 k: *const K,
+53 v: *mut V,
+54}
+55
+56unsafe impl<'a, K: Eq + Hash + Sync, V: Sync> Send for RefMutMulti<'a, K, V> {}
+57unsafe impl<'a, K: Eq + Hash + Sync, V: Sync> Sync for RefMutMulti<'a, K, V> {}
+58
+59impl<'a, K: Eq + Hash, V> RefMutMulti<'a, K, V> {
+60 pub(crate) unsafe fn new(
+61 guard: Arc<RwLockWriteGuard<'a, HashMap<K, V>>>,
+62 k: *const K,
+63 v: *mut V,
+64 ) -> Self {
+65 Self {
+66 _guard: guard,
+67 k,
+68 v,
+69 }
+70 }
+71
+72 pub fn key(&self) -> &K {
+73 self.pair().0
+74 }
+75
+76 pub fn value(&self) -> &V {
+77 self.pair().1
+78 }
+79
+80 pub fn value_mut(&mut self) -> &mut V {
+81 self.pair_mut().1
+82 }
+83
+84 pub fn pair(&self) -> (&K, &V) {
+85 unsafe { (&*self.k, &*self.v) }
+86 }
+87
+88 pub fn pair_mut(&mut self) -> (&K, &mut V) {
+89 unsafe { (&*self.k, &mut *self.v) }
+90 }
+91}
+92
+93impl<'a, K: Eq + Hash, V> Deref for RefMutMulti<'a, K, V> {
+94 type Target = V;
+95
+96 fn deref(&self) -> &V {
+97 self.value()
+98 }
+99}
+100
+101impl<'a, K: Eq + Hash, V> DerefMut for RefMutMulti<'a, K, V> {
+102 fn deref_mut(&mut self) -> &mut V {
+103 self.value_mut()
+104 }
+105}
+1use crate::lock::{RwLockReadGuard, RwLockWriteGuard};
+2use crate::HashMap;
+3use core::hash::Hash;
+4use core::ops::{Deref, DerefMut};
+5use std::fmt::{Debug, Formatter};
+6
+7pub struct Ref<'a, K, V> {
+8 _guard: RwLockReadGuard<'a, HashMap<K, V>>,
+9 k: *const K,
+10 v: *const V,
+11}
+12
+13unsafe impl<'a, K: Eq + Hash + Sync, V: Sync> Send for Ref<'a, K, V> {}
+14unsafe impl<'a, K: Eq + Hash + Sync, V: Sync> Sync for Ref<'a, K, V> {}
+15
+16impl<'a, K: Eq + Hash, V> Ref<'a, K, V> {
+17 pub(crate) unsafe fn new(
+18 guard: RwLockReadGuard<'a, HashMap<K, V>>,
+19 k: *const K,
+20 v: *const V,
+21 ) -> Self {
+22 Self {
+23 _guard: guard,
+24 k,
+25 v,
+26 }
+27 }
+28
+29 pub fn key(&self) -> &K {
+30 self.pair().0
+31 }
+32
+33 pub fn value(&self) -> &V {
+34 self.pair().1
+35 }
+36
+37 pub fn pair(&self) -> (&K, &V) {
+38 unsafe { (&*self.k, &*self.v) }
+39 }
+40
+41 pub fn map<F, T>(self, f: F) -> MappedRef<'a, K, V, T>
+42 where
+43 F: FnOnce(&V) -> &T,
+44 {
+45 MappedRef {
+46 _guard: self._guard,
+47 k: self.k,
+48 v: f(unsafe { &*self.v }),
+49 }
+50 }
+51
+52 pub fn try_map<F, T>(self, f: F) -> Result<MappedRef<'a, K, V, T>, Self>
+53 where
+54 F: FnOnce(&V) -> Option<&T>,
+55 {
+56 if let Some(v) = f(unsafe { &*self.v }) {
+57 Ok(MappedRef {
+58 _guard: self._guard,
+59 k: self.k,
+60 v,
+61 })
+62 } else {
+63 Err(self)
+64 }
+65 }
+66}
+67
+68impl<'a, K: Eq + Hash + Debug, V: Debug> Debug for Ref<'a, K, V> {
+69 fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+70 f.debug_struct("Ref")
+71 .field("k", &self.k)
+72 .field("v", &self.v)
+73 .finish()
+74 }
+75}
+76
+77impl<'a, K: Eq + Hash, V> Deref for Ref<'a, K, V> {
+78 type Target = V;
+79
+80 fn deref(&self) -> &V {
+81 self.value()
+82 }
+83}
+84
+85pub struct RefMut<'a, K, V> {
+86 guard: RwLockWriteGuard<'a, HashMap<K, V>>,
+87 k: *const K,
+88 v: *mut V,
+89}
+90
+91unsafe impl<'a, K: Eq + Hash + Sync, V: Sync> Send for RefMut<'a, K, V> {}
+92unsafe impl<'a, K: Eq + Hash + Sync, V: Sync> Sync for RefMut<'a, K, V> {}
+93
+94impl<'a, K: Eq + Hash, V> RefMut<'a, K, V> {
+95 pub(crate) unsafe fn new(
+96 guard: RwLockWriteGuard<'a, HashMap<K, V>>,
+97 k: *const K,
+98 v: *mut V,
+99 ) -> Self {
+100 Self { guard, k, v }
+101 }
+102
+103 pub fn key(&self) -> &K {
+104 self.pair().0
+105 }
+106
+107 pub fn value(&self) -> &V {
+108 self.pair().1
+109 }
+110
+111 pub fn value_mut(&mut self) -> &mut V {
+112 self.pair_mut().1
+113 }
+114
+115 pub fn pair(&self) -> (&K, &V) {
+116 unsafe { (&*self.k, &*self.v) }
+117 }
+118
+119 pub fn pair_mut(&mut self) -> (&K, &mut V) {
+120 unsafe { (&*self.k, &mut *self.v) }
+121 }
+122
+123 pub fn downgrade(self) -> Ref<'a, K, V> {
+124 unsafe { Ref::new(RwLockWriteGuard::downgrade(self.guard), self.k, self.v) }
+125 }
+126
+127 pub fn map<F, T>(self, f: F) -> MappedRefMut<'a, K, V, T>
+128 where
+129 F: FnOnce(&mut V) -> &mut T,
+130 {
+131 MappedRefMut {
+132 _guard: self.guard,
+133 k: self.k,
+134 v: f(unsafe { &mut *self.v }),
+135 }
+136 }
+137
+138 pub fn try_map<F, T>(self, f: F) -> Result<MappedRefMut<'a, K, V, T>, Self>
+139 where
+140 F: FnOnce(&mut V) -> Option<&mut T>,
+141 {
+142 let v = match f(unsafe { &mut *(self.v as *mut _) }) {
+143 Some(v) => v,
+144 None => return Err(self),
+145 };
+146 let guard = self.guard;
+147 let k = self.k;
+148 Ok(MappedRefMut {
+149 _guard: guard,
+150 k,
+151 v,
+152 })
+153 }
+154}
+155
+156impl<'a, K: Eq + Hash + Debug, V: Debug> Debug for RefMut<'a, K, V> {
+157 fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+158 f.debug_struct("RefMut")
+159 .field("k", &self.k)
+160 .field("v", &self.v)
+161 .finish()
+162 }
+163}
+164
+165impl<'a, K: Eq + Hash, V> Deref for RefMut<'a, K, V> {
+166 type Target = V;
+167
+168 fn deref(&self) -> &V {
+169 self.value()
+170 }
+171}
+172
+173impl<'a, K: Eq + Hash, V> DerefMut for RefMut<'a, K, V> {
+174 fn deref_mut(&mut self) -> &mut V {
+175 self.value_mut()
+176 }
+177}
+178
+179pub struct MappedRef<'a, K, V, T> {
+180 _guard: RwLockReadGuard<'a, HashMap<K, V>>,
+181 k: *const K,
+182 v: *const T,
+183}
+184
+185impl<'a, K: Eq + Hash, V, T> MappedRef<'a, K, V, T> {
+186 pub fn key(&self) -> &K {
+187 self.pair().0
+188 }
+189
+190 pub fn value(&self) -> &T {
+191 self.pair().1
+192 }
+193
+194 pub fn pair(&self) -> (&K, &T) {
+195 unsafe { (&*self.k, &*self.v) }
+196 }
+197
+198 pub fn map<F, T2>(self, f: F) -> MappedRef<'a, K, V, T2>
+199 where
+200 F: FnOnce(&T) -> &T2,
+201 {
+202 MappedRef {
+203 _guard: self._guard,
+204 k: self.k,
+205 v: f(unsafe { &*self.v }),
+206 }
+207 }
+208
+209 pub fn try_map<F, T2>(self, f: F) -> Result<MappedRef<'a, K, V, T2>, Self>
+210 where
+211 F: FnOnce(&T) -> Option<&T2>,
+212 {
+213 let v = match f(unsafe { &*self.v }) {
+214 Some(v) => v,
+215 None => return Err(self),
+216 };
+217 let guard = self._guard;
+218 Ok(MappedRef {
+219 _guard: guard,
+220 k: self.k,
+221 v,
+222 })
+223 }
+224}
+225
+226impl<'a, K: Eq + Hash + Debug, V, T: Debug> Debug for MappedRef<'a, K, V, T> {
+227 fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+228 f.debug_struct("MappedRef")
+229 .field("k", &self.k)
+230 .field("v", &self.v)
+231 .finish()
+232 }
+233}
+234
+235impl<'a, K: Eq + Hash, V, T> Deref for MappedRef<'a, K, V, T> {
+236 type Target = T;
+237
+238 fn deref(&self) -> &T {
+239 self.value()
+240 }
+241}
+242
+243impl<'a, K: Eq + Hash, V, T: std::fmt::Display> std::fmt::Display for MappedRef<'a, K, V, T> {
+244 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+245 std::fmt::Display::fmt(self.value(), f)
+246 }
+247}
+248
+249impl<'a, K: Eq + Hash, V, T: AsRef<TDeref>, TDeref: ?Sized> AsRef<TDeref>
+250 for MappedRef<'a, K, V, T>
+251{
+252 fn as_ref(&self) -> &TDeref {
+253 self.value().as_ref()
+254 }
+255}
+256
+257pub struct MappedRefMut<'a, K, V, T> {
+258 _guard: RwLockWriteGuard<'a, HashMap<K, V>>,
+259 k: *const K,
+260 v: *mut T,
+261}
+262
+263impl<'a, K: Eq + Hash, V, T> MappedRefMut<'a, K, V, T> {
+264 pub fn key(&self) -> &K {
+265 self.pair().0
+266 }
+267
+268 pub fn value(&self) -> &T {
+269 self.pair().1
+270 }
+271
+272 pub fn value_mut(&mut self) -> &mut T {
+273 self.pair_mut().1
+274 }
+275
+276 pub fn pair(&self) -> (&K, &T) {
+277 unsafe { (&*self.k, &*self.v) }
+278 }
+279
+280 pub fn pair_mut(&mut self) -> (&K, &mut T) {
+281 unsafe { (&*self.k, &mut *self.v) }
+282 }
+283
+284 pub fn map<F, T2>(self, f: F) -> MappedRefMut<'a, K, V, T2>
+285 where
+286 F: FnOnce(&mut T) -> &mut T2,
+287 {
+288 MappedRefMut {
+289 _guard: self._guard,
+290 k: self.k,
+291 v: f(unsafe { &mut *self.v }),
+292 }
+293 }
+294
+295 pub fn try_map<F, T2>(self, f: F) -> Result<MappedRefMut<'a, K, V, T2>, Self>
+296 where
+297 F: FnOnce(&mut T) -> Option<&mut T2>,
+298 {
+299 let v = match f(unsafe { &mut *(self.v as *mut _) }) {
+300 Some(v) => v,
+301 None => return Err(self),
+302 };
+303 let guard = self._guard;
+304 let k = self.k;
+305 Ok(MappedRefMut {
+306 _guard: guard,
+307 k,
+308 v,
+309 })
+310 }
+311}
+312
+313impl<'a, K: Eq + Hash + Debug, V, T: Debug> Debug for MappedRefMut<'a, K, V, T> {
+314 fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+315 f.debug_struct("MappedRefMut")
+316 .field("k", &self.k)
+317 .field("v", &self.v)
+318 .finish()
+319 }
+320}
+321
+322impl<'a, K: Eq + Hash, V, T> Deref for MappedRefMut<'a, K, V, T> {
+323 type Target = T;
+324
+325 fn deref(&self) -> &T {
+326 self.value()
+327 }
+328}
+329
+330impl<'a, K: Eq + Hash, V, T> DerefMut for MappedRefMut<'a, K, V, T> {
+331 fn deref_mut(&mut self) -> &mut T {
+332 self.value_mut()
+333 }
+334}
+1use crate::lock::RwLock;
+2use crate::t::Map;
+3use crate::{DashMap, HashMap};
+4use cfg_if::cfg_if;
+5use core::borrow::Borrow;
+6use core::fmt;
+7use core::hash::{BuildHasher, Hash};
+8use crossbeam_utils::CachePadded;
+9use std::collections::hash_map::RandomState;
+10
+11/// A read-only view into a `DashMap`. Allows to obtain raw references to the stored values.
+12pub struct ReadOnlyView<K, V, S = RandomState> {
+13 pub(crate) map: DashMap<K, V, S>,
+14}
+15
+16impl<K: Eq + Hash + Clone, V: Clone, S: Clone> Clone for ReadOnlyView<K, V, S> {
+17 fn clone(&self) -> Self {
+18 Self {
+19 map: self.map.clone(),
+20 }
+21 }
+22}
+23
+24impl<K: Eq + Hash + fmt::Debug, V: fmt::Debug, S: BuildHasher + Clone> fmt::Debug
+25 for ReadOnlyView<K, V, S>
+26{
+27 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+28 self.map.fmt(f)
+29 }
+30}
+31
+32impl<K, V, S> ReadOnlyView<K, V, S> {
+33 pub(crate) fn new(map: DashMap<K, V, S>) -> Self {
+34 Self { map }
+35 }
+36
+37 /// Consumes this `ReadOnlyView`, returning the underlying `DashMap`.
+38 pub fn into_inner(self) -> DashMap<K, V, S> {
+39 self.map
+40 }
+41}
+42
+43impl<'a, K: 'a + Eq + Hash, V: 'a, S: BuildHasher + Clone> ReadOnlyView<K, V, S> {
+44 /// Returns the number of elements in the map.
+45 pub fn len(&self) -> usize {
+46 self.map.len()
+47 }
+48
+49 /// Returns `true` if the map contains no elements.
+50 pub fn is_empty(&self) -> bool {
+51 self.map.is_empty()
+52 }
+53
+54 /// Returns the number of elements the map can hold without reallocating.
+55 pub fn capacity(&self) -> usize {
+56 self.map.capacity()
+57 }
+58
+59 /// Returns `true` if the map contains a value for the specified key.
+60 pub fn contains_key<Q>(&'a self, key: &Q) -> bool
+61 where
+62 K: Borrow<Q>,
+63 Q: Hash + Eq + ?Sized,
+64 {
+65 self.get(key).is_some()
+66 }
+67
+68 /// Returns a reference to the value corresponding to the key.
+69 pub fn get<Q>(&'a self, key: &Q) -> Option<&'a V>
+70 where
+71 K: Borrow<Q>,
+72 Q: Hash + Eq + ?Sized,
+73 {
+74 self.get_key_value(key).map(|(_k, v)| v)
+75 }
+76
+77 /// Returns the key-value pair corresponding to the supplied key.
+78 pub fn get_key_value<Q>(&'a self, key: &Q) -> Option<(&'a K, &'a V)>
+79 where
+80 K: Borrow<Q>,
+81 Q: Hash + Eq + ?Sized,
+82 {
+83 let hash = self.map.hash_u64(&key);
+84
+85 let idx = self.map.determine_shard(hash as usize);
+86
+87 let shard = unsafe { self.map._get_read_shard(idx) };
+88
+89 shard.find(hash, |(k, _v)| key == k.borrow()).map(|b| {
+90 let (k, v) = unsafe { b.as_ref() };
+91 (k, v.get())
+92 })
+93 }
+94
+95 /// An iterator visiting all key-value pairs in arbitrary order. The iterator element type is `(&'a K, &'a V)`.
+96 pub fn iter(&'a self) -> impl Iterator<Item = (&'a K, &'a V)> + 'a {
+97 unsafe {
+98 (0..self.map._shard_count())
+99 .map(move |shard_i| self.map._get_read_shard(shard_i))
+100 .flat_map(|shard| shard.iter())
+101 .map(|b| {
+102 let (k, v) = b.as_ref();
+103 (k, v.get())
+104 })
+105 }
+106 }
+107
+108 /// An iterator visiting all keys in arbitrary order. The iterator element type is `&'a K`.
+109 pub fn keys(&'a self) -> impl Iterator<Item = &'a K> + 'a {
+110 self.iter().map(|(k, _v)| k)
+111 }
+112
+113 /// An iterator visiting all values in arbitrary order. The iterator element type is `&'a V`.
+114 pub fn values(&'a self) -> impl Iterator<Item = &'a V> + 'a {
+115 self.iter().map(|(_k, v)| v)
+116 }
+117
+118 cfg_if! {
+119 if #[cfg(feature = "raw-api")] {
+120 /// Allows you to peek at the inner shards that store your data.
+121 /// You should probably not use this unless you know what you are doing.
+122 ///
+123 /// Requires the `raw-api` feature to be enabled.
+124 ///
+125 /// # Examples
+126 ///
+127 /// ```
+128 /// use dashmap::DashMap;
+129 ///
+130 /// let map = DashMap::<(), ()>::new().into_read_only();
+131 /// println!("Amount of shards: {}", map.shards().len());
+132 /// ```
+133 pub fn shards(&self) -> &[CachePadded<RwLock<HashMap<K, V>>>] {
+134 &self.map.shards
+135 }
+136 } else {
+137 #[allow(dead_code)]
+138 pub(crate) fn shards(&self) -> &[CachePadded<RwLock<HashMap<K, V>>>] {
+139 &self.map.shards
+140 }
+141 }
+142 }
+143}
+144
+145#[cfg(test)]
+146
+147mod tests {
+148
+149 use crate::DashMap;
+150
+151 fn construct_sample_map() -> DashMap<i32, String> {
+152 let map = DashMap::new();
+153
+154 map.insert(1, "one".to_string());
+155
+156 map.insert(10, "ten".to_string());
+157
+158 map.insert(27, "twenty seven".to_string());
+159
+160 map.insert(45, "forty five".to_string());
+161
+162 map
+163 }
+164
+165 #[test]
+166
+167 fn test_properties() {
+168 let map = construct_sample_map();
+169
+170 let view = map.clone().into_read_only();
+171
+172 assert_eq!(view.is_empty(), map.is_empty());
+173
+174 assert_eq!(view.len(), map.len());
+175
+176 assert_eq!(view.capacity(), map.capacity());
+177
+178 let new_map = view.into_inner();
+179
+180 assert_eq!(new_map.is_empty(), map.is_empty());
+181
+182 assert_eq!(new_map.len(), map.len());
+183
+184 assert_eq!(new_map.capacity(), map.capacity());
+185 }
+186
+187 #[test]
+188
+189 fn test_get() {
+190 let map = construct_sample_map();
+191
+192 let view = map.clone().into_read_only();
+193
+194 for key in map.iter().map(|entry| *entry.key()) {
+195 assert!(view.contains_key(&key));
+196
+197 let map_entry = map.get(&key).unwrap();
+198
+199 assert_eq!(view.get(&key).unwrap(), map_entry.value());
+200
+201 let key_value: (&i32, &String) = view.get_key_value(&key).unwrap();
+202
+203 assert_eq!(key_value.0, map_entry.key());
+204
+205 assert_eq!(key_value.1, map_entry.value());
+206 }
+207 }
+208
+209 #[test]
+210
+211 fn test_iters() {
+212 let map = construct_sample_map();
+213
+214 let view = map.clone().into_read_only();
+215
+216 let mut visited_items = Vec::new();
+217
+218 for (key, value) in view.iter() {
+219 map.contains_key(key);
+220
+221 let map_entry = map.get(key).unwrap();
+222
+223 assert_eq!(key, map_entry.key());
+224
+225 assert_eq!(value, map_entry.value());
+226
+227 visited_items.push((key, value));
+228 }
+229
+230 let mut visited_keys = Vec::new();
+231
+232 for key in view.keys() {
+233 map.contains_key(key);
+234
+235 let map_entry = map.get(key).unwrap();
+236
+237 assert_eq!(key, map_entry.key());
+238
+239 assert_eq!(view.get(key).unwrap(), map_entry.value());
+240
+241 visited_keys.push(key);
+242 }
+243
+244 let mut visited_values = Vec::new();
+245
+246 for value in view.values() {
+247 visited_values.push(value);
+248 }
+249
+250 for entry in map.iter() {
+251 let key = entry.key();
+252
+253 let value = entry.value();
+254
+255 assert!(visited_keys.contains(&key));
+256
+257 assert!(visited_values.contains(&value));
+258
+259 assert!(visited_items.contains(&(key, value)));
+260 }
+261 }
+262}
+1use crate::iter_set::{Iter, OwningIter};
+2#[cfg(feature = "raw-api")]
+3use crate::lock::RwLock;
+4use crate::setref::one::Ref;
+5use crate::DashMap;
+6#[cfg(feature = "raw-api")]
+7use crate::HashMap;
+8use cfg_if::cfg_if;
+9use core::borrow::Borrow;
+10use core::fmt;
+11use core::hash::{BuildHasher, Hash};
+12use core::iter::FromIterator;
+13#[cfg(feature = "raw-api")]
+14use crossbeam_utils::CachePadded;
+15use std::collections::hash_map::RandomState;
+16
+17/// DashSet is a thin wrapper around [`DashMap`] using `()` as the value type. It uses
+18/// methods and types which are more convenient to work with on a set.
+19///
+20/// [`DashMap`]: struct.DashMap.html
+21pub struct DashSet<K, S = RandomState> {
+22 pub(crate) inner: DashMap<K, (), S>,
+23}
+24
+25impl<K: Eq + Hash + fmt::Debug, S: BuildHasher + Clone> fmt::Debug for DashSet<K, S> {
+26 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+27 fmt::Debug::fmt(&self.inner, f)
+28 }
+29}
+30
+31impl<K: Eq + Hash + Clone, S: Clone> Clone for DashSet<K, S> {
+32 fn clone(&self) -> Self {
+33 Self {
+34 inner: self.inner.clone(),
+35 }
+36 }
+37
+38 fn clone_from(&mut self, source: &Self) {
+39 self.inner.clone_from(&source.inner)
+40 }
+41}
+42
+43impl<K, S> Default for DashSet<K, S>
+44where
+45 K: Eq + Hash,
+46 S: Default + BuildHasher + Clone,
+47{
+48 fn default() -> Self {
+49 Self::with_hasher(Default::default())
+50 }
+51}
+52
+53impl<'a, K: 'a + Eq + Hash> DashSet<K, RandomState> {
+54 /// Creates a new DashSet with a capacity of 0.
+55 ///
+56 /// # Examples
+57 ///
+58 /// ```
+59 /// use dashmap::DashSet;
+60 ///
+61 /// let games = DashSet::new();
+62 /// games.insert("Veloren");
+63 /// ```
+64 pub fn new() -> Self {
+65 Self::with_hasher(RandomState::default())
+66 }
+67
+68 /// Creates a new DashMap with a specified starting capacity.
+69 ///
+70 /// # Examples
+71 ///
+72 /// ```
+73 /// use dashmap::DashSet;
+74 ///
+75 /// let numbers = DashSet::with_capacity(2);
+76 /// numbers.insert(2);
+77 /// numbers.insert(8);
+78 /// ```
+79 pub fn with_capacity(capacity: usize) -> Self {
+80 Self::with_capacity_and_hasher(capacity, RandomState::default())
+81 }
+82}
+83
+84impl<'a, K: 'a + Eq + Hash, S: BuildHasher + Clone> DashSet<K, S> {
+85 /// Creates a new DashMap with a capacity of 0 and the provided hasher.
+86 ///
+87 /// # Examples
+88 ///
+89 /// ```
+90 /// use dashmap::DashSet;
+91 /// use std::collections::hash_map::RandomState;
+92 ///
+93 /// let s = RandomState::new();
+94 /// let games = DashSet::with_hasher(s);
+95 /// games.insert("Veloren");
+96 /// ```
+97 pub fn with_hasher(hasher: S) -> Self {
+98 Self::with_capacity_and_hasher(0, hasher)
+99 }
+100
+101 /// Creates a new DashMap with a specified starting capacity and hasher.
+102 ///
+103 /// # Examples
+104 ///
+105 /// ```
+106 /// use dashmap::DashSet;
+107 /// use std::collections::hash_map::RandomState;
+108 ///
+109 /// let s = RandomState::new();
+110 /// let numbers = DashSet::with_capacity_and_hasher(2, s);
+111 /// numbers.insert(2);
+112 /// numbers.insert(8);
+113 /// ```
+114 pub fn with_capacity_and_hasher(capacity: usize, hasher: S) -> Self {
+115 Self {
+116 inner: DashMap::with_capacity_and_hasher(capacity, hasher),
+117 }
+118 }
+119
+120 /// Hash a given item to produce a usize.
+121 /// Uses the provided or default HashBuilder.
+122 pub fn hash_usize<T: Hash>(&self, item: &T) -> usize {
+123 self.inner.hash_usize(item)
+124 }
+125
+126 cfg_if! {
+127 if #[cfg(feature = "raw-api")] {
+128 /// Allows you to peek at the inner shards that store your data.
+129 /// You should probably not use this unless you know what you are doing.
+130 ///
+131 /// Requires the `raw-api` feature to be enabled.
+132 ///
+133 /// # Examples
+134 ///
+135 /// ```
+136 /// use dashmap::DashSet;
+137 ///
+138 /// let set = DashSet::<()>::new();
+139 /// println!("Amount of shards: {}", set.shards().len());
+140 /// ```
+141 pub fn shards(&self) -> &[CachePadded<RwLock<HashMap<K, ()>>>] {
+142 self.inner.shards()
+143 }
+144 }
+145 }
+146
+147 cfg_if! {
+148 if #[cfg(feature = "raw-api")] {
+149 /// Finds which shard a certain key is stored in.
+150 /// You should probably not use this unless you know what you are doing.
+151 /// Note that shard selection is dependent on the default or provided HashBuilder.
+152 ///
+153 /// Requires the `raw-api` feature to be enabled.
+154 ///
+155 /// # Examples
+156 ///
+157 /// ```
+158 /// use dashmap::DashSet;
+159 ///
+160 /// let set = DashSet::new();
+161 /// set.insert("coca-cola");
+162 /// println!("coca-cola is stored in shard: {}", set.determine_map("coca-cola"));
+163 /// ```
+164 pub fn determine_map<Q>(&self, key: &Q) -> usize
+165 where
+166 K: Borrow<Q>,
+167 Q: Hash + Eq + ?Sized,
+168 {
+169 self.inner.determine_map(key)
+170 }
+171 }
+172 }
+173
+174 cfg_if! {
+175 if #[cfg(feature = "raw-api")] {
+176 /// Finds which shard a certain hash is stored in.
+177 ///
+178 /// Requires the `raw-api` feature to be enabled.
+179 ///
+180 /// # Examples
+181 ///
+182 /// ```
+183 /// use dashmap::DashSet;
+184 ///
+185 /// let set: DashSet<i32> = DashSet::new();
+186 /// let key = "key";
+187 /// let hash = set.hash_usize(&key);
+188 /// println!("hash is stored in shard: {}", set.determine_shard(hash));
+189 /// ```
+190 pub fn determine_shard(&self, hash: usize) -> usize {
+191 self.inner.determine_shard(hash)
+192 }
+193 }
+194 }
+195
+196 /// Inserts a key into the set. Returns true if the key was not already in the set.
+197 ///
+198 /// # Examples
+199 ///
+200 /// ```
+201 /// use dashmap::DashSet;
+202 ///
+203 /// let set = DashSet::new();
+204 /// set.insert("I am the key!");
+205 /// ```
+206 pub fn insert(&self, key: K) -> bool {
+207 self.inner.insert(key, ()).is_none()
+208 }
+209
+210 /// Removes an entry from the map, returning the key if it existed in the map.
+211 ///
+212 /// # Examples
+213 ///
+214 /// ```
+215 /// use dashmap::DashSet;
+216 ///
+217 /// let soccer_team = DashSet::new();
+218 /// soccer_team.insert("Jack");
+219 /// assert_eq!(soccer_team.remove("Jack").unwrap(), "Jack");
+220 /// ```
+221 pub fn remove<Q>(&self, key: &Q) -> Option<K>
+222 where
+223 K: Borrow<Q>,
+224 Q: Hash + Eq + ?Sized,
+225 {
+226 self.inner.remove(key).map(|(k, _)| k)
+227 }
+228
+229 /// Removes an entry from the set, returning the key
+230 /// if the entry existed and the provided conditional function returned true.
+231 ///
+232 /// ```
+233 /// use dashmap::DashSet;
+234 ///
+235 /// let soccer_team = DashSet::new();
+236 /// soccer_team.insert("Sam");
+237 /// soccer_team.remove_if("Sam", |player| player.starts_with("Ja"));
+238 /// assert!(soccer_team.contains("Sam"));
+239 /// ```
+240 /// ```
+241 /// use dashmap::DashSet;
+242 ///
+243 /// let soccer_team = DashSet::new();
+244 /// soccer_team.insert("Sam");
+245 /// soccer_team.remove_if("Jacob", |player| player.starts_with("Ja"));
+246 /// assert!(!soccer_team.contains("Jacob"));
+247 /// ```
+248 pub fn remove_if<Q>(&self, key: &Q, f: impl FnOnce(&K) -> bool) -> Option<K>
+249 where
+250 K: Borrow<Q>,
+251 Q: Hash + Eq + ?Sized,
+252 {
+253 // TODO: Don't create another closure around f
+254 self.inner.remove_if(key, |k, _| f(k)).map(|(k, _)| k)
+255 }
+256
+257 /// Creates an iterator over a DashMap yielding immutable references.
+258 ///
+259 /// # Examples
+260 ///
+261 /// ```
+262 /// use dashmap::DashSet;
+263 ///
+264 /// let words = DashSet::new();
+265 /// words.insert("hello");
+266 /// assert_eq!(words.iter().count(), 1);
+267 /// ```
+268 pub fn iter(&'a self) -> Iter<'a, K, S, DashMap<K, (), S>> {
+269 let iter = self.inner.iter();
+270
+271 Iter::new(iter)
+272 }
+273
+274 /// Get a reference to an entry in the set
+275 ///
+276 /// # Examples
+277 ///
+278 /// ```
+279 /// use dashmap::DashSet;
+280 ///
+281 /// let youtubers = DashSet::new();
+282 /// youtubers.insert("Bosnian Bill");
+283 /// assert_eq!(*youtubers.get("Bosnian Bill").unwrap(), "Bosnian Bill");
+284 /// ```
+285 pub fn get<Q>(&'a self, key: &Q) -> Option<Ref<'a, K>>
+286 where
+287 K: Borrow<Q>,
+288 Q: Hash + Eq + ?Sized,
+289 {
+290 self.inner.get(key).map(Ref::new)
+291 }
+292
+293 /// Remove excess capacity to reduce memory usage.
+294 pub fn shrink_to_fit(&self) {
+295 self.inner.shrink_to_fit()
+296 }
+297
+298 /// Retain elements that whose predicates return true
+299 /// and discard elements whose predicates return false.
+300 ///
+301 /// # Examples
+302 ///
+303 /// ```
+304 /// use dashmap::DashSet;
+305 ///
+306 /// let people = DashSet::new();
+307 /// people.insert("Albin");
+308 /// people.insert("Jones");
+309 /// people.insert("Charlie");
+310 /// people.retain(|name| name.contains('i'));
+311 /// assert_eq!(people.len(), 2);
+312 /// ```
+313 pub fn retain(&self, mut f: impl FnMut(&K) -> bool) {
+314 self.inner.retain(|k, _| f(k))
+315 }
+316
+317 /// Fetches the total number of keys stored in the set.
+318 ///
+319 /// # Examples
+320 ///
+321 /// ```
+322 /// use dashmap::DashSet;
+323 ///
+324 /// let people = DashSet::new();
+325 /// people.insert("Albin");
+326 /// people.insert("Jones");
+327 /// people.insert("Charlie");
+328 /// assert_eq!(people.len(), 3);
+329 /// ```
+330 pub fn len(&self) -> usize {
+331 self.inner.len()
+332 }
+333
+334 /// Checks if the set is empty or not.
+335 ///
+336 /// # Examples
+337 ///
+338 /// ```
+339 /// use dashmap::DashSet;
+340 ///
+341 /// let map = DashSet::<()>::new();
+342 /// assert!(map.is_empty());
+343 /// ```
+344 pub fn is_empty(&self) -> bool {
+345 self.inner.is_empty()
+346 }
+347
+348 /// Removes all keys in the set.
+349 ///
+350 /// # Examples
+351 ///
+352 /// ```
+353 /// use dashmap::DashSet;
+354 ///
+355 /// let people = DashSet::new();
+356 /// people.insert("Albin");
+357 /// assert!(!people.is_empty());
+358 /// people.clear();
+359 /// assert!(people.is_empty());
+360 /// ```
+361 pub fn clear(&self) {
+362 self.inner.clear()
+363 }
+364
+365 /// Returns how many keys the set can store without reallocating.
+366 pub fn capacity(&self) -> usize {
+367 self.inner.capacity()
+368 }
+369
+370 /// Checks if the set contains a specific key.
+371 ///
+372 /// # Examples
+373 ///
+374 /// ```
+375 /// use dashmap::DashSet;
+376 ///
+377 /// let people = DashSet::new();
+378 /// people.insert("Dakota Cherries");
+379 /// assert!(people.contains("Dakota Cherries"));
+380 /// ```
+381 pub fn contains<Q>(&self, key: &Q) -> bool
+382 where
+383 K: Borrow<Q>,
+384 Q: Hash + Eq + ?Sized,
+385 {
+386 self.inner.contains_key(key)
+387 }
+388}
+389
+390impl<K: Eq + Hash, S: BuildHasher + Clone> IntoIterator for DashSet<K, S> {
+391 type Item = K;
+392
+393 type IntoIter = OwningIter<K, S>;
+394
+395 fn into_iter(self) -> Self::IntoIter {
+396 OwningIter::new(self.inner.into_iter())
+397 }
+398}
+399
+400impl<K: Eq + Hash, S: BuildHasher + Clone> Extend<K> for DashSet<K, S> {
+401 fn extend<T: IntoIterator<Item = K>>(&mut self, iter: T) {
+402 let iter = iter.into_iter().map(|k| (k, ()));
+403
+404 self.inner.extend(iter)
+405 }
+406}
+407
+408impl<K: Eq + Hash, S: BuildHasher + Clone + Default> FromIterator<K> for DashSet<K, S> {
+409 fn from_iter<I: IntoIterator<Item = K>>(iter: I) -> Self {
+410 let mut set = DashSet::default();
+411
+412 set.extend(iter);
+413
+414 set
+415 }
+416}
+417
+418#[cfg(feature = "typesize")]
+419impl<K, S> typesize::TypeSize for DashSet<K, S>
+420where
+421 K: typesize::TypeSize + Eq + Hash,
+422 S: typesize::TypeSize + Clone + BuildHasher,
+423{
+424 fn extra_size(&self) -> usize {
+425 self.inner.extra_size()
+426 }
+427
+428 typesize::if_typesize_details! {
+429 fn get_collection_item_count(&self) -> Option<usize> {
+430 Some(self.len())
+431 }
+432 }
+433}
+434
+435#[cfg(test)]
+436mod tests {
+437 use crate::DashSet;
+438
+439 #[test]
+440 fn test_basic() {
+441 let set = DashSet::new();
+442
+443 set.insert(0);
+444
+445 assert_eq!(set.get(&0).as_deref(), Some(&0));
+446 }
+447
+448 #[test]
+449 fn test_default() {
+450 let set: DashSet<u32> = DashSet::default();
+451
+452 set.insert(0);
+453
+454 assert_eq!(set.get(&0).as_deref(), Some(&0));
+455 }
+456
+457 #[test]
+458 fn test_multiple_hashes() {
+459 let set = DashSet::<u32>::default();
+460
+461 for i in 0..100 {
+462 assert!(set.insert(i));
+463 }
+464
+465 for i in 0..100 {
+466 assert!(!set.insert(i));
+467 }
+468
+469 for i in 0..100 {
+470 assert_eq!(Some(i), set.remove(&i));
+471 }
+472
+473 for i in 0..100 {
+474 assert_eq!(None, set.remove(&i));
+475 }
+476 }
+477}
+1use crate::mapref;
+2use core::hash::Hash;
+3use core::ops::Deref;
+4
+5pub struct RefMulti<'a, K> {
+6 inner: mapref::multiple::RefMulti<'a, K, ()>,
+7}
+8
+9impl<'a, K: Eq + Hash> RefMulti<'a, K> {
+10 pub(crate) fn new(inner: mapref::multiple::RefMulti<'a, K, ()>) -> Self {
+11 Self { inner }
+12 }
+13
+14 pub fn key(&self) -> &K {
+15 self.inner.key()
+16 }
+17}
+18
+19impl<'a, K: Eq + Hash> Deref for RefMulti<'a, K> {
+20 type Target = K;
+21
+22 fn deref(&self) -> &K {
+23 self.key()
+24 }
+25}
+1use crate::mapref;
+2use core::hash::Hash;
+3use core::ops::Deref;
+4
+5pub struct Ref<'a, K> {
+6 inner: mapref::one::Ref<'a, K, ()>,
+7}
+8
+9impl<'a, K: Eq + Hash> Ref<'a, K> {
+10 pub(crate) fn new(inner: mapref::one::Ref<'a, K, ()>) -> Self {
+11 Self { inner }
+12 }
+13
+14 pub fn key(&self) -> &K {
+15 self.inner.key()
+16 }
+17}
+18
+19impl<'a, K: Eq + Hash> Deref for Ref<'a, K> {
+20 type Target = K;
+21
+22 fn deref(&self) -> &K {
+23 self.key()
+24 }
+25}
+1//! Central map trait to ease modifications and extensions down the road.
+2
+3use crate::iter::{Iter, IterMut};
+4use crate::lock::{RwLockReadGuard, RwLockWriteGuard};
+5use crate::mapref::entry::Entry;
+6use crate::mapref::one::{Ref, RefMut};
+7use crate::try_result::TryResult;
+8use crate::HashMap;
+9use core::borrow::Borrow;
+10use core::hash::{BuildHasher, Hash};
+11
+12/// Implementation detail that is exposed due to generic constraints in public types.
+13pub trait Map<'a, K: 'a + Eq + Hash, V: 'a, S: 'a + Clone + BuildHasher> {
+14 fn _shard_count(&self) -> usize;
+15
+16 /// # Safety
+17 ///
+18 /// The index must not be out of bounds.
+19 unsafe fn _get_read_shard(&'a self, i: usize) -> &'a HashMap<K, V>;
+20
+21 /// # Safety
+22 ///
+23 /// The index must not be out of bounds.
+24 unsafe fn _yield_read_shard(&'a self, i: usize) -> RwLockReadGuard<'a, HashMap<K, V>>;
+25
+26 /// # Safety
+27 ///
+28 /// The index must not be out of bounds.
+29 unsafe fn _yield_write_shard(&'a self, i: usize) -> RwLockWriteGuard<'a, HashMap<K, V>>;
+30
+31 /// # Safety
+32 ///
+33 /// The index must not be out of bounds.
+34 unsafe fn _try_yield_read_shard(
+35 &'a self,
+36 i: usize,
+37 ) -> Option<RwLockReadGuard<'a, HashMap<K, V>>>;
+38
+39 /// # Safety
+40 ///
+41 /// The index must not be out of bounds.
+42 unsafe fn _try_yield_write_shard(
+43 &'a self,
+44 i: usize,
+45 ) -> Option<RwLockWriteGuard<'a, HashMap<K, V>>>;
+46
+47 fn _insert(&self, key: K, value: V) -> Option<V>;
+48
+49 fn _remove<Q>(&self, key: &Q) -> Option<(K, V)>
+50 where
+51 K: Borrow<Q>,
+52 Q: Hash + Eq + ?Sized;
+53
+54 fn _remove_if<Q>(&self, key: &Q, f: impl FnOnce(&K, &V) -> bool) -> Option<(K, V)>
+55 where
+56 K: Borrow<Q>,
+57 Q: Hash + Eq + ?Sized;
+58
+59 fn _remove_if_mut<Q>(&self, key: &Q, f: impl FnOnce(&K, &mut V) -> bool) -> Option<(K, V)>
+60 where
+61 K: Borrow<Q>,
+62 Q: Hash + Eq + ?Sized;
+63
+64 fn _iter(&'a self) -> Iter<'a, K, V, S, Self>
+65 where
+66 Self: Sized;
+67
+68 fn _iter_mut(&'a self) -> IterMut<'a, K, V, S, Self>
+69 where
+70 Self: Sized;
+71
+72 fn _get<Q>(&'a self, key: &Q) -> Option<Ref<'a, K, V>>
+73 where
+74 K: Borrow<Q>,
+75 Q: Hash + Eq + ?Sized;
+76
+77 fn _get_mut<Q>(&'a self, key: &Q) -> Option<RefMut<'a, K, V>>
+78 where
+79 K: Borrow<Q>,
+80 Q: Hash + Eq + ?Sized;
+81
+82 fn _try_get<Q>(&'a self, key: &Q) -> TryResult<Ref<'a, K, V>>
+83 where
+84 K: Borrow<Q>,
+85 Q: Hash + Eq + ?Sized;
+86
+87 fn _try_get_mut<Q>(&'a self, key: &Q) -> TryResult<RefMut<'a, K, V>>
+88 where
+89 K: Borrow<Q>,
+90 Q: Hash + Eq + ?Sized;
+91
+92 fn _shrink_to_fit(&self);
+93
+94 fn _retain(&self, f: impl FnMut(&K, &mut V) -> bool);
+95
+96 fn _len(&self) -> usize;
+97
+98 fn _capacity(&self) -> usize;
+99
+100 fn _alter<Q>(&self, key: &Q, f: impl FnOnce(&K, V) -> V)
+101 where
+102 K: Borrow<Q>,
+103 Q: Hash + Eq + ?Sized;
+104
+105 fn _alter_all(&self, f: impl FnMut(&K, V) -> V);
+106
+107 fn _view<Q, R>(&self, key: &Q, f: impl FnOnce(&K, &V) -> R) -> Option<R>
+108 where
+109 K: Borrow<Q>,
+110 Q: Hash + Eq + ?Sized;
+111
+112 fn _entry(&'a self, key: K) -> Entry<'a, K, V>;
+113
+114 fn _try_entry(&'a self, key: K) -> Option<Entry<'a, K, V>>;
+115
+116 fn _hasher(&self) -> S;
+117
+118 // provided
+119 fn _clear(&self) {
+120 self._retain(|_, _| false)
+121 }
+122
+123 fn _contains_key<Q>(&'a self, key: &Q) -> bool
+124 where
+125 K: Borrow<Q>,
+126 Q: Hash + Eq + ?Sized,
+127 {
+128 self._get(key).is_some()
+129 }
+130
+131 fn _is_empty(&self) -> bool {
+132 self._len() == 0
+133 }
+134}
+1/// Represents the result of a non-blocking read from a [DashMap](crate::DashMap).
+2#[derive(Debug)]
+3pub enum TryResult<R> {
+4 /// The value was present in the map, and the lock for the shard was successfully obtained.
+5 Present(R),
+6 /// The shard wasn't locked, and the value wasn't present in the map.
+7 Absent,
+8 /// The shard was locked.
+9 Locked,
+10}
+11
+12impl<R> TryResult<R> {
+13 /// Returns `true` if the value was present in the map, and the lock for the shard was successfully obtained.
+14 pub fn is_present(&self) -> bool {
+15 matches!(self, TryResult::Present(_))
+16 }
+17
+18 /// Returns `true` if the shard wasn't locked, and the value wasn't present in the map.
+19 pub fn is_absent(&self) -> bool {
+20 matches!(self, TryResult::Absent)
+21 }
+22
+23 /// Returns `true` if the shard was locked.
+24 pub fn is_locked(&self) -> bool {
+25 matches!(self, TryResult::Locked)
+26 }
+27
+28 /// If `self` is [Present](TryResult::Present), returns the reference to the value in the map.
+29 /// Panics if `self` is not [Present](TryResult::Present).
+30 pub fn unwrap(self) -> R {
+31 match self {
+32 TryResult::Present(r) => r,
+33 TryResult::Locked => panic!("Called unwrap() on TryResult::Locked"),
+34 TryResult::Absent => panic!("Called unwrap() on TryResult::Absent"),
+35 }
+36 }
+37
+38 /// If `self` is [Present](TryResult::Present), returns the reference to the value in the map.
+39 /// If `self` is not [Present](TryResult::Present), returns `None`.
+40 pub fn try_unwrap(self) -> Option<R> {
+41 match self {
+42 TryResult::Present(r) => Some(r),
+43 _ => None,
+44 }
+45 }
+46}
+1//! This module is full of hackery and dark magic.
+2//! Either spend a day fixing it and quietly submit a PR or don't mention it to anybody.
+3use core::cell::UnsafeCell;
+4use core::{mem, ptr};
+5
+6pub const fn ptr_size_bits() -> usize {
+7 mem::size_of::<usize>() * 8
+8}
+9
+10pub fn map_in_place_2<T, U, F: FnOnce(U, T) -> T>((k, v): (U, &mut T), f: F) {
+11 unsafe {
+12 // # Safety
+13 //
+14 // If the closure panics, we must abort otherwise we could double drop `T`
+15 let promote_panic_to_abort = AbortOnPanic;
+16
+17 ptr::write(v, f(k, ptr::read(v)));
+18
+19 // If we made it here, the calling thread could have already have panicked, in which case
+20 // We know that the closure did not panic, so don't bother checking.
+21 std::mem::forget(promote_panic_to_abort);
+22 }
+23}
+24
+25/// A simple wrapper around `T`
+26///
+27/// This is to prevent UB when using `HashMap::get_key_value`, because
+28/// `HashMap` doesn't expose an api to get the key and value, where
+29/// the value is a `&mut T`.
+30///
+31/// See [#10](https://github.com/xacrimon/dashmap/issues/10) for details
+32///
+33/// This type is meant to be an implementation detail, but must be exposed due to the `Dashmap::shards`
+34#[repr(transparent)]
+35pub struct SharedValue<T> {
+36 value: UnsafeCell<T>,
+37}
+38
+39impl<T: Clone> Clone for SharedValue<T> {
+40 fn clone(&self) -> Self {
+41 let inner = self.get().clone();
+42
+43 Self {
+44 value: UnsafeCell::new(inner),
+45 }
+46 }
+47}
+48
+49unsafe impl<T: Send> Send for SharedValue<T> {}
+50
+51unsafe impl<T: Sync> Sync for SharedValue<T> {}
+52
+53impl<T> SharedValue<T> {
+54 /// Create a new `SharedValue<T>`
+55 pub const fn new(value: T) -> Self {
+56 Self {
+57 value: UnsafeCell::new(value),
+58 }
+59 }
+60
+61 /// Get a shared reference to `T`
+62 pub fn get(&self) -> &T {
+63 unsafe { &*self.value.get() }
+64 }
+65
+66 /// Get an unique reference to `T`
+67 pub fn get_mut(&mut self) -> &mut T {
+68 unsafe { &mut *self.value.get() }
+69 }
+70
+71 /// Unwraps the value
+72 pub fn into_inner(self) -> T {
+73 self.value.into_inner()
+74 }
+75
+76 /// Get a mutable raw pointer to the underlying value
+77 pub(crate) fn as_ptr(&self) -> *mut T {
+78 self.value.get()
+79 }
+80}
+81
+82struct AbortOnPanic;
+83
+84impl Drop for AbortOnPanic {
+85 fn drop(&mut self) {
+86 if std::thread::panicking() {
+87 std::process::abort()
+88 }
+89 }
+90}
+