All Classes and Interfaces
Class
Description
What an action runs against: the run's facts and the output object.
What an action did: changed the output object itself (
ActionResult.done()), or produced properties for the engine to
set on it (ActionResult.set(Map)).An action a language registered with
EvaluationContext.onCancel(Runnable), to be run when its run passes its
deadline.What every compilation of a rule list is given: the imports the engine was built with, from
RulesEngineBuilder.imports(String...), the class loader to look classes up
with, the type of the output object, this language's options and its own imports, and a way to report warnings.A compiled action, shared by every run of its rule list.
A compiled condition, shared by every run of its rule list.
What evaluating a condition returned, and, from a language that can explain it, why: the value, which must be a
Boolean, and a detail.What a condition is evaluated against.
One condition or action of a rule, as an
ExpressionCompiler compiles it: which rule it belongs to, whether
it's the condition or the action, and its text.Compiles the conditions and actions of one rule list, checks the names of the facts they run against, and creates
the sessions they run with.
Which part of a rule an expression is.
A language that rule conditions and actions are written in, such as MVEL.
What the engine promises for rules in any expression language.
An account as a JavaBean with a setter taking a
long, the output outputNumbersConverted writes a
whole Double no int holds to.An applicant, so a language's tests can run a rule against a record fact.
An applicant as a JavaBean, so a language's tests can run a rule against a fact whose property is a getter.
The fact the nested-run checks run their rules against: its
value property starts a run nested inside
the run that reads it, on the same thread, as a getter a condition or an action reads, or a function it calls,
does when it runs rules.An applicant as a JavaBean with a setter, so a language's tests can run a rule against a fact whose property a
condition could write.
The built-in, immutable
FactReference.Reads a property of a fact the way rules expect: a record component, a JavaBean getter or a
Map key.A named value that rules run against.
A store of facts, each kept under its name.
How large an import may be, as the engine bounds the imports it is built with, for a language that reads an
import in an expression's own text: it bounds that import the same way, and rejects it with the same
reason, rather than keeping a copy of the limits that could drift.Thrown by an
ExpressionCompiler to reject an expression: one that
breaks a rule the engine enforces, such as a condition that assigns to a fact, or one with an error the language can
point to, such as a syntax error.One problem a language found in an expression.
Whether an issue stops an expression compiling.
Creates the contexts the engine passes to an expression language, for unit tests of a language's compiler and
compiled expressions.
A
RuleListener that logs each rule's callbacks through SLF4J at DEBUG: beforeEvaluate,
afterEvaluate, beforeExecute, afterExecute and onError.Shortens and escapes text a language didn't write, such as a fact name, an option value, an import or its
library's own error text, for a message, as the engine does in its own messages.
MVEL 2 as an expression language for the engine, named "mvel".
Converts a value an action returned with
ActionResult.set(java.util.Map) to the type of a setter, as the
rule's expression language understands its own values.Sets a property on the output object.
A rule: a condition that decides whether it fires, and an action that runs when it does, with a name, a priority
and the language they're written in.
Builds a
Rule.Exception thrown when a rule fails to compile, or when several do.
What a run found out about one rule: whether its condition was true, false, or never evaluated, or whether the run
skipped the rule.
What evaluating a rule's condition found, or that the run skipped the rule.
Thrown by
run() when a run fails: because a rule's condition or action failed, or because something outside
any rule did.A listener interface to hook into the lifecycle of rule evaluation and execution.
Runs rules against facts: it evaluates each
Rule's condition and fires the actions of the rules that match,
as its match policy decides.Configures and builds a
RulesEngine.The rules an engine has loaded, from
RulesEngine.rules(): the rules themselves, a checksum that identifies
them, and when they were loaded.One run of an engine, given to
RuleListener's run callbacks.Settings for one run, given to
RulesEngine.runWithResult(FactStore, RunOptions).What one run did: the output object, the rules that fired, what each rule's condition evaluated to, the checksum
of the rules it used, and the tags and start time that chose which of them it used.
A language's state for one run of a rule list at a time, such as a single-threaded interpreter context.
Reads what an expression language, a rule or the application's code threw, as the engine reads it: which errors
the engine rethrows unchanged, what a stack overflow looks like once the JDK or a library has wrapped it, and the
message and causes of an exception the language didn't create, whose
getMessage() or getCause()
may throw.The base runtime exception for the Unruly engine.