Enum StrictApplyError 

#[non_exhaustive]
pub enum StrictApplyError {
    Patch(PatchError),
    PartialApply {
        report: ApplyResult,
    },
}

Represents errors that can occur during “strict” apply operations.

This enum is returned by functions like try_apply_patch_to_file() and try_apply_patch_to_content(), which treat partial applications as an error. It consolidates hard failures (PatchError) and soft failures (StrictApplyError::PartialApply) into a single error type for easier handling in apply-or-fail workflows.

Example

use mpatch::{parse_single_patch, try_apply_patch_to_content, ApplyOptions, StrictApplyError};

let original_content = "line 1\nline 2\n";
// This patch will fail because the context "WRONG CONTEXT" is not in the original content.
let failing_diff = r#"
```diff
--- a/file.txt
+++ b/file.txt
@@ -1,2 +1,2 @@
 line 1
-WRONG CONTEXT
+line two
```
"#;
let patch = parse_single_patch(failing_diff)?;
let options = ApplyOptions::exact();

// Using the try_ variant simplifies error handling for partial applications.
let result = try_apply_patch_to_content(&patch, Some(original_content), &options);

assert!(matches!(result, Err(StrictApplyError::PartialApply { .. })));
if let Err(StrictApplyError::PartialApply { report }) = result {
    assert!(!report.all_applied_cleanly());
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Patch(PatchError)

A hard error occurred during the patch operation (e.g., I/O error, file not found).

PartialApply

The patch was only partially applied, with some hunks failing.

Fields

report: ApplyResult

The detailed report of the operation, including which hunks succeeded/failed.

Trait Implementations

impl Debug for StrictApplyError

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

Formats the value using the given formatter.

impl Display for StrictApplyError

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

Formats the value using the given formatter.

impl Error for StrictApplyError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<PatchError> for StrictApplyError

fn from(source: PatchError) -> Self

Converts to this type from the input type.

impl From<StrictApplyError> for OneShotError

fn from(source: StrictApplyError) -> Self

Converts to this type from the input type.