Struct ZRecord 

pub struct ZRecord<V, K = AnyKey, M = HashMap<String, <V as VldSchema>::Output>>
where
    V: VldSchema,
{ /* private fields */ }

Schema for validating JSON objects as key-value records. Created via vld::record() (HashMap<String, V>) or vld::record_with_keys() (HashMap<K, V>); ordered() switches the output to a BTreeMap.

Values are validated against the value schema; key and value issues are reported at the key’s path. If two keys parse to the same output key, the later one wins.

Example

use vld::prelude::*;

let schema = vld::record(vld::number().int().positive());
let result = schema.parse(r#"{"a": 1, "b": 2}"#).unwrap();
assert_eq!(result.get("a"), Some(&1));

let ordered = vld::record(vld::boolean()).ordered().parse(r#"{"b": true, "a": false}"#).unwrap();
assert_eq!(ordered.keys().collect::<Vec<_>>(), ["a", "b"]);

Implementations

impl<V> ZRecord<V>

where V: VldSchema,

pub fn new(value_schema: V) -> ZRecord<V>

Create the schema (the same as its vld:: constructor function).

impl<V, K, M> ZRecord<V, K, M>

where V: VldSchema,

pub fn min_keys(self, n: usize) -> ZRecord<V, K, M>

Minimum number of keys.

pub fn max_keys(self, n: usize) -> ZRecord<V, K, M>

Maximum number of keys.

pub fn ordered( self, ) -> ZRecord<V, K, BTreeMap<<K as RecordKey>::Output, <V as VldSchema>::Output>>

where K: RecordKey, <K as RecordKey>::Output: Ord,

Produce a BTreeMap (sorted by key) instead of a HashMap.

Trait Implementations

impl<V, K, M> VldSchema for ZRecord<V, K, M>

where V: VldSchema, K: RecordKey, M: Default + Extend<(<K as RecordKey>::Output, <V as VldSchema>::Output)>,

type Output = M

The Rust type produced by this schema after successful parsing.

fn parse_value(&self, value: &Value) -> Result<M, VldError>

Parse and validate a serde_json::Value.

fn parse_missing(&self) -> Result<Self::Output, VldError>

Parse an object field whose key is absent.

fn parse<I>(&self, input: &I) -> Result<Self::Output, VldError>

where I: VldInput + ?Sized,

Parse from any supported input (JSON string, file path, serde_json::Value, etc.)

fn validate<T>(&self, value: &T) -> Result<Self::Output, VldError>

where T: Serialize,

Validate an existing Rust value against this schema.

fn is_valid<T>(&self, value: &T) -> bool

where T: Serialize,

Check if an existing Rust value passes this schema’s validation.

fn optional(self) -> ZOptional<Self>

Make this field optional. Missing or null values become None.

fn nullable(self) -> ZNullable<Self>

Allow null values. Null becomes None.

fn with_default(self, value: Self::Output) -> ZDefault<Self>

where Self::Output: Clone,

Provide a default value when the field is missing or null.

fn refine<F>(self, check: F, message: &str) -> ZRefine<Self, F>

where F: Fn(&Self::Output) -> bool,

Add a custom refinement check without changing the output type.

fn rule<R>(self, rule: R) -> ZRule<Self, R>

where Self: Sized, R: Rule<Self::Output>,

Check the output with a reusable Rule (output type unchanged).

fn rule_msg<R>(self, rule: R, msg: impl Into<String>) -> ZRule<Self, R>

where Self: Sized, R: Rule<Self::Output>,

rule with a custom error message.

fn try_transform<F, U, E>(self, f: F) -> ZTryTransform<Self, F, U>

where F: Fn(Self::Output) -> Result<U, E>, E: Display,

Transform the output with a fallible function; an Err becomes a validation issue (Custom { code: "transform" }, message = the error).

fn transform<F, U>(self, f: F) -> ZTransform<Self, F, U>

where F: Fn(Self::Output) -> U,

Transform the output value after successful parsing.

fn nullish(self) -> ZNullish<Self>

Make this field nullish (both optional and nullable).

fn catch(self, fallback: Self::Output) -> ZCatch<Self>

where Self::Output: Clone,

Return a fallback value on ANY validation error.

fn pipe<S>(self, next: S) -> ZPipe<Self, S>

where S: VldSchema, Self::Output: Serialize,

Chain this schema’s output into another schema.

fn describe(self, description: &str) -> ZDescribe<Self>

Attach a human-readable description/label to this schema.

fn super_refine<F>(self, check: F) -> ZSuperRefine<Self, F>

where F: Fn(&Self::Output, &mut VldError),

Add a custom refinement that can produce multiple errors.

fn or<B>(self, other: B) -> ZUnion2<Self, B>

where B: VldSchema,

Create a union: this schema or another. Returns Either<Self::Output, B::Output>.

fn and<B>(self, other: B) -> ZIntersection<Self, B>

where B: VldSchema,

Create an intersection: input must satisfy both schemas.

fn message(self, msg: impl Into<String>) -> ZMessage<Self>

Override the error message for this schema.