Enum Constraint 

pub enum Constraint {
    Range {
        min: f64,
        max: f64,
    },
    Pattern(String),
    AllowedValues(Vec<String>),
    Length {
        min: usize,
        max: usize,
    },
    Precision {
        decimal_places: usize,
    },
    Unique,
    NotNull,
    Custom(String),
    ArrayElements(Box<Constraint>),
    ArraySize {
        min: usize,
        max: usize,
    },
    Statistical(StatisticalConstraints),
    Temporal(TimeConstraints),
    Shape(ShapeConstraints),
    And(Vec<Constraint>),
    Or(Vec<Constraint>),
    Not(Box<Constraint>),
    If {
        condition: Box<Constraint>,
        then_constraint: Box<Constraint>,
        else_constraint: Option<Box<Constraint>>,
    },
}

Validation constraints for data fields

Variants

Range

Value must be within range (inclusive)

Fields

min: f64

max: f64

Pattern(String)

String must match pattern

AllowedValues(Vec<String>)

Value must be one of the allowed values

Length

String length constraints

Fields

min: usize

max: usize

Precision

Numeric precision constraints

Fields

decimal_places: usize

Unique

Uniqueness constraint

NotNull

Non-null constraint

Custom(String)

Custom validation rule

ArrayElements(Box<Constraint>)

Array element constraints

ArraySize

Array size constraints

Fields

min: usize

max: usize

Statistical(StatisticalConstraints)

Statistical constraints for numeric data

Temporal(TimeConstraints)

Time-based constraints

Shape(ShapeConstraints)

Matrix/array shape constraints

And(Vec<Constraint>)

Logical AND of multiple constraints - all must pass

Or(Vec<Constraint>)

Logical OR of multiple constraints - at least one must pass

Not(Box<Constraint>)

Logical NOT of a constraint - must not pass

If

Conditional constraint - if condition passes, then constraint must pass

Fields

condition: Box<Constraint>

then_constraint: Box<Constraint>

else_constraint: Option<Box<Constraint>>

Implementations

impl Constraint

pub fn all_of(constraints: Vec<Constraint>) -> Self

Create a constraint that requires all of the given constraints to pass

pub fn any_of(constraints: Vec<Constraint>) -> Self

Create a constraint that requires at least one of the given constraints to pass

pub fn not(constraint: Constraint) -> Self

Create a constraint that requires the given constraint to not pass

pub fn if_then( condition: Constraint, then_constraint: Constraint, else_constraint: Option<Constraint>, ) -> Self

Create a conditional constraint

pub fn and(self, other: Constraint) -> Self

Chain this constraint with another using AND logic

pub fn or(self, other: Constraint) -> Self

Chain this constraint with another using OR logic

Trait Implementations

impl Clone for Constraint

fn clone(&self) -> Constraint

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Constraint

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Constraint

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Constraint

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Constraint

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Constraint