Enum Predicate 

pub enum Predicate {
    Evaluator(EvaluatorId, CompiledId),
    Unusable {
        reason: String,
    },
}

What decides this policy’s outcome, once its applicability is already established.

Split from Applicability deliberately, because the two fail differently and only one of the failures is a policy’s failure. Applicability is simple declarative data — collections, path prefixes, kinds, actions — that the core itself validates at the boundary, never something an engine interprets. A record whose applicability does not parse is therefore not a malformed policy; it is a malformed record that never becomes a PolicyDeclaration at all. It enforces nothing, it is surfaced to the operator, and nothing about it is represented anywhere in this crate’s types — there is no third state here for it, and there should not be one.

What is real, because a PolicyDeclaration can still hold it: the predicate — a regular expression, a hand-rolled matcher, anything an engine actually interprets — fails to parse or load, while its already known-good applicability says exactly what the policy covers. That failure can be scoped the same way an unavailable evaluator’s is, denying only the writes it would have judged rather than everything or nothing. Unusable is that state, named rather than left implicit, because a reader needs to tell “this policy denies things because it is broken” apart from “this policy denies things because it says so.”

Variants

Evaluator(EvaluatorId, CompiledId)

Applicability and predicate both parsed and compiled; this evaluator judges it, consulting the artifact named by CompiledId – see CompiledId’s doc comment for why that, not PolicyId, is what an evaluator is handed back at decision time.

Unusable

Applicability parsed; the predicate did not. Denies every subject within this policy’s applicability — fail-closed, scoped by the tree exactly like an EvalError from a live evaluator, because from the tree’s perspective the two are the same event at different times: a predicate that cannot be asked.

Fields

reason: String

Why the predicate could not be used: bad syntax, an engine this build does not have, or one that itself failed to load.

Trait Implementations

impl Clone for Predicate

fn clone(&self) -> Predicate

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Predicate

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

Formats the value using the given formatter.

impl PartialEq for Predicate

fn eq(&self, other: &Predicate) -> 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 Eq for Predicate

impl StructuralPartialEq for Predicate