All Classes and Interfaces
Class
Description
Abstract base class that implements the
Rule interface.This class provides an abstract implementation of the RuleSession interface, delegating the session's
methods to a provided delegate object.
The Action enum represents the actions that can be performed on a rule session.
Activation manager controls whether an active rule should really fire based on the history
of previous activations.
Enum representing the activation mode for a session.
The
CollectionUtils class provides utility methods for working with collections.
Configuration class represents a configuration object that extends the Properties class and
implements the
Copyable and FluentImports interfaces.Contains constant values that are used throughout the project.
A generic alternative to Cloneable
Default and dummy activation manager that does nothing.
The DSLClassProvider class provides the implementation of the DSLKnowledgeProvider
interface for 'JAVA-CLASS' DSL knowledge.
The DSLClassProvider class provides the implementation of the DSLKnowledgeProvider
interface for 'JAVA-JAR' DSL knowledge.
DSLKnowledgeProvider is an interface that provides methods to create Knowledge instances from various types of resources.
The DSLClassProvider class provides the implementation of the DSLKnowledgeProvider
interface for 'JAVA-SOURCE' DSL knowledge.
The Environment interface provides a way to store and retrieve property values.
Annotation for methods intended to listen to changes in the
Environment.The
EvaluationListener interface should be implemented by
classes that wish to receive notifications of evaluation results.Interface for managing
EvaluationListener instances.An internal representation of every condition in the rule engine.
Evaluator handles essentially act as references to LHS (Left Hand Side) conditions, much like how each fact in working memory is associated with a fact handle.
A collection of every condition tha was ever used in the engine's runtime.
An interface with a set of basic methods that are necessary for parsing string expressions.
A Service Provider Interface (SPI) for expression parsers.
This annotation can be used to mark a parameter in a method with a fact value.
A fact declaration for
RuleBuilder.
FactHandle instances uniquely identify working instances in rule sessions.
The
FactHandleVersioned class represents a versioned FactHandle.Represents a storage system for facts, allowing for operations such as insertion, deletion, updating, and retrieval of facts.
Represents an entry in the storage, holding both a fact handle and the fact instance.
Marks a method as a field declaration.
Field references go along with rule conditions and are the key source of knowledge for building
the Rete memory graph.
A marker interface that uniquely identifies the value of a field.
The
FluentEnvironment interface extends the functionality of Environment to
support fluent API style configuration by allowing properties to be set in a chainable manner.Represents an entity capable of managing Java imports in a fluent manner.
The
ForkJoinExecutor class is a simple wrapper for the ForkJoinPoolRepresents a class for managing Java imports.
Represents a boolean-valued function of one
int-valued
and one object-valued argument.Defines an interface for conveniently accessing objects by integer indices.
Utility class for input/output operations.
A plain source Java compiler for current
RuntimeContext.The ClassSource interface represents a source code file that can be compiled by a Java compiler.
The Result interface represents the result of compiling a source code file using a Java compiler.
This interface represents the engine's alpha and beta memories as referenced in the RETE algorithm.
Enumeration representing the mode in which keys are retrieved from a memory.
Knowledge is a preprocessed ruleset.
KnowledgeService is a root element of every Evrete-based application.
The Builder class is responsible for constructing instances of the KnowledgeService class.
KnowledgeWrapper is an abstract class that delegates the knowledge's
methods to a provided delegate object.
The LhsBuilder interface is used to build the left-hand side (LHS) of a rule.
Deprecated.
A convenience interface to use for LHS fact declarations.
Represents a literal
Evaluator with its source code.
A convenience wrapper for literal expressions.
Deprecated.
use
LiteralSourceCompiler insteadAn interface that represents a Service Provider Interface (SPI) for compiling rule's literal sources.
A class that implements a
Function interface using an internal map.The
MappingReIterator class implements the ReIterator interface
and provides a mapping functionality to another ReIterator.The MemoryFactory interface defines methods for creating different types of memories used in the engine.
A Java Service Provider Interface (SPI) designed for creating various types
of memory components used within the engine.
This interface represents a multi-value key used for accessing values from memory.
This interface represents a mutable extension to the
ReIterable interface, specifically
for use with memory keys.The
MethodPredicate annotation is used to define a predicate method that
represents a condition for a rule.The Named interface represents an entity with a name.
A runtime representation of a fact declaration.
The Resolver interface is used to resolve named types based on their declared name.
Supplier of consecutive integer values.
A source-level annotation to declare that annotated elements can not be
nullA source-level annotation to declare that annotated elements can be
null under some circumstancesThe OrderedServiceProvider interface represents a service provider interface (SPI)
that allows multiple implementations to be ordered based on their assigned sort order.
An event variable that binds listener methods to a specific lifecycle event:
Annotation used to bind listener methods to specific lifecycle events.
The ReIterable interface is essentially an
Iterable that returns
a ReIterator instead of a Iterator.The
ReIterator interface represents a reusable Iterator.
Rule activation context that provides access to the rule's variables and
working memory methods.
Base interface for each rule in the engine.
Defines a method as a rule within a rule-based system.
The RuleBuilder interface represents a builder for creating rules.
Deprecated.
in favor of
RuleBuilderDeprecated.
this class has been deprecated since version 3.1.0 with bulk rule compilation
This class represents a compiled version of
RuleLiteralDataRepresents a rule that is associated with a
Knowledge instance.
A wrapper for the literal components of a rule.
Base interface for both stateful and stateless sessions
Interface describes a mutable collection of rules.
Annotation used to mark a class as a ruleset.
The
Sort enum represents different sorting modes for rule sets.`RuleSetBuilder` is an interface intended for building and appending rules to the current runtime context.
RuleSetContext is an interface that combines the functionality of
RuntimeContext and
RuleSet.The RuntimeContext interface represents the context in which the rules are executed.
The
RuntimeRule is a representation of a rule that is already associated with a RuleSession.A class that collects/inserts elements into a
RuleSession instance.An interface that defines the methods to be implemented by
classes that wish to listen for session lifecycle events.
Enumeration of the different events that can trigger the callback.
The StatefulSession interface represents a stateful rule session.
Unlike stateful sessions, stateless sessions are designed to be short-living instances
that can be fired only once, returning the resulting working memory snapshot.
Represents an engine's internal logical type, which is assigned to every fact before
it is inserted into the session's working memory.
A representation of a Type field.
TypeResolver provides dynamic mapping of Java types to engine's internal
Type.The TypeResolverProvider interface represents a service provider interface (SPI)
for providing instances of TypeResolver.
Deprecated.
This class is deprecated and will be removed in future releases.
A wrapper class that implements the
Type interface and delegates the calls to another Type implementation.Indicates that the API of the annotated method or type is subject to change in future versions.
This interface defines methods for resolving field values and retrieving them.
A wrapper for predicate over
IntToValue.This annotation can be used to define conditions for a rule method.
A unit of work with given complexity.
This utility class associates an arbitrary object with a level of complexity
LhsBuilderinstead