Struct ValidatorId 

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

A validated, process-independent validator identifier.

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::ValidatorId;
use qubit_validator::ValidatorIdError;

let id = ValidatorId::try_new("qubit.text.non_empty")?;
assert_eq!(id.as_str(), "qubit.text.non_empty");
let error = ValidatorId::try_new("qubit..non_empty").unwrap_err();
assert_eq!(error, ValidatorIdError::EmptySegment);
assert_eq!(
    ValidatorId::try_new("_custom.invalid"),
    Err(ValidatorIdError::InvalidSegment),
);

Implementations

impl ValidatorId

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

Creates a stable ID from a static string.

Parameters

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

Returns

The validated identifier.

Panics

Panics when value violates the syntax documented on ValidatorId.

Examples found in repository

examples/local_registry.rs (line 125)

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(())
}

examples/validate_named_bench.rs (line 169)

fn main() {
    let b0 = V0.bind(ValidatorId::new("bench.zero"), 0, &[]).unwrap();
    let b1 = V1.bind(ValidatorId::new("bench.one"), 0, &[]).unwrap();
    let b4 = V4.bind(ValidatorId::new("bench.four"), 0, &[]).unwrap();
    let b8 = V8.bind(ValidatorId::new("bench.eight"), 0, &[]).unwrap();
    let b9 = V9.bind(ValidatorId::new("bench.nine"), 0, &[]).unwrap();
    let number = 7_u64;
    let value = ValidationValue::Typed(&number);
    let path = ValidationPath::root().with_field("sample");
    let tail_path = ValidationPath::root().with_field("tail");

    let empty_named: [NamedValidationDependency<'_>; 0] = [];
    let empty_values: [ValidationValue<'_>; 0] = [];
    run_case("zero", &b0, &empty_named, &BoundValidationContext::new(&empty_values));

    let one_named = [NamedValidationDependency::new("a", value)];
    let one_values = [value];
    run_case("one_plain", &b1, &one_named, &BoundValidationContext::new(&one_values));
    let one_named_path = [NamedValidationDependency::new("a", value).with_path(&path)];
    let one_paths = [path.clone()];
    let one_context = BoundValidationContext::new_with_paths(&one_values, &one_paths).unwrap();
    run_case("one_path", &b1, &one_named_path, &one_context);

    let four_named = [
        NamedValidationDependency::new("a", value),
        NamedValidationDependency::new("b", value),
        NamedValidationDependency::new("c", value),
        NamedValidationDependency::new("d", value),
    ];
    let four_values = [value; 4];
    run_case(
        "four_plain",
        &b4,
        &four_named,
        &BoundValidationContext::new(&four_values),
    );
    let four_named_path = [
        NamedValidationDependency::new("a", value).with_path(&path),
        NamedValidationDependency::new("b", value).with_path(&path),
        NamedValidationDependency::new("c", value).with_path(&path),
        NamedValidationDependency::new("d", value).with_path(&path),
    ];
    let four_paths = [path.clone(), path.clone(), path.clone(), path.clone()];
    let four_context = BoundValidationContext::new_with_paths(&four_values, &four_paths).unwrap();
    run_case("four_path", &b4, &four_named_path, &four_context);

    let eight_named = [
        NamedValidationDependency::new("h", value),
        NamedValidationDependency::new("g", value),
        NamedValidationDependency::new("f", value),
        NamedValidationDependency::new("e", value),
        NamedValidationDependency::new("d", value),
        NamedValidationDependency::new("c", value),
        NamedValidationDependency::new("b", value),
        NamedValidationDependency::new("a", value),
    ];
    let eight_values = [value; 8];
    let eight_context = BoundValidationContext::new(&eight_values);
    run_case("eight_plain", &b8, &eight_named, &eight_context);
    let eight_named_mixed = [
        NamedValidationDependency::new("h", value).with_path(&path),
        NamedValidationDependency::new("g", value),
        NamedValidationDependency::new("f", value),
        NamedValidationDependency::new("e", value),
        NamedValidationDependency::new("d", value),
        NamedValidationDependency::new("c", value),
        NamedValidationDependency::new("b", value),
        NamedValidationDependency::new("a", value).with_path(&tail_path),
    ];
    let eight_paths = [
        tail_path.clone(),
        ValidationPath::root(),
        ValidationPath::root(),
        ValidationPath::root(),
        ValidationPath::root(),
        ValidationPath::root(),
        ValidationPath::root(),
        path.clone(),
    ];
    let eight_context = BoundValidationContext::new_with_paths(&eight_values, &eight_paths).unwrap();
    run_case("eight_mixed_path", &b8, &eight_named_mixed, &eight_context);

    let nine_named = [
        NamedValidationDependency::new("i", value),
        NamedValidationDependency::new("h", value),
        NamedValidationDependency::new("g", value),
        NamedValidationDependency::new("f", value),
        NamedValidationDependency::new("e", value),
        NamedValidationDependency::new("d", value),
        NamedValidationDependency::new("c", value),
        NamedValidationDependency::new("b", value),
        NamedValidationDependency::new("a", value),
    ];
    let nine_values = [value; 9];
    let nine_context = BoundValidationContext::new(&nine_values);
    run_case("nine_plain", &b9, &nine_named, &nine_context);
    let nine_named_mixed = [
        NamedValidationDependency::new("i", value).with_path(&path),
        NamedValidationDependency::new("h", value),
        NamedValidationDependency::new("g", value),
        NamedValidationDependency::new("f", value),
        NamedValidationDependency::new("e", value),
        NamedValidationDependency::new("d", value),
        NamedValidationDependency::new("c", value),
        NamedValidationDependency::new("b", value),
        NamedValidationDependency::new("a", value).with_path(&tail_path),
    ];
    let nine_paths = [
        tail_path.clone(),
        ValidationPath::root(),
        ValidationPath::root(),
        ValidationPath::root(),
        ValidationPath::root(),
        ValidationPath::root(),
        ValidationPath::root(),
        ValidationPath::root(),
        path.clone(),
    ];
    let nine_context = BoundValidationContext::new_with_paths(&nine_values, &nine_paths).unwrap();
    run_case("nine_mixed_path", &b9, &nine_named_mixed, &nine_context);
}

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

Validates and creates a stable ID.

Parameters

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

Returns

The validated identifier when value follows the protocol.

Errors

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

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

Returns the complete stable ID.

Trait Implementations

impl Borrow<str> for ValidatorId

fn borrow(&self) -> &str

Borrows the complete validated identifier as text.

Returns

The identifier text, borrowed from this value.

impl Clone for ValidatorId

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 ValidatorId

impl Debug for ValidatorId

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

Formats the value using the given formatter.

impl Eq for ValidatorId

impl Hash for ValidatorId

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 ValidatorId

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 ValidatorId

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for ValidatorId

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 ValidatorId