Enum ConstraintExpr 

pub enum ConstraintExpr<'a> {
    All {
        all: Vec<ConstraintNode<'a>>,
    },
    Any {
        any: Vec<ConstraintNode<'a>>,
    },
    Enumerate {
        enumerate: Vec<ConstraintNode<'a>>,
    },
}

Constraint expression tree: a list of types/expressions under all, any, or enumerate.

Variants

All

All children must be satisfied

Fields

all: Vec<ConstraintNode<'a>>

Children nodes that must all be satisfied

Any

Any child may satisfy the expression

Fields

any: Vec<ConstraintNode<'a>>

Children nodes where any one must be satisfied

Enumerate

All satisfiable children should be selected

Fields

enumerate: Vec<ConstraintNode<'a>>

Children nodes to evaluate and collect if satisfiable

Implementations

impl ConstraintExpr<'_>

pub fn evaluate<F>(&self, has_type: &F) -> bool

where F: Fn(&str) -> bool,

Evaluate the constraint against a predicate that reports whether a issuer schema id was provided successfully

pub fn validate_max_depth(&self, max_depth: usize) -> bool

Validate the maximum nesting depth. Depth counts the number of Expr nodes encountered. A flat list has depth 1. Allow at most 2 (one nested level under root).

pub fn validate_max_nodes(&self, max_nodes: usize) -> bool

Validate the maximum total number of nodes in the constraint AST. Counts both expression containers and leaf type nodes. Short-circuits once the running total exceeds max_nodes to avoid full traversal.

Trait Implementations

impl<'a> Clone for ConstraintExpr<'a>

fn clone(&self) -> ConstraintExpr<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for ConstraintExpr<'a>

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

Formats the value using the given formatter.

impl<'de, 'a> Deserialize<'de> for ConstraintExpr<'a>

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> PartialEq for ConstraintExpr<'a>

fn eq(&self, other: &ConstraintExpr<'a>) -> 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<'a> Serialize for ConstraintExpr<'a>

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> Eq for ConstraintExpr<'a>

impl<'a> StructuralPartialEq for ConstraintExpr<'a>