Struct dark_std::sync::map_btree::SyncBtreeMap

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

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

Implementations

impl<K: Eq + Hash, V> SyncBtreeMap<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: BTreeMap<K, V>) -> Self

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

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

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

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

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn clear(&self)where
    K: Eq + Hash,

pub fn clear_mut(&mut self)where
    K: Eq + Hash,

pub fn shrink_to_fit(&self)

pub fn shrink_to_fit_mut(&mut self)

pub fn from(map: BTreeMap<K, V>) -> Selfwhere
    K: Eq + Hash,

pub fn get<Q: ?Sized>(&self, k: &Q) -> Option<&V>where
    K: Borrow<Q> + Ord,
    Q: Hash + Eq + Ord,

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::{SyncBtreeMap};

let mut map = SyncBtreeMap::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<Q: ?Sized>(&self, k: &Q) -> Option<SyncMapRefMut<'_, V>>where
    K: Borrow<Q> + Ord,
    Q: Hash + Eq + Ord,

pub fn contains_key(&self, x: &K) -> boolwhere
    K: PartialEq + Ord,

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

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

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

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

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

Trait Implementations

impl<K: Clone + Eq + Hash, V: Clone> Clone for SyncBtreeMap<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: Eq + Hash, V> Debug for SyncBtreeMap<K, V>where
    K: Eq + Hash + Debug,
    V: Debug,

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

Formats the value using the given formatter.

impl<'de, K, V> Deserialize<'de> for SyncBtreeMap<K, V>where
    K: Eq + Hash + Ord + 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: Eq + Hash, V> From<BTreeMap<K, V, Global>> for SyncBtreeMap<K, V>

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

Converts to this type from the input type.

impl<'a, K: Eq + Hash, V> IntoIterator for &'a SyncBtreeMap<K, V>

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: Eq + Hash, V> IntoIterator for SyncBtreeMap<K, V>

type Item = (K, V)

The type of the elements being iterated over.

type IntoIter = IntoIter<K, V, Global>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K: Eq + Hash, V> Serialize for SyncBtreeMap<K, V>where
    K: Eq + Hash + Serialize + Ord,
    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 SyncBtreeMap<K, V>

this is safety, dirty mutex ensure

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

this is safety, dirty mutex ensure