feat: cleanup code

chore: making classnames more expressive and cleanup some structures
feat: implement partically cancellable tasks
2025-07-21 16:12:56 +02:00 · 2025-07-19 12:50:30 +02:00 · 2025-07-16 11:16:30 +02:00 · 2025-07-12 13:44:18 +02:00 · 2025-07-12 13:22:54 +02:00 · 2025-07-12 13:14:55 +02:00
18 changed files with 391 additions and 259 deletions
--- a/src/main/java/de/dhbwstuttgart/server/ServerTaskLogger.java
+++ b/src/main/java/de/dhbwstuttgart/server/ServerTaskLogger.java
@@ -1,6 +1,8 @@
 package de.dhbwstuttgart.server;

 import de.dhbwstuttgart.util.Logger;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
 import org.java_websocket.WebSocket;

 public class ServerTaskLogger extends Logger {
--- a/src/main/java/de/dhbwstuttgart/server/SocketServer.java
+++ b/src/main/java/de/dhbwstuttgart/server/SocketServer.java
@@ -29,6 +29,7 @@ public class SocketServer extends WebSocketServer {

  public static Logger logger = new Logger("SocketServer");
  public static final int maxTasksPerSession = 100;
+  private static boolean serverRunning = false;

  /**
   * Increase this every time a breaking change to the server communication is done.
@@ -45,12 +46,17 @@ public class SocketServer extends WebSocketServer {
    super(new InetSocketAddress(port));
    this.setConnectionLostTimeout(30);

-
+    serverRunning = true;
    // add a shutdown hook to close all connections when the process ends or is stopped by a SIGINT signal
    Runtime.getRuntime().addShutdownHook(new Thread(this::onShutdown));
  }

+  public static boolean isServerRunning() {
+    return serverRunning;
+  }
+
  private void onShutdown() {
+    serverRunning = false;
    try {
      for (var webSocket : this.getConnections()) {
        this.sendError(webSocket, "Sorry, i am shutting down. You are now on your own, good Luck!", true);
@@ -85,7 +91,7 @@ public class SocketServer extends WebSocketServer {
      // wait 10 seconds for the client to send a task and close the connection if nothing has been received until then
      final int secondsUntilTimeout = 10;
      timeoutExecutor.schedule(() -> {
-          if (webSocket.<SocketData>getAttachment().unhandledTasks.get() == 0 || !webSocket.isOpen()) {
+          if (webSocket.<SocketData>getAttachment().totalTasks.get() > 0 || !webSocket.isOpen()) {
            return;
          }
          sendMessage(webSocket, "No task received after " + secondsUntilTimeout + " seconds. Closing connection...");
--- a/src/main/java/de/dhbwstuttgart/typeinference/constraints/Constraint.java
+++ b/src/main/java/de/dhbwstuttgart/typeinference/constraints/Constraint.java
@@ -37,6 +37,10 @@ public class Constraint<A extends IConstraintElement> extends HashSet<A> impleme
    super();
  }

+  public Constraint(int initialCapacity) {
+    super(initialCapacity);
+  }
+
  public Constraint(boolean isInherited, boolean isImplemented) {
    this.isInherited = isInherited;
    this.isImplemented = isImplemented;
@@ -77,6 +81,14 @@ public class Constraint<A extends IConstraintElement> extends HashSet<A> impleme
    methodSignatureConstraint = c;
  }

+  public <B extends IConstraintElement> Constraint<B> createdMapped(Function<A,B> mapper) {
+    Constraint<B> result = new Constraint<>(this.size());
+    for (A element : this) {
+      result.add(mapper.apply(element));
+    }
+    return result;
+  }
+
  public String toString() {
    return super.toString() + "\nisInherited = " + isInherited
      + " isOveridden = " + isImplemented
--- a/src/main/java/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java
+++ b/src/main/java/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java
@@ -285,8 +285,13 @@ public class TYPEStmt implements StatementVisitor {
            // see: https://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.17
            // Expression muss zu Numeric Convertierbar sein. also von Numeric erben
            Constraint<Pair> numeric;
+            HashSet<JavaClassName> classNames = TypeUnifyTaskHelper.getPresizedHashSet(info.getAvailableClasses().size());
+            for (var classEl : info.getAvailableClasses()) {
+                classNames.add(classEl.getClassName());
+            }
+
            // PL eingefuegt 2018-07-17
-            if (info.getAvailableClasses().stream().map(ClassOrInterface::getClassName).collect(Collectors.toCollection(HashSet::new)).contains(bytee.getName())) {
+            if (classNames.contains(bytee.getName())) {
                numeric = new Constraint<>();
                numeric.add(new Pair(binary.lexpr.getType(), bytee, PairOperator.SMALLERDOT, loc(binary.getOffset())));
                numeric.add(new Pair(binary.rexpr.getType(), bytee, PairOperator.SMALLERDOT, loc(binary.getOffset())));
@@ -294,7 +299,7 @@ public class TYPEStmt implements StatementVisitor {
                numericAdditionOrStringConcatenation.add(numeric);
            }
            // PL eingefuegt 2018-07-17
-            if (info.getAvailableClasses().stream().map(ClassOrInterface::getClassName).collect(Collectors.toCollection(HashSet::new)).contains(shortt.getName())) {
+            if (classNames.contains(shortt.getName())) {
                numeric = new Constraint<>();
                numeric.add(new Pair(binary.lexpr.getType(), shortt, PairOperator.SMALLERDOT, loc(binary.getOffset())));
                numeric.add(new Pair(binary.rexpr.getType(), shortt, PairOperator.SMALLERDOT, loc(binary.getOffset())));
@@ -302,7 +307,7 @@ public class TYPEStmt implements StatementVisitor {
                numericAdditionOrStringConcatenation.add(numeric);
            }
            // PL eingefuegt 2018-07-17
-            if (info.getAvailableClasses().stream().map(ClassOrInterface::getClassName).collect(Collectors.toCollection(HashSet::new)).contains(integer.getName())) {
+            if (classNames.contains(integer.getName())) {
                numeric = new Constraint<>();
                numeric.add(new Pair(binary.lexpr.getType(), integer, PairOperator.SMALLERDOT, loc(binary.getOffset())));
                numeric.add(new Pair(binary.rexpr.getType(), integer, PairOperator.SMALLERDOT, loc(binary.getOffset())));
@@ -310,7 +315,7 @@ public class TYPEStmt implements StatementVisitor {
                numericAdditionOrStringConcatenation.add(numeric);
            }
            // PL eingefuegt 2018-07-17
-            if (info.getAvailableClasses().stream().map(ClassOrInterface::getClassName).collect(Collectors.toCollection(HashSet::new)).contains(longg.getName())) {
+            if (classNames.contains(longg.getName())) {
                numeric = new Constraint<>();
                numeric.add(new Pair(binary.lexpr.getType(), longg, PairOperator.SMALLERDOT, loc(binary.getOffset())));
                numeric.add(new Pair(binary.rexpr.getType(), longg, PairOperator.SMALLERDOT, loc(binary.getOffset())));
@@ -318,7 +323,7 @@ public class TYPEStmt implements StatementVisitor {
                numericAdditionOrStringConcatenation.add(numeric);
            }
            // PL eingefuegt 2018-07-17
-            if (info.getAvailableClasses().stream().map(ClassOrInterface::getClassName).collect(Collectors.toCollection(HashSet::new)).contains(floatt.getName())) {
+            if (classNames.contains(floatt.getName())) {
                numeric = new Constraint<>();
                numeric.add(new Pair(binary.lexpr.getType(), floatt, PairOperator.SMALLERDOT, loc(binary.getOffset())));
                numeric.add(new Pair(binary.rexpr.getType(), floatt, PairOperator.SMALLERDOT, loc(binary.getOffset())));
@@ -326,7 +331,7 @@ public class TYPEStmt implements StatementVisitor {
                numericAdditionOrStringConcatenation.add(numeric);
            }
            // PL eingefuegt 2018-07-17
-            if (info.getAvailableClasses().stream().map(ClassOrInterface::getClassName).collect(Collectors.toCollection(HashSet::new)).contains(doublee.getName())) {
+            if (classNames.contains(doublee.getName())) {
                numeric = new Constraint<>();
                numeric.add(new Pair(binary.lexpr.getType(), doublee, PairOperator.SMALLERDOT, loc(binary.getOffset())));
                numeric.add(new Pair(binary.rexpr.getType(), doublee, PairOperator.SMALLERDOT, loc(binary.getOffset())));
@@ -341,7 +346,7 @@ public class TYPEStmt implements StatementVisitor {

            if (binary.operation.equals(BinaryExpr.Operator.ADD)) {
                // Dann kann der Ausdruck auch das aneinanderfügen zweier Strings sein: ("a" + "b") oder (1 + 2)
-                if (info.getAvailableClasses().stream().map(ClassOrInterface::getClassName).collect(Collectors.toCollection(HashSet::new)).contains(string.getName())) {
+                if (classNames.contains(string.getName())) {
                    Constraint<Pair> stringConcat = new Constraint<>();
                    stringConcat.add(new Pair(binary.lexpr.getType(), string, PairOperator.EQUALSDOT, loc(binary.getOffset())));
                    stringConcat.add(new Pair(binary.rexpr.getType(), string, PairOperator.EQUALSDOT, loc(binary.getOffset())));
--- a/src/main/java/de/dhbwstuttgart/typeinference/unify/CancellableTask.java
+++ b/src/main/java/de/dhbwstuttgart/typeinference/unify/CancellableTask.java
@@ -0,0 +1,91 @@
+package de.dhbwstuttgart.typeinference.unify;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.RecursiveTask;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * An intermediate class for the recursive steps of the TypeUnifyTask:
+ * This allows canceling parts of the recursion tree, instead of only  the whole execution as before. But in
+ * order for that to work, all cancellable child tasks must be added when they are created
+ *
+ * @param <T>
+ */
+public abstract class CancellableTask<T> extends RecursiveTask<T> {
+
+  private final AtomicBoolean executionCancelled = new AtomicBoolean(false);
+  private final List<CancellableTask<?>> childTasks = new LinkedList<>();
+  private CancellableTask<?> parentTask = null;
+
+  /**
+   * Set the execution for this task and all its (recursive) children to be canceled
+   */
+  protected void cancelExecution() {
+    // is this branch already canceled? Then do nothing
+    if (this.executionCancelled.getAndSet(true)) return;
+    this.cancelChildExecution();
+  }
+
+  private void cancelChildExecution() {
+    synchronized (this.childTasks) {
+      for (var childTask : childTasks) {
+        // no need to cancel a branch that is already finished
+        if (!childTask.isDone()) {
+          childTask.cancelExecution();
+        }
+      }
+    }
+  }
+
+  private void cancelChildExecutionAfter(CancellableTask<?> checkpointTask) {
+    boolean reachedCheckpoint = false;
+    int i = 0;
+    for (var childTask : childTasks) {
+      if (!reachedCheckpoint) {
+        reachedCheckpoint = childTask == checkpointTask;
+      }
+      else {
+        // no need to cancel a branch that is already finished
+        if (!childTask.isDone()) {
+          childTask.cancelExecution();
+        }
+        i++;
+      }
+    }
+    System.out.println("Skipped " + i + " younger siblings");
+  }
+
+  protected void cancelSiblingTasks() {
+    if (this.parentTask != null) {
+      boolean thisWasCancelledBefore = this.executionCancelled.get();
+      this.parentTask.cancelChildExecution();
+      this.executionCancelled.set(thisWasCancelledBefore);
+    }
+  }
+
+  public void cancelYoungerSiblingTasks() {
+    if (this.parentTask != null) {
+      this.parentTask.cancelChildExecutionAfter(this);
+    }
+  }
+
+  public Boolean isExecutionCancelled() {
+    return executionCancelled.get();
+  }
+
+  public void addChildTask(CancellableTask<?> childTask) {
+    this.childTasks.add(childTask);
+    childTask.setParentTask(this);
+    if (this.executionCancelled.get()) {
+      childTask.executionCancelled.set(true);
+    }
+  }
+
+  private void setParentTask(CancellableTask<?> parentTask) {
+    this.parentTask = parentTask;
+  }
+
+}
--- a/src/main/java/de/dhbwstuttgart/typeinference/unify/MartelliMontanariUnify.java
+++ b/src/main/java/de/dhbwstuttgart/typeinference/unify/MartelliMontanariUnify.java
@@ -94,8 +94,8 @@ public class MartelliMontanariUnify implements IUnify {
 			// SUBST - Rule
 			if(lhsType instanceof PlaceholderType) {
 				mgu.add((PlaceholderType) lhsType, rhsType);
-				//PL 2018-04-01 nach checken, ob es richtig ist, dass keine Substitutionen uebergeben werden muessen. 
-				termsList = termsList.stream().map(x -> mgu.apply(x)).collect(Collectors.toCollection(ArrayList::new));
+				//PL 2018-04-01 nach checken, ob es richtig ist, dass keine Substitutionen uebergeben werden muessen.
+				termsList.replaceAll(mgu::apply);
 				idx = idx+1 == termsList.size() ? 0 : idx+1;
 				continue;
 			}
--- a/src/main/java/de/dhbwstuttgart/typeinference/unify/RuleSet.java
+++ b/src/main/java/de/dhbwstuttgart/typeinference/unify/RuleSet.java
@@ -6,6 +6,7 @@ import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.ListIterator;
 import java.util.Optional;
 import java.util.Queue;
 import java.util.Set;
@@ -652,12 +653,13 @@ public class RuleSet implements IRuleSet{
 		HashMap<UnifyType, Integer> typeMap = new HashMap<>(200);
 		
 		Stack<UnifyType> occuringTypes = new Stack<>();
-		
+		occuringTypes.ensureCapacity(pairs.size() * 3);
+
 		for(UnifyPair pair : pairs) {
 			occuringTypes.push(pair.getLhsType());
 			occuringTypes.push(pair.getRhsType());
 		}
-		
+
 		while(!occuringTypes.isEmpty()) {
 			UnifyType t1 = occuringTypes.pop();
 			if(!typeMap.containsKey(t1))
@@ -669,9 +671,9 @@ public class RuleSet implements IRuleSet{
 			if(t1 instanceof SuperType)
 				occuringTypes.push(((SuperType) t1).getSuperedType());
 			else
-				t1.getTypeParams().forEach(x -> occuringTypes.push(x));	
+				t1.getTypeParams().forEach(occuringTypes::push);
 		}
-		Queue<UnifyPair> result1 = new LinkedList<UnifyPair>(pairs);
+		LinkedList<UnifyPair> result1 = new LinkedList<UnifyPair>(pairs);
 		ArrayList<UnifyPair> result = new ArrayList<UnifyPair>();
 		boolean applied = false;

@@ -692,19 +694,30 @@ public class RuleSet implements IRuleSet{
 					&& !((rhsType instanceof WildcardType) && ((WildcardType)rhsType).getWildcardedType().equals(lhsType))) //PL eigefuegt 2018-02-18
 			{
 				Unifier uni = new Unifier(lhsType,  rhsType);
-				result = result.stream().map(x -> uni.apply(pair,x)).collect(Collectors.toCollection(ArrayList::new));
-				result1 = result1.stream().map(x -> uni.apply(pair,x)).collect(Collectors.toCollection(LinkedList::new));
-				
+				// apply unifier to result and result1 in place
+				result.replaceAll(p -> uni.apply(pair, p));
+				ListIterator<UnifyPair> result1Iterator = result1.listIterator();
+				while (result1Iterator.hasNext()) {
+					UnifyPair x = result1Iterator.next();
+					result1Iterator.set(uni.apply(pair, x));
+				}
+
 				Function<? super Constraint<UnifyPair>,? extends Constraint<UnifyPair>> applyUni = b -> b.stream().map(
 						x -> uni.apply(pair,x)).collect(Collectors.toCollection((b.getExtendConstraint() != null)
 								? () -> new Constraint<UnifyPair>(
 										  b.isInherited(),
 										  b.isImplemented(),
-										  b.getExtendConstraint().stream().map(x -> uni.apply(pair,x)).collect(Collectors.toCollection(Constraint::new)),
+										  b.getExtendConstraint().createdMapped(x -> uni.apply(pair,x)),
 										  b.getmethodSignatureConstraint().stream().map(x -> uni.apply(pair,x)).collect(Collectors.toCollection(HashSet::new)))
 								: () -> new Constraint<UnifyPair>(b.isInherited(), b.isImplemented())
 									));
-				oderConstraints.replaceAll(oc -> oc.stream().map(applyUni).collect(Collectors.toCollection(HashSet::new)));
+				oderConstraints.replaceAll(oc -> {
+						HashSet<Constraint<UnifyPair>> mapped = new HashSet<>(oc.size());
+						for (var element : oc) {
+							mapped.add(applyUni.apply(element));
+						}
+						return mapped;
+				});
 				/*
 						oderConstraints = oderConstraints.stream().map(
 						a -> a.stream().map(applyUni
--- a/src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnify2Task.java
+++ b/src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnify2Task.java
@@ -45,7 +45,7 @@ public class TypeUnify2Task extends TypeUnifyTask {
               */
    //writeLog("xxx");
    //noOfThread--;
-    if (this.myIsCancelled()) {
+    if (this.isExecutionCancelled()) {
      return CompletableFuture.completedFuture(new HashSet<>());
    } else {
      return res;
--- a/src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java
+++ b/src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java
@@ -27,11 +27,7 @@ import de.dhbwstuttgart.typeinference.unify.model.WildcardType;
 import de.dhbwstuttgart.util.Logger;
 import de.dhbwstuttgart.util.Pair;
 import de.dhbwstuttgart.util.Tuple;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.io.OutputStreamWriter;
 import java.io.Serial;
-import java.io.Writer;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -50,7 +46,6 @@ import java.util.concurrent.RecursiveTask;
 import java.util.function.BiFunction;
 import java.util.function.BinaryOperator;
 import java.util.stream.Collectors;
-import org.apache.commons.io.output.NullOutputStream;


 /**
@@ -58,7 +53,7 @@ import org.apache.commons.io.output.NullOutputStream;
 *
 * @author Florian Steurer
 */
-public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<UnifyPair>>>> {
+public class TypeUnifyTask extends CancellableTask<CompletableFuture<Set<Set<UnifyPair>>>> {

  @Serial
  private static final long serialVersionUID = 1L;
@@ -118,8 +113,6 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
  public static int noShortendElements;
  public static int noou = 0;

-  boolean myIsCanceled = false;
-
  public TypeUnifyTask(UnifyContext context) {
    this.context = context.newWithLogger(Logger.NULL_LOGGER);
    rules = new RuleSet(context.placeholderRegistry());
@@ -214,13 +207,6 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
 		}		
 }
 */
-  void myCancel(boolean b) {
-    myIsCanceled = true;
-  }
-
-  public boolean myIsCancelled() {
-    return myIsCanceled;
-  }

  public CompletableFuture<Set<Set<UnifyPair>>> compute() {
    if (one) {
@@ -250,7 +236,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
        throw new TypeinferenceException("Unresolved constraints: " + res, new NullToken()); //return new HashSet<>();
      }

-      if (this.myIsCancelled()) {
+      if (this.isExecutionCancelled()) {
        return new HashSet<>();
      }

@@ -287,7 +273,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify

    //.collect(Collectors.toCollection(HashSet::new)));

-    if (this.myIsCancelled()) {
+    if (this.isExecutionCancelled()) {
      return CompletableFuture.completedFuture(new HashSet<>());
    }

@@ -316,14 +302,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
    /*
     * Occurs-Check durchfuehren
     */
-    Set<UnifyPair> ocurrPairs = eq.stream().filter(x -> {
-        UnifyType lhs, rhs;
-        return (lhs = x.getLhsType()) instanceof PlaceholderType
-          && !((rhs = x.getRhsType()) instanceof PlaceholderType)
-          && rhs.getTypeParams().occurs((PlaceholderType) lhs);
-      })
-      .peek(UnifyPair::setUndefinedPair)
-      .collect(Collectors.toCollection(HashSet::new));
+    Set<UnifyPair> ocurrPairs = TypeUnifyTaskHelper.occursCheck(eq);

    Set<UnifyPair> finalOcurrPairs = ocurrPairs;
    context.logger().debug(() -> "ocurrPairs: " + finalOcurrPairs);
@@ -347,14 +326,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
      /* In commit dfd91b5f8b7fca1cb5f302eec4b0ba3330271c9b eingefuegt ANFANG */
      Set<UnifyPair> occurcheck = new HashSet<>(eq0);
      occurcheck.removeAll(eq0Prime);
-      ocurrPairs = occurcheck.stream().filter(x -> {
-          UnifyType lhs, rhs;
-          return (lhs = x.getLhsType()) instanceof PlaceholderType
-            && !((rhs = x.getRhsType()) instanceof PlaceholderType)
-            && rhs.getTypeParams().occurs((PlaceholderType) lhs);
-        })
-        .peek(UnifyPair::setUndefinedPair)
-        .collect(Collectors.toCollection(HashSet::new));
+      ocurrPairs = TypeUnifyTaskHelper.occursCheck(occurcheck);
      Set<UnifyPair> finalOcurrPairs1 = ocurrPairs;
      context.logger().debug(() -> "ocurrPairs: " + finalOcurrPairs1);
      if (!ocurrPairs.isEmpty()) {
@@ -491,7 +463,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
    //		.collect(Collectors.toCollection(HashSet::new));
    //Muss auskommentiert werden, wenn computeCartesianRecursive ENDE

-    if (this.myIsCancelled()) {
+    if (this.isExecutionCancelled()) {
      return CompletableFuture.completedFuture(new HashSet<>());
    }

@@ -768,7 +740,8 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
    // Ergebnisvariable für die parallele Verabeitung: Tupel aus
    // - forkOrig result : currentThreadResult (frueher "res")
    // - fork results : forkResults (frueher "add_res")
-    CompletableFuture<Tuple<Set<Set<UnifyPair>>, Set<Set<Set<UnifyPair>>>>> parallelResultDataFuture;
+    CompletableFuture<VarianceCase.ComputationResults> parallelResultDataFuture;
+

    if (parallel) {
      parallelResultDataFuture = varianceCase.computeParallel(
@@ -779,13 +752,16 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
      // same as variance = 0
      elems.add(varianceCase.a); //PL 2019-01-16 muss das wirklich hin steht schon in Zeile 859 ja braucht man siehe Zeile 859
      parallelResultDataFuture =  this.unify2(elems, eq, oderConstraints, fc, false, rekTiefe, new HashSet<>(methodSignatureConstraint))
-        .thenApply(currentThreadResult -> new Tuple<>(currentThreadResult, new HashSet<>()));
+        .thenApply(VarianceCase.ComputationResults::new);
    }

+    if (this.isExecutionCancelled()) {
+      return CompletableFuture.completedFuture(new HashSet<>());
+    }

    return parallelResultDataFuture.thenCompose(parallelResultData -> {
-      Set<Set<UnifyPair>> currentThreadResult = parallelResultData.getFirst();
-      Set<Set<Set<UnifyPair>>> forkResults = parallelResultData.getSecond();
+      Set<Set<UnifyPair>> currentThreadResult = parallelResultData.mainResult;
+      Set<Set<Set<UnifyPair>>> forkResults = parallelResultData.forkResults;

      Set<Set<UnifyPair>> result = prevResult;
      List<Set<UnifyPair>> nextSetAsList = prevNextSetAsList;
@@ -882,6 +858,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
        // Iterator<Set<UnifyPair>> nextSetasListIt = new ArrayList<>(nextSetAsList).iterator();
        boolean shouldBreak = varianceCase.eraseInvalidSets(rekTiefe, aParDef, nextSetAsList);
        if (shouldBreak) {
+          // this.cancelYoungerSiblingTasks();
          return CompletableFuture.completedFuture(result);
        }

--- a/src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnifyTaskHelper.java
+++ b/src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnifyTaskHelper.java
@@ -186,6 +186,24 @@ public class TypeUnifyTaskHelper {
      .collect(Collectors.toCollection(ArrayList::new));
  }

+
+  public static Set<UnifyPair> occursCheck(final Set<UnifyPair> eq) {
+    Set<UnifyPair> ocurrPairs = new HashSet<>(eq.size());
+    for (UnifyPair x : eq) {
+      UnifyType lhs = x.getLhsType();
+      UnifyType rhs = x.getRhsType();
+      if (lhs instanceof PlaceholderType lhsPlaceholder &&
+        !(rhs instanceof PlaceholderType) &&
+        rhs.getTypeParams().occurs(lhsPlaceholder))
+      {
+        x.setUndefinedPair();
+        ocurrPairs.add(x);
+      }
+    }
+    return ocurrPairs;
+  }
+
+
  public static <T> HashSet<T> getPresizedHashSet(int minElements) {
    if (minElements < 16) return new HashSet<>();
    // HashSet and HashMap will resize at 75% load, so we account for that by multiplying with 1.5
--- a/src/main/java/de/dhbwstuttgart/typeinference/unify/UnifyTaskModel.java
+++ b/src/main/java/de/dhbwstuttgart/typeinference/unify/UnifyTaskModel.java
@@ -12,7 +12,7 @@ public class UnifyTaskModel {
    
    public synchronized void cancel() {
    	for(TypeUnifyTask t : usedTasks) {
-    		t.myCancel(true);
+    		t.cancelExecution();
    	}
    }
 }
--- a/src/main/java/de/dhbwstuttgart/typeinference/unify/cartesianproduct/ContravarianceCase.java
+++ b/src/main/java/de/dhbwstuttgart/typeinference/unify/cartesianproduct/ContravarianceCase.java
@@ -1,6 +1,5 @@
 package de.dhbwstuttgart.typeinference.unify.cartesianproduct;

-import de.dhbwstuttgart.exceptions.UnifyCancelException;
 import de.dhbwstuttgart.typeinference.constraints.Constraint;
 import de.dhbwstuttgart.typeinference.unify.TypeUnify2Task;
 import de.dhbwstuttgart.typeinference.unify.TypeUnifyTask;
@@ -17,11 +16,11 @@ import java.util.Set;
 import java.util.concurrent.CompletableFuture;
 import java.util.stream.Collectors;

-public class Variance1Case extends VarianceCase {
+public class ContravarianceCase extends VarianceCase {

  protected final int variance = 1;

-  protected Variance1Case(boolean isOderConstraint, TypeUnifyTask typeUnifyTask, UnifyContext context) {
+  protected ContravarianceCase(boolean isOderConstraint, TypeUnifyTask typeUnifyTask, UnifyContext context) {
    super(isOderConstraint, typeUnifyTask, context);
  }

@@ -37,7 +36,7 @@ public class Variance1Case extends VarianceCase {
    if (this.isOderConstraint) {
      nextSetasListOderConstraints.add(((Constraint<UnifyPair>) a).getExtendConstraint());
    }
-    context.logger().debug("nextSetasListOderConstraints 1: " + nextSetasListOderConstraints);
+    context.logger().debug(() -> "nextSetasListOderConstraints 1: " + nextSetasListOderConstraints);

    //Alle maximale Elemente in nextSetasListRest bestimmen
    //nur für diese wird parallele Berechnung angestossen.
@@ -49,7 +48,7 @@ public class Variance1Case extends VarianceCase {


  @Override
-  public CompletableFuture<Tuple<Set<Set<UnifyPair>>, Set<Set<Set<UnifyPair>>>>> computeParallel(
+  public CompletableFuture<ComputationResults> computeParallel(
    Set<Set<UnifyPair>> elems,
    Set<UnifyPair> eq,
    List<Set<Constraint<UnifyPair>>> oderConstraints,
@@ -61,10 +60,6 @@ public class Variance1Case extends VarianceCase {
    Set<Set<UnifyPair>> result,
    Set<Set<UnifyPair>> aParDef
  ) {
-    CompletableFuture<Tuple<Set<Set<UnifyPair>>, Set<Set<Set<UnifyPair>>>>> resultValues = CompletableFuture.completedFuture(new Tuple<>(
-      new HashSet<>(), new HashSet<>()
-    ));
-
    Set<UnifyPair> newEqOrig = new HashSet<>(eq);
    Set<Set<UnifyPair>> newElemsOrig = new HashSet<>(elems);
    List<Set<Constraint<UnifyPair>>> newOderConstraintsOrig = new ArrayList<>(oderConstraints);
@@ -72,18 +67,19 @@ public class Variance1Case extends VarianceCase {

    /* FORK ANFANG */
    TypeUnify2Task forkOrig = new TypeUnify2Task(newElemsOrig, newEqOrig, newOderConstraintsOrig, a, fc, context, rekTiefe, methodSignatureConstraint);
+    typeUnifyTask.addChildTask(forkOrig);
    // schedule compute() on another thread
    CompletableFuture<Set<Set<UnifyPair>>> forkOrigFuture = CompletableFuture.supplyAsync(forkOrig::compute, context.executor()).thenCompose(f -> f);
-    resultValues = resultValues.thenCombine(forkOrigFuture,
-      (prevResults, currentThreadResult) -> {
+    CompletableFuture<ComputationResults> resultValues = forkOrigFuture.thenApply(
+      (currentThreadResult) -> {
        forkOrig.context.logger().debug("final Orig 1");
        forkOrig.closeLogFile();
-        return new Tuple<>(currentThreadResult, prevResults.getSecond());
+        return new ComputationResults(currentThreadResult);
      });

    //forks.add(forkOrig);
-    if (typeUnifyTask.myIsCancelled()) {
-      throw new UnifyCancelException();
+    if (typeUnifyTask.isExecutionCancelled()) {
+      return CompletableFuture.completedFuture(new ComputationResults());
    }
    /* FORK ENDE */

@@ -108,16 +104,17 @@ public class Variance1Case extends VarianceCase {
      List<Set<Constraint<UnifyPair>>> newOderConstraints = new ArrayList<>(oderConstraints);
      newElems.add(nSaL);
      TypeUnify2Task fork = new TypeUnify2Task(newElems, newEq, newOderConstraints, nSaL, fc, context, rekTiefe, new HashSet<>(methodSignatureConstraint));
+      typeUnifyTask.addChildTask(fork);
      // schedule compute() on another thread
      CompletableFuture<Set<Set<UnifyPair>>> forkFuture = CompletableFuture.supplyAsync(fork::compute, context.executor()).thenCompose(f -> f);
      resultValues = resultValues.thenCombine(forkFuture,
        (prevResults, fork_res) -> {
-          if (typeUnifyTask.myIsCancelled()) {
-            throw new UnifyCancelException();
+          if (typeUnifyTask.isExecutionCancelled()) {
+            return new ComputationResults();
          }
          context.logger().debug("fork_res: " + fork_res.toString());
          context.logger().debug(Boolean.valueOf((typeUnifyTask.isUndefinedPairSetSet(fork_res))).toString());
-          prevResults.getSecond().add(fork_res);
+          prevResults.addForkResult(fork_res);
          if (!typeUnifyTask.isUndefinedPairSetSet(fork_res)) {
            aParDef.add(fork.getNextSetElement());
          }
@@ -127,8 +124,8 @@ public class Variance1Case extends VarianceCase {
        }
      );

-      if (typeUnifyTask.myIsCancelled()) {
-        throw new UnifyCancelException();
+      if (typeUnifyTask.isExecutionCancelled()) {
+        return CompletableFuture.completedFuture(new ComputationResults());
      }
    }

--- a/src/main/java/de/dhbwstuttgart/typeinference/unify/cartesianproduct/CovarianceCase.java
+++ b/src/main/java/de/dhbwstuttgart/typeinference/unify/cartesianproduct/CovarianceCase.java
@@ -1,6 +1,5 @@
 package de.dhbwstuttgart.typeinference.unify.cartesianproduct;

-import de.dhbwstuttgart.exceptions.UnifyCancelException;
 import de.dhbwstuttgart.typeinference.constraints.Constraint;
 import de.dhbwstuttgart.typeinference.unify.TypeUnify2Task;
 import de.dhbwstuttgart.typeinference.unify.TypeUnifyTask;
@@ -17,11 +16,11 @@ import java.util.Set;
 import java.util.concurrent.CompletableFuture;
 import java.util.stream.Collectors;

-public class VarianceM1Case extends VarianceCase {
+public class CovarianceCase extends VarianceCase {

  protected final int variance = -1;

-  protected VarianceM1Case(boolean isOderConstraint, TypeUnifyTask typeUnifyTask, UnifyContext context) {
+  protected CovarianceCase(boolean isOderConstraint, TypeUnifyTask typeUnifyTask, UnifyContext context) {
    super(isOderConstraint, typeUnifyTask, context);
  }

@@ -49,7 +48,7 @@ public class VarianceM1Case extends VarianceCase {


  @Override
-  public CompletableFuture<Tuple<Set<Set<UnifyPair>>, Set<Set<Set<UnifyPair>>>>> computeParallel(
+  public CompletableFuture<ComputationResults> computeParallel(
    Set<Set<UnifyPair>> elems,
    Set<UnifyPair> eq,
    List<Set<Constraint<UnifyPair>>> oderConstraints,
@@ -61,10 +60,6 @@ public class VarianceM1Case extends VarianceCase {
    Set<Set<UnifyPair>> result,
    Set<Set<UnifyPair>> aParDef
  ) {
-    CompletableFuture<Tuple<Set<Set<UnifyPair>>, Set<Set<Set<UnifyPair>>>>> resultValues = CompletableFuture.completedFuture(new Tuple<>(
-      new HashSet<>(), new HashSet<>()
-    ));
-
    Set<UnifyPair> newEqOrig = new HashSet<>(eq);
    Set<Set<UnifyPair>> newElemsOrig = new HashSet<>(elems);
    List<Set<Constraint<UnifyPair>>> newOderConstraintsOrig = new ArrayList<>(oderConstraints);
@@ -72,18 +67,19 @@ public class VarianceM1Case extends VarianceCase {

    /* FORK ANFANG */
    TypeUnify2Task forkOrig = new TypeUnify2Task(newElemsOrig, newEqOrig, newOderConstraintsOrig, a, fc, context, rekTiefe, methodSignatureConstraint);
+    typeUnifyTask.addChildTask(forkOrig);
    // schedule compute() on another thread
    CompletableFuture<Set<Set<UnifyPair>>> forkOrigFuture = CompletableFuture.supplyAsync(forkOrig::compute, context.executor()).thenCompose(f -> f);
-    resultValues = resultValues.thenCombine(forkOrigFuture,
-      (prevResults, currentThreadResult) -> {
+    CompletableFuture<ComputationResults> resultValues = forkOrigFuture.thenApply(
+      (currentThreadResult) -> {
        forkOrig.context.logger().debug("final Orig -1");
        forkOrig.closeLogFile();
-        return new Tuple<>(currentThreadResult, prevResults.getSecond());
+        return new ComputationResults(currentThreadResult);
      });

    //forks.add(forkOrig);
-    if (typeUnifyTask.myIsCancelled()) {
-      throw new UnifyCancelException();
+    if (typeUnifyTask.isExecutionCancelled()) {
+      return resultValues;
    }
    /* FORK ENDE */

@@ -109,16 +105,17 @@ public class VarianceM1Case extends VarianceCase {
      List<Set<Constraint<UnifyPair>>> newOderConstraints = new ArrayList<>(oderConstraints);
      newElems.add(nSaL);
      TypeUnify2Task fork = new TypeUnify2Task(newElems, newEq, newOderConstraints, nSaL, fc, context, rekTiefe, new HashSet<>(methodSignatureConstraint));
+      typeUnifyTask.addChildTask(fork);
      // schedule compute() on another thread
      CompletableFuture<Set<Set<UnifyPair>>> forkFuture = CompletableFuture.supplyAsync(fork::compute, context.executor()).thenCompose(f -> f);
      resultValues = resultValues.thenCombine(forkFuture,
        (prevResults, fork_res) -> {
-          if (typeUnifyTask.myIsCancelled()) {
-            throw new UnifyCancelException();
+          if (typeUnifyTask.isExecutionCancelled()) {
+            return prevResults;
          }
          context.logger().debug(() -> "fork_res: " + fork_res.toString());
          context.logger().debug(() -> Boolean.valueOf((typeUnifyTask.isUndefinedPairSetSet(fork_res))).toString());
-          prevResults.getSecond().add(fork_res);
+          prevResults.addForkResult(fork_res);
          if (!typeUnifyTask.isUndefinedPairSetSet(fork_res)) {
            aParDef.add(fork.getNextSetElement());
          }
@@ -128,8 +125,8 @@ public class VarianceM1Case extends VarianceCase {
        }
      );

-      if (typeUnifyTask.myIsCancelled()) {
-        throw new UnifyCancelException();
+      if (typeUnifyTask.isExecutionCancelled()) {
+        return resultValues;
      }
    }

--- a/src/main/java/de/dhbwstuttgart/typeinference/unify/cartesianproduct/InvarianceOrConstraintCase.java
+++ b/src/main/java/de/dhbwstuttgart/typeinference/unify/cartesianproduct/InvarianceOrConstraintCase.java
@@ -1,6 +1,5 @@
 package de.dhbwstuttgart.typeinference.unify.cartesianproduct;

-import de.dhbwstuttgart.exceptions.UnifyCancelException;
 import de.dhbwstuttgart.typeinference.constraints.Constraint;
 import de.dhbwstuttgart.typeinference.unify.TypeUnify2Task;
 import de.dhbwstuttgart.typeinference.unify.TypeUnifyTask;
@@ -15,11 +14,12 @@ import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.CompletableFuture;

-public class Variance2Case extends VarianceCase {
+public class InvarianceOrConstraintCase extends VarianceCase {

+  // either for invariance or for oderConstraints
  protected final int variance = 2;

-  protected Variance2Case(boolean isOderConstraint, TypeUnifyTask typeUnifyTask, UnifyContext context) {
+  protected InvarianceOrConstraintCase(boolean isOderConstraint, TypeUnifyTask typeUnifyTask, UnifyContext context) {
    super(isOderConstraint, typeUnifyTask, context);
  }

@@ -37,7 +37,7 @@ public class Variance2Case extends VarianceCase {


  @Override
-  public CompletableFuture<Tuple<Set<Set<UnifyPair>>, Set<Set<Set<UnifyPair>>>>> computeParallel(
+  public CompletableFuture<ComputationResults> computeParallel(
    Set<Set<UnifyPair>> elems,
    Set<UnifyPair> eq,
    List<Set<Constraint<UnifyPair>>> oderConstraints,
@@ -49,8 +49,6 @@ public class Variance2Case extends VarianceCase {
    Set<Set<UnifyPair>> result,
    Set<Set<UnifyPair>> aParDef
  ) {
-    CompletableFuture<Tuple<Set<Set<UnifyPair>>, Set<Set<Set<UnifyPair>>>>> resultValuesFuture;
-
    context.logger().debug("var2einstieg");
    Set<TypeUnify2Task> forks = new HashSet<>();
    Set<UnifyPair> newEqOrig = new HashSet<>(eq);
@@ -60,14 +58,16 @@ public class Variance2Case extends VarianceCase {

    /* FORK ANFANG */
    TypeUnify2Task forkOrig = new TypeUnify2Task(newElemsOrig, newEqOrig, newOderConstraintsOrig, a, fc, context, rekTiefe, new HashSet<>(methodSignatureConstraint));
+    typeUnifyTask.addChildTask(forkOrig);
    CompletableFuture<Set<Set<UnifyPair>>> forkOrigFuture = CompletableFuture.supplyAsync(forkOrig::compute, context.executor()).thenCompose(f -> f);
-    resultValuesFuture = forkOrigFuture.thenApply((currentThreadResult) -> {
+    CompletableFuture<ComputationResults> resultValues = forkOrigFuture.thenApply((currentThreadResult) -> {
      forkOrig.context.logger().debug("final Orig 2");
      forkOrig.closeLogFile();
-      return new Tuple<>(currentThreadResult, new HashSet<>());
+      return new ComputationResults(currentThreadResult);
    });
-    if (typeUnifyTask.myIsCancelled()) {
-      throw new UnifyCancelException();
+
+    if (typeUnifyTask.isExecutionCancelled()) {
+      return resultValues;
    }
    /* FORK ENDE */

@@ -89,27 +89,24 @@ public class Variance2Case extends VarianceCase {
      List<Set<Constraint<UnifyPair>>> newOderConstraints = new ArrayList<>(oderConstraints);
      newElems.add(nSaL);
      TypeUnify2Task fork = new TypeUnify2Task(newElems, newEq, newOderConstraints, nSaL, fc, context, rekTiefe, new HashSet<>(methodSignatureConstraintForParallel));
+      typeUnifyTask.addChildTask(fork);
      CompletableFuture<Set<Set<UnifyPair>>> forkFuture = CompletableFuture.supplyAsync(fork::compute, context.executor()).thenCompose(f -> f);
-      resultValuesFuture = resultValuesFuture.thenCombine(forkFuture, (resultValues, fork_res) -> {
-        if (typeUnifyTask.myIsCancelled()) {
-          throw new UnifyCancelException();
+      resultValues = resultValues.thenCombine(forkFuture, (prevResults, fork_res) -> {
+        if (typeUnifyTask.isExecutionCancelled()) {
+          return prevResults;
        }
-        resultValues.getSecond().add(fork_res);
+        prevResults.addForkResult(fork_res);
        fork.context.logger().debug("final 2");
        fork.closeLogFile();
-        return resultValues;
+        return prevResults;
      });

-      if (typeUnifyTask.myIsCancelled()) {
-        throw new UnifyCancelException();
+      if (typeUnifyTask.isExecutionCancelled()) {
+        return resultValues;
      }
    }

-    if (typeUnifyTask.myIsCancelled()) {
-      throw new UnifyCancelException();
-    }
-
-    return resultValuesFuture;
+    return resultValues;
  }

  @Override
--- a/src/main/java/de/dhbwstuttgart/typeinference/unify/cartesianproduct/UnknownVarianceCase.java
+++ b/src/main/java/de/dhbwstuttgart/typeinference/unify/cartesianproduct/UnknownVarianceCase.java
@@ -13,14 +13,13 @@ import java.util.List;
 import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ExecutionException;
 import java.util.stream.Collectors;

-public class Variance0Case extends VarianceCase {
+public class UnknownVarianceCase extends VarianceCase {

  protected final int variance = 0;

-  protected Variance0Case(boolean isOderConstraint, TypeUnifyTask typeUnifyTask, UnifyContext context) {
+  protected UnknownVarianceCase(boolean isOderConstraint, TypeUnifyTask typeUnifyTask, UnifyContext context) {
    super(isOderConstraint, typeUnifyTask, context);
  }

@@ -50,7 +49,7 @@ public class Variance0Case extends VarianceCase {
  }

  @Override
-  public CompletableFuture<Tuple<Set<Set<UnifyPair>>, Set<Set<Set<UnifyPair>>>>> computeParallel(
+  public CompletableFuture<ComputationResults> computeParallel(
    Set<Set<UnifyPair>> elems,
    Set<UnifyPair> eq,
    List<Set<Constraint<UnifyPair>>> oderConstraints,
@@ -62,10 +61,9 @@ public class Variance0Case extends VarianceCase {
    Set<Set<UnifyPair>> result,
    Set<Set<UnifyPair>> aParDef
  ) {
-    elems.add(a); //PL 2019-01-16 muss das wirklich hin steht schon in Zeile 859 ja braucht man siehe Zeile 859
-    return typeUnifyTask.unify2(elems, eq, oderConstraints, fc, context.parallel(), rekTiefe, new HashSet<>(methodSignatureConstraint)).thenApply(
-      unify2Result -> new Tuple<>(unify2Result, new HashSet<>())
-    );
+    elems.add(a);
+    return typeUnifyTask.unify2(elems, eq, oderConstraints, fc, context.parallel(), rekTiefe, new HashSet<>(methodSignatureConstraint))
+      .thenApply(ComputationResults::new);
  }

  @Override
@@ -75,7 +73,7 @@ public class Variance0Case extends VarianceCase {
    Set<UnifyPair> compResult,
    Set<UnifyPair> compRes
  ) {
-    context.logger().debug("RES var=1 ADD:" + result.toString() + " " + currentThreadResult.toString());
+    context.logger().debug("RES var=0 ADD:" + result.toString() + " " + currentThreadResult.toString());
    result.addAll(currentThreadResult);
  }

--- a/src/main/java/de/dhbwstuttgart/typeinference/unify/cartesianproduct/VarianceCase.java
+++ b/src/main/java/de/dhbwstuttgart/typeinference/unify/cartesianproduct/VarianceCase.java
@@ -5,9 +5,9 @@ import de.dhbwstuttgart.typeinference.unify.TypeUnifyTask;
 import de.dhbwstuttgart.typeinference.unify.UnifyContext;
 import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
-import de.dhbwstuttgart.util.Logger;
 import de.dhbwstuttgart.util.Tuple;
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Optional;
 import java.util.Set;
@@ -17,11 +17,11 @@ public abstract class VarianceCase {

  public static VarianceCase createFromVariance(int variance, boolean isOderConstraint, TypeUnifyTask typeUnifyTask, UnifyContext context) {
    return switch (variance) {
-      case 0 -> new Variance0Case(isOderConstraint, typeUnifyTask, context);
-      case 1 -> new Variance1Case(isOderConstraint, typeUnifyTask, context);
-      case -1 -> new VarianceM1Case(isOderConstraint, typeUnifyTask, context);
-      case 2 -> new Variance2Case(isOderConstraint, typeUnifyTask, context);
-      default -> throw new RuntimeException("Invalid variance: " + variance);
+      case 0    -> new UnknownVarianceCase(isOderConstraint, typeUnifyTask, context);
+      case 1    -> new ContravarianceCase(isOderConstraint, typeUnifyTask, context);
+      case -1   -> new CovarianceCase(isOderConstraint, typeUnifyTask, context);
+      case 2    -> new InvarianceOrConstraintCase(isOderConstraint, typeUnifyTask, context);
+      default   -> throw new RuntimeException("Invalid variance: " + variance);
    };
  }

@@ -72,7 +72,7 @@ public abstract class VarianceCase {
  /**
   *
   */
-  public abstract CompletableFuture<Tuple<Set<Set<UnifyPair>>, Set<Set<Set<UnifyPair>>>>> computeParallel(
+  public abstract CompletableFuture<ComputationResults> computeParallel(
    Set<Set<UnifyPair>> elems,
    Set<UnifyPair> eq,
    List<Set<Constraint<UnifyPair>>> oderConstraints,
@@ -104,4 +104,29 @@ public abstract class VarianceCase {
    Set<Set<UnifyPair>> aParDef,
    List<Set<UnifyPair>> nextSetAsList
  );
+
+  /**
+   * Wrapper class for the parallel computation results
+   */
+  public static class ComputationResults {
+    public Set<Set<UnifyPair>> mainResult;
+    public Set<Set<Set<UnifyPair>>> forkResults;
+
+    public ComputationResults() {
+      this(new HashSet<>(), new HashSet<>());
+    }
+
+    public ComputationResults(Set<Set<UnifyPair>> mainResult) {
+      this(mainResult, new HashSet<>());
+    }
+
+    public ComputationResults(Set<Set<UnifyPair>> mainResult, Set<Set<Set<UnifyPair>>> forkResults) {
+      this.mainResult = mainResult;
+      this.forkResults = forkResults;
+    }
+
+    void addForkResult(Set<Set<UnifyPair>> forkResult) {
+      forkResults.add(forkResult);
+    }
+  }
 }
--- a/src/main/java/de/dhbwstuttgart/typeinference/unify/model/OrderingUnifyPair.java
+++ b/src/main/java/de/dhbwstuttgart/typeinference/unify/model/OrderingUnifyPair.java
@@ -170,30 +170,66 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 		left.add(p2);
 		left.add(p4);
 		*/
-		

-		Set<UnifyPair> lefteq = left.stream()
-				.filter(x -> (x.getLhsType() instanceof PlaceholderType && x.getPairOp() == PairOperator.EQUALSDOT))
-				.collect(Collectors.toCollection(HashSet::new));
-		Set<UnifyPair> righteq = right.stream()
-				.filter(x -> (x.getLhsType() instanceof PlaceholderType && x.getPairOp() == PairOperator.EQUALSDOT))
-				.collect(Collectors.toCollection(HashSet::new));
-		Set<UnifyPair> leftle = left.stream()
-				.filter(x -> ((x.getLhsType() instanceof PlaceholderType || x.getRhsType() instanceof PlaceholderType) 
-						      && x.getPairOp() == PairOperator.SMALLERDOT))
-				.collect(Collectors.toCollection(HashSet::new));
-		Set<UnifyPair> rightle = right.stream()
-				.filter(x -> ((x.getLhsType() instanceof PlaceholderType || x.getRhsType() instanceof PlaceholderType) 
-						      && x.getPairOp() == PairOperator.SMALLERDOT))
-				.collect(Collectors.toCollection(HashSet::new));
-		Set<UnifyPair> leftlewc = left.stream()
-				.filter(x -> ((x.getLhsType() instanceof PlaceholderType || x.getRhsType() instanceof PlaceholderType) 
-						      && x.getPairOp() == PairOperator.SMALLERDOTWC))
-				.collect(Collectors.toCollection(HashSet::new));
-		Set<UnifyPair> rightlewc = right.stream()
-				.filter(x -> ((x.getLhsType() instanceof PlaceholderType || x.getRhsType() instanceof PlaceholderType) 
-						      && x.getPairOp() == PairOperator.SMALLERDOTWC))
-				.collect(Collectors.toCollection(HashSet::new));
+		Set<UnifyPair> lefteq = new HashSet<>();
+		Set<UnifyPair> leftle = new HashSet<>();
+		Set<UnifyPair> leftlewc = new HashSet<>();
+		Set<UnifyPair> lefteqOder = new HashSet<>();
+		Set<UnifyPair> lefteqRet = new HashSet<>();
+		Set<UnifyPair> leftleOder = new HashSet<>();
+		for (var x : left) {
+			boolean isLeftPlaceholder = x.getLhsType() instanceof PlaceholderType;
+			boolean isRightPlaceholder = x.getRhsType() instanceof PlaceholderType;
+			boolean hasPlaceholder = isLeftPlaceholder || isRightPlaceholder;
+
+			if (isLeftPlaceholder && x.getPairOp() == PairOperator.EQUALSDOT) lefteq.add(x);
+			if (hasPlaceholder && x.getPairOp() == PairOperator.SMALLERDOT) leftle.add(x);
+			if (hasPlaceholder && x.getPairOp() == PairOperator.SMALLERDOTWC) leftlewc.add(x);
+
+			UnifyPair y = x.getGroundBasePair();
+			boolean isBasePairLeftPlaceholder = y.getLhsType() instanceof PlaceholderType;
+			boolean isBasePairRightPlaceholder = y.getRhsType() instanceof PlaceholderType;
+			if (isBasePairLeftPlaceholder && !isBasePairRightPlaceholder && x.getPairOp() == PairOperator.EQUALSDOT) {
+				lefteqOder.add(x);
+			}
+			else if (isBasePairRightPlaceholder && ((PlaceholderType)y.getRhsType()).getOrCons() == (byte)-1) {
+				lefteqRet.add(x);
+			}
+			else if (x.getPairOp() == PairOperator.SMALLERDOT) {
+				leftleOder.add(x);
+			}
+		}
+
+
+		Set<UnifyPair> righteq = new HashSet<>();
+		Set<UnifyPair> rightle = new HashSet<>();
+		Set<UnifyPair> rightlewc = new HashSet<>();
+		Set<UnifyPair> righteqOder = new HashSet<>();
+		Set<UnifyPair> righteqRet = new HashSet<>();
+		Set<UnifyPair> rightleOder = new HashSet<>();
+		for (var x : right) {
+			boolean isLeftPlaceholder = x.getLhsType() instanceof PlaceholderType;
+			boolean isRightPlaceholder = x.getRhsType() instanceof PlaceholderType;
+			boolean hasPlaceholder = isLeftPlaceholder || isRightPlaceholder;
+
+			if (isLeftPlaceholder && x.getPairOp() == PairOperator.EQUALSDOT) righteq.add(x);
+			if (hasPlaceholder && x.getPairOp() == PairOperator.SMALLERDOT) 	rightle.add(x);
+			if (hasPlaceholder && x.getPairOp() == PairOperator.SMALLERDOTWC) rightlewc.add(x);
+
+			UnifyPair y = x.getGroundBasePair();
+			boolean isBasePairLeftPlaceholder = y.getLhsType() instanceof PlaceholderType;
+			boolean isBasePairRightPlaceholder = y.getRhsType() instanceof PlaceholderType;
+			if (isBasePairLeftPlaceholder && !isBasePairRightPlaceholder && x.getPairOp() == PairOperator.EQUALSDOT) {
+				righteqOder.add(x);
+			}
+			else if (isBasePairRightPlaceholder && ((PlaceholderType)y.getRhsType()).getOrCons() == (byte)-1) {
+				righteqRet.add(x);
+			}
+			else if (x.getPairOp() == PairOperator.SMALLERDOT) {
+				rightleOder.add(x);
+			}
+		}
+
 		//context.logger().info(left.toString());
 		//Fall 2
 		//if (lefteq.iterator().next().getLhsType().getName().equals("AJO")) {
@@ -201,54 +237,14 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 		//}
 		
 		//ODER-CONSTRAINT
-		Set<UnifyPair> leftBase = left.stream().map(x -> x.getGroundBasePair()).collect(Collectors.toCollection(HashSet::new));
-		Set<UnifyPair> rightBase = right.stream().map(x -> x.getGroundBasePair()).collect(Collectors.toCollection(HashSet::new));
+		// Set<UnifyPair> leftBase = left.stream().map(x -> x.getGroundBasePair()).collect(Collectors.toCollection(HashSet::new));
+		// Set<UnifyPair> rightBase = right.stream().map(x -> x.getGroundBasePair()).collect(Collectors.toCollection(HashSet::new));

-		Set<UnifyPair> lefteqOder = left.stream()
-				.filter(x -> { UnifyPair y = x.getGroundBasePair();
-				/*try {
-					((FiniteClosure)fc).logFile.write("leftBase: " + leftBase.toString() +"\n");
-					((FiniteClosure)fc).logFile.write("rightBase: " + rightBase.toString() +"\n\n");
-					((FiniteClosure)fc).logFile.write("left: " + left.toString() +"\n");
-					((FiniteClosure)fc).logFile.write("right: " + right.toString() +"\n\n");
-					((FiniteClosure)fc).logFile.write("y: " + y.toString() +"\n");
-					((FiniteClosure)fc).logFile.write("y.getLhsType() : " + y.getLhsType() .toString() +"\n\n");
-					((FiniteClosure)fc).logFile.write("y.getRhsType(): " + y.getRhsType().toString() +"\n");
-					((FiniteClosure)fc).logFile.write("x.getPairOp(): " + x.getPairOp().toString() +"\n\n");
-					}
-					catch (IOException ie) {
-					}	*/
-	               return (y.getLhsType() instanceof PlaceholderType && 
-	            		   !(y.getRhsType() instanceof PlaceholderType) && 
-	            		   x.getPairOp() == PairOperator.EQUALSDOT);})
-				.collect(Collectors.toCollection(HashSet::new));
 		left.removeAll(lefteqOder);
-		Set<UnifyPair> righteqOder = right.stream()
-				.filter(x -> { UnifyPair y = x.getGroundBasePair(); 
-	               return (y.getLhsType() instanceof PlaceholderType && 
-	            		   !(y.getRhsType() instanceof PlaceholderType) && 
-	            		   x.getPairOp() == PairOperator.EQUALSDOT);})
-				.collect(Collectors.toCollection(HashSet::new));
-		right.removeAll(righteqOder);
-		Set<UnifyPair> lefteqRet = left.stream()
-				.filter(x -> { UnifyPair y = x.getGroundBasePair(); 
-	               return (y.getRhsType() instanceof PlaceholderType && 
-	            		   ((PlaceholderType)y.getRhsType()).getOrCons() == (byte)-1);})
-				.collect(Collectors.toCollection(HashSet::new));
 		left.removeAll(lefteqRet);
-		Set<UnifyPair> righteqRet = right.stream()
-				.filter(x -> { UnifyPair y = x.getGroundBasePair(); 
-	               return (y.getRhsType() instanceof PlaceholderType && 
-	            		   ((PlaceholderType)y.getRhsType()).getOrCons() == (byte)-1);})
-				.collect(Collectors.toCollection(HashSet::new));
+		right.removeAll(righteqOder);
 		right.removeAll(righteqRet);
-		Set<UnifyPair> leftleOder = left.stream()
-				.filter(x -> (x.getPairOp() == PairOperator.SMALLERDOT))
-				.collect(Collectors.toCollection(HashSet::new));
-		Set<UnifyPair> rightleOder = right.stream()
-				.filter(x -> (x.getPairOp() == PairOperator.SMALLERDOT))
-				.collect(Collectors.toCollection(HashSet::new));
-		
+
 		/*
 		synchronized(this) {
 					try {
@@ -273,59 +269,43 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 		int compareEq;
 		if (lefteqOder.size() == 1 && righteqOder.size() == 1 && lefteqRet.size() == 1 && righteqRet.size() == 1) {
 			Match m = new Match();
-			if ((compareEq = compareEq(lefteqOder.iterator().next().getGroundBasePair(), righteqOder.iterator().next().getGroundBasePair())) == -1) {
-				ArrayList<UnifyPair> matchList = 
-						rightleOder.stream().map(x -> { 
-							UnifyPair leftElem = leftleOder.stream()
+			compareEq = compareEq(lefteqOder.iterator().next().getGroundBasePair(), righteqOder.iterator().next().getGroundBasePair());
+
+			if (compareEq == -1) {
+				ArrayList<UnifyPair> matchList =
+						rightleOder.stream().map(x -> {
+								UnifyPair leftElem = leftleOder.stream()
 														     .filter(y -> y.getGroundBasePair().getLhsType().equals(x.getGroundBasePair().getLhsType()))
-														     .findAny().get(); 
-							return new UnifyPair(x.getRhsType(), leftElem.getRhsType(), PairOperator.EQUALSDOT);})
-											.collect(Collectors.toCollection(ArrayList::new));
-				if (m.match(matchList).isPresent()) {
-					//try { ((FiniteClosure)fc).logFile.write("result1: -1 \n\n"); } catch (IOException ie) {}
-					return -1;
-				}
-				else {
-					//try { ((FiniteClosure)fc).logFile.write("result1: 0 \n\n"); } catch (IOException ie) {}
-					return 0;
-				}
+														     .findAny().orElseThrow();
+								return new UnifyPair(x.getRhsType(), leftElem.getRhsType(), PairOperator.EQUALSDOT);}
+							)
+							.collect(Collectors.toCollection(ArrayList::new));
+
+				return (m.match(matchList).isPresent()) ? -1 : 0;
 			} else if (compareEq == 1) {
-				ArrayList<UnifyPair> matchList = 
-						leftleOder.stream().map(x -> { 
+				ArrayList<UnifyPair> matchList =
+						leftleOder.stream().map(x -> {
 							UnifyPair rightElem = rightleOder.stream()
-									                        .filter(y -> 
-									                        	y.getGroundBasePair().getLhsType().equals(x.getGroundBasePair().getLhsType()))
-									                        .findAny().get(); 
-														return new UnifyPair(x.getRhsType(), rightElem.getRhsType(), PairOperator.EQUALSDOT);})
-											.collect(Collectors.toCollection(ArrayList::new));
-				if (m.match(matchList).isPresent()) {
-					//try { ((FiniteClosure)fc).logFile.write("result2: 1 \n\n"); } catch (IOException ie) {}
-					return 1;
-				}
-				else {
-					//try { ((FiniteClosure)fc).logFile.write("result2: 0 \n\n"); } catch (IOException ie) {}
-					return 0;
-				}
+								.filter(y -> y.getGroundBasePair().getLhsType().equals(x.getGroundBasePair().getLhsType()))
+								.findAny().orElseThrow();
+							return new UnifyPair(x.getRhsType(), rightElem.getRhsType(), PairOperator.EQUALSDOT);}
+						)
+						.collect(Collectors.toCollection(ArrayList::new));
+				return (m.match(matchList).isPresent()) ? 1 : 0;
 			} else {
 				/*
-				synchronized(this) {
-					try {
-						((FiniteClosure)fc).logFile.write("leftBase: " + leftBase.toString() +"\n");
-						((FiniteClosure)fc).logFile.write("rightBase: " + rightBase.toString() +"\n\n");
-						((FiniteClosure)fc).logFile.write("left: " + left.toString() +"\n");
-						((FiniteClosure)fc).logFile.write("right: " + right.toString() +"\n\n");
-						((FiniteClosure)fc).logFile.write("lefteqOder: " + lefteqOder.toString() +"\n");
-						((FiniteClosure)fc).logFile.write("righteqOder: " + righteqOder.toString() +"\n\n");
-						((FiniteClosure)fc).logFile.write("lefteqRet: " + lefteqRet.toString() +"\n");
-						((FiniteClosure)fc).logFile.write("righteqRet: " + righteqRet.toString() +"\n\n");
-						((FiniteClosure)fc).logFile.write("leftleOder: " + leftleOder.toString() +"\n");
-						((FiniteClosure)fc).logFile.write("rightleOder: " + rightleOder.toString() +"\n\n");
-						((FiniteClosure)fc).logFile.write("result3: 0 \n\n");
-						((FiniteClosure)fc).logFile.flush();
-					}
-					catch (IOException ie) {
-					}
-				}
+					((FiniteClosure)fc).logFile.write("leftBase: " + leftBase.toString() +"\n");
+					((FiniteClosure)fc).logFile.write("rightBase: " + rightBase.toString() +"\n\n");
+					((FiniteClosure)fc).logFile.write("left: " + left.toString() +"\n");
+					((FiniteClosure)fc).logFile.write("right: " + right.toString() +"\n\n");
+					((FiniteClosure)fc).logFile.write("lefteqOder: " + lefteqOder.toString() +"\n");
+					((FiniteClosure)fc).logFile.write("righteqOder: " + righteqOder.toString() +"\n\n");
+					((FiniteClosure)fc).logFile.write("lefteqRet: " + lefteqRet.toString() +"\n");
+					((FiniteClosure)fc).logFile.write("righteqRet: " + righteqRet.toString() +"\n\n");
+					((FiniteClosure)fc).logFile.write("leftleOder: " + leftleOder.toString() +"\n");
+					((FiniteClosure)fc).logFile.write("rightleOder: " + rightleOder.toString() +"\n\n");
+					((FiniteClosure)fc).logFile.write("result3: 0 \n\n");
+					((FiniteClosure)fc).logFile.flush();
 				*/
 				return 0;
 			}
@@ -392,12 +372,12 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 				//TODO: Hier wird bei Wildcards nicht das richtige compare aufgerufen PL 18-04-20
 				Pair<Integer, Set<UnifyPair>> int_Unifier = compare(lseq.getRhsType(), rseq.getRhsType());
 				Unifier uni = new Unifier();
-				int_Unifier.getValue().get().forEach(x -> uni.add((PlaceholderType) x.getLhsType(), x.getRhsType()));
-				if (!lseq.getRhsType().getName().equals(rseq.getRhsType().getName()) 
+				int_Unifier.getValue().orElseThrow().forEach(x -> uni.add((PlaceholderType) x.getLhsType(), x.getRhsType()));
+				if (!lseq.getRhsType().getName().equals(rseq.getRhsType().getName())
 					|| leftlewc.isEmpty() || rightlewc.isEmpty()) return int_Unifier.getKey();
 				else {
-					Set <UnifyPair> lsleuni = leftlewc.stream().map(x -> uni.apply(x)).collect(Collectors.toCollection(HashSet::new));
-					Set <UnifyPair> rsleuni = rightlewc.stream().map(x -> uni.apply(x)).collect(Collectors.toCollection(HashSet::new));
+					Set <UnifyPair> lsleuni = leftlewc.stream().map(uni::apply).collect(Collectors.toCollection(HashSet::new));
+					Set <UnifyPair> rsleuni = rightlewc.stream().map(uni::apply).collect(Collectors.toCollection(HashSet::new));
 					BinaryOperator<HashMap<UnifyType,UnifyPair>> combiner = (x,y) -> { x.putAll(y); return x;};
 				
 					HashMap<UnifyType,UnifyPair> hm;
@@ -418,6 +398,7 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 				}
 			} else {
 				if (!leftlewc.isEmpty()) {
+					/*
 					Set<UnifyPair> subst;
 					subst = leftlewc.stream().map(x -> { 
 						if (x.getLhsType() instanceof PlaceholderType) {
@@ -426,6 +407,7 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 						else {
 							return new UnifyPair(x.getRhsType(), x.getLhsType(), PairOperator.EQUALSDOT);
 						}}).collect(Collectors.toCollection(HashSet::new));
+					 */
 					Unifier uni = new Unifier();
 					lseq = uni.apply(lseq);
 				}
--- a/src/main/java/de/dhbwstuttgart/util/Logger.java
+++ b/src/main/java/de/dhbwstuttgart/util/Logger.java
@@ -2,11 +2,14 @@ package de.dhbwstuttgart.util;

 import com.diogonunes.jcolor.Attribute;
 import de.dhbwstuttgart.core.ConsoleInterface;
+import de.dhbwstuttgart.server.SocketServer;
 import java.io.File;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.Writer;
 import java.nio.file.Path;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
 import java.util.Arrays;
 import java.util.Objects;
 import java.util.function.Supplier;
@@ -16,11 +19,12 @@ import static com.diogonunes.jcolor.Ansi.colorize;

 public class Logger {

+  public static final Logger NULL_LOGGER = new NullLogger();
+  private static final DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
+
  protected final Writer writer;
  protected final String prefix;

-  public static Logger NULL_LOGGER = new NullLogger();
-
  public Logger() {
    this(null, "");
  }
@@ -54,7 +58,7 @@ public class Logger {
  /**
   * Create a new logger object that inherits the writer of the given logger object
   *
-   * @param logger    The old logger object, that will provide the writer
+   * @param logger    The old logger object that will provide the writer
   * @return          The new prefix for the new logger object
   */
  public static Logger inherit(Logger logger, String newPrefix) {
@@ -84,7 +88,15 @@ public class Logger {
   */
  protected void print(String s, LogLevel logLevel) {
    String coloredPrefix = this.getPrefix(logLevel);
-    if (logLevel.isHigherOrEqualTo(LogLevel.ERROR)) {
+
+    // if we are running the server, prepend the timestamp
+    if(SocketServer.isServerRunning()) {
+      String timestamp = LocalDateTime.now().format(timeFormatter);
+      coloredPrefix = "[" + timestamp + "] " + coloredPrefix;
+    }
+
+    // output to the correct output-stream
+    if (logLevel.getValue() == LogLevel.ERROR.getValue()) {
      System.out.println(coloredPrefix + s);
    }
    else {
@@ -224,7 +236,7 @@ public class Logger {
        " | " + stackTraceElement.toString()
      ).collect(Collectors.joining("\n"));

-    // if there will be a cause printed afterward, announce it with the print of the exception
+    // if there is a cause printed afterward, announce it with the print of the exception
    if (throwable.getCause() != null) {
      s += "\n\nCaused by: ";
    }
Author	SHA1	Message	Date
Fabian Holzwarth	3d99f282f5	feat: cleanup code	2025-07-21 16:12:56 +02:00
Fabian Holzwarth	303c91dc87	chore: making classnames more expressive and cleanup some structures	2025-07-19 12:50:30 +02:00
Fabian Holzwarth	603a8b176a	feat: implement partically cancellable tasks	2025-07-16 11:16:30 +02:00
Fabian Holzwarth	f396189a4b	feat: add timestamp to server output	2025-07-12 13:44:18 +02:00
Fabian Holzwarth	e7f4a94908	feat: fixed old condition on server timeout	2025-07-12 13:22:54 +02:00
Fabian Holzwarth	ce49a4b9a5	feat: reduce temporary objects and repeated loops	2025-07-12 13:14:55 +02:00