Enum Error

pub enum Error {
    InvalidInteger {
        kind: IntErrorKind,
    },
    InvalidVariant(ParseError),
    InvalidEmail(Error),
    InvalidUrl(ParseError),
    InvalidLicense(ParseError),
    InvalidSemver {
        kind: String,
    },
    ValueContainsInvalidChars {
        invalid_char: char,
    },
    IncorrectLength {
        length: usize,
        expected: usize,
    },
    DelimiterNotFound {
        delimiter: char,
    },
    ValueDoesNotMatchRestrictions {
        restrictions: Vec<String>,
    },
    RegexDoesNotMatch {
        value: String,
        regex_type: String,
        regex: String,
    },
    MissingComponent {
        component: &'static str,
    },
    PathNotAbsolute(PathBuf),
    PathNotRelative(PathBuf),
    FileNameContainsInvalidChars(PathBuf, char),
    FileNameIsEmpty,
    DeprecatedLicense(String),
    InvalidOpenPGPv4Fingerprint,
}

The library’s error type

These errors are usually parsing errors and they each contain a context about why the error has occurred and the value that caused the error.

The original error is also included in the variants that have the source field. You can access it using the source() method. See Error::source for more information.

Variants

InvalidInteger

An invalid integer

Fields

kind: IntErrorKind

InvalidVariant(ParseError)

An invalid enum variant

InvalidEmail(Error)

An invalid email address

InvalidUrl(ParseError)

An invalid URL

InvalidLicense(ParseError)

An invalid license

InvalidSemver

An invalid semantic version string

This error occurs when a semantic version cannot be parsed from a string We cannot use #[source] semver::Error here because it does not implement PartialEq. See: https://github.com/dtolnay/semver/issues/326

TODO: Use the error source when the issue above is resolved.

Fields

kind: String

ValueContainsInvalidChars

Value contains invalid characters

Fields

invalid_char: char

IncorrectLength

Value length is incorrect

Fields

length: usize

expected: usize

DelimiterNotFound

Value is missing a delimiter character

Fields

delimiter: char

ValueDoesNotMatchRestrictions

Value does not match the restrictions

Fields

restrictions: Vec<String>

RegexDoesNotMatch

A validation regex does not match the value

Fields

value: String

regex_type: String

regex: String

MissingComponent

Missing field in a value

Fields

component: &'static str

PathNotAbsolute(PathBuf)

An invalid absolute path (i.e. does not start with a /)

PathNotRelative(PathBuf)

An invalid relative path (i.e. starts with a /)

FileNameContainsInvalidChars(PathBuf, char)

File name contains invalid characters

FileNameIsEmpty

File name is empty

DeprecatedLicense(String)

A deprecated license

InvalidOpenPGPv4Fingerprint

An invalid OpenPGP v4 fingerprint

Trait Implementations

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

Formats the value using the given formatter.

impl Error for Error

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<Error> for Error

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<ParseError> for Error

fn from(source: ParseError) -> Self

Converts to this type from the input type.

impl From<ParseError> for Error

fn from(source: ParseError) -> Self

Converts to this type from the input type.

impl From<ParseError> for Error

fn from(source: ParseError) -> Self

Converts to this type from the input type.

impl PartialEq for Error

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