Struct ValidationPath 

pub struct ValidationPath { /* private fields */ }

A structured path to a value being validated.

Debug and Display do not reveal field labels. Call Self::render explicitly only in a trusted presentation layer; even rendered map entries contain opaque positions rather than raw map keys.

Field labels are static program declarations. Runtime map keys must be represented by opaque map-entry segments.

Examples

use qubit_validator::ValidationPath;

let path = ValidationPath::root().with_field("profile").with_index(2);
assert_eq!(path.render(), "profile[2]");
assert_eq!(path.as_segments().len(), 2);

Runtime field names cannot be retained in a path. Represent dynamic map entries with Self::with_map_entry instead.

use qubit_validator::ValidationPath;
let runtime_name = String::from("user supplied key");
let _ = ValidationPath::root().with_field(&runtime_name);

Implementations

impl ValidationPath

pub const fn root() -> Self

Creates an empty root path.

Returns

A path with no segments. Rendering this path produces an empty string.

Examples found in repository

examples/validate_named_bench.rs (line 176)

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 fn as_segments(&self) -> &[PathSegment]

Returns the path segments in order.

Returns

A borrowed slice ordered from the root toward the target.

pub fn with_field(self, field: &'static str) -> Self

Appends a statically declared field segment.

Use only program-declared field labels. Runtime map keys belong in an opaque map-entry segment so their text is not retained.

Parameters

• field: Static label of the declared field.

Returns

The path with field appended after its existing segments.

Examples found in repository

examples/validate_named_bench.rs (line 176)

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 fn with_index(self, index: usize) -> Self

Appends a zero-based sequence index segment.

Parameters

• index: Position of the element in its sequence.

Returns

The path with the index appended after its existing segments.

pub fn with_map_entry(self, index: usize) -> Self

Appends an opaque map entry position without retaining its key.

Parameters

• index: Stable position assigned by the caller to the map entry.

Returns

The path with the map-entry position appended.

pub fn with_map_key(self) -> Self

Appends the key side of a map entry without storing the key itself.

Returns

The path with a map-key marker appended.

pub fn with_map_value(self) -> Self

Appends the value side of a map entry.

Returns

The path with a map-value marker appended.

pub fn concat(&self, relative: &Self) -> Self

Appends a relative path to this path without rendering either one.

Returns a new path and leaves both inputs unchanged. Segments from relative follow this path’s segments in their original order.

Parameters

• relative: Relative suffix to append to this path.

Returns

A newly allocated path containing both segment sequences.

pub fn render(&self) -> String

Explicitly renders this path for a trusted presentation layer.

The result can contain program-supplied field labels but never contains a raw validation value or map key. Simple ASCII identifiers use dotted notation; other field labels use JSON-escaped [...] notation. This changes the rendered format for special field labels.

Returns

A newly allocated string containing the rendered field and positional segments, or an empty string for the root path.

Trait Implementations

impl Clone for ValidationPath

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 ValidationPath

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

Formats only the segment count so field labels remain private.

impl Display for ValidationPath

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

Formats a redacted placeholder instead of rendering path labels.

impl Eq for ValidationPath

impl Hash for ValidationPath

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 ValidationPath

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 ValidationPath

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for ValidationPath

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 ValidationPath