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,
    },
    ParseError(String),
    MissingComponent {
        component: &'static str,
    },
    PathNotAbsolute(PathBuf),
    PathNotRelative(PathBuf),
    FileNameContainsInvalidChars(PathBuf, char),
    FileNameIsEmpty,
    DeprecatedLicense(String),
    InvalidComponent {
        component: &'static str,
        context: &'static str,
    },
    InvalidOpenPGPv4Fingerprint,
    InvalidOpenPGPKeyId(String),
    InvalidSonameV1(&'static str),
    Package(PackageError),
    UnknownCompressionAlgorithmFileExtension {
        value: String,
    },
    UnknownFileTypeIdentifier {
        value: String,
    },
}

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

The reason for the invalid integer.

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

The reason for the invalid semantic version.

ValueContainsInvalidChars

Value contains an invalid character

Fields

invalid_char: char

The invalid character

IncorrectLength

Value length is incorrect

Fields

length: usize

The incorrect length.

expected: usize

The expected length.

DelimiterNotFound

Value is missing a delimiter character

Fields

delimiter: char

The required delimiter.

ValueDoesNotMatchRestrictions

Value does not match the restrictions

Fields

restrictions: Vec<String>

The list of restrictions that cannot be met.

RegexDoesNotMatch

A validation regex does not match the value

Fields

value: String

The value that does not match.

regex_type: String

The type of regular expression applied to the value.

regex: String

The regular expression applied to the value.

ParseError(String)

A winnow parser for a type didn’t work and produced an error.

MissingComponent

Missing field in a value

Fields

component: &'static str

The component that is missing.

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

InvalidComponent

A component is invalid and cannot be used.

Fields

component: &'static str

The invalid component

context: &'static str

The context in which the error occurs.

This is meant to complete the sentence “Invalid component {component} encountered while “.

InvalidOpenPGPv4Fingerprint

An invalid OpenPGP v4 fingerprint

InvalidOpenPGPKeyId(String)

An invalid OpenPGP key ID

InvalidSonameV1(&'static str)

An invalid shared object name (v1)

Package(PackageError)

A package data error.

UnknownCompressionAlgorithmFileExtension

A string represents an unknown compression algorithm file extension.

Fields

value: String

A String representing an unknown compression algorithm file extension.

UnknownFileTypeIdentifier

A string represents an unknown file type identifier.

Fields

value: String

A String representing an unknown file type identifier.

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

fn from(source: PackageError) -> Self

Converts to this type from the input type.

impl<'a> From<ParseError<&'a str, ContextError>> for Error

fn from(value: ParseError<&'a str, ContextError>) -> Self

Converts a [winnow::error::ParseError] into an Error::ParseError.

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

fn from(e: ParseIntError) -> Self

Converts a std::num::ParseIntError into an Error::InvalidInteger.

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