All Classes and Interfaces
Class
Description
This class provides an abstract implementation of the RuleSession interface, delegating the session's
methods to a provided delegate object.
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.
Base class for all generated Java sources.
An implementation of the
Events.Publisher interface that can broadcast events.An iterator that generates all possible combinations of elements from source objects.
Represents a compiled
ValuesPredicate along with its source code and resolved fields.Manages
CompletableFuture instances associated with given keys.Represents an event that occurs when a condition is evaluated.
Previously part of the
RuleBuilder interface, since version 4.0.0, this interface contains methods
for declaring various rule-level conditions and obtaining their references.
Configuration class represents a configuration object that extends the Properties class and
implements the
Copyable and FluentImports interfaces.Constants interface defines the constant values for different providers.
Contains constant values that are used throughout the project.
A marker interface for all
RuntimeContext events.A generic alternative to Cloneable.
Default and dummy activation manager that does nothing.
A wrapper for an
ExecutorService that supports an externally supplied or internally created instance.General interface for two-stage memory instances where insert operations
are buffered in an internal delta storage and then committed to the main storage
by invoking the
DeltaInsertMemory.commit() method.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.
An interface for creating and integrating Domain-Specific Language (DSL) implementations with the rule engine.
The DSLClassProvider class provides the implementation of the DSLKnowledgeProvider
interface for 'JAVA-SOURCE' DSL knowledge.
Provides an iterator for all combinations of enum values for a given enum class
E
inside a given array E[].The Environment interface provides a way to store and retrieve property values.
Interface representing an
ContextEvent that occurs when an environment property changes.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 context that maintains a collection of every condition used in the engine's runtime.
Interface representing an Event Bus for subscribing to events.
A simpler alternative to the
Flow class and its interfaces.A marker interface for all events.
A Publisher provides a mechanism to subscribe consumers to it.
Interface for controlling the subscription.
Utility class for cancelling multiple
Events.Subscription objects at once.Annotation for methods that serve as subscribers to the engine's events.
This annotation can be used to mark a parameter in a method with a fact value.
A fact declaration for
RuleBuilder.Represents a unique identifier for a fact in working memory.
A fact storage interface
Marks a method as a field declaration.
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.
A basic map data structure that can be used in implementations of the
Copyable interface.
A map-like storage that holds objects grouped by keys, similar to
Map<Long, Set<V>>.The Hierarchy class represents a hierarchical structure of elements.
Represents a class for managing Java imports.
An object with an assigned unique index.
Represents an object with an assigned unique index.
Represents a boolean-valued function of one
int-valued
and one object-valued argument.Defines an interface for conveniently accessing objects by integer indices.
Knowledge is a preprocessed ruleset.
Represents an event that occurs when a new instance of
Knowledge is created.
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.
A generic class for representing LHS conditions.
A convenience interface to use for LHS fact declarations.
A convenient generic class for referencing LHS (Left-Hand Side) field declarations.
In many cases, the order of field references matters, and this class provides a wrapper for an array
of references.
Represents a literal condition
A class that implements a
Function interface using an internal map.The
MappingReIterator class implements the Iterator interface
and maps values using the provided functional interface.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.
Defines memory scopes for use with instances of
ReteMemory
and provides utilities for iterating over state combinations based on these scopes.Provides streaming methods for handling in-memory facts.
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.
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.
A marker interface used to indicate that the annotated method is referenced by one or
more
MethodPredicate annotations and should not be flagged as unused by the IDE.Describes a general session-level memory interface related to the Rete algorithm.
Provides access to the rule's RHS (Right-Hand Side) variables and
the session memory's 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.
This class represents a compiled version of
RuleLiteralDataRepresents a rule that is associated with a
Knowledge instance.A marker interface indicating that the annotated type, method, field, parameter, or package is being used inside rules.
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.Represents an event that occurs when a
RuleSession is closedA class that collects/inserts elements into a
RuleSession instance.Represents an event that occurs when a new
RuleSession is createdRepresents an event that occurs immediately after
RuleSession.fire() is called.Deprecated.
since 4.0.0.
Enumeration of the different events that can trigger the callback.
The SourceCompiler interface is used to compile Java source files.
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.
Provides instances of
SourceCompiler.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.
The TimedEvent interface represents a
ContextEvent that has a start and end time.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 the engine's internal
Type.The TypeResolverProvider interface represents a service provider interface (SPI)
for providing instances of TypeResolver.
A wrapper class that implements the
Type interface and delegates the calls to another Type implementation.A collection that stores values and assigns them a unique
long identifier.Every condition in the engine is a
ValuesPredicate.This annotation can be used to define conditions for a rule method.
A unit of work with given complexity.