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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
use super::*;
pub struct Entry<'a, V> {
pub(crate) value: &'a mut Option<V>,
}
impl<'a, K, V> DeltaHashMap<K, V>
where
K: Hash + Eq,
V: Clone,
{
pub fn entry(&'a mut self, key: K) -> Entry<'a, V> {
let state = self.base.get(&key);
let value = self.delta.entry(key).or_insert_with(|| state.cloned());
Entry { value }
}
}
impl<'a, V> Entry<'a, V> {
/// Ensures a value is in the entry by inserting the default if empty, and returns
/// a mutable reference to the value in the entry.
///
/// # Examples
///
/// ```
/// use delta_collections::DeltaHashMap as HashMap;
///
/// let mut map: HashMap<&str, u32> = HashMap::new();
///
/// map.entry("poneyland").or_insert(3);
/// assert_eq!(map["poneyland"], 3);
///
/// *map.entry("poneyland").or_insert(10) *= 2;
/// assert_eq!(map["poneyland"], 6);
/// ```
#[inline]
pub fn or_insert(self, default: V) -> &'a mut V {
self.value.get_or_insert(default)
}
/// Ensures a value is in the entry by inserting the result of the default function if empty,
/// and returns a mutable reference to the value in the entry.
///
/// # Examples
///
/// ```
/// use delta_collections::DeltaHashMap as HashMap;
///
/// let mut map = HashMap::new();
/// let value = "hoho";
///
/// map.entry("poneyland").or_insert_with(|| value);
///
/// assert_eq!(map["poneyland"], "hoho");
/// ```
#[inline]
pub fn or_insert_with<F: FnOnce() -> V>(self, default: F) -> &'a mut V {
self.value.get_or_insert_with(default)
}
// /// Ensures a value is in the entry by inserting, if empty, the result of the default function.
// /// This method allows for generating key-derived values for insertion by providing the default
// /// function a reference to the key that was moved during the `.entry(key)` method call.
// ///
// /// The reference to the moved key is provided so that cloning or copying the key is
// /// unnecessary, unlike with `.or_insert_with(|| ... )`.
// ///
// /// # Examples
// ///
// /// ```
// /// use delta_collections::DeltaHashMap as HashMap;
// ///
// /// let mut map: HashMap<&str, usize> = HashMap::new();
// ///
// /// map.entry("poneyland").or_insert_with_key(|key| key.chars().count());
// ///
// /// assert_eq!(map["poneyland"], 9);
// /// ```
// #[inline]
// pub fn or_insert_with_key<F: FnOnce(&K) -> V>(self, default: F) -> &'a mut V {
// match self {
// Occupied(entry) => entry.into_mut(),
// Vacant(entry) => {
// let value = default(entry.key());
// entry.insert(value)
// }
// }
// }
// /// Returns a reference to this entry's key.
// ///
// /// # Examples
// ///
// /// ```
// /// use delta_collections::DeltaHashMap as HashMap;
// ///
// /// let mut map: HashMap<&str, u32> = HashMap::new();
// /// assert_eq!(map.entry("poneyland").key(), &"poneyland");
// /// ```
// #[inline]
// pub fn key(&self) -> &K {
// match *self {
// Occupied(ref entry) => entry.key(),
// Vacant(ref entry) => entry.key(),
// }
// }
/// Provides in-place mutable access to an occupied entry before any
/// potential inserts into the map.
///
/// # Examples
///
/// ```
/// use delta_collections::DeltaHashMap as HashMap;
///
/// let mut map: HashMap<&str, u32> = HashMap::new();
///
/// map.entry("poneyland")
/// .and_modify(|e| { *e += 1 })
/// .or_insert(42);
/// assert_eq!(map["poneyland"], 42);
///
/// map.entry("poneyland")
/// .and_modify(|e| { *e += 1 })
/// .or_insert(42);
/// assert_eq!(map["poneyland"], 43);
/// ```
#[inline]
pub fn and_modify<F>(self, f: F) -> Self
where
F: FnOnce(&mut V),
{
if let Some(v) = self.value {
f(v);
}
self
}
// /// Sets the value of the entry, and returns an `OccupiedEntry`.
// ///
// /// # Examples
// ///
// /// ```
// /// #![feature(entry_insert)]
// /// use delta_collections::DeltaHashMap as HashMap;
// ///
// /// let mut map: HashMap<&str, String> = HashMap::new();
// /// let entry = map.entry("poneyland").insert_entry("hoho".to_string());
// ///
// /// assert_eq!(entry.key(), &"poneyland");
// /// ```
// #[inline]
// #[unstable(feature = "entry_insert", issue = "65225")]
// pub fn insert_entry(self, value: V) -> OccupiedEntry<'a, K, V> {
// match self {
// Occupied(mut entry) => {
// entry.insert(value);
// entry
// }
// Vacant(entry) => entry.insert_entry(value),
// }
// }
}
impl<'a, V: Default> Entry<'a, V> {
/// Ensures a value is in the entry by inserting the default value if empty,
/// and returns a mutable reference to the value in the entry.
///
/// # Examples
///
/// ```
/// # fn main() {
/// use delta_collections::DeltaHashMap as HashMap;
///
/// let mut map: HashMap<&str, Option<u32>> = HashMap::new();
/// map.entry("poneyland").or_default();
///
/// assert_eq!(map["poneyland"], None);
/// # }
/// ```
#[inline]
pub fn or_default(self) -> &'a mut V {
self.or_insert_with(Default::default)
}
}