refactor(interpreter): generify RepresentativeElectionAlgorithm

Let representative election be used in places where IncSCCAlg was used with
generic arguments other than Object.

5 files changed, 42 insertions, 42 deletions

diff --git a/subprojects/interpreter-rete/src/main/java/tools/refinery/interpreter/rete/itc/alg/representative/RepresentativeElectionAlgorithm.java b/subprojects/interpreter-rete/src/main/java/tools/refinery/interpreter/rete/itc/alg/representative/RepresentativeElectionAlgorithm.java
index 4d3ad759..ac5e2082 100644
--- a/subprojects/interpreter-rete/src/main/java/tools/refinery/interpreter/rete/itc/alg/representative/RepresentativeElectionAlgorithm.java
+++ b/subprojects/interpreter-rete/src/main/java/tools/refinery/interpreter/rete/itc/alg/representative/RepresentativeElectionAlgorithm.java
@@ -14,13 +14,13 @@ import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
 
-public abstract class RepresentativeElectionAlgorithm implements IGraphObserver<Object> {
-        protected final Graph<Object> graph;
-        protected final Map<Object, Object> representatives = new HashMap<>();
-        protected final Map<Object, Set<Object>> components = new HashMap<>();
-        private RepresentativeObserver observer;
+public abstract class RepresentativeElectionAlgorithm<T> implements IGraphObserver<T> {
+        protected final Graph<T> graph;
+        protected final Map<T, T> representatives = new HashMap<>();
+        protected final Map<T, Set<T>> components = new HashMap<>();
+        private RepresentativeObserver<? super T> observer;
 
-        protected RepresentativeElectionAlgorithm(Graph<Object> graph) {
+        protected RepresentativeElectionAlgorithm(Graph<T> graph) {
                 this.graph = graph;
                 initializeComponents();
                 graph.attachObserver(this);
@@ -28,7 +28,7 @@ public abstract class RepresentativeElectionAlgorithm implements IGraphObserver<
 
         protected abstract void initializeComponents();
 
-        protected void initializeSet(Set<Object> set) {
+        protected void initializeSet(Set<T> set) {
                 var iterator = set.iterator();
                 if (!iterator.hasNext()) {
                         // Set is empty.
@@ -45,13 +45,13 @@ public abstract class RepresentativeElectionAlgorithm implements IGraphObserver<
                 components.put(representative, set);
         }
 
-        protected void merge(Set<Object> toMerge) {
+        protected void merge(Set<T> toMerge) {
                 if (toMerge.isEmpty()) {
                         return;
                 }
-                var representativesToMerge = new HashSet<>();
-                Object bestRepresentative = null;
-                Set<Object> bestSet = null;
+                var representativesToMerge = new HashSet<T>();
+                T bestRepresentative = null;
+                Set<T> bestSet = null;
                 for (var object : toMerge) {
                         var representative = getRepresentative(object);
                         if (representativesToMerge.add(representative)) {
@@ -79,7 +79,7 @@ public abstract class RepresentativeElectionAlgorithm implements IGraphObserver<
                 }
         }
 
-        protected void merge(Object leftRepresentative, Object rightRepresentative) {
+        protected void merge(T leftRepresentative, T rightRepresentative) {
                 if (leftRepresentative.equals(rightRepresentative)) {
                         return;
                 }
@@ -92,8 +92,7 @@ public abstract class RepresentativeElectionAlgorithm implements IGraphObserver<
                 }
         }
 
-        private void merge(Object preservedRepresentative, Set<Object> preservedSet, Object removedRepresentative,
-                                           Set<Object> removedSet) {
+        private void merge(T preservedRepresentative, Set<T> preservedSet, T removedRepresentative, Set<T> removedSet) {
                 components.remove(removedRepresentative);
                 for (var node : removedSet) {
                         representatives.put(node, preservedRepresentative);
@@ -102,7 +101,7 @@ public abstract class RepresentativeElectionAlgorithm implements IGraphObserver<
                 }
         }
 
-        protected void assignNewRepresentative(Object oldRepresentative, Set<Object> set) {
+        protected void assignNewRepresentative(T oldRepresentative, Set<T> set) {
                 var iterator = set.iterator();
                 if (!iterator.hasNext()) {
                         return;
@@ -119,19 +118,19 @@ public abstract class RepresentativeElectionAlgorithm implements IGraphObserver<
                 }
         }
 
-        public void setObserver(RepresentativeObserver observer) {
+        public void setObserver(RepresentativeObserver<? super T> observer) {
                 this.observer = observer;
         }
 
-        public Map<Object, Set<Object>> getComponents() {
+        public Map<T, Set<T>> getComponents() {
                 return components;
         }
 
-        public Object getRepresentative(Object node) {
+        public T getRepresentative(T node) {
                 return representatives.get(node);
         }
 
-        public Set<Object> getComponent(Object representative) {
+        public Set<T> getComponent(T representative) {
                 return components.get(representative);
         }
 
@@ -140,15 +139,15 @@ public abstract class RepresentativeElectionAlgorithm implements IGraphObserver<
         }
 
         @Override
-        public void nodeInserted(Object n) {
-                var component = new HashSet<>(1);
+        public void nodeInserted(T n) {
+                var component = new HashSet<T>(1);
                 component.add(n);
                 initializeSet(component);
                 notifyToObservers(n, n, Direction.INSERT);
         }
 
         @Override
-        public void nodeDeleted(Object n) {
+        public void nodeDeleted(T n) {
                 var representative = representatives.remove(n);
                 if (!representative.equals(n)) {
                         throw new IllegalStateException("Trying to delete node with dangling edges");
@@ -157,18 +156,19 @@ public abstract class RepresentativeElectionAlgorithm implements IGraphObserver<
                 notifyToObservers(n, representative, Direction.DELETE);
         }
 
-        protected void notifyToObservers(Object node, Object oldRepresentative, Object newRepresentative) {
+        protected void notifyToObservers(T node, T oldRepresentative, T newRepresentative) {
                 notifyToObservers(node, oldRepresentative, Direction.DELETE);
                 notifyToObservers(node, newRepresentative, Direction.INSERT);
         }
 
-        protected void notifyToObservers(Object node, Object representative, Direction direction) {
+        protected void notifyToObservers(T node, T representative, Direction direction) {
                 if (observer != null) {
                         observer.tupleChanged(node, representative, direction);
                 }
         }
 
+        @FunctionalInterface
         public interface Factory {
-                RepresentativeElectionAlgorithm create(Graph<Object> graph);
+                <T> RepresentativeElectionAlgorithm<T> create(Graph<T> graph);
         }
 }
diff --git a/subprojects/interpreter-rete/src/main/java/tools/refinery/interpreter/rete/itc/alg/representative/RepresentativeObserver.java b/subprojects/interpreter-rete/src/main/java/tools/refinery/interpreter/rete/itc/alg/representative/RepresentativeObserver.java
index 7844f1c7..2a4f7102 100644
--- a/subprojects/interpreter-rete/src/main/java/tools/refinery/interpreter/rete/itc/alg/representative/RepresentativeObserver.java
+++ b/subprojects/interpreter-rete/src/main/java/tools/refinery/interpreter/rete/itc/alg/representative/RepresentativeObserver.java
@@ -7,6 +7,6 @@ package tools.refinery.interpreter.rete.itc.alg.representative;
 
 import tools.refinery.interpreter.matchers.util.Direction;
 
-public interface RepresentativeObserver {
-        void tupleChanged(Object node, Object representative, Direction direction);
+public interface RepresentativeObserver<T> {
+        void tupleChanged(T node, T representative, Direction direction);
 }
diff --git a/subprojects/interpreter-rete/src/main/java/tools/refinery/interpreter/rete/itc/alg/representative/StronglyConnectedComponentAlgorithm.java b/subprojects/interpreter-rete/src/main/java/tools/refinery/interpreter/rete/itc/alg/representative/StronglyConnectedComponentAlgorithm.java
index 44afd73e..d2e524f7 100644
--- a/subprojects/interpreter-rete/src/main/java/tools/refinery/interpreter/rete/itc/alg/representative/StronglyConnectedComponentAlgorithm.java
+++ b/subprojects/interpreter-rete/src/main/java/tools/refinery/interpreter/rete/itc/alg/representative/StronglyConnectedComponentAlgorithm.java
@@ -13,8 +13,8 @@ import tools.refinery.interpreter.rete.itc.alg.misc.scc.SCC;
 import java.util.Collection;
 import java.util.Set;
 
-public class StronglyConnectedComponentAlgorithm extends RepresentativeElectionAlgorithm {
-        public StronglyConnectedComponentAlgorithm(Graph<Object> graph) {
+public class StronglyConnectedComponentAlgorithm<T> extends RepresentativeElectionAlgorithm<T> {
+        public StronglyConnectedComponentAlgorithm(Graph<T> graph) {
                 super(graph);
         }
 
@@ -27,7 +27,7 @@ public class StronglyConnectedComponentAlgorithm extends RepresentativeElectionA
         }
 
         @Override
-        public void edgeInserted(Object source, Object target) {
+        public void edgeInserted(T source, T target) {
                 var sourceRoot = getRepresentative(source);
                 var targetRoot = getRepresentative(target);
                 if (sourceRoot.equals(targetRoot)) {
@@ -43,7 +43,7 @@ public class StronglyConnectedComponentAlgorithm extends RepresentativeElectionA
         }
 
         @Override
-        public void edgeDeleted(Object source, Object target) {
+        public void edgeDeleted(T source, T target) {
                 var sourceRoot = getRepresentative(source);
                 var targetRoot = getRepresentative(target);
                 if (!sourceRoot.equals(targetRoot)) {
@@ -57,7 +57,7 @@ public class StronglyConnectedComponentAlgorithm extends RepresentativeElectionA
                 }
         }
 
-        private void split(Object preservedRepresentative, Collection<? extends Set<Object>> sets) {
+        private void split(T preservedRepresentative, Collection<? extends Set<T>> sets) {
                 for (var set : sets) {
                         if (set.contains(preservedRepresentative)) {
                                 components.put(preservedRepresentative, set);
diff --git a/subprojects/interpreter-rete/src/main/java/tools/refinery/interpreter/rete/itc/alg/representative/WeaklyConnectedComponentAlgorithm.java b/subprojects/interpreter-rete/src/main/java/tools/refinery/interpreter/rete/itc/alg/representative/WeaklyConnectedComponentAlgorithm.java
index 58227c44..6b6c19ed 100644
--- a/subprojects/interpreter-rete/src/main/java/tools/refinery/interpreter/rete/itc/alg/representative/WeaklyConnectedComponentAlgorithm.java
+++ b/subprojects/interpreter-rete/src/main/java/tools/refinery/interpreter/rete/itc/alg/representative/WeaklyConnectedComponentAlgorithm.java
@@ -11,8 +11,8 @@ import java.util.ArrayDeque;
 import java.util.HashSet;
 import java.util.Set;
 
-public class WeaklyConnectedComponentAlgorithm extends RepresentativeElectionAlgorithm {
-        public WeaklyConnectedComponentAlgorithm(Graph<Object> graph) {
+public class WeaklyConnectedComponentAlgorithm<T> extends RepresentativeElectionAlgorithm<T> {
+        public WeaklyConnectedComponentAlgorithm(Graph<T> graph) {
                 super(graph);
         }
 
@@ -28,14 +28,14 @@ public class WeaklyConnectedComponentAlgorithm extends RepresentativeElectionAlg
         }
 
         @Override
-        public void edgeInserted(Object source, Object target) {
+        public void edgeInserted(T source, T target) {
                 var sourceRoot = getRepresentative(source);
                 var targetRoot = getRepresentative(target);
                 merge(sourceRoot, targetRoot);
         }
 
         @Override
-        public void edgeDeleted(Object source, Object target) {
+        public void edgeDeleted(T source, T target) {
                 var sourceRoot = getRepresentative(source);
                 var targetRoot = getRepresentative(target);
                 if (!sourceRoot.equals(targetRoot)) {
@@ -47,7 +47,7 @@ public class WeaklyConnectedComponentAlgorithm extends RepresentativeElectionAlg
                 }
         }
 
-        private void split(Object sourceRepresentative, Set<Object> targetReachable) {
+        private void split(T sourceRepresentative, Set<T> targetReachable) {
                 var sourceComponent = getComponent(sourceRepresentative);
                 sourceComponent.removeAll(targetReachable);
                 if (targetReachable.contains(sourceRepresentative)) {
@@ -58,10 +58,10 @@ public class WeaklyConnectedComponentAlgorithm extends RepresentativeElectionAlg
                 }
         }
 
-        private Set<Object> getReachableNodes(Object source) {
-                var retSet = new HashSet<>();
+        private Set<T> getReachableNodes(T source) {
+                var retSet = new HashSet<T>();
                 retSet.add(source);
-                var nodeQueue = new ArrayDeque<>();
+                var nodeQueue = new ArrayDeque<T>();
                 nodeQueue.addLast(source);
 
                 while (!nodeQueue.isEmpty()) {
diff --git a/subprojects/interpreter-rete/src/main/java/tools/refinery/interpreter/rete/single/RepresentativeElectionNode.java b/subprojects/interpreter-rete/src/main/java/tools/refinery/interpreter/rete/single/RepresentativeElectionNode.java
index 75aa32ef..eb5ce363 100644
--- a/subprojects/interpreter-rete/src/main/java/tools/refinery/interpreter/rete/single/RepresentativeElectionNode.java
+++ b/subprojects/interpreter-rete/src/main/java/tools/refinery/interpreter/rete/single/RepresentativeElectionNode.java
@@ -23,11 +23,11 @@ import tools.refinery.interpreter.matchers.util.timeline.Timeline;
 import java.util.Collection;
 import java.util.Map;
 
-public class RepresentativeElectionNode extends SingleInputNode implements Clearable, RepresentativeObserver,
+public class RepresentativeElectionNode extends SingleInputNode implements Clearable, RepresentativeObserver<Object>,
         ReinitializedNode {
         private final RepresentativeElectionAlgorithm.Factory algorithmFactory;
         private Graph<Object> graph;
-        private RepresentativeElectionAlgorithm algorithm;
+        private RepresentativeElectionAlgorithm<Object> algorithm;
 
         public RepresentativeElectionNode(ReteContainer reteContainer,
                                       RepresentativeElectionAlgorithm.Factory algorithmFactory) {