Struct BoundValidator 

pub struct BoundValidator { /* private fields */ }

A bound occurrence that owns a reusable prepared validator instance.

A prepared validator reports only whether its execution was valid or invalid. Callers decide whether an occurrence should be skipped and build the corresponding ValidationOutcome themselves.

Examples

use std::sync::Arc;

use qubit_validator::ArgumentReader;
use qubit_validator::BindError;
use qubit_validator::BoundValidationContext;
use qubit_validator::ExecutionError;
use qubit_validator::InputType;
use qubit_validator::PreparedOutcome;
use qubit_validator::PreparedValidator;
use qubit_validator::ValidationOutcome;
use qubit_validator::ValidationValue;
use qubit_validator::ValidatorDescriptor;
use qubit_validator::ValidatorId;
use qubit_validator::ValidatorSignature;

struct AcceptAll;

impl PreparedValidator for AcceptAll {
    fn input_type(&self) -> InputType { InputType::Text }
    fn dependency_specs(&self) -> &'static [qubit_validator::DependencySpec] { &[] }
    fn validate(
        &self,
        _: ValidationValue<'_>,
        _: &BoundValidationContext<'_>,
    ) -> Result<PreparedOutcome, ExecutionError> {
        Ok(PreparedOutcome::Valid)
    }
}

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

static SIGNATURES: &[ValidatorSignature] = &[
    ValidatorSignature::new(InputType::Text, &[], prepare),
];
let descriptor = ValidatorDescriptor::new(SIGNATURES);
let bound = descriptor.bind(ValidatorId::new("example.accept_all"), 0, &[])?;
let outcome = bound.validate(
    ValidationValue::Text("accepted"),
    &BoundValidationContext::new(&[]),
)?;
assert_eq!(outcome, ValidationOutcome::Valid);

Implementations

impl BoundValidator

pub fn try_from_prepared<T: 'static>( rule_id: ValidatorId, prepared: Arc<dyn PreparedValidator>, ) -> Result<Self, BindError>

Creates a zero-dependency binding for an already prepared typed rule.

The binding checks that calls supply exactly T and no dependency slots before invoking the prepared validator. It does not perform registry lookup or parameter decoding.

Type Parameters

• T: Exact concrete value type accepted by the prepared validator.

Parameters

• rule_id: Stable identity attached to violations and execution errors.
• prepared: Immutable prepared implementation shared by clones.

Returns

A reusable bound validator accepting values of type T without dependencies.

Errors

Returns PreparedSignatureMismatch with rule_id attached when the prepared validator does not accept exactly T or declares dependencies.

pub fn validate( &self, value: ValidationValue<'_>, context: &BoundValidationContext<'_>, ) -> Result<ValidationOutcome, ExecutionError>

Validates one value after checking its erased input and dependencies.

Dependency values and paths must already follow Self::dependency_specs order. Use Self::validate_named for directly assembled dependency sets or whenever same-typed dependencies could be supplied in the wrong order.

Parameters

• value: Borrowed target value.
• context: Dependency values and paths in signature order.

Returns

The bound validation outcome.

Errors

Returns a shape, dependency, adapter, or rule execution error.

Examples found in repository

examples/local_registry.rs (line 162)

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 139)

