Method get_or_insert

src/models/lru_cache.rs:236–274

Gets the value from the cache if it exists, else tries to insert the result of the fn `f` into the cache and returns the same

(
        &self,
        key: K,
        f: impl FnOnce() -> Result<V, E>,
    )

    /// insert the result of the fn `f` into the cache and returns the
    /// same
    pub fn get_or_insert<E>(
        &self,
        key: K,
        f: impl FnOnce() -> Result<V, E>,
    ) -> Result<CachedValue<V>, E> {
        let mut inserted = false;
        let k1 = key.clone();
        let k2 = key.clone();
        let res = self
            .map
            .entry(key)
            .and_modify(|(_, counter)| {
                let old_counter = *counter;
                let new_counter = self.increment_counter();
                self.index.on_cache_hit(old_counter, new_counter, k1.into());
                *counter = new_counter;
            })
            .or_try_insert_with(|| {
                inserted = true;
                let counter = self.increment_counter();
                self.index.on_cache_miss(counter, k2.into());
                f().map(|v| (v, counter))
            })
            .map(|v| v.0.clone());
        // @NOTE: We need to clone the value before calling
        // `self.evict`, that too in a separate block! Otherwise
        // it causes some deadlock
        match res {
            Ok(v) => {
                if inserted {
                    self.evict();
                    Ok(CachedValue::Miss(v))
                } else {
                    Ok(CachedValue::Hit(v))
                }
            }
            Err(e) => Err(e),
        }
    }

    fn evict(&self) {
        if self.map.len() > self.capacity {