clashmap 1.2.1

Sharded hashmap suitable for fast concurrent access
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

use hashbrown::hash_table;

use core::mem;

pub enum EntryMut<'a, T> {
    Occupied(OccupiedEntryMut<'a, T>),
    Vacant(VacantEntryMut<'a, T>),
}

impl<'a, T> EntryMut<'a, T> {
    /// Apply a function to the stored value if it exists.
    pub fn and_modify(self, f: impl FnOnce(&mut T)) -> Self {
        match self {
            EntryMut::Occupied(mut entry) => {
                f(entry.get_mut());

                EntryMut::Occupied(entry)
            }

            EntryMut::Vacant(entry) => EntryMut::Vacant(entry),
        }
    }

    /// Return a mutable reference to the element if it exists,
    /// otherwise insert the default and return a mutable reference to that.
    pub fn or_default(self) -> &'a mut T
    where
        T: Default,
    {
        match self {
            EntryMut::Occupied(entry) => entry.into_mut(),
            EntryMut::Vacant(entry) => entry.insert(T::default()),
        }
    }

    /// Return a mutable reference to the element if it exists,
    /// otherwise a provided value and return a mutable reference to that.
    pub fn or_insert(self, value: T) -> &'a mut T {
        match self {
            EntryMut::Occupied(entry) => entry.into_mut(),
            EntryMut::Vacant(entry) => entry.insert(value),
        }
    }

    /// 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.
    pub fn or_insert_with(self, value: impl FnOnce() -> T) -> &'a mut T {
        match self {
            EntryMut::Occupied(entry) => entry.into_mut(),
            EntryMut::Vacant(entry) => entry.insert(value()),
        }
    }

    pub fn or_try_insert_with<E>(
        self,
        value: impl FnOnce() -> Result<T, E>,
    ) -> Result<&'a mut T, E> {
        match self {
            EntryMut::Occupied(entry) => Ok(entry.into_mut()),
            EntryMut::Vacant(entry) => Ok(entry.insert(value()?)),
        }
    }

    /// Sets the value of the entry, and returns a reference to the inserted value.
    pub fn insert(self, value: T) -> &'a mut T {
        match self {
            EntryMut::Occupied(mut entry) => {
                entry.insert(value);
                entry.into_mut()
            }
            EntryMut::Vacant(entry) => entry.insert(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.
    ///
    /// [`insert`]: EntryMut::insert
    pub fn insert_entry(self, value: T) -> OccupiedEntryMut<'a, T> {
        match self {
            EntryMut::Occupied(mut entry) => {
                entry.insert(value);
                entry
            }
            EntryMut::Vacant(entry) => entry.insert_entry(value),
        }
    }
}

pub struct VacantEntryMut<'a, T> {
    pub(crate) entry: hash_table::VacantEntry<'a, T>,
}

impl<'a, T> VacantEntryMut<'a, T> {
    pub(crate) fn new(entry: hash_table::VacantEntry<'a, T>) -> Self {
        Self { entry }
    }

    pub fn insert(self, value: T) -> &'a mut T {
        let occupied = self.entry.insert(value);
        occupied.into_mut()
    }

    /// Sets the value of the entry with the VacantEntry’s key, and returns an OccupiedEntry.
    pub fn insert_entry(self, value: T) -> OccupiedEntryMut<'a, T> {
        let entry = self.entry.insert(value);
        OccupiedEntryMut::new(entry)
    }
}

pub struct OccupiedEntryMut<'a, T> {
    pub(crate) entry: hash_table::OccupiedEntry<'a, T>,
}

impl<'a, T> OccupiedEntryMut<'a, T> {
    pub(crate) fn new(entry: hash_table::OccupiedEntry<'a, T>) -> Self {
        Self { entry }
    }

    pub fn get(&self) -> &T {
        self.entry.get()
    }

    pub fn get_mut(&mut self) -> &mut T {
        self.entry.get_mut()
    }

    pub fn insert(&mut self, value: T) -> T {
        mem::replace(self.get_mut(), value)
    }

    pub fn into_mut(self) -> &'a mut T {
        self.entry.into_mut()
    }

    pub fn remove(self) -> T {
        let (v, _) = self.entry.remove();
        v
    }

    pub fn remove_entry(self) -> (T, VacantEntryMut<'a, T>) {
        let (v, e) = self.entry.remove();
        (v, VacantEntryMut::new(e))
    }
}