20 files changed, 2139 insertions, 0 deletions

diff --git a/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/DefaultIndexerListener.java b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/DefaultIndexerListener.java
new file mode 100644
index 00000000..6306a482
--- /dev/null
+++ b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/DefaultIndexerListener.java
@@ -0,0 +1,28 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.rete.index;
+
+import java.lang.ref.WeakReference;
+
+import tools.refinery.viatra.runtime.rete.network.Node;
+
+public abstract class DefaultIndexerListener implements IndexerListener {
+
+    WeakReference<Node> owner;
+
+    public DefaultIndexerListener(Node owner) {
+        this.owner = new WeakReference<Node>(owner);
+    }
+
+    @Override
+    public Node getOwner() {
+        return owner.get();
+    }
+
+}
diff --git a/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/DualInputNode.java b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/DualInputNode.java
new file mode 100644
index 00000000..170ac460
--- /dev/null
+++ b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/DualInputNode.java
@@ -0,0 +1,348 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2008 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.rete.index;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+import tools.refinery.viatra.runtime.matchers.util.Direction;
+import tools.refinery.viatra.runtime.matchers.util.timeline.Timeline;
+import tools.refinery.viatra.runtime.rete.network.NetworkStructureChangeSensitiveNode;
+import tools.refinery.viatra.runtime.rete.network.Receiver;
+import tools.refinery.viatra.runtime.rete.network.ReteContainer;
+import tools.refinery.viatra.runtime.rete.network.StandardNode;
+import tools.refinery.viatra.runtime.rete.network.communication.Timestamp;
+import tools.refinery.viatra.runtime.rete.network.communication.Timestamp.AllZeroMap;
+import tools.refinery.viatra.runtime.rete.network.delayed.DelayedConnectCommand;
+import tools.refinery.viatra.runtime.rete.traceability.TraceInfo;
+import tools.refinery.viatra.runtime.rete.util.Options;
+
+/**
+ * Abstract superclass for nodes with two inputs that are matched against each other.
+ * 
+ * @author Gabor Bergmann
+ */
+public abstract class DualInputNode extends StandardNode implements NetworkStructureChangeSensitiveNode {
+
+    /**
+     * @since 2.3
+     */
+    protected NetworkStructureChangeSensitiveLogic logic;
+
+    public IterableIndexer getPrimarySlot() {
+        return primarySlot;
+    }
+
+    public Indexer getSecondarySlot() {
+        return secondarySlot;
+    }
+
+    /**
+     * @author Gabor Bergmann
+     * 
+     */
+    public enum Side {
+        PRIMARY, SECONDARY, BOTH;
+
+        public Side opposite() {
+            switch (this) {
+            case PRIMARY:
+                return SECONDARY;
+            case SECONDARY:
+                return PRIMARY;
+            case BOTH:
+                return BOTH;
+            default:
+                return BOTH;
+            }
+        }
+    }
+
+    /**
+     * Holds the primary input slot of this node.
+     */
+    protected IterableIndexer primarySlot;
+
+    /**
+     * Holds the secondary input slot of this node.
+     */
+    protected Indexer secondarySlot;
+
+    /**
+     * Optional complementer mask
+     */
+    protected TupleMask complementerSecondaryMask;
+
+    /**
+     * true if the primary and secondary slots coincide
+     */
+    protected boolean coincidence;
+
+    /**
+     * @param reteContainer
+     */
+    public DualInputNode(final ReteContainer reteContainer, final TupleMask complementerSecondaryMask) {
+        super(reteContainer);
+        this.complementerSecondaryMask = complementerSecondaryMask;
+        this.indexerGroupCache = CollectionsFactory.createMap();
+        this.refreshIndexerGroupCache();
+    }
+
+    /**
+     * Should be called only once, when node is initialized.
+     */
+    public void connectToIndexers(final IterableIndexer primarySlot, final Indexer secondarySlot) {
+        this.primarySlot = primarySlot;
+        this.secondarySlot = secondarySlot;
+
+        reteContainer.getCommunicationTracker().registerDependency(primarySlot, this);
+        reteContainer.getCommunicationTracker().registerDependency(secondarySlot, this);
+
+        // attach listeners
+        // if there is syncing, do this after the flush done for pulling, but before syncing updates
+        coincidence = primarySlot.equals(secondarySlot);
+
+        if (!coincidence) { // regular case
+            primarySlot.attachListener(new DefaultIndexerListener(this) {
+                @Override
+                public void notifyIndexerUpdate(final Direction direction, final Tuple updateElement,
+                        final Tuple signature, final boolean change, final Timestamp timestamp) {
+                    DualInputNode.this.logic.notifyUpdate(Side.PRIMARY, direction, updateElement, signature, change,
+                            timestamp);
+                }
+
+                @Override
+                public String toString() {
+                    return "primary@" + DualInputNode.this;
+                }
+            });
+            secondarySlot.attachListener(new DefaultIndexerListener(this) {
+                public void notifyIndexerUpdate(final Direction direction, final Tuple updateElement,
+                        final Tuple signature, final boolean change, final Timestamp timestamp) {
+                    DualInputNode.this.logic.notifyUpdate(Side.SECONDARY, direction, updateElement, signature, change,
+                            timestamp);
+                }
+
+                @Override
+                public String toString() {
+                    return "secondary@" + DualInputNode.this;
+                }
+            });
+        } else { // if the two slots are the same, updates have to be handled carefully
+            primarySlot.attachListener(new DefaultIndexerListener(this) {
+                public void notifyIndexerUpdate(final Direction direction, final Tuple updateElement,
+                        final Tuple signature, final boolean change, final Timestamp timestamp) {
+                    DualInputNode.this.logic.notifyUpdate(Side.BOTH, direction, updateElement, signature, change,
+                            timestamp);
+                }
+
+                @Override
+                public String toString() {
+                    return "both@" + DualInputNode.this;
+                }
+            });
+        }
+
+        for (final Receiver receiver : getReceivers()) {
+            this.reteContainer.getDelayedCommandQueue()
+                    .add(new DelayedConnectCommand(this, receiver, this.reteContainer));
+        }
+        
+        // Given that connectToIndexers registers new dependencies, the networkStructureChanged() method will be called
+        // by the CommunicationTracker, and the implementation of that method in turn will call refreshIndexerGroupCache() anyway.
+        this.refreshIndexerGroupCache();
+    }
+
+    /**
+     * Helper: retrieves all stored substitutions from the opposite side memory.
+     *
+     * @return the collection of opposite substitutions if any, or null if none
+     */
+    protected Collection<Tuple> retrieveOpposites(final Side side, final Tuple signature) {
+        return getSlot(side.opposite()).get(signature);
+    }
+
+    /**
+     * @since 2.3
+     */
+    protected NetworkStructureChangeSensitiveLogic createLogic() {
+        if (this.reteContainer.isTimelyEvaluation()
+                && this.reteContainer.getCommunicationTracker().isInRecursiveGroup(this)) {
+            return createTimelyLogic();
+        } else {
+            return createTimelessLogic();
+        }
+    }
+
+    /**
+     * Helper: unifies a left and right partial matching.
+     */
+    protected Tuple unify(final Tuple left, final Tuple right) {
+        return complementerSecondaryMask.combine(left, right, Options.enableInheritance, true);
+    }
+
+    @Override
+    public void pullInto(final Collection<Tuple> collector, final boolean flush) {
+        this.logic.pullInto(collector, flush);
+    }
+
+    @Override
+    public void pullIntoWithTimeline(final Map<Tuple, Timeline<Timestamp>> collector, final boolean flush) {
+        this.logic.pullIntoWithTimeline(collector, flush);
+    }
+
+    /**
+     * Helper: unifies a substitution from the specified side with another substitution from the other side.
+     */
+    protected Tuple unify(final Side side, final Tuple ps, final Tuple opposite) {
+        switch (side) {
+        case PRIMARY:
+            return unify(ps, opposite);
+        case SECONDARY:
+            return unify(opposite, ps);
+        case BOTH:
+            return unify(ps, opposite);
+        default:
+            return null;
+        }
+    }
+
+    /**
+     * Simulates the behavior of the node for calibration purposes only.
+     */
+    public abstract Tuple calibrate(final Tuple primary, final Tuple secondary);
+
+    /**
+     * @param complementerSecondaryMask
+     *            the complementerSecondaryMask to set
+     */
+    public void setComplementerSecondaryMask(final TupleMask complementerSecondaryMask) {
+        this.complementerSecondaryMask = complementerSecondaryMask;
+    }
+
+    /**
+     * Retrieves the slot corresponding to the specified side.
+     */
+    protected Indexer getSlot(final Side side) {
+        if (side == Side.SECONDARY) {
+            return secondarySlot;
+        } else {
+            return primarySlot;
+        }
+    }
+
+    @Override
+    public void assignTraceInfo(final TraceInfo traceInfo) {
+        super.assignTraceInfo(traceInfo);
+        if (traceInfo.propagateToIndexerParent()) {
+            if (primarySlot != null) {
+                primarySlot.acceptPropagatedTraceInfo(traceInfo);
+            }
+            if (secondarySlot != null) {
+                secondarySlot.acceptPropagatedTraceInfo(traceInfo);
+            }
+        }
+    }
+
+    @Override
+    public void networkStructureChanged() {
+        super.networkStructureChanged();
+        this.logic = createLogic();
+        this.refreshIndexerGroupCache();
+    }
+
+    /**
+     * @since 2.3
+     */
+    protected abstract NetworkStructureChangeSensitiveLogic createTimelyLogic();
+
+    /**
+     * @since 2.3
+     */
+    protected abstract NetworkStructureChangeSensitiveLogic createTimelessLogic();
+
+    /**
+     * This map caches the result of a CommunicationTracker.areInSameGroup(indexer, this) call. It does that for both
+     * the primary and secondary slots. This way we can avoid the lookup in the getWithTimestamp call for each tuple.
+     * The cache needs to be maintained when the network structure changes.
+     * @since 2.3
+     */
+    protected Map<Indexer, Boolean> indexerGroupCache;
+
+    /**
+     * @since 2.3
+     */
+    protected void refreshIndexerGroupCache() {
+        this.indexerGroupCache.clear();
+        if (this.primarySlot != null) {
+            this.indexerGroupCache.put(this.primarySlot,
+                    this.reteContainer.getCommunicationTracker().areInSameGroup(this.primarySlot, this));
+        }
+        if (this.secondarySlot != null) {
+            this.indexerGroupCache.put(this.secondarySlot,
+                    this.reteContainer.getCommunicationTracker().areInSameGroup(this.secondarySlot, this));
+        }
+    }
+
+    /**
+     * @since 2.4
+     */
+    protected Map<Tuple, Timeline<Timestamp>> getTimeline(final Tuple signature, final Indexer indexer) {
+        if (this.indexerGroupCache.get(indexer)) {
+            // recursive timely case
+            return indexer.getTimeline(signature);
+        } else {
+            // the indexer is in a different group, treat all of its tuples as they would have timestamp 0
+            final Collection<Tuple> tuples = indexer.get(signature);
+            if (tuples == null) {
+                return null;
+            } else {
+                return new AllZeroMap<Tuple>((Set<Tuple>) tuples);
+            }
+        }
+    }
+
+    /**
+     * @since 2.3
+     */
+    protected static abstract class NetworkStructureChangeSensitiveLogic {
+
+        /**
+         * Abstract handler for update event.
+         * 
+         * @param side
+         *            The side on which the event occurred.
+         * @param direction
+         *            The direction of the update.
+         * @param updateElement
+         *            The partial matching that is inserted.
+         * @param signature
+         *            Masked signature of updateElement.
+         * @param change
+         *            Indicates whether this is/was the first/last instance of this signature in this slot.
+         * @since 2.4
+         */
+        public abstract void notifyUpdate(final Side side, final Direction direction, final Tuple updateElement,
+                final Tuple signature, final boolean change, final Timestamp timestamp);
+
+        public abstract void pullInto(final Collection<Tuple> collector, final boolean flush);
+
+        /**
+         * @since 2.4
+         */
+        public abstract void pullIntoWithTimeline(final Map<Tuple, Timeline<Timestamp>> collector, final boolean flush);
+
+    }
+
+}
diff --git a/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/ExistenceNode.java b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/ExistenceNode.java
new file mode 100644
index 00000000..275ff638
--- /dev/null
+++ b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/ExistenceNode.java
@@ -0,0 +1,199 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2008 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.rete.index;
+
+import java.util.Collection;
+import java.util.Map;
+
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.util.Direction;
+import tools.refinery.viatra.runtime.matchers.util.Signed;
+import tools.refinery.viatra.runtime.matchers.util.timeline.Timeline;
+import tools.refinery.viatra.runtime.rete.network.ReteContainer;
+import tools.refinery.viatra.runtime.rete.network.communication.Timestamp;
+
+/**
+ * Propagates all substitutions arriving at the PRIMARY slot if and only if (a matching substitution on the SECONDARY is
+ * present) xor (NEGATIVE).
+ * 
+ * The negative parameter specifies whether this node checks for existence or non-existence.
+ * <p>
+ * It is mandatory in differential dataflow evaluation that the secondary parent is in an upstream dependency component
+ * (so that every secondary tuple comes with zero timestamp).
+ * 
+ * @author Gabor Bergmann
+ */
+public class ExistenceNode extends DualInputNode {
+
+    protected boolean negative;
+
+    /**
+     * @param reteContainer
+     * @param negative
+     *            if false, act as existence checker, otherwise a nonexistence-checker
+     */
+    public ExistenceNode(final ReteContainer reteContainer, final boolean negative) {
+        super(reteContainer, null);
+        this.negative = negative;
+        this.logic = createLogic();
+    }
+
+    @Override
+    public Tuple calibrate(final Tuple primary, final Tuple secondary) {
+        return primary;
+    }
+
+    @Override
+    public void networkStructureChanged() {
+        if (this.reteContainer.isTimelyEvaluation() && this.secondarySlot != null
+                && this.reteContainer.getCommunicationTracker().areInSameGroup(this, this.secondarySlot)) {
+            throw new IllegalStateException("Secondary parent must be in an upstream dependency component!");
+        }
+        super.networkStructureChanged();
+    }
+
+    private final NetworkStructureChangeSensitiveLogic TIMELESS = new NetworkStructureChangeSensitiveLogic() {
+
+        @Override
+        public void pullIntoWithTimeline(final Map<Tuple, Timeline<Timestamp>> collector, final boolean flush) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public void pullInto(final Collection<Tuple> collector, final boolean flush) {
+            if (primarySlot == null || secondarySlot == null) {
+                return;
+            }
+            if (flush) {
+                reteContainer.flushUpdates();
+            }
+
+            for (final Tuple signature : primarySlot.getSignatures()) {
+                // primaries can not be null due to the contract of IterableIndex.getSignatures()
+                final Collection<Tuple> primaries = primarySlot.get(signature);
+                final Collection<Tuple> opposites = secondarySlot.get(signature);
+                if ((opposites != null) ^ negative) {
+                    collector.addAll(primaries);
+                }
+            }
+        }
+
+        @Override
+        public void notifyUpdate(final Side side, final Direction direction, final Tuple updateElement,
+                final Tuple signature, final boolean change, final Timestamp timestamp) {
+            // in the default case, all timestamps must be zero
+            assert Timestamp.ZERO.equals(timestamp);
+
+            switch (side) {
+            case PRIMARY:
+                if ((retrieveOpposites(side, signature) != null) ^ negative) {
+                    propagateUpdate(direction, updateElement, timestamp);
+                }
+                break;
+            case SECONDARY:
+                if (change) {
+                    final Collection<Tuple> opposites = retrieveOpposites(side, signature);
+                    if (opposites != null) {
+                        for (final Tuple opposite : opposites) {
+                            propagateUpdate((negative ? direction.opposite() : direction), opposite, timestamp);
+                        }
+                    }
+                }
+                break;
+            case BOTH:
+                // in case the slots coincide,
+                // negative --> always empty
+                // !positive --> identity
+                if (!negative) {
+                    propagateUpdate(direction, updateElement, timestamp);
+                }
+                break;
+            }
+        }
+    };
+
+    private final NetworkStructureChangeSensitiveLogic TIMELY = new NetworkStructureChangeSensitiveLogic() {
+
+        @Override
+        public void pullIntoWithTimeline(final Map<Tuple, Timeline<Timestamp>> collector, final boolean flush) {
+            if (primarySlot == null || secondarySlot == null) {
+                return;
+            }
+            if (flush) {
+                reteContainer.flushUpdates();
+            }
+
+            for (final Tuple signature : primarySlot.getSignatures()) {
+                // primaries can not be null due to the contract of IterableIndex.getSignatures()
+                final Map<Tuple, Timeline<Timestamp>> primaries = getTimeline(signature, primarySlot);
+                // see contract: secondary must be in an upstream SCC
+                final Collection<Tuple> opposites = secondarySlot.get(signature);
+                if ((opposites != null) ^ negative) {
+                    for (final Tuple primary : primaries.keySet()) {
+                        collector.put(primary, primaries.get(primary));
+                    }
+                }
+            }
+        }
+
+        @Override
+        public void pullInto(final Collection<Tuple> collector, final boolean flush) {
+            ExistenceNode.this.TIMELESS.pullInto(collector, flush);
+        }
+
+        @Override
+        public void notifyUpdate(final Side side, final Direction direction, final Tuple updateElement,
+                final Tuple signature, final boolean change, final Timestamp timestamp) {
+            switch (side) {
+            case PRIMARY: {
+                final Collection<Tuple> opposites = secondarySlot.get(signature);
+                if ((opposites != null) ^ negative) {
+                    propagateUpdate(direction, updateElement, timestamp);
+                }
+                break;
+            }
+            case SECONDARY: {
+                final Map<Tuple, Timeline<Timestamp>> opposites = primarySlot.getTimeline(signature);
+                if (change) {
+                    if (opposites != null) {
+                        for (final Tuple opposite : opposites.keySet()) {
+                            for (final Signed<Timestamp> oppositeSigned : opposites.get(opposite).asChangeSequence()) {
+                                final Direction product = direction.multiply(oppositeSigned.getDirection());
+                                propagateUpdate((negative ? product.opposite() : product), opposite,
+                                        oppositeSigned.getPayload());
+                            }
+                        }
+                    }
+                }
+                break;
+            }
+            case BOTH:
+                // in case the slots coincide,
+                // negative --> always empty
+                // positive --> identity
+                if (!negative) {
+                    propagateUpdate(direction, updateElement, timestamp);
+                }
+                break;
+            }
+        }
+    };
+
+    @Override
+    protected NetworkStructureChangeSensitiveLogic createTimelessLogic() {
+        return this.TIMELESS;
+    }
+
+    @Override
+    protected NetworkStructureChangeSensitiveLogic createTimelyLogic() {
+        return this.TIMELY;
+    }
+
+}
diff --git a/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/GenericProjectionIndexer.java b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/GenericProjectionIndexer.java
new file mode 100644
index 00000000..3de10def
--- /dev/null
+++ b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/GenericProjectionIndexer.java
@@ -0,0 +1,76 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2008 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.rete.index;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.matchers.util.Direction;
+import tools.refinery.viatra.runtime.matchers.util.timeline.Timeline;
+import tools.refinery.viatra.runtime.rete.network.Receiver;
+import tools.refinery.viatra.runtime.rete.network.ReteContainer;
+import tools.refinery.viatra.runtime.rete.network.communication.Timestamp;
+
+/**
+ * A generic Indexer capable of indexing along any valid TupleMask. Does not keep track of parents, because will not
+ * ever pull parents.
+ * 
+ * @author Gabor Bergmann
+ * 
+ */
+public class GenericProjectionIndexer extends IndexerWithMemory implements ProjectionIndexer {
+
+    public GenericProjectionIndexer(ReteContainer reteContainer, TupleMask mask) {
+        super(reteContainer, mask);
+    }
+
+    @Override
+    protected void update(Direction direction, Tuple updateElement, Tuple signature, boolean change,
+            Timestamp timestamp) {
+        propagate(direction, updateElement, signature, change, timestamp);
+    }
+
+    @Override
+    public Collection<Tuple> get(Tuple signature) {
+        return memory.get(signature);
+    }
+
+    @Override
+    public Map<Tuple, Timeline<Timestamp>> getTimeline(Tuple signature) {
+        return memory.getWithTimeline(signature);
+    }
+
+    @Override
+    public Iterator<Tuple> iterator() {
+        return memory.iterator();
+    }
+
+    @Override
+    public Iterable<Tuple> getSignatures() {
+        return memory.getSignatures();
+    }
+
+    /**
+     * @since 2.0
+     */
+    @Override
+    public int getBucketCount() {
+        return memory.getKeysetSize();
+    }
+
+    @Override
+    public Receiver getActiveNode() {
+        return this;
+    }
+
+}
diff --git a/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/IdentityIndexer.java b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/IdentityIndexer.java
new file mode 100644
index 00000000..6c158f2c
--- /dev/null
+++ b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/IdentityIndexer.java
@@ -0,0 +1,76 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2012 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.rete.index;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.matchers.util.Direction;
+import tools.refinery.viatra.runtime.rete.network.Node;
+import tools.refinery.viatra.runtime.rete.network.ReteContainer;
+import tools.refinery.viatra.runtime.rete.network.Supplier;
+import tools.refinery.viatra.runtime.rete.network.communication.Timestamp;
+
+/**
+ * Defines an abstract trivial indexer that identically projects the contents of some stateful node, and can therefore
+ * save space. Can only exist in connection with a stateful store, and must be operated by another node (the active
+ * node). Do not attach parents directly!
+ * 
+ * @author Gabor Bergmann
+ * @noimplement Rely on the provided implementations
+ * @noreference Use only via standard Node and Indexer interfaces
+ * @noinstantiate This class is not intended to be instantiated by clients.
+ */
+public abstract class IdentityIndexer extends SpecializedProjectionIndexer {
+
+    protected abstract Collection<Tuple> getTuples();
+
+    public IdentityIndexer(ReteContainer reteContainer, int tupleWidth, Supplier parent, 
+            Node activeNode, List<ListenerSubscription> sharedSubscriptionList) {
+        super(reteContainer, TupleMask.identity(tupleWidth), parent, activeNode, sharedSubscriptionList);
+    }
+
+    @Override
+    public Collection<Tuple> get(Tuple signature) {
+        if (contains(signature)) {
+            return Collections.singleton(signature);
+        } else
+            return null;
+    }
+    
+    protected boolean contains(Tuple signature) {
+        return getTuples().contains(signature);
+    }
+
+    @Override
+    public Collection<Tuple> getSignatures() {
+        return getTuples();
+    }
+    
+    @Override
+    public int getBucketCount() {
+        return getTuples().size();
+    }
+    
+    @Override
+    public Iterator<Tuple> iterator() {
+        return getTuples().iterator();
+    }
+    
+    @Override
+    public void propagateToListener(IndexerListener listener, Direction direction, Tuple updateElement, Timestamp timestamp) {
+        listener.notifyIndexerUpdate(direction, updateElement, updateElement, true, timestamp);
+    }
+
+}
\ No newline at end of file
diff --git a/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/Indexer.java b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/Indexer.java
new file mode 100644
index 00000000..fc9d7781
--- /dev/null
+++ b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/Indexer.java
@@ -0,0 +1,71 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2008 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.rete.index;
+
+import java.util.Collection;
+import java.util.Map;
+
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.matchers.util.timeline.Timeline;
+import tools.refinery.viatra.runtime.rete.network.Node;
+import tools.refinery.viatra.runtime.rete.network.Supplier;
+import tools.refinery.viatra.runtime.rete.network.communication.Timestamp;
+
+/**
+ * A node that indexes incoming Tuples by their signatures as specified by a TupleMask. Notifies listeners about such
+ * update events through the IndexerListener.
+ * 
+ * Signature tuples are created by transforming the update tuples using the mask. Tuples stored with the same signature
+ * are grouped together. The group or a reduction thereof is retrievable.
+ * 
+ * @author Gabor Bergmann
+ */
+public interface Indexer extends Node {
+    /**
+     * @return the mask by which the contents are indexed.
+     */
+    public TupleMask getMask();
+
+    /**
+     * @return the node whose contents are indexed.
+     */
+    public Supplier getParent();
+
+    /**
+     * @return all stored tuples that conform to the specified signature, null if there are none such. CONTRACT: do not
+     *         modify!
+     */
+    public Collection<Tuple> get(Tuple signature);
+    
+    /**
+     * @since 2.4
+     */
+    default public Map<Tuple, Timeline<Timestamp>> getTimeline(Tuple signature) {
+        throw new UnsupportedOperationException();
+    }
+
+    /**
+     * This indexer will be updated whenever a Rete update is sent to the active node (or an equivalent time slot
+     * allotted to it). The active node is typically the indexer itself, but it can be a different node such as its
+     * parent.
+     * 
+     * @return the active node that operates this indexer
+     */
+    public Node getActiveNode();
+
+    
+    public Collection<IndexerListener> getListeners();
+    
+    public void attachListener(IndexerListener listener);
+
+    public void detachListener(IndexerListener listener);
+
+}
diff --git a/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/IndexerListener.java b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/IndexerListener.java
new file mode 100644
index 00000000..f52b6a06
--- /dev/null
+++ b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/IndexerListener.java
@@ -0,0 +1,41 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2008 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.rete.index;
+
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.util.Direction;
+import tools.refinery.viatra.runtime.rete.network.Node;
+import tools.refinery.viatra.runtime.rete.network.communication.Timestamp;
+
+/**
+ * A listener for update events concerning an Indexer.
+ * 
+ * @author Gabor Bergmann
+ * 
+ */
+public interface IndexerListener {
+    /**
+     * Notifies recipient that the indexer has just received an update. Contract: indexer already reflects the updated
+     * state.
+     * 
+     * @param direction
+     *            the direction of the update.
+     * @param updateElement
+     *            the tuple that was updated.
+     * @param signature
+     *            the signature of the tuple according to the indexer's mask.
+     * @param change
+     *            whether this was the first inserted / last revoked update element with this particular signature.
+     * @since 2.4
+     */
+    void notifyIndexerUpdate(Direction direction, Tuple updateElement, Tuple signature, boolean change, Timestamp timestamp);
+
+    Node getOwner();
+}
diff --git a/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/IndexerWithMemory.java b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/IndexerWithMemory.java
new file mode 100644
index 00000000..a31562e9
--- /dev/null
+++ b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/IndexerWithMemory.java
@@ -0,0 +1,284 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2009 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.rete.index;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import tools.refinery.viatra.runtime.matchers.memories.MaskedTupleMemory;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory.MemoryType;
+import tools.refinery.viatra.runtime.matchers.util.Direction;
+import tools.refinery.viatra.runtime.matchers.util.Signed;
+import tools.refinery.viatra.runtime.matchers.util.timeline.Diff;
+import tools.refinery.viatra.runtime.rete.matcher.TimelyConfiguration.TimelineRepresentation;
+import tools.refinery.viatra.runtime.rete.network.NetworkStructureChangeSensitiveNode;
+import tools.refinery.viatra.runtime.rete.network.Receiver;
+import tools.refinery.viatra.runtime.rete.network.ReteContainer;
+import tools.refinery.viatra.runtime.rete.network.Supplier;
+import tools.refinery.viatra.runtime.rete.network.communication.CommunicationGroup;
+import tools.refinery.viatra.runtime.rete.network.communication.Timestamp;
+import tools.refinery.viatra.runtime.rete.network.communication.timely.ResumableNode;
+import tools.refinery.viatra.runtime.rete.network.mailbox.Mailbox;
+import tools.refinery.viatra.runtime.rete.network.mailbox.timeless.BehaviorChangingMailbox;
+import tools.refinery.viatra.runtime.rete.network.mailbox.timely.TimelyMailbox;
+
+/**
+ * @author Gabor Bergmann
+ * @author Tamas Szabo
+ */
+public abstract class IndexerWithMemory extends StandardIndexer
+        implements Receiver, NetworkStructureChangeSensitiveNode, ResumableNode {
+
+    protected MaskedTupleMemory<Timestamp> memory;
+
+    /**
+     * @since 2.3
+     */
+    protected NetworkStructureChangeSensitiveLogic logic;
+
+    /**
+     * @since 1.6
+     */
+    protected final Mailbox mailbox;
+
+    /**
+     * @since 2.4
+     */
+    protected CommunicationGroup group;
+
+    public IndexerWithMemory(final ReteContainer reteContainer, final TupleMask mask) {
+        super(reteContainer, mask);
+        final boolean isTimely = reteContainer.isTimelyEvaluation()
+                && reteContainer.getCommunicationTracker().isInRecursiveGroup(this);
+        memory = MaskedTupleMemory.create(mask, MemoryType.SETS, this, isTimely, isTimely && reteContainer
+                .getTimelyConfiguration().getTimelineRepresentation() == TimelineRepresentation.FAITHFUL);
+        reteContainer.registerClearable(memory);
+        mailbox = instantiateMailbox();
+        reteContainer.registerClearable(mailbox);
+        this.logic = createLogic();
+    }
+
+    @Override
+    public CommunicationGroup getCurrentGroup() {
+        return this.group;
+    }
+
+    @Override
+    public void setCurrentGroup(final CommunicationGroup group) {
+        this.group = group;
+    }
+
+    @Override
+    public void networkStructureChanged() {
+        super.networkStructureChanged();
+        final boolean wasTimely = this.memory.isTimely();
+        final boolean isTimely = this.reteContainer.isTimelyEvaluation()
+                && this.reteContainer.getCommunicationTracker().isInRecursiveGroup(this);
+        if (wasTimely != isTimely) {
+            final MaskedTupleMemory<Timestamp> newMemory = MaskedTupleMemory.create(mask, MemoryType.SETS, this,
+                    isTimely, isTimely && reteContainer.getTimelyConfiguration()
+                            .getTimelineRepresentation() == TimelineRepresentation.FAITHFUL);
+            newMemory.initializeWith(this.memory, Timestamp.ZERO);
+            memory.clear();
+            memory = newMemory;
+        }
+        this.logic = createLogic();
+    }
+
+    /**
+     * Instantiates the {@link Mailbox} of this receiver. Subclasses may override this method to provide their own
+     * mailbox implementation.
+     * 
+     * @return the mailbox
+     * @since 2.0
+     */
+    protected Mailbox instantiateMailbox() {
+        if (this.reteContainer.isTimelyEvaluation()) {
+            return new TimelyMailbox(this, this.reteContainer);
+        } else {
+            return new BehaviorChangingMailbox(this, this.reteContainer);
+        }
+    }
+
+    @Override
+    public Mailbox getMailbox() {
+        return this.mailbox;
+    }
+
+    /**
+     * @since 2.0
+     */
+    public MaskedTupleMemory<Timestamp> getMemory() {
+        return memory;
+    }
+
+    @Override
+    public void update(final Direction direction, final Tuple updateElement, final Timestamp timestamp) {
+        this.logic.update(direction, updateElement, timestamp);
+    }
+
+    /**
+     * Refined version of update
+     * 
+     * @since 2.4
+     */
+    protected abstract void update(final Direction direction, final Tuple updateElement, final Tuple signature,
+            final boolean change, final Timestamp timestamp);
+
+    @Override
+    public void appendParent(final Supplier supplier) {
+        if (parent == null) {
+            parent = supplier;
+        } else {
+            throw new UnsupportedOperationException("Illegal RETE edge: " + this + " already has a parent (" + parent
+                    + ") and cannot connect to additional parent (" + supplier + "). ");
+        }
+    }
+
+    @Override
+    public void removeParent(final Supplier supplier) {
+        if (parent == supplier) {
+            parent = null;
+        } else {
+            throw new IllegalArgumentException(
+                    "Illegal RETE edge removal: the parent of " + this + " is not " + supplier);
+        }
+    }
+
+    /**
+     * @since 2.4
+     */
+    @Override
+    public Collection<Supplier> getParents() {
+        return Collections.singleton(parent);
+    }
+
+    /**
+     * @since 2.4
+     */
+    @Override
+    public void resumeAt(final Timestamp timestamp) {
+        this.logic.resumeAt(timestamp);
+    }
+
+    /**
+     * @since 2.4
+     */
+    @Override
+    public Timestamp getResumableTimestamp() {
+        return this.memory.getResumableTimestamp();
+    }
+
+    /**
+     * @since 2.3
+     */
+    protected static abstract class NetworkStructureChangeSensitiveLogic {
+
+        /**
+         * @since 2.4
+         */
+        public abstract void update(final Direction direction, final Tuple updateElement, final Timestamp timestamp);
+
+        /**
+         * @since 2.4
+         */
+        public abstract void resumeAt(final Timestamp timestamp);
+
+    }
+
+    /**
+     * @since 2.3
+     */
+    protected NetworkStructureChangeSensitiveLogic createLogic() {
+        if (this.reteContainer.isTimelyEvaluation()
+                && this.reteContainer.getCommunicationTracker().isInRecursiveGroup(this)) {
+            return TIMELY;
+        } else {
+            return TIMELESS;
+        }
+    }
+
+    private final NetworkStructureChangeSensitiveLogic TIMELY = new NetworkStructureChangeSensitiveLogic() {
+
+        @Override
+        public void resumeAt(final Timestamp timestamp) {
+            final Iterable<Tuple> signatures = memory.getResumableSignatures();
+
+            final Map<Tuple, Boolean> wasPresent = CollectionsFactory.createMap();
+            for (final Tuple signature : signatures) {
+                wasPresent.put(signature, memory.isPresentAtInfinity(signature));
+            }
+
+            final Map<Tuple, Map<Tuple, Diff<Timestamp>>> signatureMap = memory.resumeAt(timestamp);
+
+            for (final Entry<Tuple, Map<Tuple, Diff<Timestamp>>> outerEntry : signatureMap.entrySet()) {
+                final Tuple signature = outerEntry.getKey();
+                final Map<Tuple, Diff<Timestamp>> diffMap = outerEntry.getValue();
+                final boolean isPresent = memory.isPresentAtInfinity(signature);
+                // only send out a potential true value the first time for a given signature, then set it to false
+                boolean change = wasPresent.get(signature) ^ isPresent;
+
+                for (final Entry<Tuple, Diff<Timestamp>> innerEntry : diffMap.entrySet()) {
+                    final Tuple tuple = innerEntry.getKey();
+                    final Diff<Timestamp> diffs = innerEntry.getValue();
+                    for (final Signed<Timestamp> signed : diffs) {
+                        IndexerWithMemory.this.update(signed.getDirection(), tuple, signature, change,
+                                signed.getPayload());
+                    }
+                    // change is a signature-wise flag, so it is ok to "try" to signal it for the first tuple only
+                    change = false;
+                }
+            }
+
+            final Timestamp nextTimestamp = memory.getResumableTimestamp();
+            if (nextTimestamp != null) {
+                group.notifyHasMessage(mailbox, nextTimestamp);
+            }
+        }
+
+        @Override
+        public void update(final Direction direction, final Tuple update, final Timestamp timestamp) {
+            final Tuple signature = mask.transform(update);
+            final boolean wasPresent = memory.isPresentAtInfinity(signature);
+            final Diff<Timestamp> resultDiff = direction == Direction.INSERT
+                    ? memory.addWithTimestamp(update, signature, timestamp)
+                    : memory.removeWithTimestamp(update, signature, timestamp);
+            final boolean isPresent = memory.isPresentAtInfinity(signature);
+            final boolean change = wasPresent ^ isPresent;
+            for (final Signed<Timestamp> signed : resultDiff) {
+                IndexerWithMemory.this.update(signed.getDirection(), update, signature, change, signed.getPayload());
+            }
+        }
+
+    };
+
+    private final NetworkStructureChangeSensitiveLogic TIMELESS = new NetworkStructureChangeSensitiveLogic() {
+
+        @Override
+        public void update(final Direction direction, final Tuple update, final Timestamp timestamp) {
+            final Tuple signature = mask.transform(update);
+            final boolean change = direction == Direction.INSERT ? memory.add(update, signature)
+                    : memory.remove(update, signature);
+            IndexerWithMemory.this.update(direction, update, signature, change, timestamp);
+        }
+
+        @Override
+        public void resumeAt(final Timestamp timestamp) {
+            // there is nothing to resume in the timeless case because we do not even care about timestamps
+        }
+
+    };
+
+}
\ No newline at end of file
diff --git a/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/IterableIndexer.java b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/IterableIndexer.java
new file mode 100644
index 00000000..d6f8ef05
--- /dev/null
+++ b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/IterableIndexer.java
@@ -0,0 +1,34 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2009 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.rete.index;
+
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+
+/**
+ * An indexer that allows the iteration of all retrievable tuple groups (or reduced groups).
+ * 
+ * @author Gabor Bergmann
+ * 
+ */
+public interface IterableIndexer extends Indexer, Iterable<Tuple> {
+
+    /**
+     * A view consisting of exactly those signatures whose tuple group is not empty
+     * @since 2.0
+     */
+    public Iterable<Tuple> getSignatures();
+
+    /**
+     * @return the number of signatures whose tuple group is not empty
+     * @since 2.0
+     */
+    public int getBucketCount();
+    
+}
diff --git a/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/JoinNode.java b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/JoinNode.java
new file mode 100644
index 00000000..9a6a0de9
--- /dev/null
+++ b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/JoinNode.java
@@ -0,0 +1,193 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2008 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.rete.index;
+
+import java.util.Collection;
+import java.util.Map;
+
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.matchers.util.Direction;
+import tools.refinery.viatra.runtime.matchers.util.Signed;
+import tools.refinery.viatra.runtime.matchers.util.timeline.Timeline;
+import tools.refinery.viatra.runtime.rete.network.ReteContainer;
+import tools.refinery.viatra.runtime.rete.network.communication.Timestamp;
+
+/**
+ * @author Gabor Bergmann
+ * 
+ */
+public class JoinNode extends DualInputNode {
+
+    public JoinNode(final ReteContainer reteContainer, final TupleMask complementerSecondaryMask) {
+        super(reteContainer, complementerSecondaryMask);
+        this.logic = createLogic();
+    }
+
+    @Override
+    public Tuple calibrate(final Tuple primary, final Tuple secondary) {
+        return unify(primary, secondary);
+    }
+
+    private final NetworkStructureChangeSensitiveLogic TIMELESS = new NetworkStructureChangeSensitiveLogic() {
+
+        @Override
+        public void pullIntoWithTimeline(final Map<Tuple, Timeline<Timestamp>> collector, final boolean flush) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public void pullInto(final Collection<Tuple> collector, final boolean flush) {
+            if (primarySlot == null || secondarySlot == null) {
+                return;
+            }
+
+            if (flush) {
+                reteContainer.flushUpdates();
+            }
+
+            for (final Tuple signature : primarySlot.getSignatures()) {
+                // primaries can not be null due to the contract of IterableIndex.getSignatures()
+                final Collection<Tuple> primaries = primarySlot.get(signature);
+                final Collection<Tuple> opposites = secondarySlot.get(signature);
+                if (opposites != null) {
+                    for (final Tuple primary : primaries) {
+                        for (final Tuple opposite : opposites) {
+                            collector.add(unify(primary, opposite));
+                        }
+                    }
+                }
+            }
+        }
+
+        @Override
+        public void notifyUpdate(final Side side, final Direction direction, final Tuple updateElement,
+                final Tuple signature, final boolean change, final Timestamp timestamp) {
+            // in the default case, all timestamps must be zero
+            assert Timestamp.ZERO.equals(timestamp);
+
+            final Collection<Tuple> opposites = retrieveOpposites(side, signature);
+
+            if (!coincidence) {
+                if (opposites != null) {
+                    for (final Tuple opposite : opposites) {
+                        propagateUpdate(direction, unify(side, updateElement, opposite), timestamp);
+                    }
+                }
+            } else {
+                // compensate for coincidence of slots - this is the case when an Indexer is joined with itself
+                if (opposites != null) {
+                    for (final Tuple opposite : opposites) {
+                        if (opposite.equals(updateElement)) {
+                            // handle self-joins of a single tuple separately
+                            continue;
+                        }
+                        propagateUpdate(direction, unify(opposite, updateElement), timestamp);
+                        propagateUpdate(direction, unify(updateElement, opposite), timestamp);
+                    }
+                }
+
+                // handle self-joins here
+                propagateUpdate(direction, unify(updateElement, updateElement), timestamp);
+            }
+        }
+    };
+
+    private final NetworkStructureChangeSensitiveLogic TIMELY = new NetworkStructureChangeSensitiveLogic() {
+
+        @Override
+        public void pullIntoWithTimeline(final Map<Tuple, Timeline<Timestamp>> collector, final boolean flush) {
+            if (primarySlot == null || secondarySlot == null) {
+                return;
+            }
+
+            if (flush) {
+                reteContainer.flushUpdates();
+            }
+
+            for (final Tuple signature : primarySlot.getSignatures()) {
+                // primaries can not be null due to the contract of IterableIndex.getSignatures()
+                final Map<Tuple, Timeline<Timestamp>> primaries = getTimeline(signature, primarySlot);
+                final Map<Tuple, Timeline<Timestamp>> opposites = getTimeline(signature, secondarySlot);
+                if (opposites != null) {
+                    for (final Tuple primary : primaries.keySet()) {
+                        for (final Tuple opposite : opposites.keySet()) {
+                            final Timeline<Timestamp> primaryTimeline = primaries.get(primary);
+                            final Timeline<Timestamp> oppositeTimeline = opposites.get(opposite);
+                            final Timeline<Timestamp> mergedTimeline = primaryTimeline
+                                    .mergeMultiplicative(oppositeTimeline);
+                            if (!mergedTimeline.isEmpty()) {
+                                collector.put(unify(primary, opposite), mergedTimeline);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        @Override
+        public void pullInto(final Collection<Tuple> collector, final boolean flush) {
+            JoinNode.this.TIMELESS.pullInto(collector, flush);
+        }
+
+        @Override
+        public void notifyUpdate(final Side side, final Direction direction, final Tuple updateElement,
+                final Tuple signature, final boolean change, final Timestamp timestamp) {
+            final Indexer oppositeIndexer = getSlot(side.opposite());
+            final Map<Tuple, Timeline<Timestamp>> opposites = getTimeline(signature, oppositeIndexer);
+
+            if (!coincidence) {
+                if (opposites != null) {
+                    for (final Tuple opposite : opposites.keySet()) {
+                        final Tuple unifiedTuple = unify(side, updateElement, opposite);
+                        for (final Signed<Timestamp> signed : opposites.get(opposite).asChangeSequence()) {
+                            // TODO only consider signed timestamps that are greater or equal to timestamp
+                            // plus compact the previous timestamps into at most one update
+                            propagateUpdate(signed.getDirection().multiply(direction), unifiedTuple,
+                                    timestamp.max(signed.getPayload()));
+                        }
+                    }
+                }
+            } else {
+                // compensate for coincidence of slots - this is the case when an Indexer is joined with itself
+                if (opposites != null) {
+                    for (final Tuple opposite : opposites.keySet()) {
+                        if (opposite.equals(updateElement)) {
+                            // handle self-joins of a single tuple separately
+                            continue;
+                        }
+                        final Tuple u1 = unify(opposite, updateElement);
+                        final Tuple u2 = unify(updateElement, opposite);
+                        for (final Signed<Timestamp> oppositeSigned : opposites.get(opposite).asChangeSequence()) {
+                            final Direction updateDirection = direction.multiply(oppositeSigned.getDirection());
+                            final Timestamp updateTimestamp = timestamp.max(oppositeSigned.getPayload());
+                            propagateUpdate(updateDirection, u1, updateTimestamp);
+                            propagateUpdate(updateDirection, u2, updateTimestamp);
+                        }
+                    }
+                }
+
+                // handle self-join here
+                propagateUpdate(direction, unify(updateElement, updateElement), timestamp);
+            }
+        }
+    };
+
+    @Override
+    protected NetworkStructureChangeSensitiveLogic createTimelessLogic() {
+        return this.TIMELESS;
+    }
+
+    @Override
+    protected NetworkStructureChangeSensitiveLogic createTimelyLogic() {
+        return this.TIMELY;
+    }
+
+}
diff --git a/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/MemoryIdentityIndexer.java b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/MemoryIdentityIndexer.java
new file mode 100644
index 00000000..59b75c33
--- /dev/null
+++ b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/MemoryIdentityIndexer.java
@@ -0,0 +1,55 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2008 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.rete.index;
+
+import java.util.Collection;
+import java.util.List;
+
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.rete.network.Receiver;
+import tools.refinery.viatra.runtime.rete.network.ReteContainer;
+import tools.refinery.viatra.runtime.rete.network.Supplier;
+
+/**
+ * Defines a trivial indexer that identically projects the contents of a memory-equipped node, and can therefore save
+ * space. Can only exist in connection with a memory, and must be operated by another node. Do not attach parents
+ * directly!
+ * 
+ * @noimplement Rely on the provided implementations
+ * @noreference Use only via standard Node and Indexer interfaces
+ * @noinstantiate This class is not intended to be instantiated by clients.
+ * @author Gabor Bergmann
+ */
+
+public class MemoryIdentityIndexer extends IdentityIndexer {
+
+    protected final Collection<Tuple> memory;
+
+    /**
+     * @param reteContainer
+     * @param tupleWidth
+     *            the width of the tuples of memoryNode
+     * @param memory
+     *            the memory whose contents are to be identity-indexed
+     * @param parent
+     *            the parent node that owns the memory
+     */
+    public MemoryIdentityIndexer(ReteContainer reteContainer, int tupleWidth, Collection<Tuple> memory,
+            Supplier parent, Receiver activeNode, List<ListenerSubscription> sharedSubscriptionList) {
+        super(reteContainer, tupleWidth, parent, activeNode, sharedSubscriptionList);
+        this.memory = memory;
+    }
+
+    @Override
+    protected Collection<Tuple> getTuples() {
+        return this.memory;
+    }
+
+}
diff --git a/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/MemoryNullIndexer.java b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/MemoryNullIndexer.java
new file mode 100644
index 00000000..204fe433
--- /dev/null
+++ b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/MemoryNullIndexer.java
@@ -0,0 +1,54 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2008 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.rete.index;
+
+import java.util.Collection;
+import java.util.List;
+
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.rete.network.Receiver;
+import tools.refinery.viatra.runtime.rete.network.ReteContainer;
+import tools.refinery.viatra.runtime.rete.network.Supplier;
+
+/**
+ * Defines a trivial indexer that projects the contents of a memory-equipped node to the empty tuple, and can therefore
+ * save space. Can only exist in connection with a memory, and must be operated by another node. Do not attach parents
+ * directly!
+ * 
+ * @author Gabor Bergmann
+ * @noimplement Rely on the provided implementations
+ * @noreference Use only via standard Node and Indexer interfaces
+ * @noinstantiate This class is not intended to be instantiated by clients.
+ */
+public class MemoryNullIndexer extends NullIndexer {
+
+    Collection<Tuple> memory;
+
+    /**
+     * @param reteContainer
+     * @param tupleWidth
+     *            the width of the tuples of memoryNode
+     * @param memory
+     *            the memory whose contents are to be null-indexed
+     * @param parent
+     *            the parent node that owns the memory
+     */
+    public MemoryNullIndexer(ReteContainer reteContainer, int tupleWidth, Collection<Tuple> memory,
+            Supplier parent, Receiver activeNode, List<ListenerSubscription> sharedSubscriptionList) {
+        super(reteContainer, tupleWidth, parent, activeNode, sharedSubscriptionList);
+        this.memory = memory;
+    }
+
+    @Override
+    protected Collection<Tuple> getTuples() {
+        return this.memory;
+    }
+
+}
diff --git a/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/NullIndexer.java b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/NullIndexer.java
new file mode 100644
index 00000000..a875b29f
--- /dev/null
+++ b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/NullIndexer.java
@@ -0,0 +1,88 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2012 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.rete.index;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuples;
+import tools.refinery.viatra.runtime.matchers.util.Direction;
+import tools.refinery.viatra.runtime.rete.network.Node;
+import tools.refinery.viatra.runtime.rete.network.ReteContainer;
+import tools.refinery.viatra.runtime.rete.network.Supplier;
+import tools.refinery.viatra.runtime.rete.network.communication.Timestamp;
+
+/**
+ * Defines an abstract trivial indexer that projects the contents of some stateful node to the empty tuple, and can
+ * therefore save space. Can only exist in connection with a stateful store, and must be operated by another node (the
+ * active node). Do not attach parents directly!
+ * 
+ * @author Gabor Bergmann
+ * @noimplement Rely on the provided implementations
+ * @noreference Use only via standard Node and Indexer interfaces
+ * @noinstantiate This class is not intended to be instantiated by clients.
+ */
+public abstract class NullIndexer extends SpecializedProjectionIndexer {
+
+    protected abstract Collection<Tuple> getTuples();
+
+    protected static final Tuple nullSignature = Tuples.staticArityFlatTupleOf();
+    protected static final Collection<Tuple> nullSingleton = Collections.singleton(nullSignature);
+    protected static final Collection<Tuple> emptySet = Collections.emptySet();
+
+    public NullIndexer(ReteContainer reteContainer, int tupleWidth, Supplier parent, Node activeNode,
+            List<ListenerSubscription> sharedSubscriptionList) {
+        super(reteContainer, TupleMask.linear(0, tupleWidth), parent, activeNode, sharedSubscriptionList);
+    }
+
+    @Override
+    public Collection<Tuple> get(Tuple signature) {
+        if (nullSignature.equals(signature))
+            return isEmpty() ? null : getTuples();
+        else
+            return null;
+    }
+
+    @Override
+    public Collection<Tuple> getSignatures() {
+        return isEmpty() ? emptySet : nullSingleton;
+    }
+
+    protected boolean isEmpty() {
+        return getTuples().isEmpty();
+    }
+
+    protected boolean isSingleElement() {
+        return getTuples().size() == 1;
+    }
+
+    @Override
+    public Iterator<Tuple> iterator() {
+        return getTuples().iterator();
+    }
+
+    @Override
+    public int getBucketCount() {
+        return getTuples().isEmpty() ? 0 : 1;
+    }
+
+    @Override
+    public void propagateToListener(IndexerListener listener, Direction direction, Tuple updateElement,
+            Timestamp timestamp) {
+        boolean radical = (direction == Direction.DELETE && isEmpty())
+                || (direction == Direction.INSERT && isSingleElement());
+        listener.notifyIndexerUpdate(direction, updateElement, nullSignature, radical, timestamp);
+    }
+
+}
\ No newline at end of file
diff --git a/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/OnetimeIndexer.java b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/OnetimeIndexer.java
new file mode 100644
index 00000000..fef84bb1
--- /dev/null
+++ b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/OnetimeIndexer.java
@@ -0,0 +1,47 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2008 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.rete.index;
+
+import java.util.Collection;
+
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.rete.network.ReteContainer;
+import tools.refinery.viatra.runtime.rete.network.Supplier;
+
+/**
+ * @author Gabor Bergmann Indexer whose lifetime last until the first get() DO NOT connect to nodes!
+ */
+public class OnetimeIndexer extends GenericProjectionIndexer {
+
+    public OnetimeIndexer(ReteContainer reteContainer, TupleMask mask) {
+        super(reteContainer, mask);
+    }
+
+    @Override
+    public Collection<Tuple> get(Tuple signature) {
+        if (tools.refinery.viatra.runtime.rete.util.Options.releaseOnetimeIndexers) {
+            reteContainer.unregisterClearable(memory);
+            reteContainer.unregisterNode(this);
+        }
+        return super.get(signature);
+    }
+
+    @Override
+    public void appendParent(Supplier supplier) {
+        throw new UnsupportedOperationException("onetime indexer cannot have parents");
+    }
+
+    @Override
+    public void attachListener(IndexerListener listener) {
+        throw new UnsupportedOperationException("onetime indexer cannot have listeners");
+    }
+
+}
diff --git a/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/ProjectionIndexer.java b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/ProjectionIndexer.java
new file mode 100644
index 00000000..58e593d9
--- /dev/null
+++ b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/ProjectionIndexer.java
@@ -0,0 +1,21 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2009 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.rete.index;
+
+/**
+ * An iterable indexer that receives updates from a node, and groups received tuples intact, i.e. it does not reduce
+ * tuple groups.
+ * 
+ * @author Gabor Bergmann
+ * 
+ */
+public interface ProjectionIndexer extends IterableIndexer {
+
+}
diff --git a/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/SpecializedProjectionIndexer.java b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/SpecializedProjectionIndexer.java
new file mode 100644
index 00000000..9c647aa9
--- /dev/null
+++ b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/SpecializedProjectionIndexer.java
@@ -0,0 +1,176 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2012 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.rete.index;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.matchers.util.Direction;
+import tools.refinery.viatra.runtime.rete.network.Node;
+import tools.refinery.viatra.runtime.rete.network.ReteContainer;
+import tools.refinery.viatra.runtime.rete.network.Supplier;
+import tools.refinery.viatra.runtime.rete.network.communication.CommunicationTracker;
+import tools.refinery.viatra.runtime.rete.network.communication.Timestamp;
+
+/**
+ * A specialized projection indexer that can be memory-less (relying on an external source of information).
+ * 
+ * <p>
+ * All specialized projection indexers of a single node will share the same listener list, so that notification order is
+ * maintained (see Bug 518434).
+ * 
+ * @author Gabor Bergmann
+ * @noimplement Rely on the provided implementations
+ * @noreference Use only via standard Node and Indexer interfaces
+ * @noinstantiate This class is not intended to be instantiated by clients.
+ */
+public abstract class SpecializedProjectionIndexer extends StandardIndexer implements ProjectionIndexer {
+
+    protected Node activeNode;
+    protected List<ListenerSubscription> subscriptions;
+
+    /**
+     * @since 1.7
+     */
+    public SpecializedProjectionIndexer(final ReteContainer reteContainer, final TupleMask mask, final Supplier parent,
+            final Node activeNode, final List<ListenerSubscription> subscriptions) {
+        super(reteContainer, mask);
+        this.parent = parent;
+        this.activeNode = activeNode;
+        this.subscriptions = subscriptions;
+    }
+
+    public List<ListenerSubscription> getSubscriptions() {
+        return subscriptions;
+    }
+
+    @Override
+    public Node getActiveNode() {
+        return activeNode;
+    }
+
+    @Override
+    protected void propagate(final Direction direction, final Tuple updateElement, final Tuple signature,
+            final boolean change, final Timestamp timestamp) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void attachListener(final IndexerListener listener) {
+        super.attachListener(listener);
+        final CommunicationTracker tracker = this.getCommunicationTracker();
+        final IndexerListener proxy = tracker.proxifyIndexerListener(this, listener);
+        final ListenerSubscription subscription = new ListenerSubscription(this, proxy);
+        tracker.registerDependency(this, proxy.getOwner());
+        // See Bug 518434
+        // Must add to the first position, so that the later listeners are notified earlier.
+        // Thus if the beta node added as listener is also an indirect descendant of the same indexer on its opposite
+        // slot,
+        // then the beta node is connected later than its ancestor's listener, therefore it will be notified earlier,
+        // eliminating duplicate insertions and lost deletions that would result from fall-through update propagation
+        subscriptions.add(0, subscription);
+    }
+
+    @Override
+    public void detachListener(final IndexerListener listener) {
+        final CommunicationTracker tracker = this.getCommunicationTracker();
+        // obtain the proxy before the super call would unregister the dependency
+        final IndexerListener proxy = tracker.proxifyIndexerListener(this, listener);
+        super.detachListener(listener);
+        final ListenerSubscription subscription = new ListenerSubscription(this, proxy);
+        final boolean wasContained = subscriptions.remove(subscription);
+        assert wasContained;
+        tracker.unregisterDependency(this, proxy.getOwner());
+    }
+
+    @Override
+    public void networkStructureChanged() {
+        super.networkStructureChanged();
+        final List<ListenerSubscription> oldSubscriptions = new ArrayList<ListenerSubscription>();
+        oldSubscriptions.addAll(subscriptions);
+        subscriptions.clear();
+        for (final ListenerSubscription oldSubscription : oldSubscriptions) {
+            // there is no need to unregister and re-register the dependency between indexer and listener
+            // because the owner of the listener is the same (even if it is proxified)
+            final CommunicationTracker tracker = this.getCommunicationTracker();
+            // the subscriptions are shared, so we MUST reuse the indexer of the subscription instead of simply 'this'
+            final IndexerListener proxy = tracker.proxifyIndexerListener(oldSubscription.indexer, oldSubscription.listener);
+            final ListenerSubscription newSubscription = new ListenerSubscription(oldSubscription.indexer, proxy);
+            subscriptions.add(newSubscription);
+        }
+    }
+
+    /**
+     * @since 2.4
+     */
+    public abstract void propagateToListener(IndexerListener listener, Direction direction, Tuple updateElement,
+            Timestamp timestamp);
+
+    /**
+     * Infrastructure to share subscriptions between specialized indexers of the same parent node.
+     * 
+     * @author Gabor Bergmann
+     * @since 1.7
+     */
+    public static class ListenerSubscription {
+        protected SpecializedProjectionIndexer indexer;
+        protected IndexerListener listener;
+
+        public ListenerSubscription(SpecializedProjectionIndexer indexer, IndexerListener listener) {
+            super();
+            this.indexer = indexer;
+            this.listener = listener;
+        }
+
+        /**
+         * @since 2.4
+         */
+        public SpecializedProjectionIndexer getIndexer() {
+            return indexer;
+        }
+
+        /**
+         * @since 2.4
+         */
+        public IndexerListener getListener() {
+            return listener;
+        }
+
+        /**
+         * Call this from parent node.
+         * @since 2.4
+         */
+        public void propagate(Direction direction, Tuple updateElement, Timestamp timestamp) {
+            indexer.propagateToListener(listener, direction, updateElement, timestamp);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(indexer, listener);
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (this == obj)
+                return true;
+            if (obj == null)
+                return false;
+            if (getClass() != obj.getClass())
+                return false;
+            ListenerSubscription other = (ListenerSubscription) obj;
+            return Objects.equals(listener, other.listener) && Objects.equals(indexer, other.indexer);
+        }
+
+    }
+
+}
diff --git a/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/StandardIndexer.java b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/StandardIndexer.java
new file mode 100644
index 00000000..9847a8dd
--- /dev/null
+++ b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/StandardIndexer.java
@@ -0,0 +1,127 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2008 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.rete.index;
+
+import java.util.Collection;
+import java.util.List;
+
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+import tools.refinery.viatra.runtime.matchers.util.Direction;
+import tools.refinery.viatra.runtime.rete.network.BaseNode;
+import tools.refinery.viatra.runtime.rete.network.NetworkStructureChangeSensitiveNode;
+import tools.refinery.viatra.runtime.rete.network.ReteContainer;
+import tools.refinery.viatra.runtime.rete.network.Supplier;
+import tools.refinery.viatra.runtime.rete.network.communication.Timestamp;
+import tools.refinery.viatra.runtime.rete.traceability.TraceInfo;
+
+/**
+ * An abstract standard implementation of the Indexer interface, providing common bookkeeping functionality.
+ * 
+ * @author Gabor Bergmann
+ * 
+ */
+public abstract class StandardIndexer extends BaseNode implements Indexer, NetworkStructureChangeSensitiveNode {
+
+    protected Supplier parent;
+    private final List<IndexerListener> originalListeners;
+    private final List<IndexerListener> proxyListeners;
+    protected TupleMask mask;
+
+    public StandardIndexer(ReteContainer reteContainer, TupleMask mask) {
+        super(reteContainer);
+        this.parent = null;
+        this.mask = mask;
+        this.originalListeners = CollectionsFactory.createObserverList();
+        this.proxyListeners = CollectionsFactory.createObserverList();
+    }
+
+    /**
+     * @since 2.4
+     */
+    protected void propagate(Direction direction, Tuple updateElement, Tuple signature, boolean change, Timestamp timestamp) {
+        for (IndexerListener listener : proxyListeners) {
+            listener.notifyIndexerUpdate(direction, updateElement, signature, change, timestamp);
+        }
+    }
+
+    @Override
+    public TupleMask getMask() {
+        return mask;
+    }
+
+    @Override
+    public Supplier getParent() {
+        return parent;
+    }
+
+    @Override
+    public void attachListener(IndexerListener listener) {
+        this.getCommunicationTracker().registerDependency(this, listener.getOwner());
+        // obtain the proxy after registering the dependency because then the proxy reflects the new SCC structure
+        final IndexerListener proxy = this.getCommunicationTracker().proxifyIndexerListener(this, listener);
+        // See Bug 518434
+        // Must add to the first position, so that the later listeners are notified earlier.
+        // Thus if the beta node added as listener is also an indirect descendant of the same indexer on its opposite slot, 
+        // then the beta node is connected later than its ancestor's listener, therefore it will be notified earlier,
+        // eliminating duplicate insertions and lost deletions that would result from fall-through update propagation
+        this.originalListeners.add(0, listener);
+        this.proxyListeners.add(0, proxy);
+    }
+
+    @Override
+    public void detachListener(IndexerListener listener) {
+        this.originalListeners.remove(listener);
+        IndexerListener listenerToRemove = null;
+        for (final IndexerListener proxyListener : this.proxyListeners) {
+            if (proxyListener.getOwner() == listener.getOwner()) {
+                listenerToRemove = proxyListener;
+                break;
+            }
+        }
+        assert listenerToRemove != null;
+        this.proxyListeners.remove(listenerToRemove);
+        this.getCommunicationTracker().unregisterDependency(this, listener.getOwner());
+    }
+    
+    @Override
+    public void networkStructureChanged() {
+        this.proxyListeners.clear();
+        for (final IndexerListener original : this.originalListeners) {
+            this.proxyListeners.add(this.getCommunicationTracker().proxifyIndexerListener(this, original));
+        }
+    }
+
+    @Override
+    public Collection<IndexerListener> getListeners() {
+        return proxyListeners;
+    }
+
+    @Override
+    public ReteContainer getContainer() {
+        return reteContainer;
+    }
+
+    @Override
+    protected String toStringCore() {
+        return super.toStringCore() + "(" + parent + "/" + mask + ")";
+    }
+    
+    @Override
+    public void assignTraceInfo(TraceInfo traceInfo) {
+        super.assignTraceInfo(traceInfo);
+        if (traceInfo.propagateFromIndexerToSupplierParent())
+            if (parent != null)
+                parent.acceptPropagatedTraceInfo(traceInfo);
+    }
+
+    
+}
diff --git a/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/TransitiveClosureNodeIndexer.java b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/TransitiveClosureNodeIndexer.java
new file mode 100644
index 00000000..77202004
--- /dev/null
+++ b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/TransitiveClosureNodeIndexer.java
@@ -0,0 +1,121 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Gabor Bergmann, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.rete.index;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.rete.itc.alg.incscc.IncSCCAlg;
+import tools.refinery.viatra.runtime.matchers.tuple.MaskedTuple;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuples;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+import tools.refinery.viatra.runtime.matchers.util.Direction;
+import tools.refinery.viatra.runtime.rete.network.Receiver;
+import tools.refinery.viatra.runtime.rete.single.TransitiveClosureNode;
+
+// UNFINISHED, not used yet
+public class TransitiveClosureNodeIndexer extends StandardIndexer implements IterableIndexer {
+    private TransitiveClosureNode tcNode;
+    private IncSCCAlg<Object> tcAlg;
+    private Collection<Tuple> emptySet;
+
+    public TransitiveClosureNodeIndexer(TupleMask mask, IncSCCAlg<Object> tcAlg, TransitiveClosureNode tcNode) {
+        super(tcNode.getContainer(), mask);
+        this.tcAlg = tcAlg;
+        this.tcNode = tcNode;
+        this.emptySet = Collections.emptySet();
+        this.parent = tcNode;
+    }
+
+    @Override
+    public Collection<Tuple> get(Tuple signature) {
+        if (signature.getSize() == mask.sourceWidth) {
+            if (mask.indices.length == 0) {
+                // mask ()/2
+                return getSignatures();
+            } else if (mask.indices.length == 1) {
+                Set<Tuple> retSet = CollectionsFactory.createSet();
+
+                // mask (0)/2
+                if (mask.indices[0] == 0) {
+                    Object source = signature.get(0);
+                    for (Object target : tcAlg.getAllReachableTargets(source)) {
+                        retSet.add(Tuples.staticArityFlatTupleOf(source, target));
+                    }
+                    return retSet;
+                }
+                // mask (1)/2
+                if (mask.indices[0] == 1) {
+                    Object target = signature.get(1);
+                    for (Object source : tcAlg.getAllReachableSources(target)) {
+                        retSet.add(Tuples.staticArityFlatTupleOf(source, target));
+                    }
+                    return retSet;
+                }
+            } else {
+                // mask (0,1)/2
+                if (mask.indices[0] == 0 && mask.indices[1] == 1) {
+                    Object source = signature.get(0);
+                    Object target = signature.get(1);
+                    Tuple singleton = Tuples.staticArityFlatTupleOf(source, target);
+                    return (tcAlg.isReachable(source, target) ? Collections.singleton(singleton) : emptySet);
+                }
+                // mask (1,0)/2
+                if (mask.indices[0] == 1 && mask.indices[1] == 0) {
+                    Object source = signature.get(1);
+                    Object target = signature.get(0);
+                    Tuple singleton = Tuples.staticArityFlatTupleOf(source, target);
+                    return (tcAlg.isReachable(source, target) ? Collections.singleton(singleton) : emptySet);
+                }
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public int getBucketCount() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public Collection<Tuple> getSignatures() {
+        return asTupleCollection(tcAlg.getTcRelation());
+    }
+
+    @Override
+    public Iterator<Tuple> iterator() {
+        return asTupleCollection(tcAlg.getTcRelation()).iterator();
+    }
+
+    private Collection<Tuple> asTupleCollection(
+            Collection<tools.refinery.viatra.runtime.rete.itc.alg.misc.Tuple<Object>> tuples) {
+        Set<Tuple> retSet = CollectionsFactory.createSet();
+        for (tools.refinery.viatra.runtime.rete.itc.alg.misc.Tuple<Object> tuple : tuples) {
+            retSet.add(Tuples.staticArityFlatTupleOf(tuple.getSource(), tuple.getTarget()));
+        }
+        return retSet;
+    }
+
+    /**
+     * @since 2.4
+     */
+    public void propagate(Direction direction, Tuple updateElement, boolean change) {
+        propagate(direction, updateElement, new MaskedTuple(updateElement, mask), change, null);
+    }
+
+    @Override
+    public Receiver getActiveNode() {
+        return tcNode;
+    }
+
+}
diff --git a/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/timely/TimelyMemoryIdentityIndexer.java b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/timely/TimelyMemoryIdentityIndexer.java
new file mode 100644
index 00000000..4319ee29
--- /dev/null
+++ b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/timely/TimelyMemoryIdentityIndexer.java
@@ -0,0 +1,51 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2019, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.rete.index.timely;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.util.TimelyMemory;
+import tools.refinery.viatra.runtime.matchers.util.timeline.Timeline;
+import tools.refinery.viatra.runtime.rete.index.IdentityIndexer;
+import tools.refinery.viatra.runtime.rete.network.Receiver;
+import tools.refinery.viatra.runtime.rete.network.ReteContainer;
+import tools.refinery.viatra.runtime.rete.network.Supplier;
+import tools.refinery.viatra.runtime.rete.network.communication.Timestamp;
+
+public class TimelyMemoryIdentityIndexer extends IdentityIndexer {
+
+    protected final TimelyMemory<Timestamp> memory;
+
+    public TimelyMemoryIdentityIndexer(final ReteContainer reteContainer, final int tupleWidth,
+            final TimelyMemory<Timestamp> memory, final Supplier parent, final Receiver activeNode,
+            final List<ListenerSubscription> sharedSubscriptionList) {
+        super(reteContainer, tupleWidth, parent, activeNode, sharedSubscriptionList);
+        this.memory = memory;
+    }
+
+    @Override
+    public Map<Tuple, Timeline<Timestamp>> getTimeline(final Tuple signature) {
+        final Timeline<Timestamp> timestamp = this.memory.get(signature);
+        if (timestamp != null) {
+            return Collections.singletonMap(signature, timestamp);
+        } else {
+            return null;
+        }
+    }
+    
+    @Override
+    protected Collection<Tuple> getTuples() {
+        return this.memory.getTuplesAtInfinity();
+    }
+
+}
diff --git a/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/timely/TimelyMemoryNullIndexer.java b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/timely/TimelyMemoryNullIndexer.java
new file mode 100644
index 00000000..0386b006
--- /dev/null
+++ b/subprojects/viatra-runtime-rete/src/main/java/tools/refinery/viatra/runtime/rete/index/timely/TimelyMemoryNullIndexer.java
@@ -0,0 +1,49 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2019, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.rete.index.timely;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.util.TimelyMemory;
+import tools.refinery.viatra.runtime.matchers.util.timeline.Timeline;
+import tools.refinery.viatra.runtime.rete.index.NullIndexer;
+import tools.refinery.viatra.runtime.rete.network.Receiver;
+import tools.refinery.viatra.runtime.rete.network.ReteContainer;
+import tools.refinery.viatra.runtime.rete.network.Supplier;
+import tools.refinery.viatra.runtime.rete.network.communication.Timestamp;
+
+public class TimelyMemoryNullIndexer extends NullIndexer {
+
+    protected final TimelyMemory<Timestamp> memory;
+
+    public TimelyMemoryNullIndexer(final ReteContainer reteContainer, final int tupleWidth,
+            final TimelyMemory<Timestamp> memory, final Supplier parent,
+            final Receiver activeNode, final List<ListenerSubscription> sharedSubscriptionList) {
+        super(reteContainer, tupleWidth, parent, activeNode, sharedSubscriptionList);
+        this.memory = memory;
+    }
+
+    @Override
+    public Map<Tuple, Timeline<Timestamp>> getTimeline(final Tuple signature) {
+        if (nullSignature.equals(signature)) {
+            return isEmpty() ? null : this.memory.asMap();
+        } else {
+            return null;
+        }
+    }
+    
+    @Override
+    protected Collection<Tuple> getTuples() {
+        return this.memory.getTuplesAtInfinity();
+    }
+
+}