Struct SyncIndexMap

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

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

Implementations

impl<K, V> SyncIndexMap<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::{SyncIndexMap};

let mut map = SyncIndexMap::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 SyncIndexMap<K, V>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K, V> Debug for SyncIndexMap<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 SyncIndexMap<K, V>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, K, V> Deserialize<'de> for SyncIndexMap<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 SyncIndexMap<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<IndexMap<K, V>> for SyncIndexMap<K, V>

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

Converts to this type from the input type.

impl<K, V> Index<&K> for SyncIndexMap<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 SyncIndexMap<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 SyncIndexMap<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 SyncIndexMap<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 SyncIndexMap<K, V>

this is safety, dirty mutex ensure

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

this is safety, dirty mutex ensure