Add try_get_or_insert() method

Author: redforks

src/lib.rs

@@ -508,6 +508,61 @@ impl<K: Hash + Eq, V, S: BuildHasher> LruCache<K, V, S> {
         }
     }
 
+    /// Returns a reference to the value of the key in the cache if it is
+    /// present in the cache and moves the key to the head of the LRU list.
+    /// If the key does not exist the provided `FnOnce` is used to populate
+    /// the list and a reference is returned. If `FnOnce` returns `Err`,
+    /// returns the `Err`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use lru::LruCache;
+    /// use std::num::NonZeroUsize;
+    /// let mut cache = LruCache::new(NonZeroUsize::new(2).unwrap());
+    ///
+    /// cache.put(1, "a");
+    /// cache.put(2, "b");
+    /// cache.put(2, "c");
+    /// cache.put(3, "d");
+    ///
+    /// let f = ||->Result<&str, String> {Err("failed".to_owned())};
+    /// let a = ||->Result<&str, String> {Ok("a")};
+    /// let b = ||->Result<&str, String> {Ok("b")};
+    /// assert_eq!(cache.try_get_or_insert(2, a), Ok(&"c"));
+    /// assert_eq!(cache.try_get_or_insert(3, a), Ok(&"d"));
+    /// assert_eq!(cache.try_get_or_insert(1, f), Err("failed".to_owned()));
+    /// assert_eq!(cache.try_get_or_insert(1, b), Ok(&"b"));
+    /// assert_eq!(cache.try_get_or_insert(1, a), Ok(&"b"));
+    /// ```
+    pub fn try_get_or_insert<F, E>(&mut self, k: K, f: F) -> Result<&V, E>
+    where
+        F: FnOnce() -> Result<V, E>,
+    {
+        if let Some(node) = self.map.get_mut(&KeyRef { k: &k }) {
+            let node_ptr: *mut LruEntry<K, V> = node.as_ptr();
+
+            self.detach(node_ptr);
+            self.attach(node_ptr);
+
+            unsafe { Ok(&*(*node_ptr).val.as_ptr()) }
+        } else {
+            match f() {
+                Err(e) => Err(e),
+                Ok(v) => {
+                    let (_, node) = self.replace_or_create_node(k, v);
+                    let node_ptr: *mut LruEntry<K, V> = node.as_ptr();
+
+                    self.attach(node_ptr);
+
+                    let keyref = unsafe { (*node_ptr).key.as_ptr() };
+                    self.map.insert(KeyRef { k: keyref }, node);
+                    Ok(unsafe { &*(*node_ptr).val.as_ptr() })
+                }
+            }
+        }
+    }
+
     /// Returns a mutable reference to the value of the key in the cache if it is
     /// present in the cache and moves the key to the head of the LRU list.
     /// If the key does not exist the provided `FnOnce` is used to populate