Struct ZIntersection 

pub struct ZIntersection<A, B>
where
    A: VldSchema,
    B: VldSchema,
{ /* private fields */ }

Intersection of two schemas: input must satisfy both.

Both schemas are run on the same input. If both succeed, the output of the first schema is returned. If either fails, all errors are merged.

Created via vld::intersection().

Example

let schema = vld::intersection(
    vld::string().min(3),
    vld::string().email(),
);

Implementations

impl<A, B> ZIntersection<A, B>

where A: VldSchema, B: VldSchema,

pub fn new(first: A, second: B) -> ZIntersection<A, B>

pub fn schema_a(&self) -> &A

Access the first schema.

pub fn schema_b(&self) -> &B

Access the second schema.

Trait Implementations

impl<A, B> VldSchema for ZIntersection<A, B>

where A: VldSchema, B: VldSchema,

type Output = <A as VldSchema>::Output

The Rust type produced by this schema after successful parsing.

fn parse_value( &self, value: &Value, ) -> Result<<A as VldSchema>::Output, VldError>

Parse and validate a serde_json::Value.

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 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.