Method load

atomic-repository/src/repository/insert.rs:164–199

(
        &mut self,
        txn: &T,
        inode: Inode,
    )

    }

    fn load<T>(
        &mut self,
        txn: &T,
        inode: Inode,
    ) -> Result<&ImportGraphFirstInodeCache, RepositoryError>
    where
        T: TreeTxnT,
    {
        if let std::collections::hash_map::Entry::Vacant(entry) = self.by_inode.entry(inode) {
            let mut inode_cache = ImportGraphFirstInodeCache::default();
            let vertices = txn
                .iter_inode_vertices(inode)
                .map_err(|e| RepositoryError::Database(e.to_string()))?;
            for result in vertices {
                let (node, _edge) = result.map_err(|e| RepositoryError::Database(e.to_string()))?;
                inode_cache.by_end.entry(node.end_pos()).or_insert(node);
                inode_cache
                    .by_start
                    .entry(node.start_pos())
                    .and_modify(|existing| {
                        if existing.start == existing.end && node.start != node.end {
                            *existing = node;
                        }
                    })
                    .or_insert(node);
            }
            entry.insert(inode_cache);
        }

        self.by_inode.get(&inode).ok_or_else(|| {
            RepositoryError::Apply(format!(
                "missing import vertex cache for inode {}",
                inode.get()
            ))
        })
    }
}

type PendingImportEdge = (