Method get

arc-disk-cache/src/lib.rs:483–535

(&self, q: &Q)

    }

    pub fn get<Q>(&self, q: &Q) -> Option<CacheObj<K, D>>
    where
        K: Borrow<Q>,
        Q: Hash + Eq + Ord + ?Sized,
    {
        let mut rtxn = self.cache.read();
        let maybe_obj = rtxn
            .get(q)
            .and_then(|obj| {
                let mut file = File::open(&obj.fhandle.path).ok()?;

                let amt = file
                    .metadata()
                    .map(|m| m.len() as usize)
                    .map_err(|e| {
                        error!("Unable to access metadata -> {:?}", e);
                    })
                    .ok()?;

                if !self.durable_fs {
                    if amt < CHECK_INLINE {
                        let crc_ck = crc32c_len(&mut file).ok()?;
                        if crc_ck != obj.fhandle.crc {
                            warn!("file potentially corrupted - {:?}", obj.fhandle.meta_path);
                            return None;
                        }
                    } else {
                        info!("Skipping crc check, file too large");
                    }
                }

                Some(obj)
            })
            .cloned();

        // We manually quiesce and finish for stat management here
        // In theory, this should only affect hit counts since evict / include
        // should only occur in a write with how this is setup
        rtxn.finish();

        let mut stat_guard = self.stats.write();
        stat_guard.ops += 1;
        if maybe_obj.is_some() {
            stat_guard.hits += 1;
        }
        stat_guard.ratio = (f64::from(stat_guard.hits) / f64::from(stat_guard.ops)) * 100.0;

        let stats = self.cache.try_quiesce_stats(TraceStat::default());
        stat_guard.update(stats);
        stat_guard.commit();

        maybe_obj
    }

    pub fn path(&self) -> &Path {
        &self.content_dir