Struct RestoreReport 

pub struct RestoreReport {

    pub dest: PathBuf,
    pub manifest: Manifest,
    pub dry_run: bool,
    pub entries_written: u64,
    pub destination_exists: bool,
    pub would_overwrite: Vec<String>,
    pub would_remain: Vec<String>,
    pub rewritten_worktrees: Vec<String>,
    pub missing_worktrees: Vec<String>,
    pub conflicting_worktrees: Vec<WorktreeConflict>,
    pub missing_worktree_parent: Option<String>,
    pub dangling_symlinks: Vec<SymlinkRecord>,
    pub link_reports_suppressed: Vec<String>,
    pub regenerable_caches: Vec<CacheRecord>,
    pub secrets_not_carried: Vec<SkipRecord>,
    pub hard_links_not_created: Vec<HardLinkRecord>,
}

What restore did — or, on a dry run, what it would do.

Fields

dest: PathBuf

Where the project was restored, or would be.

manifest: Manifest

Manifest read from the archive.

dry_run: bool

Whether this was a prediction rather than a restore.

entries_written: u64

Number of entries written, or that would be written.

destination_exists: bool

Whether the destination already exists.

Only meaningful on a dry run; a real restore either refused or was given force.

would_overwrite: Vec<String>

Existing files the restore would replace.

Populated on a dry run only. Empty when the destination is new.

would_remain: Vec<String>

Existing files the pack does not carry, which would survive the restore.

This is the concrete form of “--force overwrites, it does not wipe”: everything listed here is still there afterwards. Populated on a dry run only.

rewritten_worktrees: Vec<String>

Worktrees whose pointer files were rewritten for the new location.

Includes worktrees that live beside the root rather than inside it: their contents travel in their own pack, but the wiring is repaired here as soon as both halves are on this machine.

missing_worktrees: Vec<String>

Worktrees registered at pack time whose checkout is not on this machine.

Their contents are not in this pack — restore the pack that holds them and the wiring completes itself, in either order.

conflicting_worktrees: Vec<WorktreeConflict>

Worktree pairings left unwired because the counterpart’s place is occupied by something that is not this worktree’s other half.

Nothing was written: wiring writes both pointer files, and one of them belongs to whatever is sitting there — an unrelated repository, or a worktree of a different one. Overwriting it would break that project to repair this one, so the collision is reported and the decision is the operator’s.

missing_worktree_parent: Option<String>

Set when this pack is a worktree checkout and its repository was not found beside the restored root, leaving the checkout with no repository.

Holds the repository’s path as of pack time, as a hint for where its pack belongs.

dangling_symlinks: Vec<SymlinkRecord>

Restored symlinks whose targets do not exist on this machine.

Covers every link the pack reported. Links the pack’s author declared under no_link_report are restored but never checked here, which is what Self::link_reports_suppressed exists to say.

link_reports_suppressed: Vec<String>

no_link_report rules that were in force when this pack was written.

Informational, and deliberately not part of Self::needs_attention: the author declared those links expected, so there is nothing to act on. It is reported anyway because otherwise an empty dangling_symlinks reads as “every link here is fine” when it means “every link I was allowed to look at is fine”.

regenerable_caches: Vec<CacheRecord>

Cache directories the pack deliberately dropped; regenerate as needed.

Each carries the file count and size that went with it, so a directory that was named a cache by mistake is visible as one whose figures do not look like a build tree’s.

secrets_not_carried: Vec<SkipRecord>

Secrets the pack deliberately did not carry; move them out of band.

hard_links_not_created: Vec<HardLinkRecord>

Hard links the archive carried, which this restore did not create.

Each carries the command that would create it. Deciding whether to run it is the operator’s, which is the whole reason the entry is listed here rather than acted on — see HardLinkRecord.

Implementations

impl RestoreReport

pub fn needs_attention(&self) -> bool

Whether anything needs operator attention after the restore.

On a dry run this reads as “would need attention”, and additionally counts a destination that already holds files: proceeding there needs --force, and whatever the pack does not carry stays behind.

Trait Implementations

impl Clone for RestoreReport

fn clone(&self) -> RestoreReport

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RestoreReport

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.