Method get_lazy_object

src/models/cache_loader.rs:189–245

(
        &self,
        file_index: FileIndex<IndexFileId>,
        max_loads: u16,
        skipm: &mut FxHashSet<u64>,
    )

    }

    pub fn get_lazy_object(
        &self,
        file_index: FileIndex<IndexFileId>,
        max_loads: u16,
        skipm: &mut FxHashSet<u64>,
    ) -> Result<SharedNode, BufIoError> {
        let combined_index = Self::combine_index(&file_index);

        if let Some(item) = self.registry.get(&combined_index) {
            return Ok(item);
        }

        if max_loads == 0 || !skipm.insert(combined_index) {
            return Ok(LazyItem::new_pending(file_index));
        }

        let mut mutex = self
            .loading_items
            .get_or_create(combined_index, || Arc::new(Mutex::new(false)));
        let mut load_complete = mutex.lock().unwrap();

        loop {
            // check again
            if let Some(item) = self.registry.get(&combined_index) {
                return Ok(item);
            }

            // another thread loaded the data but its not in the registry (got evicted), retry
            if *load_complete {
                drop(load_complete);
                mutex = self
                    .loading_items
                    .get_or_create(combined_index, || Arc::new(Mutex::new(false)));
                load_complete = mutex.lock().unwrap();
                continue;
            }

            break;
        }

        let bufman = self.bufmans.get(file_index.file_id)?;
        let data = ProbNode::deserialize(
            &bufman,
            &self.latest_version_links_bufman,
            file_index,
            self,
            max_loads - 1,
            skipm,
        )?;
        let item = LazyItem::new(data, file_index.file_id, file_index.offset);

        self.registry.insert(combined_index, item);
        *load_complete = true;
        self.loading_items.delete(&combined_index);

        Ok(item)
    }