fn run_case(
    label: &str,
    bound: &BoundValidator,
    named: &[NamedValidationDependency<'_>],
    ordered: &BoundValidationContext<'_>,
) {
    let value = ValidationValue::Text("sample");
    assert!(
        matches!(bound.validate_named(value, named), Ok(ValidationOutcome::Valid)),
        "named benchmark setup must validate"
    );
    assert!(
        matches!(bound.validate(value, ordered), Ok(ValidationOutcome::Valid)),
        "ordered benchmark setup must validate"
    );
    let mut call_named = || {
        let _ = black_box(black_box(bound).validate_named(black_box(value), black_box(named)));
    };
    let mut call_ordered = || {
        let _ = black_box(black_box(bound).validate(black_box(value), black_box(ordered)));
    };
    ns_per_call(100_000, &mut call_named);
    ns_per_call(100_000, &mut call_ordered);
    let mut named_samples = Vec::new();
    let mut ordered_samples = Vec::new();
    for round in 0..5 {
        if round % 2 == 0 {
            named_samples.push(ns_per_call(1_000_000, &mut call_named));
            ordered_samples.push(ns_per_call(1_000_000, &mut call_ordered));
        } else {
            ordered_samples.push(ns_per_call(1_000_000, &mut call_ordered));
            named_samples.push(ns_per_call(1_000_000, &mut call_named));
        }
    }
    println!(
        "{label}: named={named_samples:?} ordered={ordered_samples:?} median_named={} median_ordered={}",
        median(&named_samples),
        median(&ordered_samples),
    );
}

pub fn validate_named( &self, value: ValidationValue<'_>, dependencies: &[NamedValidationDependency<'_>], ) -> Result<ValidationOutcome, ExecutionError>

Validates a value after resolving dependency values by signature name.

This entry point protects direct callers from swapping dependencies that have the same input type. Values are reordered into signature slot order for this call. Use Self::validate when a caller has already checked and constructed values in that order. Zero or one dependency needs no reordering container; two to eight use fixed-size stack buffers, while more than eight allocate vectors as needed. Cloning a supplied non-root path may still allocate.

Parameters

• value: Borrowed target value.
• dependencies: Borrowed dependency values keyed by signature name. Every declared slot must be present; optional values can use ValidationValue::Missing.

Returns

The bound validation outcome.

Errors

Returns a named-binding, input-shape, dependency-shape, adapter, or rule execution error.

Examples found in repository

examples/local_registry.rs (line 133)

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

examples/validate_named_bench.rs (line 135)

fn run_case(
    label: &str,
    bound: &BoundValidator,
    named: &[NamedValidationDependency<'_>],
    ordered: &BoundValidationContext<'_>,
) {
    let value = ValidationValue::Text("sample");
    assert!(
        matches!(bound.validate_named(value, named), Ok(ValidationOutcome::Valid)),
        "named benchmark setup must validate"
    );
    assert!(
        matches!(bound.validate(value, ordered), Ok(ValidationOutcome::Valid)),
        "ordered benchmark setup must validate"
    );
    let mut call_named = || {
        let _ = black_box(black_box(bound).validate_named(black_box(value), black_box(named)));
    };
    let mut call_ordered = || {
        let _ = black_box(black_box(bound).validate(black_box(value), black_box(ordered)));
    };
    ns_per_call(100_000, &mut call_named);
    ns_per_call(100_000, &mut call_ordered);
    let mut named_samples = Vec::new();
    let mut ordered_samples = Vec::new();
    for round in 0..5 {
        if round % 2 == 0 {
            named_samples.push(ns_per_call(1_000_000, &mut call_named));
            ordered_samples.push(ns_per_call(1_000_000, &mut call_ordered));
        } else {
            ordered_samples.push(ns_per_call(1_000_000, &mut call_ordered));
            named_samples.push(ns_per_call(1_000_000, &mut call_named));
        }
    }
    println!(
        "{label}: named={named_samples:?} ordered={ordered_samples:?} median_named={} median_ordered={}",
        median(&named_samples),
        median(&ordered_samples),
    );
}

pub const fn input_type(&self) -> InputType

Returns the selected input shape.

pub const fn dependency_specs(&self) -> &'static [DependencySpec]

Returns dependencies in their execution slot order.

Examples found in repository

examples/local_registry.rs (line 127)

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

pub const fn rule_id(&self) -> ValidatorId

Returns the stable rule identifier.

Trait Implementations

impl Clone for BoundValidator

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BoundValidator

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

Formats structural metadata without exposing the prepared implementation.