All Classes and Interfaces
Class
Description
Groups incoming tuples by the given mask, and aggregates values at a specific index in each group.
Ensures that no identical copies get to the output.
An abstract mailbox implementation that is capable of splitting update messages based on some form of monotonicity
(anti-monotone and monotone).
An adaptable mailbox can be wrapped by another mailbox to act in behalf of that.
Remote identifier of a node of type T.
Base implementation for a Rete node.
Basic layout that builds a linear RETE net based on a heuristic ordering of constraints.
This mailbox changes its behavior based on the position of its
Receiver in the network topology.Timeless implementation of the column aggregator node.
A communication group represents a set of nodes in the communication graph that form a strongly connected component.
An instance of this class is associated with every
ReteContainer.Indicates that recipe expresses the finished match set of a query.
A trace marker associating a Rete recipe with a query SubPlan.
Calculated index mappings for a join, based on the common variables of the two parent subplans.
Node that always contains a single constant Tuple
This class is the optimized implementation of the Counting algorithm.
Transitive closure relation implementation for the Counting algorithm.
An aggregation node that simply counts the number of tuples conforming to the signature.
Default configuration for DeltaMonitor.
Default mailbox implementation.
Default implementation of the Production node, based on UniquenessEnforcerNode
A monitoring object that connects to the rete network as a receiver to reflect changes since an arbitrary state
acknowledged by the client.
A depth-first search implementation of the
IGraphPathFinder.For objects that connect a RETE implementation to the underlying model.
A bucket holds a filtered set of tuples of its parent
DiscriminatorDispatcherNode.Node that sends tuples off to different buckets (attached as children of type
DiscriminatorBucketNode), based
on the value of a given column.This class contains utility methods to generate dot representations for
Graph instances.A
ReteBackendFactory implementation that creates ReteEngines that use delete and re-derive
evaluation.Abstract superclass for nodes with two inputs that are matched against each other.
An instance of this class performs the evaluation of Java expressions.
Propagates all substitutions arriving at the PRIMARY slot if and only if (a matching substitution on the SECONDARY is
present) xor (NEGATIVE).
An input node representing an enumerable extensional input relation and receiving external updates.
A filter node representing a (stateless, typically non-enumerable) extensional input relation.
Faithful column aggregator with parallel aggregation architecture.
Faithful column aggregator with sequential aggregation architecture.
FaithfulSequentialTimelyColumnAggregatorNode.CumulativeAggregate<Domain,Accumulator,AggregateResult>
Faithful timely implementation of the column aggregator node.
A fall through capable mailbox can directly call the update method of its
Receiver instead of using the
standard post-deliver mailbox semantics.This node implements a simple filter.
First-only column aggregator with parallel aggregation architecture.
First-only column aggregator with sequential aggregation architecture.
First-only timely implementation of the column aggregator node.
A generic Indexer capable of indexing along any valid TupleMask.
Utility class for graph related operations.
An optimized
Map implementation where each key is produced by joining together a group tuple and some other
object (via left inheritance).An optimized
Set implementation where each contained value is produced by combining together a grouping value
and some other (key) object.Expresses that aggregators expose specialized non-enumerable indexers for outer joining.
A bi-directional graph data source supports all operations that an
IGraphDataSource does, but it
also makes it possible to query the incoming edges of nodes, not only the outgoing edges.This class can be used to wrap an
IGraphDataSource into an IBiDirectionalGraphDataSource.Defines an abstract trivial indexer that identically projects the contents of some stateful node, and can therefore
save space.
This interface is required for the communication between the evaluation core end the evaluator node.
The interface prescribes the set of operations that a graph data source must support.
Interface GraphObserver is used to observ the changes in a graph; edge and node insertion/deleteion.
The path finder provides methods for retrieving paths in a graph between a source node and one or more target nodes.
Incremental SCC maintenance + counting algorithm.
A node that indexes incoming Tuples by their signatures as specified by a TupleMask.
A special node depending on a projection indexer to aggregate tuple groups with the same projection.
A listener for update events concerning an Indexer.
This node filters patterns according to equalities and inequalities of elements.
A class responsible for connecting input nodes to the runtime context.
This interface defines those methods that a transitive reachability data source should provide.
Interface ITcObserver is used to observe the changes in a transitive closure relation; tuple insertion/deletion.
An indexer that allows the iteration of all retrievable tuple groups (or reduced groups).
A comparator that compares two iterables based on the lexicographic sorting induced by a comparator on elements.
A mailbox is associated with every
Receiver.Defines a trivial indexer that identically projects the contents of a memory-equipped node, and can therefore save
space.
Defines a trivial indexer that projects the contents of a memory-equipped node to the empty tuple, and can therefore
save space.
A message indexer is used by
Mailboxes to index their contents.A factory used to create message indexers for
Mailboxes.Subclasses of this interface represent meta data of update messages in Rete.
Nodes implementing this interface are sensitive to changes in the dependency graph maintained by the
CommunicationTracker.A node of a rete network, should be uniquely identified by network and nodeId.
Stores the internal parts of a rete network.
Defines an abstract trivial indexer that projects the contents of some stateful node to the empty tuple, and can
therefore save space.
Feature switches.
Comparing agent for an ordering.
An evaluator node that caches the evaluation result.
The recipe projects the finished results of a
PBody onto the list of parameters.One kind of trace marker that merely establishes the pattern for which the node was built.
A default message selector that can be used to associate phases to messages.
A trace marker associating a Rete recipe with a query SubPlan.
A monotonicity aware mailbox implementation.
Interface intended for nodes containing complete matches.
An iterable indexer that receives updates from a node, and groups received tuples intact, i.e.
Layout ideas: see https://bugs.eclipse.org/bugs/show_bug.cgi?id=398763
ALL METHODS: FOR INTERNAL USE ONLY; ONLY INVOKE FROM
ReteContainerA trace marker that indicates the recipe for which the node was built.
In a recursive query structure, query composition references can be cut off so that the remaining structure is DAG.
A communication group representing either a single node where the
node is a monotonicity aware one or a set of nodes that form an SCC.
A rederivable node can potentially re-derive tuples after the Rete network has finished the delivery of messages.
A node that operates in batch-style (see
and evaluates arbitrary Java
logic represented by an
invalid reference
Receiver#doesProcessUpdatesInBatch()IRelationEvaluator on the input relations.This node delivers updates to a remote recipient; no updates are propagated further in this network.
This node receives updates from a remote supplier; no local updates are expected.
Nodes that implement this interface can resume folding of their states when instructed during timely evaluation.Responsible for the storage, maintenance and communication of the nodes of the network that are accessible form the
outside for various reasons.
Provides key objects (of type
QueryHintOption) for QueryEvaluationHints.A problem has occurred during the construction of the RETE net.
Compiles queries and query plans into Rete recipes, traced by respectively a
CompiledQuery or
CompiledSubPlan.Efficient algorithms to compute the Strongly Connected Components in a directed graph.
A communication group containing only a single node with a single default
mailbox.
A specialized projection indexer that can be memory-less (relying on an external source of information).
Infrastructure to share subscriptions between specialized indexers of the same parent node.
An abstract standard implementation of the Indexer interface, providing common bookkeeping functionality.
Base implementation for a supplier node.
Class providing comparators for breaking ties somewhat more deterministically.
Timeless implementation of the communication tracker.
A timely communication group implementation.
Timely (DDF) implementation of the
CommunicationTracker.Configuration of timely evaluation.
A timely proxy for another
IndexerListener, which performs some preprocessing
on the differential timestamps before passing it on to the real recipient.A timely proxy for another
Mailbox, which performs some preprocessing
on the differential timestamps before passing it on to the real recipient.Differential dataflow implementation of the Production node, based on
TimelyUniquenessEnforcerNode.A
ReteBackendFactory implementation that creates ReteEngines that use non-scattered timely
evaluation.Timely uniqueness enforcer node implementation.
A timestamp associated with update messages in timely evaluation.
A
Map implementation that associates the zero timestamp with every key.Values of this enum perform different kind of preprocessing on
Timestamps.Traces the node back to a purpose for which the node was built,
to explain why the node is there and what it means.
This class represents a transitive closure node in the Rete net.
Simply propagates everything.
Trims the matchings as specified by a mask.
Timeless uniqueness enforcer node implementation.
A mailbox implementation that splits updates messages according to the standard subset ordering into anti-monotonic
(deletions) and monotonic (insertions) updates.
A filter node that keeps only those tuples that contain a certain value at a certain position.