Struct ViolationCode 

pub struct ViolationCode(/* private fields */);

A stable violation code using the point-separated ASCII protocol.

The value is non-empty and consists of one or more dot-separated segments. Each segment starts with an ASCII letter and continues with ASCII letters, digits, or underscores. Empty segments, whitespace, non-ASCII letters, and hyphens are rejected. No trimming or case normalization is performed.

Examples

use qubit_validator::ViolationCode;
use qubit_validator::ViolationCodeError;

let code = ViolationCode::try_new("text.length.minimum")?;
assert_eq!(code.as_str(), "text.length.minimum");
let error = ViolationCode::try_new("text..minimum").unwrap_err();
assert_eq!(error, ViolationCodeError::EmptySegment);
assert_eq!(
    ViolationCode::try_new("text.min-length"),
    Err(ViolationCodeError::InvalidSegment),
);

Implementations

impl ViolationCode

pub const fn new(value: &'static str) -> Self

Creates a code from a valid static string.

Parameters

• value: A static string containing the complete protocol value.

Returns

The validated violation code.

Panics

Panics when value violates the syntax documented on ViolationCode.

Examples found in repository

examples/local_registry.rs (line 71)

fn prepare_non_blank(_reader: &mut ArgumentReader<'_>) -> Result<Arc<dyn PreparedValidator>, BindError> {
    Ok(prepare_text_validator(NonBlank, |_| {
        ViolationDraft::new(ViolationCode::new("text.blank"))
    }))
}

static SIGNATURES: &[ValidatorSignature] = &[ValidatorSignature::new(InputType::Text, &[], prepare_non_blank)];
static DESCRIPTOR: ValidatorDescriptor = ValidatorDescriptor::new(SIGNATURES);

#[cfg(feature = "inventory")]
register_validator!(id = "text.non_blank.global", descriptor = &DESCRIPTOR);

static DEPENDENCIES: &[DependencySpec] = &[
    DependencySpec::new("minimum", InputType::Text, false),
    DependencySpec::new("maximum", InputType::Text, false),
];

struct CheckDependencySlots;

impl PreparedValidator for CheckDependencySlots {
    fn input_type(&self) -> InputType {
        InputType::Text
    }
    fn dependency_specs(&self) -> &'static [DependencySpec] {
        DEPENDENCIES
    }

    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",
            ))])
        })
    }
}

fn prepare_dependency_slots(_reader: &mut ArgumentReader<'_>) -> Result<Arc<dyn PreparedValidator>, BindError> {
    Ok(Arc::new(CheckDependencySlots))
}

static DEPENDENCY_SIGNATURES: &[ValidatorSignature] = &[ValidatorSignature::new(
    InputType::Text,
    DEPENDENCIES,
    prepare_dependency_slots,
)];
static DEPENDENCY_DESCRIPTOR: ValidatorDescriptor = ValidatorDescriptor::new(DEPENDENCY_SIGNATURES);

fn assert_dependency_specs_come_from_signature() -> Result<(), ExecutionError> {
    let bound = DEPENDENCY_DESCRIPTOR
        .bind(ValidatorId::new("text.dependent"), 0, &[])
        .expect("signature binds");
    assert_eq!(bound.dependency_specs(), DEPENDENCIES);
    let dependencies = [
        NamedValidationDependency::new("maximum", ValidationValue::Text("maximum")),
        NamedValidationDependency::new("minimum", ValidationValue::Text("minimum")),
    ];
    assert_eq!(
        bound.validate_named(ValidationValue::Text("target"), &dependencies)?,
        ValidationOutcome::Valid,
    );
    Ok(())
}

fn assert_parameters_are_consumed_once() -> Result<(), BindError> {
    let args = [NamedValidationArgument::new("limit", ValidationArgument::Unsigned(10))];
    let mut reader = ArgumentReader::new(&args)?;
    assert_eq!(reader.required_u32("limit")?, 10);
    let error = reader
        .required_u32("limit")
        .expect_err("a parameter cannot be read twice");
    assert_eq!(error.kind(), BindErrorKind::ParameterAlreadyConsumed);
    Ok(())
}

fn main() -> Result<(), Box<dyn Error>> {
    let registration = ValidatorRegistration::new(
        ValidatorId::new("text.non_blank"),
        &DESCRIPTOR,
        RegistrationSource::new(env!("CARGO_PKG_NAME"), module_path!(), file!(), line!()),
    );
    let registry = ValidatorRegistry::from_registrations([registration])?;

    assert!(registry.get("text.non_blank").is_some());
    let validator = registry.bind("text.non_blank", InputType::Text, &[])?;
    let context = BoundValidationContext::new(&[]);

    let valid = validator.validate(ValidationValue::Text("Ada"), &context)?;
    assert_eq!(valid, ValidationOutcome::Valid);

    let invalid = validator.validate(ValidationValue::Text("   "), &context)?;
    let ValidationOutcome::Invalid(violations) = invalid else {
        panic!("blank text must be invalid");
    };
    assert_eq!(violations.len(), 1);
    assert_eq!(violations[0].code(), ViolationCode::new("text.blank"));

    assert_dependency_specs_come_from_signature()?;
    assert_parameters_are_consumed_once()?;

    #[cfg(feature = "inventory")]
    {
        let global = ValidatorRegistry::try_global()?;
        assert!(global.get("text.non_blank.global").is_some());
    }

    Ok(())
}

pub const fn try_new(value: &'static str) -> Result<Self, ViolationCodeError>

Validates and creates a code.

Parameters

• value: A static string containing the complete protocol value.

Returns

The validated violation code when value follows the protocol.

Errors

Returns ViolationCodeError::Empty for an empty string, ViolationCodeError::EmptySegment for an empty dot-separated segment, or ViolationCodeError::InvalidSegment for a segment with invalid characters or an invalid first character.

pub const fn as_str(self) -> &'static str

Returns the complete stable code.

Trait Implementations

impl Clone for ViolationCode

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 ViolationCode

impl Debug for ViolationCode

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

Formats the validated, program-declared code.

impl Display for ViolationCode

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

Formats the validated, program-declared code.

impl Eq for ViolationCode

impl Hash for ViolationCode

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 Ord for ViolationCode

fn cmp(&self, other: &Self) -> 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.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for ViolationCode

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for ViolationCode

fn partial_cmp(&self, other: &Self) -> 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 StructuralPartialEq for ViolationCode