Enum BindErrorKind 

#[non_exhaustive]
pub enum BindErrorKind {
    UnknownParameter,
    DuplicateParameter,
    MissingParameter,
    ParameterAlreadyConsumed,
    ParameterTypeMismatch,
    ParameterOutOfRange,
    InvalidBounds,
    InvalidPattern,
    MissingRule,
    UnsupportedInput,
    MissingDependencyDeclaration,
    UnknownDependencyDeclaration,
    DependencyOrderMismatch,
    PreparedSignatureMismatch,
    DependencyOptionalityMismatch,
    DependencyTypeMismatch,
    UnreadablePath,
    AmbiguousSignature,
    UnsupportedConstraint,
    MissingFeature,
    InvalidDeclaration,
    InvalidSelection,
}

A configuration or declaration error found while binding a rule.

Examples

use qubit_validator::BindErrorKind;

let kind = BindErrorKind::MissingParameter;
assert_eq!(kind.to_string(), "missing parameter");

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.

UnknownParameter

A parameter name is not known to the rule.

DuplicateParameter

A parameter was supplied more than once.

MissingParameter

A required parameter is absent.

ParameterAlreadyConsumed

A parameter has already been consumed by this reader.

ParameterTypeMismatch

A parameter has the wrong value type.

ParameterOutOfRange

A parameter is outside the supported range.

InvalidBounds

Bounds are internally inconsistent.

InvalidPattern

A pattern cannot be compiled.

MissingRule

The requested rule is not registered.

UnsupportedInput

A registered rule cannot consume the requested input.

MissingDependencyDeclaration

A dependency declaration is missing.

UnknownDependencyDeclaration

A dependency declaration is unknown.

DependencyOrderMismatch

Dependency declarations do not follow the signature’s slot order.

PreparedSignatureMismatch

A prepared implementation disagrees with its declared signature.

DependencyOptionalityMismatch

A required dependency may be absent on a statically known path.

DependencyTypeMismatch

A dependency has the wrong type.

UnreadablePath

A dependency path cannot be read.

AmbiguousSignature

More than one signature matches the declaration.

UnsupportedConstraint

A declared constraint has no implementation.

MissingFeature

An implementation feature is disabled.

InvalidDeclaration

A declaration is malformed.

InvalidSelection

A requested selection is not known.

Trait Implementations

impl Clone for BindErrorKind

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for BindErrorKind

impl Debug for BindErrorKind

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

Formats the value using the given formatter.

impl Display for BindErrorKind

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

Formats the stable human-readable error category.

Parameters

• formatter: Destination that receives the formatted category.

Errors

Returns the formatter’s error if writing the category fails.

impl Eq for BindErrorKind

impl PartialEq for BindErrorKind

fn eq(&self, other: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for BindErrorKind