Enum ValidationValue 

#[non_exhaustive]
pub enum ValidationValue<'a> {
    Text(&'a str),
    Typed(&'a dyn Any),
    Missing,
}

A value view that deliberately avoids implicit stringification and cloning.

Type Parameters

• 'a: Lifetime for which the borrowed input remains available.

Examples

use qubit_validator::ValidationValue;

let value = ValidationValue::Text("hello");
assert_eq!(value.as_text(), Some("hello"));
assert!(!value.is_missing());

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.

Text(&'a str)

A borrowed UTF-8 string slice.

Tuple Fields

0: &'a str

Raw text borrowed only for the duration of validation.

Typed(&'a dyn Any)

A borrowed value with an exact concrete type available through Any.

Tuple Fields

0: &'a dyn Any

Raw typed value borrowed only for the duration of validation.

Missing

An explicitly expanded optional value which is absent.

Implementations

impl<'a> ValidationValue<'a>

pub fn input_type(self) -> Option<InputType>

Returns the concrete input shape, if one is present.

Returns

Returns None only for Self::Missing.

pub const fn as_text(self) -> Option<&'a str>

Returns the text view when this is a text value.

Returns

Returns None for typed and missing values.

Examples found in repository

examples/local_registry.rs (line 101)

    fn validate(
        &self,
        _: ValidationValue<'_>,
        context: &BoundValidationContext<'_>,
    ) -> Result<PreparedOutcome, ExecutionError> {
        let valid = context.value(0)?.as_text() == Some("minimum") && context.value(1)?.as_text() == Some("maximum");
        Ok(if valid {
            PreparedOutcome::Valid
        } else {
            PreparedOutcome::Invalid(vec![ViolationDraft::new(ViolationCode::new(
                "text.dependencies_mismatch",
            ))])
        })
    }

pub const fn is_missing(self) -> bool

Returns whether this value is the explicit missing marker.

Returns

Returns true only for Self::Missing.

pub fn typed<T: 'static>(self) -> Option<&'a T>

Attempts to borrow the value as its exact concrete type.

Type Parameters

• T: Requested concrete type, which must be 'static for Any.

Returns

Returns None for text, missing, and differently typed values.

Trait Implementations

impl<'a> Clone for ValidationValue<'a>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for ValidationValue<'a>

impl Debug for ValidationValue<'_>

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

Formats only the value shape and always redacts raw input.

Parameters

• formatter: Destination used to write the redacted value shape.

Returns

Returns Ok(()) when formatting succeeds, or the formatter’s error otherwise.