Enum ValidationError

pub enum ValidationError<'a> {
    RenameToUnknownPackage {
        old: &'a str,
        new: &'a str,
    },
    RenameToItself(&'a str),
    RenameExistingPackage(&'a str),
    ArtefactHasUnknownComponent {
        artefact: ArtefactQuery<'a>,
        component_pkg: &'a str,
    },
    ArtefactComponentHasUnknownTarget {
        artefact: ArtefactQuery<'a>,
        component: ArtefactQuery<'a>,
    },
    ArtefactHasUnknownExtension {
        artefact: ArtefactQuery<'a>,
        extension_pkg: &'a str,
    },
    ArtefactExtensionHasUnknownTarget {
        artefact: ArtefactQuery<'a>,
        extension: ArtefactQuery<'a>,
    },
    DependencyLoop(Vec<ArtefactQuery<'a>>),
    // some variants omitted
}

Possible ways in which channel metadata could be inconsistent.

See Channel::validate for more information.

Variants

RenameToUnknownPackage

The channel’s renames field says package old was renamed to new, but no package named new is listed in the channel’s pkg map.

Fields

old: &'a str

The old name for a package.

new: &'a str

The alleged new name for the package, which isn’t listed in the channel metadata.

RenameToItself(&'a str)

The channel’s renames field says this package was renamed to the same name.

RenameExistingPackage(&'a str)

The channel’s renames field says this package was renamed, but it’s still listed in the channel’s pkg map.

ArtefactHasUnknownComponent

artefact claims one of its components is an artefact built from a package named component_pkg, but no such package is listed in the channel’s pkg map.

Fields

artefact: ArtefactQuery<'a>

The artefact that claims an unknown component.

component_pkg: &'a str

The alleged package name that is a component of artefact.

ArtefactComponentHasUnknownTarget

artefact claims one of its components is component, but component.target is not listed in component.pkg’s target map.

Fields

artefact: ArtefactQuery<'a>

The artefact that claims a component with an unknown target.

component: ArtefactQuery<'a>

The alleged artefact with the unknown target.

ArtefactHasUnknownExtension

artefact claims one of its extensions is an artefact built from a package named extension_pkg, but no such package is listed in the channel’s pkg map.

Fields

artefact: ArtefactQuery<'a>

The artefact that claims an unknown extension.

extension_pkg: &'a str

The alleged package name that is a extension of this artefact.

ArtefactExtensionHasUnknownTarget

artefact claims one of its extensions is extension, but extension.target is not listed in extension.pkg’s target map.

Fields

artefact: ArtefactQuery<'a>

The artefact that claims an extension with an unknown target.

extension: ArtefactQuery<'a>

The alleged artefact with the unknown target.

DependencyLoop(Vec<ArtefactQuery<'a>>)

A dependency loop was detected through all these artefacts.

That is, each artefact lists the next artefact as a required component, and the last artefact requires the first one.

Trait Implementations

impl<'a> Clone for ValidationError<'a>

fn clone(&self) -> ValidationError<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for ValidationError<'a>

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

Formats the value using the given formatter.

impl<'de: 'a, 'a> Deserialize<'de> for ValidationError<'a>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> Display for ValidationError<'a>

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

Formats the value using the given formatter.

impl<'a> Error for ValidationError<'a>

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

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

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

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<'a> Hash for ValidationError<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> Ord for ValidationError<'a>

fn cmp(&self, other: &ValidationError<'a>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<'a> PartialEq for ValidationError<'a>

fn eq(&self, other: &ValidationError<'a>) -> 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<'a> PartialOrd for ValidationError<'a>

fn partial_cmp(&self, other: &ValidationError<'a>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a> Serialize for ValidationError<'a>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> Eq for ValidationError<'a>

impl<'a> StructuralPartialEq for ValidationError<'a>