Struct ApplyResult 

pub struct ApplyResult {
    pub hunk_results: Vec<HunkApplyStatus>,
}

Contains detailed results for each hunk within a patch operation.

This struct provides a granular report on the outcome of a patch application. It is a key component of both PatchResult and InMemoryResult. You can use its methods like all_applied_cleanly() for a high-level summary or failures() to inspect specific issues.

Example

let original_content = "line 1\n";
// This patch will fail because the context is wrong.
let diff = r#"
```diff
--- a/test.txt
+++ b/test.txt
@@ -1 +1 @@
-WRONG CONTEXT
+line 1
```
"#;
let patch = parse_single_patch(diff)?;
let options = ApplyOptions::exact();

let result = apply_patch_to_content(&patch, Some(original_content), &options);
let report = result.report; // This is the ApplyResult

assert!(!report.all_applied_cleanly());
assert_eq!(report.failure_count(), 1);

let failure = &report.failures()[0];
assert_eq!(failure.hunk_index, 1);
assert!(matches!(failure.reason, HunkApplyError::ContextNotFound));

Fields

hunk_results: Vec<HunkApplyStatus>

A list of statuses, one for each hunk in the original patch.

Implementations

impl ApplyResult

pub fn all_applied_cleanly(&self) -> bool

Checks if all hunks in the patch were applied successfully or skipped.

Returns false if any hunk failed to apply.

Example

let successful_result = ApplyResult {
    hunk_results: vec![
        HunkApplyStatus::Applied { location: HunkLocation { start_index: 0, length: 1 }, match_type: MatchType::Exact, replaced_lines: vec!["old".to_string()] },
        HunkApplyStatus::SkippedNoChanges
    ],
};
assert!(successful_result.all_applied_cleanly());

let failed_result = ApplyResult {
    hunk_results: vec![
        HunkApplyStatus::Applied { location: HunkLocation { start_index: 0, length: 1 }, match_type: MatchType::Exact, replaced_lines: vec!["old".to_string()] },
        HunkApplyStatus::Failed(HunkApplyError::ContextNotFound),
    ],
};
assert!(!failed_result.all_applied_cleanly());

pub fn failures(&self) -> Vec<HunkFailure>

Returns a list of all hunks that failed to apply, along with their index.

This provides a more convenient way to inspect failures than iterating through hunk_results manually.

Example

let failed_result = ApplyResult {
    hunk_results: vec![
        // The first hunk applied successfully.
        HunkApplyStatus::Applied { location: HunkLocation { start_index: 0, length: 1 }, match_type: MatchType::Exact, replaced_lines: vec!["old".to_string()] },
        HunkApplyStatus::Failed(HunkApplyError::ContextNotFound),
    ],
};
let failures = failed_result.failures();
assert_eq!(failures.len(), 1);
assert_eq!(failures[0], HunkFailure {
    hunk_index: 2, // 1-based index
    reason: HunkApplyError::ContextNotFound,
});

impl ApplyResult

pub fn has_failures(&self) -> bool

Checks if any hunk in the patch failed to apply.

This is the logical opposite of all_applied_cleanly.

Example

let failed_result = ApplyResult {
    hunk_results: vec![
        HunkApplyStatus::Applied { location: HunkLocation { start_index: 0, length: 1 }, match_type: MatchType::Exact, replaced_lines: vec!["old".to_string()] },
        HunkApplyStatus::Failed(HunkApplyError::ContextNotFound),
    ],
};
assert!(failed_result.has_failures());

let successful_result = ApplyResult {
    hunk_results: vec![ HunkApplyStatus::SkippedNoChanges ],
};
assert!(!successful_result.has_failures());

pub fn failure_count(&self) -> usize

Returns the number of hunks that failed to apply.

This is a convenience method that counts how many hunks in the hunk_results list have a status of HunkApplyStatus::Failed.

Example

let result = ApplyResult {
    hunk_results: vec![
        HunkApplyStatus::Applied { location: HunkLocation { start_index: 0, length: 1 }, match_type: MatchType::Exact, replaced_lines: vec!["old".to_string()] },
        HunkApplyStatus::Failed(HunkApplyError::ContextNotFound),
        HunkApplyStatus::Failed(HunkApplyError::AmbiguousExactMatch(vec![])),
    ],
};
assert_eq!(result.failure_count(), 2);

pub fn success_count(&self) -> usize

Returns the number of hunks that were applied successfully or skipped.

This method counts how many hunks in the hunk_results list have a status of either HunkApplyStatus::Applied or HunkApplyStatus::SkippedNoChanges.

Example

let result = ApplyResult {
    hunk_results: vec![
        HunkApplyStatus::Applied { location: HunkLocation { start_index: 0, length: 1 }, match_type: MatchType::Exact, replaced_lines: vec!["old".to_string()] },
        HunkApplyStatus::SkippedNoChanges,
        HunkApplyStatus::Failed(HunkApplyError::ContextNotFound),
    ],
};
assert_eq!(result.success_count(), 2);

Trait Implementations

impl Clone for ApplyResult

fn clone(&self) -> ApplyResult

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ApplyResult

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

Formats the value using the given formatter.

impl PartialEq for ApplyResult

fn eq(&self, other: &ApplyResult) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for ApplyResult