near_sdk/store/lookup_map/entry.rs
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 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365
use crate::env::abort;
use crate::utils::CacheEntry;
/// A view into a single entry in the map, which can be vacant or occupied.
pub enum Entry<'a, K: 'a, V: 'a> {
Occupied(OccupiedEntry<'a, K, V>),
Vacant(VacantEntry<'a, K, V>),
}
impl<'a, K, V> Entry<'a, K, V> {
/// Returns a reference to this entry's key.
///
/// # Examples
///
/// ```
/// use near_sdk::store::LookupMap;
///
/// let mut map: LookupMap<String, u32> = LookupMap::new(b"m");
/// assert_eq!(map.entry("poneyland".to_string()).key(), "poneyland");
/// ```
pub fn key(&self) -> &K {
match self {
Entry::Occupied(entry) => entry.key(),
Entry::Vacant(entry) => entry.key(),
}
}
/// 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 near_sdk::store::LookupMap;
///
/// let mut map: LookupMap<String, u32> = LookupMap::new(b"m");
///
/// map.entry("poneyland".to_string()).or_insert(3);
/// assert_eq!(map["poneyland"], 3);
///
/// *map.entry("poneyland".to_string()).or_insert(10) *= 2;
/// assert_eq!(map["poneyland"], 6);
/// ```
pub fn or_insert(self, default: V) -> &'a mut V {
self.or_insert_with(|| 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 near_sdk::store::LookupMap;
///
/// let mut map: LookupMap<String, String> = LookupMap::new(b"m");
/// let s = "hoho".to_string();
///
/// map.entry("poneyland".to_string()).or_insert_with(|| s);
///
/// assert_eq!(map["poneyland"], "hoho".to_string());
/// ```
pub fn or_insert_with<F: FnOnce() -> V>(self, default: F) -> &'a mut V {
self.or_insert_with_key(|_| 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 near_sdk::store::LookupMap;
///
/// let mut map: LookupMap<String, u32> = LookupMap::new(b"m");
///
/// map.entry("poneyland".to_string()).or_insert_with_key(|key| key.chars().count() as u32);
///
/// assert_eq!(map["poneyland"], 9);
/// ```
pub fn or_insert_with_key<F: FnOnce(&K) -> V>(self, default: F) -> &'a mut V {
match self {
Self::Occupied(entry) => entry.into_mut(),
Self::Vacant(entry) => {
let value = default(entry.key());
entry.insert(value)
}
}
}
/// 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 near_sdk::store::LookupMap;
///
/// let mut map: LookupMap<String, Option<u32>> = LookupMap::new(b"m");
/// map.entry("poneyland".to_string()).or_default();
///
/// assert_eq!(map["poneyland"], None);
/// # }
/// ```
pub fn or_default(self) -> &'a mut V
where
V: Default,
{
match self {
Self::Occupied(entry) => entry.into_mut(),
Self::Vacant(entry) => entry.insert(Default::default()),
}
}
/// Provides in-place mutable access to an occupied entry before any
/// potential inserts into the map.
///
/// # Examples
///
/// ```
/// use near_sdk::store::LookupMap;
///
/// let mut map: LookupMap<String, u32> = LookupMap::new(b"m");
///
/// map.entry("poneyland".to_string())
/// .and_modify(|e| { *e += 1 })
/// .or_insert(42);
/// assert_eq!(map["poneyland"], 42);
///
/// map.entry("poneyland".to_string())
/// .and_modify(|e| { *e += 1 })
/// .or_insert(42);
/// assert_eq!(map["poneyland"], 43);
/// ```
pub fn and_modify<F>(mut self, f: F) -> Self
where
F: FnOnce(&mut V),
{
if let Self::Occupied(entry) = &mut self {
f(entry.get_mut());
}
self
}
}
/// View into an occupied entry in a [`LookupMap`](super::LookupMap).
/// This is part of the [`Entry`] enum.
pub struct OccupiedEntry<'a, K, V> {
pub(super) key: K,
pub(super) entry: &'a mut CacheEntry<V>,
}
impl<'a, K, V> OccupiedEntry<'a, K, V> {
/// Gets a reference to the key in the entry.
pub fn key(&self) -> &K {
&self.key
}
/// Take the ownership of the key and value from the map.
///
/// # Examples
///
/// ```
/// use near_sdk::store::LookupMap;
/// use near_sdk::store::lookup_map::Entry;
///
/// let mut map: LookupMap<String, u32> = LookupMap::new(b"m");
/// map.entry("poneyland".to_string()).or_insert(12);
///
/// if let Entry::Occupied(o) = map.entry("poneyland".to_string()) {
/// // We delete the entry from the map.
/// o.remove_entry();
/// }
///
/// assert_eq!(map.contains_key("poneyland"), false);
/// ```
pub fn remove_entry(self) -> (K, V) {
// OnceCell guaranteed to be filled and value to be `Some` in occupied entry
let value = self.entry.value_mut().take().unwrap_or_else(|| abort());
(self.key, value)
}
/// Gets a reference to the value in the entry.
///
/// # Examples
///
/// ```
/// use near_sdk::store::LookupMap;
/// use near_sdk::store::lookup_map::Entry;
///
/// let mut map: LookupMap<String, u32> = LookupMap::new(b"m");
/// map.entry("poneyland".to_string()).or_insert(12);
///
/// if let Entry::Occupied(o) = map.entry("poneyland".to_string()) {
/// assert_eq!(o.get(), &12);
/// }
/// ```
pub fn get(&self) -> &V {
// Value guaranteed to be `Some` as it's occupied
self.entry.value().as_ref().unwrap_or_else(|| abort())
}
/// Gets a mutable reference to the value in the entry.
///
/// If you need a reference to the `OccupiedEntry` which may outlive the
/// destruction of the `Entry` value, see [`into_mut`].
///
/// [`into_mut`]: Self::into_mut
///
/// # Examples
///
/// ```
/// use near_sdk::store::LookupMap;
/// use near_sdk::store::lookup_map::Entry;
///
/// let mut map: LookupMap<String, u32> = LookupMap::new(b"m");
/// map.entry("poneyland".to_string()).or_insert(12);
///
/// assert_eq!(map["poneyland"], 12);
/// if let Entry::Occupied(mut o) = map.entry("poneyland".to_string()) {
/// *o.get_mut() += 10;
/// assert_eq!(*o.get(), 22);
///
/// // We can use the same Entry multiple times.
/// *o.get_mut() += 2;
/// }
///
/// assert_eq!(map["poneyland"], 24);
/// ```
pub fn get_mut(&mut self) -> &mut V {
// Value guaranteed to be `Some` as it's occupied
self.entry.value_mut().as_mut().unwrap_or_else(|| abort())
}
/// Converts the `OccupiedEntry` into a mutable reference to the value in the entry
/// with a lifetime bound to the map itself.
///
/// If you need multiple references to the `OccupiedEntry`, see [`get_mut`].
///
/// [`get_mut`]: Self::get_mut
///
/// # Examples
///
/// ```
/// use near_sdk::store::LookupMap;
/// use near_sdk::store::lookup_map::Entry;
///
/// let mut map: LookupMap<String, u32> = LookupMap::new(b"m");
/// map.entry("poneyland".to_string()).or_insert(12);
///
/// assert_eq!(map["poneyland"], 12);
/// if let Entry::Occupied(o) = map.entry("poneyland".to_string()) {
/// *o.into_mut() += 10;
/// }
///
/// assert_eq!(map["poneyland"], 22);
/// ```
pub fn into_mut(self) -> &'a mut V {
// If entry is occupied, value is guaranteed to be `Some`
self.entry.value_mut().as_mut().unwrap_or_else(|| abort())
}
/// Sets the value of the entry, and returns the entry's old value.
///
/// # Examples
///
/// ```
/// use near_sdk::store::LookupMap;
/// use near_sdk::store::lookup_map::Entry;
///
/// let mut map: LookupMap<String, u32> = LookupMap::new(b"m");
/// map.entry("poneyland".to_string()).or_insert(12);
///
/// if let Entry::Occupied(mut o) = map.entry("poneyland".to_string()) {
/// assert_eq!(o.insert(15), 12);
/// }
///
/// assert_eq!(map["poneyland"], 15);
/// ```
pub fn insert(&mut self, value: V) -> V {
self.entry.replace(Some(value)).unwrap_or_else(|| abort())
}
/// Takes the value out of the entry, and returns it.
///
/// # Examples
///
/// ```
/// use near_sdk::store::LookupMap;
/// use near_sdk::store::lookup_map::Entry;
///
/// let mut map: LookupMap<String, u32> = LookupMap::new(b"m");
/// map.entry("poneyland".to_string()).or_insert(12);
///
/// if let Entry::Occupied(o) = map.entry("poneyland".to_string()) {
/// assert_eq!(o.remove(), 12);
/// }
///
/// assert_eq!(map.contains_key("poneyland"), false);
/// ```
pub fn remove(self) -> V {
self.remove_entry().1
}
}
/// View into a vacant entry in a [`LookupMap`](super::LookupMap).
/// This is part of the [`Entry`] enum.
pub struct VacantEntry<'a, K, V> {
pub(super) key: K,
pub(super) entry: &'a mut CacheEntry<V>,
}
impl<'a, K, V> VacantEntry<'a, K, V> {
/// Gets a reference to the key that would be used when inserting a value
/// through the `VacantEntry`.
pub fn key(&self) -> &K {
&self.key
}
/// Take ownership of the key.
///
/// # Examples
///
/// ```
/// use near_sdk::store::LookupMap;
/// use near_sdk::store::lookup_map::Entry;
///
/// let mut map: LookupMap<String, u32> = LookupMap::new(b"m");
///
/// if let Entry::Vacant(v) = map.entry("poneyland".to_string()) {
/// v.into_key();
/// }
/// ```
pub fn into_key(self) -> K {
self.key
}
/// Sets the value of the entry with the `VacantEntry`'s key,
/// and returns a mutable reference to it.
///
/// # Examples
///
/// ```
/// use near_sdk::store::LookupMap;
/// use near_sdk::store::lookup_map::Entry;
///
/// let mut map: LookupMap<String, u32> = LookupMap::new(b"m");
///
/// if let Entry::Vacant(o) = map.entry("poneyland".to_string()) {
/// o.insert(37);
/// }
/// assert_eq!(map["poneyland"], 37);
/// ```
pub fn insert(self, value: V) -> &'a mut V {
self.entry.replace(Some(value));
// Insertion done above, cache is filled and the value is Some
self.entry.value_mut().as_mut().unwrap_or_else(|| abort())
}
}