Struct FieldRule 

#[non_exhaustive]
pub struct FieldRule<C> {
    pub at: PathPat,
    pub ty: Option<FieldType>,
    pub constraint: Option<C>,
    pub present: Presentation,
}

One field rule: which node(s) it governs, the type it expects, an optional constraint of the embedder’s own type C, and how to present it.

#[non_exhaustive]: a rule gains ways to describe a field over time, so it is built from FieldRule::new and the chainable setters rather than a struct literal. Reading the fields is unchanged.

use fig_schema::{FieldRule, FieldType, PathPat, Presentation, Validate, Validation};
let rule = FieldRule::new(PathPat::each_item_of("audience"))
    .ty(FieldType::Str)
    .constraint(Vocab)
    .present(Presentation::default().title("Audience"));
assert_eq!(rule.ty, Some(FieldType::Str));

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

at: PathPat

Which node(s) this governs (reaches list elements, not only scalars).

ty: Option<FieldType>

The expected type — drives type-directed parsing and widget choice.

constraint: Option<C>

A value constraint, in whatever shape the embedder defines.

present: Presentation

Renderer-neutral presentation hints.

Implementations

impl<C> FieldRule<C>

pub fn new(at: PathPat) -> Self

A rule governing at, with no type, no constraint and no presentation hints — the parts a caller adds with the setters below.

pub fn ty(self, ty: impl Into<Option<FieldType>>) -> Self

Set the expected type. Takes a FieldType or an Option<FieldType>, so a caller reading a config that may not declare one can pass it straight through.

pub fn constraint(self, constraint: C) -> Self

Set the value constraint.

This one takes a C rather than an impl Into<Option<C>> the way FieldRule::ty does: with C otherwise unconstrained, Into cannot tell C from Option<C> and the call fails to infer. Use FieldRule::constraint_opt for a constraint that may be absent.

pub fn constraint_opt(self, constraint: Option<C>) -> Self

Set the value constraint from an optional one. None leaves the rule imposing nothing, which is what a type-only rule wants.

pub fn present(self, present: Presentation) -> Self

Set the presentation hints.

impl<C: Validate> FieldRule<C>

pub fn validate(&self, value: &Value) -> Validation

Validate a candidate value against this rule’s constraint. A rule with no constraint (or a type-only rule) imposes nothing here.

Trait Implementations

impl<C: Clone> Clone for FieldRule<C>

fn clone(&self) -> FieldRule<C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C: Debug> Debug for FieldRule<C>

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

Formats the value using the given formatter.