Enum SingleParseError 

#[non_exhaustive]
pub enum SingleParseError {
    Parse(ParseError),
    NoPatchesFound,
    MultiplePatchesFound(usize),
}

Represents errors that can occur when parsing a diff expected to contain exactly one patch.

This enum is returned by parse_single_patch() when the input content does not result in exactly one Patch object. It handles errors from format detection, parsing, and patch count validation.

Example

use mpatch::{parse_single_patch, SingleParseError};

// This diff content contains two patches, which is not allowed.
let multi_patch_diff = r#"
```diff
--- a/file1.txt
+++ b/file1.txt
@@ -1 +1 @@
-a
+b
--- a/file2.txt
+++ b/file2.txt
@@ -1 +1 @@
-c
+d
```
"#;

let result = parse_single_patch(multi_patch_diff);
assert!(matches!(result, Err(SingleParseError::MultiplePatchesFound(2))));

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.

Parse(ParseError)

An error occurred during the underlying diff parsing.

NoPatchesFound

The provided diff content did not contain any valid patches (Markdown blocks, Unified Diffs, or Conflict Markers).

MultiplePatchesFound(usize)

The provided diff content contained patches for more than one file, which is not supported by this function. Use parse_diffs() for multi-file operations.

Trait Implementations

impl Debug for SingleParseError

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

Formats the value using the given formatter.

impl Display for SingleParseError

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

Formats the value using the given formatter.

impl Error for SingleParseError

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<ParseError> for SingleParseError

fn from(source: ParseError) -> Self

Converts to this type from the input type.

impl PartialEq for SingleParseError

fn eq(&self, other: &SingleParseError) -> 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 SingleParseError