Struct SyncHashMap

pub struct SyncHashMap<K: Eq + Hash, V> { /* private fields */ }

this sync map used to many reader,writer less.space-for-time strategy

Implementations

impl<K, V> SyncHashMap<K, V>

where K: Eq + Hash,

pub fn new_arc() -> Arc<Self>

pub fn new() -> Self

pub fn with_capacity(capacity: usize) -> Self

pub fn with_map(map: Map<K, V>) -> Self

pub fn insert(&self, k: K, v: V) -> Option<V>

pub fn insert_mut(&mut self, k: K, v: V) -> Option<V>

pub fn remove(&self, k: &K) -> Option<V>

pub fn remove_mut(&mut self, k: &K) -> Option<V>

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn clear(&self)

pub fn clear_mut(&mut self)

pub fn shrink_to_fit(&self)

pub fn shrink_to_fit_mut(&mut self)

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

where K: Eq + Hash,

pub fn get<Q>(&self, k: &Q) -> Option<&V>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Returns a reference to the value corresponding to the key.

The key may be any borrowed form of the map’s key type, but Hash and Eq on the borrowed form must match those for the key type.

Since reading a map is unlocked, it is very fast

test bench_sync_hash_map_read … bench: 8 ns/iter (+/- 0)

Examples

use dark_std::sync::{SyncHashMap};

let mut map = SyncHashMap::new();
map.insert_mut(1, "a");
assert_eq!(*map.get(&1).unwrap(), "a");
assert_eq!(map.get(&2).is_none(), true);

pub fn get_mut(&self, k: &K) -> Option<HashMapRefMut<'_, K, V>>

where K: Hash + Eq + Clone,

pub fn contains_key(&self, x: &K) -> bool

where K: PartialEq,

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

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

pub fn into_iter(self) -> MapIntoIter<K, V>

pub fn dirty_ref(&self) -> &Map<K, V>

pub fn into_inner(self) -> Map<K, V>

Trait Implementations

impl<K: Clone + Eq + Hash, V: Clone> Clone for SyncHashMap<K, V>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K, V> Debug for SyncHashMap<K, V>

where K: Eq + Hash + Debug, V: Debug,

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

Formats the value using the given formatter.

impl<K: Eq + Hash, V> Default for SyncHashMap<K, V>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, K, V> Deserialize<'de> for SyncHashMap<K, V>

where K: Eq + Hash + Deserialize<'de>, V: Deserialize<'de>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<K, V> Display for SyncHashMap<K, V>

where K: Eq + Hash + Display, V: Display,

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

Formats the value using the given formatter.

impl<K: Eq + Hash, V> From<HashMap<K, V>> for SyncHashMap<K, V>

fn from(arg: Map<K, V>) -> Self

Converts to this type from the input type.

impl<K, V> Index<&K> for SyncHashMap<K, V>

where K: Eq + Hash,

type Output = V

The returned type after indexing.

fn index(&self, index: &K) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, K, V> IntoIterator for &'a SyncHashMap<K, V>

where K: Eq + Hash,

type Item = (&'a K, &'a V)

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K, V> IntoIterator for SyncHashMap<K, V>

where K: Eq + Hash,

type Item = (K, V)

The type of the elements being iterated over.

type IntoIter = IntoIter<K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K, V> Serialize for SyncHashMap<K, V>

where K: Eq + Hash + Serialize, V: Serialize,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<K: Eq + Hash, V> Send for SyncHashMap<K, V>

this is safety, dirty mutex ensure

impl<K: Eq + Hash, V> Sync for SyncHashMap<K, V>

this is safety, dirty mutex ensure