Method get_file_content

atomic-repository/src/repository/content.rs:27–113

Get the recorded content for a tracked file. This method builds a **change filter** that defines the current view's content perspective, then retrieves file content through the raw transaction. Since all edges live in the global GRAPH, the raw transaction sees everything — the change filter handles view isolation. # Arguments `path` - Path to the file (relative to repository root) # Returns

(
        &self,
        path: P,
    )

    /// let content = repo.get_file_content("src/main.rs")?;
    /// ```
    pub fn get_file_content<P: AsRef<Path>>(
        &self,
        path: P,
    ) -> Result<Option<Vec<u8>>, RepositoryError> {
        use atomic_core::output::alive::RetrieveOptions;
        let path = path.as_ref();
        let normalized = normalize_path(path);

        let txn = self
            .pristine
            .read_txn()
            .map_err(|e| RepositoryError::Database(e.to_string()))?;

        let view = txn
            .get_view(&self.current_view)
            .map_err(|e| RepositoryError::Database(e.to_string()))?
            .ok_or_else(|| RepositoryError::ViewNotFound {
                name: self.current_view.clone(),
            })?;

        // Check if file is tracked (tree tables are global)
        if !is_tracked(&txn, &normalized).map_err(|e| RepositoryError::Database(e.to_string()))? {
            return Ok(None);
        }

        // Get inode → position
        let inode = match get_inode(&txn, &normalized) {
            Ok(Some(inode)) => inode,
            Ok(None) => return Ok(None),
            Err(e) => return Err(RepositoryError::Database(e.to_string())),
        };

        let position = match txn.inode_position(inode) {
            Ok(Some(pos)) => pos,
            Ok(None) => return Ok(None),
            Err(e) => return Err(RepositoryError::Database(e.to_string())),
        };

        // NOTE on CRDT-driven output (task #24):
        // The new `output_file_via_crdt` walker in atomic_core::output::crdt
        // is faster and avoids the byte-graph linear-walker bugs that
        // overcount bytes on multi-edge vertices.  Callers that want the
        // *materialized* (no-filter, single-view) content can call it
        // directly via `get_file_content_via_crdt`.
        //
        // We don't use it here because this entry point honors the
        // view's `change_filter`, and the CRDT walker reads
        // `branch.state` directly — the materialized state across all
        // applied changes.  For multi-view scenarios that would expose
        // branches from views the caller isn't on.
        //
        // Wiring the CRDT walker into the filter-aware path requires
        // either (a) per-(change, branch) state-change tracking or
        // (b) replaying BranchOps from filter-in changes — both deferred.

        // Always build the change filter.
        //
        // There is no "fast path" for shared root views: draft views