feat: update parallelization for 0variance

.gitea/workflows/build_and_test.yml

@@ -15,7 +15,7 @@ jobs:
         uses: actions/setup-java@v4
         with:
           distribution: 'temurin'
-          java-version: '22'
+          java-version: '23'
           cache: 'maven'
       - name: Compile project
         run: |

Makefile

@@ -1,3 +0,0 @@
-NoOptParallel:
-	mvn -DskipTests package
-	cp target/JavaTXcompiler-0.1-jar-with-dependencies.jar target/JavaTXcompiler-0.1-jar-with-dependencies_NoOptParallel.jar

independentTest.sh

@@ -0,0 +1,40 @@
+#!/usr/bin/env bash
+
+
+REPO="https://gitea.hb.dhbw-stuttgart.de/f.holzwarth/JavaCompilerCore.git"
+TDIR="./testBuild"
+
+rm -rf "$TDIR" 2>/dev/null
+mkdir $TDIR
+
+cd $TDIR
+git clone $REPO .
+git checkout feat/unify-server
+# git checkout 93e1a8787cd94c73f4538f6a348f58613893a584
+# git checkout dad468368b86bdd5a3d3b2754b17617cee0a9107 # 1:55
+# git checkout a0c11b60e8c9d7addcbe0d3a09c9ce2924e9d5c0 # 2:25
+# git checkout 4cddf73e6d6c9116d3e1705c4b27a8e7f18d80c3 # 2:27
+# git checkout 6c2d97b7703d954e4a42eef3ec374bcf313af75c # 2:13
+# git checkout f722a00fbb6e69423d48a890e4a6283471763e64 # 1:35
+# git checkout f0a4a51ce65639ce9a9470ff0fdb538fdf9c02cc # 2:19
+# git checkout 1391206dfe59263cdb22f93371cfd1dd5465d97f # 1:29
+
+date "+%Y.%m.%d %H:%M:%S"
+# sed -i -e 's/source>21/source>23/g' pom.xml
+# sed -i -e 's/target>21/target>23/g' pom.xml
+
+
+mvn clean compile -DskipTests package
+time java -jar target/JavaTXcompiler-0.1-jar-with-dependencies.jar resources/bytecode/javFiles/Matrix.jav;
+
+# mvn clean compile test
+
+
+echo -e "\nCleanup... "
+cd -
+rm -rf "$TDIR" 2>/dev/null
+
+echo -e "\nFinished "
+date "+%Y.%m.%d %H:%M:%S"
+echo -e "\n "
+

pom.xml

@@ -44,7 +44,6 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 			<artifactId>asm</artifactId>
 			<version>9.5</version>
 		</dependency>
-
 		<dependency>
 			<groupId>org.java-websocket</groupId>
 			<artifactId>Java-WebSocket</artifactId>
@@ -60,7 +59,11 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 			<artifactId>jackson-databind</artifactId>
 			<version>2.17.2</version>
 		</dependency>
-
+		<dependency>
+			<groupId>com.diogonunes</groupId>
+			<artifactId>JColor</artifactId>
+			<version>5.5.1</version>
+		</dependency>
 	</dependencies>
 
 	<build>

resources/LaufzeitTests/DeeplyNested.jav

@@ -0,0 +1,51 @@
+class C1 {
+    C1 self() {
+        return this;
+    }
+}
+
+class C2 {
+    C2 self() {
+        return this;
+    }
+}
+
+class Example {
+    untypedMethod(var) {
+        return var.self().self().self().self()
+                  .self().self().self().self()
+                  .self().self().self().self()
+                  .self().self().self().self()
+                  .self().self().self().self()
+                  .self().self().self().self()
+                  .self().self().self().self()
+                  .self().self().self().self()
+                  .self().self().self().self()
+                  .self().self().self().self()
+                  .self().self().self().self()
+                  .self().self().self().self()
+                  .self().self().self().self()
+                  .self().self().self().self()
+                  .self().self().self().self()
+                  .self().self().self().self()
+                  .self().self().self().self()
+                  .self().self().self().self()
+                  .self().self().self().self()
+                  .self().self().self().self()
+                  .self().self().self().self()
+                  .self().self().self().self()
+                  .self().self().self().self()
+                  .self().self().self().self()
+                  .self().self().self().self()
+                  .self().self().self().self()
+                  .self().self().self().self()
+                  .self().self().self().self()
+                  .self().self().self().self()
+                  .self().self().self().self()
+                  .self().self().self().self()
+                  .self().self().self().self()
+                  .self().self().self().self()
+                  .self().self().self().self()
+                  .self().self().self().self();
+    }
+}

resources/LaufzeitTests/GridSearch.jav

@@ -0,0 +1,43 @@
+import java.lang.Integer;
+import java.lang.Boolean;
+import java.util.Queue;
+import java.util.Vector;
+import java.util.List;
+import java.util.ArrayDeque;
+
+class Pos {
+    public Integer x;
+    public Integer y;
+    public Pos(Integer x, Integer y) {
+        this.x = x;
+        this.y = y;
+    }
+}
+
+class GridSearch {
+
+    Pos search(Vector<Vector<Boolean>> grid) {
+        var w = grid.size();
+        var h = grid.getFirst().size();
+
+        // keep a queue on which cells to check
+        var cellQueue = new ArrayDeque<Pos>();
+        cellQueue.add(new Pos(0,0));
+
+        while (!cellQueue.isEmpty()) {
+            var pos = cellQueue.poll();
+            // if the target was found: return the position
+            var value = grid.get(pos.x).get(pos.y);
+            if (value) {
+                return pos;
+            }
+
+            // keep searching on neighboring tiles
+            if (pos.x < w-1)    cellQueue.add(new Pos(pos.x + 1, pos.y));
+            if (pos.y < h-1)    cellQueue.add(new Pos(pos.x, pos.y + 1));
+        }
+
+        return (Pos)null;
+    }
+
+}

resources/LaufzeitTests/Mask.jav

@@ -0,0 +1,42 @@
+import java.util.List;
+import java.util.AbstractList;
+import java.util.Vector;
+import java.lang.Integer;
+
+class Pixel {
+    public color;
+}
+
+class Mask {
+
+    mask;
+
+    Mask(mask) {
+        this.mask = mask;
+    }
+
+    apply(pixels) {
+        var w = mask.size();
+        var h = mask.get(0).size();
+        var imgW = pixels.size();
+        var imgH = pixels.get(0).size();
+
+        for (var x = 0; x < imgW - w; x++) {
+            for (var y = 0; y < imgH - h; y++) {
+
+                var total = 0;
+                for (var xd = 0; xd < w; xd++) {
+                    for (var yd = 0; yd < h; yd++) {
+                        var p = pixels.get(x + xd).get(y + yd);
+                        var m = mask.get(xd).get(yd);
+                        total = total + (p.color * m);
+                    }
+                }
+
+                pixels.get(x).get(y).color = total;
+            }
+        }
+
+        return pixels;
+    }
+}

resources/LaufzeitTests/PascalsTriangle.jav

@@ -0,0 +1,39 @@
+import java.lang.Integer;
+import java.lang.Boolean;
+import java.util.ArrayList;
+import java.util.HashMap;
+
+public class PascalsTriangle {
+
+    create(n) {
+        var rows = new ArrayList<ArrayList<Integer>>();
+        var evens = new ArrayList<ArrayList<Boolean>>();
+
+        if (n <= 0) return rows;
+        // first row
+        rows.add(new ArrayList<Integer>(1));
+        evens.add(new ArrayList<Boolean>(false));
+
+        for (int y = 1; y < n; y++) {
+            var row = new ArrayList<Integer>();
+            var evensRow = new ArrayList<Boolean>();
+            row.add(1);
+            evensRow.add(false);
+
+            for (int x = 1; x < y-1; x++) {
+                int tl = rows.getLast().get(x-1);
+                int tr = rows.getLast().get(x);
+                row.add(tl + tr);
+                evensRow.add(((tl + tr) % 2) == 1);
+            }
+
+            row.add(1);
+            rows.add(row);
+            evensRow.add(false);
+            evens.add(evensRow);
+        }
+
+        return rows;
+    }
+
+}

resources/bytecode/javFiles/Merge2.jav

@@ -0,0 +1,17 @@
+import java.util.List;
+import java.lang.Integer;
+//import java.util.Collection;
+
+public class Merge2  {
+
+	public merge(a, b) {
+     	a.addAll(b);
+		return a;
+	}
+
+  	public sort(in){
+    	var firstHalf = in.subList(1,2);
+    	return merge(sort(firstHalf), sort(in));
+    }
+    
+}

resources/bytecode/javFiles/Scalar.jav

@@ -1,4 +1,4 @@
-//import java.util.Vector;
+import java.util.Vector;
 import java.lang.Integer;
 import java.lang.Float;
 //import java.lang.Byte;
@@ -12,14 +12,15 @@ public class Scalar extends Vector<Integer> {
 	while(i < v.size()) {
 	  this.add(v.elementAt(i));
           i=i+1;
-	}
+	} 
     }
-
+   
     public mul(v) {
         var ret = 0;
         var i = 0;
         while(i < size()) {
             ret = ret + this.elementAt(i) * v.elementAt(i);
+	    i = i+1;
          }
         return ret;
     }

server-tests/.gitignore

@@ -1,2 +0,0 @@
-out
-outputs

server-tests/Lambda.jav

@@ -1,13 +0,0 @@
-
-class Apply { }
-
-public class Lambda {
-
-  m () {
-   var lam1 = (x) -> {
-        return x;
-   };
-   return lam1.apply(new Apply());
-  }
-}
-

server-tests/Matrix.jav

@@ -1,28 +0,0 @@
-import java.util.Vector;
-import java.lang.Integer;
-
-class Matrix extends Vector<Vector<Integer>> {
-	Integer mul1(Integer x, Integer y) { return x;}
-	Integer add1(Integer x, Integer y) { return x;}
-    mul(m) {
-        var ret = new Matrix();
-        var i = 0;
-        while(i < size()) {
-            var v1 = this.elementAt(i);
-            var v2 = new Vector<Integer>();
-            var j = 0;
-            while(j < v1.size()) {
-                var erg = 0;
-                var k = 0;
-                while(k < v1.size()) {
-                  erg = erg + v1.elementAt(k) * m.elementAt(k).elementAt(j);
-                  //erg = add1(erg, mul1(v1.elementAt(k),
-                  //           m.elementAt(k).elementAt(j)));
-                    k++; }
-                v2.addElement(new Integer(erg));
-                j++; }
-            ret.addElement(v2);
-            i++; }
-        return ret;
-    }
-}

server-tests/SomeList.jav

@@ -1,25 +0,0 @@
-import java.util.Vector;
-import java.lang.Integer;
-
-class SomeEvenMoreAbstractList<A, B> extends Vector<A> {
-}
-
-class SomeAbstractList<A, B> extends SomeEvenMoreAbstractList<A, B> {
-}
-
-class SomeList extends SomeAbstractList<Integer, Integer> {
-
-    mul(otherList) {
-        var result = new SomeList();
-
-        var i = 0;
-        while (i < 4) {
-            i++;
-            var a = this.elementAt(i);
-            var b = otherList.elementAt(i);
-            result.addElement(a * b);
-        }
-
-        return result;
-    }
-}

server-tests/_runClient.sh

@@ -1,21 +0,0 @@
-#!/usr/bin/env bash
-
-# build the compiler if -c is set
-if [[ "${@,,}" == *"-c"* ]]; then
-  (cd .. && make || exit)
-fi
-
-# a very small and short running example
-# JAV_FILE="Lambda.jav"
-
-# a medium and average running example
-JAV_FILE="SomeList.jav"
-
-# a very large and long running example
-# JAV_FILE="Matrix.jav"
-
-
-# remove old generated files and run the compiler
-rm -rf ./out/client
-mkdir -p ./out/client \
-  && java -jar ../target/JavaTXcompiler-0.1-jar-with-dependencies.jar -d ./out/client $JAV_FILE

server-tests/_runServer.sh

@@ -1,12 +0,0 @@
-#!/usr/bin/env bash
-
-# build the compiler if -c is set
-if [[ "${@,,}" == *"-c"* ]]; then
-  (cd .. && make || exit)
-fi
-
-# remove old generated files
-rm -rf ./out/server
-
-# run the server
-mkdir -p ./out/server && java -jar ../target/JavaTXcompiler-0.1-jar-with-dependencies.jar -d ./out/server -server 5000

src/main/java/de/dhbwstuttgart/bytecode/Codegen.java

@@ -8,17 +8,20 @@ import de.dhbwstuttgart.target.generate.ASTToTargetAST;
 import de.dhbwstuttgart.target.tree.*;
 import de.dhbwstuttgart.target.tree.expression.*;
 import de.dhbwstuttgart.target.tree.type.*;
+import de.dhbwstuttgart.util.Logger;
 import org.objectweb.asm.*;
 
 import java.lang.invoke.*;
 import java.lang.reflect.Modifier;
 import java.util.*;
 
+import static org.objectweb.asm.Opcodes.*;
 import static de.dhbwstuttgart.target.tree.expression.TargetBinaryOp.*;
 import static de.dhbwstuttgart.target.tree.expression.TargetLiteral.*;
-import static org.objectweb.asm.Opcodes.*;
 
 public class Codegen {
+    public static Logger logger = new Logger("codegen");
+
     private final TargetStructure clazz;
     private final ClassWriter cw;
     public final String className;
@@ -1317,7 +1320,7 @@ public class Codegen {
                 types.add(Type.getObjectType(guard.inner().type().getInternalName()));
                 // TODO Same here we need to evaluate constant;
             } else {
-                System.out.println(label);
+                logger.info(label);
                 throw new NotImplementedException();
             }
         }
@@ -1530,7 +1533,7 @@ public class Codegen {
         MethodVisitor mv = cw.visitMethod(constructor.access(), "<init>", constructor.getDescriptor(), constructor.getSignature(), null);
         if (constructor.txGenerics() != null)
             mv.visitAttribute(new JavaTXSignatureAttribute(constructor.getTXSignature()));
-
+        
         mv.visitCode();
         var state = new State(null, mv, 1);
         for (var param : constructor.parameters()) {

src/main/java/de/dhbwstuttgart/bytecode/FunNGenerator.java

@@ -120,7 +120,7 @@ public class FunNGenerator {
             superFunNMethodDescriptor.append(")V");
         }
 
-        System.out.println(superFunNMethodSignature);
+        Codegen.logger.info(superFunNMethodSignature);
 
         ClassWriter classWriter = new ClassWriter(0);
         MethodVisitor methodVisitor;

src/main/java/de/dhbwstuttgart/core/ConsoleInterface.java

@@ -1,77 +1,81 @@
 package de.dhbwstuttgart.core;
 
+import de.dhbwstuttgart.server.SocketClient;
+import de.dhbwstuttgart.util.Logger;
 import java.io.File;
 import java.io.IOException;
-import java.io.OutputStream;
-import java.io.PrintStream;
 import java.util.*;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Iterator;
-import java.util.List;
 
 public class ConsoleInterface {
-    private static final String directory = System.getProperty("user.dir");
 
-    public static void main(String[] args) throws IOException, ClassNotFoundException {
-        List<File> input = new ArrayList<>();
-        List<File> classpath = new ArrayList<>();
-        String outputPath = null;
-        int runAsServerWithPort = -1;
-        String unificationServer = null;
+  /**
+   * Leave the argument configurations here for the rest of the code to read
+   */
+  public static Logger.LogLevel logLevel = Logger.LogLevel.ERROR;
+  public static boolean writeLogFiles = false;
+  public static Optional<String> unifyServerUrl = Optional.empty();
 
-        Iterator<String> it = Arrays.asList(args).iterator();
-        if (args.length == 0) {
-            System.out.println("No input files given. Get help with --help");
-            System.exit(1);
-        } else if (args.length == 1 && args[0].equals("--help")) {
-            System.out.println("Usage: javatx [OPTION]... [FILE]...\n" +
-                    "\t-cp\tSet Classpath\n" +
-                    "\t-d\tSet destination directory\n" +
-                    "\t-s\tRun the compiler in server mode and listen for incoming requests on the given port\n" +
-                    "\t-us\tSet the address of a remote server for the unification process"
-            );
-            System.exit(1);
-        }
-        while (it.hasNext()) {
-            String arg = it.next();
-            if (arg.equals("-d")) {
-                outputPath = it.next();
-            }
-            else if (arg.startsWith("-d")) {
-                outputPath = arg.substring(2);
-            }
-            else if (arg.equals("-cp") || arg.equals("-classpath")) {
-                String[] cps = it.next().split(":");
-                for (String cp : cps) {
-                    classpath.add(new File(cp));
-                }
-            }
-            else if (arg.equals("-s") || arg.equals("-server")) {
-                if (unificationServer != null) {
-                    throw new IllegalArgumentException("Cannot run in server-Mode and use unification server at the same time");
-                }
-                runAsServerWithPort = Integer.parseInt(it.next());
-            }
-            else if (arg.equals("-us") || arg.equals("-unification-server")) {
-                if (runAsServerWithPort != -1) {
-                    throw new IllegalArgumentException("Cannot run in server-Mode and use unification server at the same time");
-                }
-                unificationServer = it.next();
-            } else {
-                input.add(new File(arg));
-            }
-        }
+  public static void main(String[] args) throws IOException, ClassNotFoundException {
+    List<File> input = new ArrayList<>();
+    List<File> classpath = new ArrayList<>();
+    String outputPath = null;
+    Iterator<String> it = Arrays.asList(args).iterator();
+    Optional<Integer> serverPort = Optional.empty();
 
-        if (runAsServerWithPort != -1) {
-            JavaTXServer server = new JavaTXServer(runAsServerWithPort);
+    if (args.length == 0) {
+      System.out.println("No input files given. Get help with --help");
+      System.exit(1);
+    } else if (args.length == 1 && args[0].equals("--help")) {
+      System.out.println("Usage: javatx [OPTION]... [FILE]...\n" +
+        "\t-cp\tSet Classpath\n" +
+        "\t-d\tSet destination directory\n" +
+        "\t[--server-mode <port>]\n" +
+        "\t[--unify-server <url>]\n" +
+        "\t[--write-logs]\n" +
+        "\t[-v|-vv-|-vvv]");
+      System.exit(1);
+    }
+    while (it.hasNext()) {
+      String arg = it.next();
+      if (arg.equals("-d")) {
+        outputPath = it.next();
+      } else if (arg.startsWith("-d")) {
+        outputPath = arg.substring(2);
+      } else if (arg.equals("-cp") || arg.equals("-classpath")) {
+        String[] cps = it.next().split(":");
+        for (String cp : cps) {
+          classpath.add(new File(cp));
         }
-        else {
-            JavaTXCompiler compiler = new JavaTXCompiler(input, classpath, outputPath != null ? new File(outputPath) : null);
-            //compiler.typeInference();
-            compiler.generateBytecode();
-        }
-	}
+      } else if (arg.equals("--server-mode")) {
+        serverPort = Optional.of(Integer.parseInt(it.next()));
+      } else if (arg.equals("--unify-server")) {
+        unifyServerUrl = Optional.of(it.next());
+      } else if (arg.equals("--write-logs")) {
+        ConsoleInterface.writeLogFiles = true;
+      } else if (arg.startsWith("-v")) {
+        logLevel = switch (arg) {
+          case "-v" -> Logger.LogLevel.WARNING;
+          case "-vv" -> Logger.LogLevel.INFO;
+          case "-vvv" -> Logger.LogLevel.DEBUG;
+          default -> throw new IllegalArgumentException("Argument " + arg + " is not a valid verbosity level");
+        };
+      } else {
+        input.add(new File(arg));
+      }
+    }
+
+    if (serverPort.isPresent()) {
+      if (unifyServerUrl.isPresent()) throw new RuntimeException("Cannot use unifyServer when in server mode!");
+      JavaTXServer server = new JavaTXServer(serverPort.get());
+      server.listen();
+    }
+    else {
+      JavaTXCompiler compiler = new JavaTXCompiler(input, classpath, outputPath != null ? new File(outputPath) : null);
+      //compiler.typeInference();
+      compiler.generateBytecode();
+      SocketClient.closeIfOpen();
+    }
+  }
 
 
 }

src/main/java/de/dhbwstuttgart/core/JavaTXCompiler.java

@@ -13,6 +13,10 @@ import de.dhbwstuttgart.parser.antlr.Java17Parser.SourceFileContext;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.parser.scope.JavaClassRegistry;
 import de.dhbwstuttgart.server.SocketClient;
+import de.dhbwstuttgart.server.SocketFuture;
+import de.dhbwstuttgart.server.packet.SetAutoclosePacket;
+import de.dhbwstuttgart.server.packet.UnifyRequestPacket;
+import de.dhbwstuttgart.server.packet.UnifyResultPacket;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
 import de.dhbwstuttgart.syntaxtree.Method;
@@ -20,6 +24,7 @@ import de.dhbwstuttgart.syntaxtree.ParameterList;
 import de.dhbwstuttgart.syntaxtree.SourceFile;
 import de.dhbwstuttgart.syntaxtree.GenericDeclarationList;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
+import de.dhbwstuttgart.syntaxtree.factory.NameGenerator;
 import de.dhbwstuttgart.syntaxtree.factory.UnifyTypeFactory;
 import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
 import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
@@ -31,20 +36,29 @@ import de.dhbwstuttgart.syntaxtree.type.TypeVisitor;
 import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
 import de.dhbwstuttgart.target.generate.ASTToTargetAST;
 import de.dhbwstuttgart.target.generate.GenericsResult;
-import de.dhbwstuttgart.typeinference.TypeInference;
-import de.dhbwstuttgart.typeinference.TypeInferenceHelper;
 import de.dhbwstuttgart.typeinference.constraints.Constraint;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import de.dhbwstuttgart.typeinference.constraints.Pair;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
 import de.dhbwstuttgart.typeinference.typeAlgo.TYPE;
-import de.dhbwstuttgart.typeinference.unify.*;
+import de.dhbwstuttgart.typeinference.unify.PlaceholderRegistry;
+import de.dhbwstuttgart.typeinference.unify.RuleSet;
+import de.dhbwstuttgart.typeinference.unify.TypeUnify;
+import de.dhbwstuttgart.typeinference.unify.UnifyContext;
+import de.dhbwstuttgart.typeinference.unify.distributeVariance;
 import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
+import de.dhbwstuttgart.typeinference.unify.model.FiniteClosure;
 import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
 import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyType;
+import de.dhbwstuttgart.typeinference.unify.TypeUnifyTask;
+import de.dhbwstuttgart.typeinference.unify.UnifyResultListener;
+import de.dhbwstuttgart.typeinference.unify.UnifyResultListenerImpl;
+import de.dhbwstuttgart.typeinference.unify.UnifyResultModel;
+import de.dhbwstuttgart.typeinference.unify.UnifyTaskModel;
 
+import de.dhbwstuttgart.util.Logger;
 import java.io.*;
 import java.lang.reflect.Modifier;
 import java.nio.file.Path;
@@ -53,19 +67,20 @@ import java.util.Map.Entry;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
-import de.dhbwstuttgart.util.Logger;
 import org.apache.commons.io.output.NullOutputStream;
 
 public class JavaTXCompiler {
 
+	// do not use this in any code, that can be executed serverside!
+	public static PlaceholderRegistry defaultClientPlaceholderRegistry = new PlaceholderRegistry();
+	public static Logger defaultLogger = new Logger();
+
 	// public static JavaTXCompiler INSTANCE;
 	final CompilationEnvironment environment;
 	Boolean resultmodel = true;
-    Optional<String> unificationServer = Optional.empty();
-    public final Map<File, SourceFile> sourceFiles = new HashMap<>();
+	public final Map<File, SourceFile> sourceFiles = new HashMap<>();
 
-    Boolean log = false; //gibt an ob ein Log-File nach System.getProperty("user.dir")+""/logFiles/"" geschrieben werden soll?
-	public UnifyTaskModelParallel usedTasks = new UnifyTaskModelParallel();
+	public volatile UnifyTaskModel usedTasks = new UnifyTaskModel();
 	public final DirectoryClassLoader classLoader;
 
 	public final List<File> classPath;
@@ -74,14 +89,9 @@ public class JavaTXCompiler {
 	public DirectoryClassLoader getClassLoader() {
 		return classLoader;
 	}
-   
-	public JavaTXCompiler(File sourceFile) throws IOException, ClassNotFoundException {
-		this(Arrays.asList(sourceFile), List.of(), new File("."));
-	}
 
-	public JavaTXCompiler(File sourceFile, Boolean log) throws IOException, ClassNotFoundException {
-		this(sourceFile);
-		this.log = log;
+	public JavaTXCompiler(File sourceFile) throws IOException, ClassNotFoundException {
+		this(Collections.singletonList(sourceFile), List.of(), new File("."));
 	}
 
 	public JavaTXCompiler(List<File> sourceFiles) throws IOException, ClassNotFoundException {
@@ -89,6 +99,11 @@ public class JavaTXCompiler {
 	}
 
 	public JavaTXCompiler(List<File> sources, List<File> contextPath, File outputPath) throws IOException, ClassNotFoundException {
+		// ensure new default placeholder registry for tests
+		defaultClientPlaceholderRegistry = new PlaceholderRegistry();
+		NameGenerator.reset();
+		ASTToTargetAST.OBJECT = ASTFactory.createObjectType();
+
 		var path = new ArrayList<>(contextPath);
 		if (contextPath.isEmpty()) {
 			// When no contextPaths are given, the working directory is the sources root
@@ -280,7 +295,7 @@ public class JavaTXCompiler {
 	 * x.getRhsType().accept(new distributeVariance(), a.getVariance());}); eq1 = new HashSet<>(eq); eq1.removeIf(x -> !(x.getRhsType() instanceof PlaceholderType && ((PlaceholderType)x.getRhsType()).equals(a))); eq1.stream().forEach(x -> { x.getLhsType().accept(new distributeVariance(), a.getVariance());}); phSetVariance = new ArrayList<>(phSet); phSetVariance.removeIf(x -> (x.getVariance() == 0 || usedTPH.contains(x))); } }
 	 */
 
-	public UnifyResultModelParallel typeInferenceAsync(UnifyResultListener resultListener, Writer logFile) throws ClassNotFoundException, IOException {
+	public UnifyResultModel typeInferenceAsync(UnifyResultListener resultListener, Writer logFile) throws ClassNotFoundException, IOException {
 		List<ClassOrInterface> allClasses = new ArrayList<>();// environment.getAllAvailableClasses();
 		// Alle Importierten Klassen in allen geparsten Sourcefiles kommen ins FC
 		for (Entry<File, SourceFile> source : this.sourceFiles.entrySet()) {
@@ -296,68 +311,57 @@ public class JavaTXCompiler {
 		}
 
 		Set<Set<UnifyPair>> results = new HashSet<>();
-		UnifyResultModelParallel urm = null;
+		UnifyResultModel urm = null;
 		// urm.addUnifyResultListener(resultListener);
-		try {
-			Logger logger = new Logger(true, "log_" + sourceFiles.keySet().iterator().next().getName());
-			if (logFile == null) {
-				logFile = logger.getLogFileWriter();
+		logFile = logFile == null ? new FileWriter("log_" + sourceFiles.keySet().iterator().next().getName()) : logFile;
+		Logger logger = new Logger(logFile, "TypeInferenceAsync");
+		UnifyContext context = new UnifyContext(logger, true, urm, usedTasks, defaultClientPlaceholderRegistry);
+
+		IFiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses, logger, getClassLoader(), this, context.placeholderRegistry());
+		logger.info(finiteClosure.toString());
+		urm = new UnifyResultModel(cons, finiteClosure);
+		urm.addUnifyResultListener(resultListener);
+		ConstraintSet<UnifyPair> unifyCons = UnifyTypeFactory.convert(this, cons, context.placeholderRegistry());
+
+		Function<UnifyPair, UnifyPair> distributeInnerVars = x -> {
+			UnifyType lhs, rhs;
+			if (((lhs = x.getLhsType()) instanceof PlaceholderType) && ((rhs = x.getRhsType()) instanceof PlaceholderType) && (((PlaceholderType) lhs).isInnerType() || ((PlaceholderType) rhs).isInnerType())) {
+				((PlaceholderType) lhs).setInnerType(true);
+				((PlaceholderType) rhs).setInnerType(true);
 			}
+			return x;
 
-			IFiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses, logger, getClassLoader(), this);
-			System.out.println(finiteClosure);
-			urm = new UnifyResultModelParallel(cons, finiteClosure);
-			urm.addUnifyResultListener(resultListener);
-			ConstraintSet<UnifyPair> unifyCons = UnifyTypeFactory.convert(this, cons);
-
-			Function<UnifyPair, UnifyPair> distributeInnerVars = x -> {
-				UnifyType lhs, rhs;
-				if (((lhs = x.getLhsType()) instanceof PlaceholderType) && ((rhs = x.getRhsType()) instanceof PlaceholderType) && (((PlaceholderType) lhs).isInnerType() || ((PlaceholderType) rhs).isInnerType())) {
-					((PlaceholderType) lhs).setInnerType(true);
-					((PlaceholderType) rhs).setInnerType(true);
-				}
-				return x;
-
-			};
-			logFile.write(unifyCons.toString());
-			unifyCons = unifyCons.map(distributeInnerVars);
-			logFile.write(unifyCons.toString());
-			TypeUnify unify = new TypeUnify();
-			// Set<Set<UnifyPair>> results = new HashSet<>(); Nach vorne gezogen
-			logFile.write("FC:\\" + finiteClosure.toString() + "\n");
-			for (SourceFile f : this.sourceFiles.values()) {
-				logFile.write(ASTTypePrinter.print(f));
-			}
-			logFile.flush();
-			Set<PlaceholderType> varianceTPHold;
-			Set<PlaceholderType> varianceTPH = new HashSet<>();
-			varianceTPH = varianceInheritanceConstraintSet(unifyCons);
-
-			/*
-			 * PL 2018-11-07 wird in varianceInheritanceConstraintSet erledigt do { //PL 2018-11-05 Huellenbildung Variance auf alle TPHs der Terme auf der jeweiligen //anderen Seite übertragen varianceTPHold = new HashSet<>(varianceTPH); varianceTPH = varianceInheritanceConstraintSet(unifyCons); unifyCons.map( y -> { if ((y.getLhsType() instanceof PlaceholderType) && (y.getRhsType() instanceof PlaceholderType)) { if (((PlaceholderType)y.getLhsType()).getVariance() != 0 &&
-			 * ((PlaceholderType)y.getRhsType()).getVariance() == 0) { ((PlaceholderType)y.getRhsType()).setVariance(((PlaceholderType)y.getLhsType( )).getVariance()); } if (((PlaceholderType)y.getLhsType()).getVariance() == 0 && ((PlaceholderType)y.getRhsType()).getVariance() != 0) { ((PlaceholderType)y.getLhsType()).setVariance(((PlaceholderType)y.getRhsType( )).getVariance()); } } return y; } ); } while (!varianceTPHold.equals(varianceTPH));
-			 */
-
-			// Set<Set<UnifyPair>> result = unify.unifySequential(xConsSet, finiteClosure,
-			// logFile, log);
-			// Set<Set<UnifyPair>> result = unify.unify(xConsSet, finiteClosure);
-			List<Set<Constraint<UnifyPair>>> oderConstraints = unifyCons.getOderConstraints()/*
-																								 * .stream().map(x -> { Set<Set<UnifyPair>> ret = new HashSet<>(); for (Constraint<UnifyPair> y : x) { ret.add(new HashSet<>(y)); } return ret; }).collect(Collectors. toCollection(ArrayList::new))
-																								 */;
-			unify.unifyAsync(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, logFile, log, urm, usedTasks);
-		} catch (IOException e) {
-			System.err.println("kein LogFile");
+		};
+		logger.debug(unifyCons.toString());
+		unifyCons = unifyCons.map(distributeInnerVars);
+		logger.debug(unifyCons.toString());
+		// Set<Set<UnifyPair>> results = new HashSet<>(); Nach vorne gezogen
+		logger.debug("FC:\\" + finiteClosure.toString() + "\n");
+		for (SourceFile f : this.sourceFiles.values()) {
+			logger.debug(ASTTypePrinter.print(f));
 		}
+		// logFile.flush();
+		Set<PlaceholderType> varianceTPHold;
+		Set<PlaceholderType> varianceTPH = new HashSet<>();
+		varianceTPH = varianceInheritanceConstraintSet(unifyCons);
+
+		/*
+		 * PL 2018-11-07 wird in varianceInheritanceConstraintSet erledigt do { //PL 2018-11-05 Huellenbildung Variance auf alle TPHs der Terme auf der jeweiligen //anderen Seite übertragen varianceTPHold = new HashSet<>(varianceTPH); varianceTPH = varianceInheritanceConstraintSet(unifyCons); unifyCons.map( y -> { if ((y.getLhsType() instanceof PlaceholderType) && (y.getRhsType() instanceof PlaceholderType)) { if (((PlaceholderType)y.getLhsType()).getVariance() != 0 &&
+		 * ((PlaceholderType)y.getRhsType()).getVariance() == 0) { ((PlaceholderType)y.getRhsType()).setVariance(((PlaceholderType)y.getLhsType( )).getVariance()); } if (((PlaceholderType)y.getLhsType()).getVariance() == 0 && ((PlaceholderType)y.getRhsType()).getVariance() != 0) { ((PlaceholderType)y.getLhsType()).setVariance(((PlaceholderType)y.getRhsType( )).getVariance()); } } return y; } ); } while (!varianceTPHold.equals(varianceTPH));
+		 */
+
+		// Set<Set<UnifyPair>> result = unify.unifySequential(xConsSet, finiteClosure,
+		// logFile, log);
+		// Set<Set<UnifyPair>> result = unify.unify(xConsSet, finiteClosure);
+		List<Set<Constraint<UnifyPair>>> oderConstraints = unifyCons.getOderConstraints()/*
+																							 * .stream().map(x -> { Set<Set<UnifyPair>> ret = new HashSet<>(); for (Constraint<UnifyPair> y : x) { ret.add(new HashSet<>(y)); } return ret; }).collect(Collectors. toCollection(ArrayList::new))
+																							 */;
+		TypeUnify.unifyAsync(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, context);
+
 		return urm;
 	}
 
 	public List<ResultSet> typeInference(File file) throws ClassNotFoundException, IOException {
-
-		// START create logger
-		Logger logger = new Logger(log, "log_" + sourceFiles.keySet().iterator().next().getName());
-		// END create logger
-
-		// START gather classes and interfaces
 		var sf = sourceFiles.get(file);
 		Set<ClassOrInterface> allClasses = new HashSet<>();// environment.getAllAvailableClasses();
 		allClasses.addAll(getAvailableClasses(sf));
@@ -370,56 +374,116 @@ public class JavaTXCompiler {
 			if (allClasses.stream().noneMatch(old -> old.getClassName().equals(clazz.getClassName())))
 				allClasses.add(clazz);
 		}
-		logger.write(ASTTypePrinter.print(sf));
-		// END gather classes and interfaces
 
-		// START create finite closure
-		IFiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses.stream().toList(), logger, classLoader, this);
-		logger.write("FC:\\" + finiteClosure.toString() + "\n");
-		// END create finite closure
+		final ConstraintSet<Pair> cons = getConstraints(file);
+		Set<Set<UnifyPair>> results = new HashSet<>();
+		PlaceholderRegistry placeholderRegistry = new PlaceholderRegistry();
 
-		// START create unify constraints
-		ConstraintSet<Pair> cons = getConstraints(file);
-		ConstraintSet<UnifyPair> unifyCons = UnifyTypeFactory.convert(this, cons);
-		logger.write("Unify:" + unifyCons.toString());
-		unifyCons = unifyCons.map(TypeInferenceHelper::distributeInnerVars);
-		logger.write("\nUnify_distributeInnerVars: " + unifyCons.toString());
-		System.out.println("xxx1");
-		// END create unify constraints
+		var logFolder = new File(System.getProperty("user.dir") + "/logFiles/");
+		if (ConsoleInterface.writeLogFiles && !logFolder.mkdirs()) throw new RuntimeException("Could not creat directoy for log files: " + logFolder);
+		Writer logFile = ConsoleInterface.writeLogFiles ? new FileWriter(new File(logFolder, "log_" + sourceFiles.keySet().iterator().next().getName())) : new OutputStreamWriter(new NullOutputStream());
+		Logger logger = new Logger(logFile, "TypeInference");
 
-		// START unused variance calculation
+		FiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses.stream().toList(), logger, classLoader, this, placeholderRegistry);
+		logger.info(finiteClosure.toString());
+		ConstraintSet<UnifyPair> unifyCons = UnifyTypeFactory.convert(this, cons, placeholderRegistry);
+		logger.info("xxx1");
+		Function<UnifyPair, UnifyPair> distributeInnerVars = x -> {
+			UnifyType lhs, rhs;
+			if (((lhs = x.getLhsType()) instanceof PlaceholderType) && ((rhs = x.getRhsType()) instanceof PlaceholderType) && (((PlaceholderType) lhs).isInnerType() || ((PlaceholderType) rhs).isInnerType())) {
+				((PlaceholderType) lhs).setInnerType(true);
+				((PlaceholderType) rhs).setInnerType(true);
+			}
+			return x;
+
+		};
+
+		logger.debug("Unify:" + unifyCons.toString());
+		logger.info("Unify:" + unifyCons.toString());
+		unifyCons = unifyCons.map(distributeInnerVars);
+		logger.debug("\nUnify_distributeInnerVars: " + unifyCons.toString());
+		// Set<Set<UnifyPair>> results = new HashSet<>(); Nach vorne gezogen
+		logger.debug("FC:\\" + finiteClosure.toString() + "\n");
+		logger.debug(ASTTypePrinter.print(sf));
+		logger.info(ASTTypePrinter.print(sf));
+		// logFile.flush();
+		logger.info("Unify nach Oder-Constraints-Anpassung:" + unifyCons.toString());
 		Set<PlaceholderType> varianceTPHold;
-		Set<PlaceholderType> varianceTPH = varianceInheritanceConstraintSet(unifyCons);
+		Set<PlaceholderType> varianceTPH = new HashSet<>();
+		varianceTPH = varianceInheritanceConstraintSet(unifyCons);
+
 		/*
 		 * PL 2018-11-07 wird in varianceInheritanceConstraintSet erledigt do { //PL 2018-11-05 Huellenbildung Variance auf alle TPHs der Terme auf der jeweiligen //anderen Seite übertragen varianceTPHold = new HashSet<>(varianceTPH); varianceTPH = varianceInheritanceConstraintSet(unifyCons); unifyCons.map( y -> { if ((y.getLhsType() instanceof PlaceholderType) && (y.getRhsType() instanceof PlaceholderType)) { if (((PlaceholderType)y.getLhsType()).getVariance() != 0 &&
 		 * ((PlaceholderType)y.getRhsType()).getVariance() == 0) { ((PlaceholderType)y.getRhsType()).setVariance(((PlaceholderType)y.getLhsType( )).getVariance()); } if (((PlaceholderType)y.getLhsType()).getVariance() == 0 && ((PlaceholderType)y.getRhsType()).getVariance() != 0) { ((PlaceholderType)y.getLhsType()).setVariance(((PlaceholderType)y.getRhsType( )).getVariance()); } } return y; } ); } while (!varianceTPHold.equals(varianceTPH));
 		 */
-		// END unused variance calculation
 
-		TypeInference typeInference = new TypeInference(
-			logger,
-			classLoader,
-			usedTasks,
-			file,
-			cons,
-			allClasses,
-			finiteClosure,
-			unifyCons
-		);
-		if (unificationServer.isPresent()) {
-			return typeInference.executeOnRemoteServer(unificationServer.get());
+		// Set<Set<UnifyPair>> result = unify.unifySequential(xConsSet, finiteClosure,
+		// logFile, log);
+		// Set<Set<UnifyPair>> result = unify.unify(xConsSet, finiteClosure);
+		List<Set<Constraint<UnifyPair>>> oderConstraints = unifyCons.getOderConstraints()// .stream().map(x -> {
+		/*
+		 * Set<Set<UnifyPair>> ret = new HashSet<>(); for (Constraint<UnifyPair> y : x) { ret.add(new HashSet<>(y)); } return ret; }).collect(Collectors.toCollection(ArrayList::new))
+		 */;
+
+		if (ConsoleInterface.unifyServerUrl.isPresent()) {
+			UnifyResultModel urm = new UnifyResultModel(cons, finiteClosure);
+			UnifyContext context = new UnifyContext(logger, true, urm, usedTasks, placeholderRegistry);
+			SocketFuture<UnifyResultPacket> future = SocketClient.execute(
+				UnifyRequestPacket.create(finiteClosure, cons, unifyCons, context.placeholderRegistry())
+			);
+			SocketClient.execute(SetAutoclosePacket.create());
+			return future.get().getResultSet(context);
 		}
 		else if (resultmodel) {
-			return typeInference.executeResultModel();
+			/* UnifyResultModel Anfang */
+			UnifyResultModel urm = new UnifyResultModel(cons, finiteClosure);
+			UnifyResultListenerImpl li = new UnifyResultListenerImpl();
+			urm.addUnifyResultListener(li);
+			UnifyContext context = new UnifyContext(logger, true, urm, usedTasks, placeholderRegistry);
+			TypeUnify.unifyParallel(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, context);
+			logger.info("RESULT Final: " + li.getResults());
+			logger.info("Constraints for Generated Generics: " + " ???");
+			logFile.write("RES_FINAL: " + li.getResults().toString() + "\n");
+			// logFile.flush();
+			return li.getResults();
 		}
+		/* UnifyResultModel End */
 		else {
-			return typeInference.executeNoResultModel();
+			// Set<Set<UnifyPair>> result = unify.unify(unifyCons.getUndConstraints(),
+			// oderConstraints, finiteClosure, logFile, log, new UnifyResultModel(cons,
+			// finiteClosure));
+			UnifyContext context = new UnifyContext(logger, false, new UnifyResultModel(cons, finiteClosure), usedTasks, placeholderRegistry);
+			Set<Set<UnifyPair>> result = TypeUnify.unifyOderConstraints(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, context);
+			logger.info("RESULT: " + result);
+			logFile.write("RES: " + result.toString() + "\n");
+			// logFile.flush();
+			results.addAll(result);
+
+			results = results.stream().map(x -> {
+				Optional<Set<UnifyPair>> res = new RuleSet(placeholderRegistry).subst(x.stream().map(y -> {
+					if (y.getPairOp() == PairOperator.SMALLERDOTWC)
+						y.setPairOp(PairOperator.EQUALSDOT);
+					return y; // alle Paare a <.? b erden durch a =. b ersetzt
+				}).collect(Collectors.toCollection(HashSet::new)));
+				if (res.isPresent()) {// wenn subst ein Erg liefert wurde was veraendert
+					return new TypeUnifyTask(context).applyTypeUnificationRules(res.get(), finiteClosure);
+				} else
+					return x; // wenn nichts veraendert wurde wird x zurueckgegeben
+			}).collect(Collectors.toCollection(HashSet::new));
+			logger.info("RESULT Final: " + results);
+			logger.info("Constraints for Generated Generics: " + " ???");
+			logger.debug("RES_FINAL: " + results.toString() + "\n");
+			// logFile.flush();
+			logger.debug("PLACEHOLDERS: " + placeholderRegistry);
+			// logFile.flush();
 		}
+
+		return results.stream().map((unifyPairs -> new ResultSet(UnifyTypeFactory.convert(unifyPairs, Pair.generateTPHMap(cons), placeholderRegistry)))).collect(Collectors.toList());
 	}
 
 	/**
 	 * Vererbt alle Variancen bei Paaren (a <. theta) oder (Theta <. a) wenn a eine Variance !=0 hat auf alle Typvariablen in Theta.
-	 *
+	 * 
 	 *
 	 */
 	private Set<PlaceholderType> varianceInheritanceConstraintSet(ConstraintSet<UnifyPair> cons) {
@@ -546,10 +610,6 @@ public class JavaTXCompiler {
 		}
 	}
 
-	/**
-	 * @param path - output-Directory can be null, then class file output is in the same directory as the parsed source files
-	 * @return
-	 */
 	public Map<JavaClassName, byte[]> generateBytecode(File sourceFile) throws ClassNotFoundException, IOException {
 		var sf = sourceFiles.get(sourceFile);
 		if (sf.isGenerated()) return null;
@@ -604,15 +664,15 @@ public class JavaTXCompiler {
 		FileOutputStream output;
 		for (JavaClassName name : classFiles.keySet()) {
 			byte[] bytecode = classFiles.get(name);
-			System.out.println("generating " + name + ".class file ...");
+			defaultLogger.info("generating " + name + ".class file ...");
 			var subPath = preserveHierarchy ? path : Path.of(path.toString(), name.getPackageName().split("\\.")).toFile();
 			File outputFile = new File(subPath, name.getClassName() + ".class");
 			outputFile.getAbsoluteFile().getParentFile().mkdirs();
-			System.out.println(outputFile);
+			defaultLogger.info(outputFile.toString());
 			output = new FileOutputStream(outputFile);
 			output.write(bytecode);
 			output.close();
-			System.out.println(name + ".class file generated");
+			defaultLogger.success(name + ".class file generated");
 		}
 	}
 

src/main/java/de/dhbwstuttgart/core/JavaTXServer.java

@@ -4,12 +4,28 @@ import de.dhbwstuttgart.server.SocketServer;
 
 public class JavaTXServer {
 
-  JavaTXServer(int port) {
-    try {
-      SocketServer socketServer = new SocketServer(port);
-      socketServer.start();
-    } catch (Exception e) {
-      e.printStackTrace();
-    }
+  public static boolean isRunning = false;
+
+  final SocketServer socketServer;
+
+  public JavaTXServer(int port) {
+    this.socketServer = new SocketServer(port);
   }
+
+  public void listen() {
+    isRunning = true;
+    socketServer.start();
+  }
+
+  public void forceStop() {
+    try {
+      socketServer.stop();
+    }
+    catch (InterruptedException exception) {
+      System.err.println("Interrupted socketServer: " + exception);
+    }
+    isRunning = false;
+  }
+
+
 }

src/main/java/de/dhbwstuttgart/environment/CompilationEnvironment.java

@@ -1,5 +1,11 @@
 package de.dhbwstuttgart.environment;
 
+import java.io.File;
+import java.io.IOException;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.*;
+
 import com.google.common.collect.Lists;
 import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
@@ -12,17 +18,6 @@ import de.dhbwstuttgart.parser.antlr.Java17Parser.SourceFileContext;
 import de.dhbwstuttgart.parser.antlr.Java17Parser.SrcfileContext;
 import de.dhbwstuttgart.parser.scope.GatherNames;
 import de.dhbwstuttgart.parser.scope.JavaClassRegistry;
-import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
-import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
-import org.antlr.v4.runtime.tree.TerminalNode;
-
-import java.io.File;
-import java.io.IOException;
-import java.net.MalformedURLException;
-import java.net.URL;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
 
 /**
  * Stellt die Java-Environment dar und speichert alle Binarys, Librarys und Sourcefiles im zu kompilierenden Projekt Sie erstellt anhand dieser Informationen die JavaClassNameRegistry
@@ -36,7 +31,7 @@ public class CompilationEnvironment {
 
 	/**
 	 * Imitiert die Environment beim Aufruf des JavaCompilers auf einer Menge von java-Dateien Die Environment enth<74>lt automatisch die Java Standard Library
-	 *
+	 * 
 	 * @param sourceFiles die zu kompilierenden Dateien
 	 */
 	public CompilationEnvironment(List<File> sourceFiles, DirectoryClassLoader classLoader) {

src/main/java/de/dhbwstuttgart/exceptions/UnifyCancelException.java

@@ -0,0 +1,11 @@
+package de.dhbwstuttgart.exceptions;
+
+
+/**
+ * Eine Runtime Exception, die für den Fall genutzt wird, dass eine Unifikation abgebrochen wird.
+ * Durch das Werfen einer Exception können Abbrüche auch aus Methodenaufrufen heraus
+ * geprüft werden, da zuvor nur ein return X; stattfinden würde.
+ */
+public class UnifyCancelException extends RuntimeException {
+
+}

src/main/java/de/dhbwstuttgart/parser/JavaTXParser.java

@@ -7,16 +7,20 @@ import de.dhbwstuttgart.parser.antlr.Java17Parser;
 import de.dhbwstuttgart.parser.scope.JavaClassRegistry;
 import de.dhbwstuttgart.syntaxtree.SourceFile;
 
+import de.dhbwstuttgart.util.Logger;
 import org.antlr.v4.runtime.CharStream;
 import org.antlr.v4.runtime.CharStreams;
 import org.antlr.v4.runtime.CommonTokenStream;
 
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.IOException;
-import java.io.InputStream;
+import java.io.*;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
 
 public class JavaTXParser {
+
+    public static Logger logger = new Logger("Parser");
+
     public static Java17Parser.SourceFileContext parse(File source) throws IOException, java.lang.ClassNotFoundException {
         InputStream stream = new FileInputStream(source);
         // DEPRECATED: ANTLRInputStream input = new ANTLRInputStream(stream);

src/main/java/de/dhbwstuttgart/parser/SourceLoc.java

@@ -1,4 +1,25 @@
 package de.dhbwstuttgart.parser;
 
-public record SourceLoc(String file, int line) {
+import de.dhbwstuttgart.server.packet.dataContainers.ISerializableData;
+import de.dhbwstuttgart.server.packet.dataContainers.KeyStorage;
+import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialMap;
+
+public record SourceLoc(String file, int line) implements ISerializableData {
+
+
+  @Override
+  public SerialMap toSerial(KeyStorage keyStorage) {
+    var serialized = new SerialMap();
+    serialized.put("file", file);
+    serialized.put("line", line);
+    return serialized;
+  }
+
+  public static SourceLoc fromSerial(SerialMap data) {
+    return new SourceLoc(
+      data.getValue("file").getOf(String.class),
+      data.getValue("line").getOf(Integer.class)
+    );
+  }
+
 }

src/main/java/de/dhbwstuttgart/parser/SyntaxTreeGenerator/AssignToLocal.java

@@ -2,6 +2,7 @@ package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
 
 import de.dhbwstuttgart.syntaxtree.StatementVisitor;
 import de.dhbwstuttgart.syntaxtree.statement.AssignLeftSide;
+import de.dhbwstuttgart.syntaxtree.statement.Expression;
 import de.dhbwstuttgart.syntaxtree.statement.LocalVar;
 
 public class AssignToLocal extends AssignLeftSide {
@@ -16,4 +17,4 @@ public class AssignToLocal extends AssignLeftSide {
     public void accept(StatementVisitor visitor) {
         visitor.visit(this);
     }
-}
+}

src/main/java/de/dhbwstuttgart/parser/SyntaxTreeGenerator/FCGenerator.java

@@ -12,12 +12,14 @@ import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 import de.dhbwstuttgart.syntaxtree.factory.UnifyTypeFactory;
 import de.dhbwstuttgart.syntaxtree.type.*;
 import de.dhbwstuttgart.typeinference.constraints.Pair;
-import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
-import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
+import de.dhbwstuttgart.typeinference.unify.PlaceholderRegistry;
+import de.dhbwstuttgart.typeinference.unify.model.*;
 
 import java.util.*;
 import java.util.stream.Collectors;
 
+import org.antlr.v4.runtime.Token;
+
 public class FCGenerator {
     /**
      * Baut die FiniteClosure aus availableClasses.
@@ -25,19 +27,24 @@ public class FCGenerator {
      *
      * @param availableClasses - Alle geparsten Klassen
      */
-    public static Set<UnifyPair> toUnifyFC(JavaTXCompiler compiler, Collection<ClassOrInterface> availableClasses, ClassLoader classLoader) throws ClassNotFoundException {
-        return toFC(availableClasses, classLoader).stream().map(t -> UnifyTypeFactory.convert(compiler, t)).collect(Collectors.toSet());
+    public static Set<UnifyPair> toUnifyFC(JavaTXCompiler compiler, Collection<ClassOrInterface> availableClasses, ClassLoader classLoader, PlaceholderRegistry placeholderRegistry) throws ClassNotFoundException {
+        return toFC(
+          availableClasses,
+          classLoader,
+          placeholderRegistry
+        ).stream().map(t -> UnifyTypeFactory.convert(compiler, t, placeholderRegistry))
+          .collect(Collectors.toSet());
     }
 
-    public static Set<Pair> toFC(Collection<ClassOrInterface> availableClasses, ClassLoader classLoader) throws ClassNotFoundException {
+    public static Set<Pair> toFC(Collection<ClassOrInterface> availableClasses, ClassLoader classLoader, PlaceholderRegistry placeholderRegistry) throws ClassNotFoundException {
         HashSet<Pair> pairs = new HashSet<>();
         //PL 2018-09-18: gtvs vor die for-Schleife gezogen, damit immer die gleichen Typeplaceholder eingesetzt werden.
         HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> gtvs = new HashMap<>();
         for(ClassOrInterface cly : availableClasses){
-        	List<Pair> newPairs = getSuperTypes(cly, availableClasses, gtvs, classLoader);
+        	List<Pair> newPairs = getSuperTypes(cly, availableClasses, gtvs, classLoader, placeholderRegistry);
             pairs.addAll(newPairs);
-
-            //For all Functional Interfaces FI: FunN$$<... args auf dem Functional Interface ...> <. FI is added to FC
+            
+            //For all Functional Interfaces FI: FunN$$<... args auf dem Functional Interface ...> <. FI is added to FC 
             if (isFunctionalInterface(cly)) {
             	pairs.add(genImplFunType(cly, newPairs.get(0).TA1, gtvs));
             }
@@ -47,19 +54,19 @@ public class FCGenerator {
     
     
     private static Boolean isFunctionalInterface(ClassOrInterface cly)	{
-    	return (cly.isInterface() && (cly.isFunctionalInterface() || cly.getMethods().size() == 1));
+    	return (cly.isInterface() && (cly.isFunctionalInterface() || cly.getMethods().size() == 1)); 
     }
-
+    
     private static Pair genImplFunType(ClassOrInterface cly, RefTypeOrTPHOrWildcardOrGeneric fIType, HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> gtvs) {
     	for(Method m : cly.getMethods()) {
     		if (!java.lang.reflect.Modifier.isAbstract(m.modifier))
     			continue;
-    		List<RefTypeOrTPHOrWildcardOrGeneric> tl =
+    		List<RefTypeOrTPHOrWildcardOrGeneric> tl = 
     				(m.getParameterList().getFormalparalist()
     						.stream().map(p -> p.getType().acceptTV(new TypeExchanger(gtvs)))
     						.collect(Collectors.toList()));
     		tl.add(m.getReturnType().acceptTV(new TypeExchanger(gtvs)));
-    		return new Pair(new RefType(new JavaClassName("Fun" + (tl.size()-1) + "$$"), tl, new NullToken()),
+    		return new Pair(new RefType(new JavaClassName("Fun" + (tl.size()-1) + "$$"), tl, new NullToken()), 
     					    fIType, PairOperator.SMALLER);
     	}
     	return null; //kann nicht passieren, da die Methode nur aufgerufen wird wenn cl Functional Interface ist
@@ -74,8 +81,13 @@ public class FCGenerator {
      * @param forType
      * @return
      */
-    private static List<Pair> getSuperTypes(ClassOrInterface forType, Collection<ClassOrInterface> availableClasses, ClassLoader classLoader) throws ClassNotFoundException {
-        return getSuperTypes(forType, availableClasses, new HashMap<>(), classLoader);
+    private static List<Pair> getSuperTypes(
+      ClassOrInterface forType,
+      Collection<ClassOrInterface> availableClasses,
+      ClassLoader classLoader,
+      PlaceholderRegistry placeholderRegistry
+    ) throws ClassNotFoundException {
+        return getSuperTypes(forType, availableClasses, new HashMap<>(), classLoader, placeholderRegistry);
     }
 
     /**
@@ -86,8 +98,13 @@ public class FCGenerator {
      * @return
      * @throws ClassNotFoundException
      */
-    private static List<Pair> getSuperTypes(ClassOrInterface forType, Collection<ClassOrInterface> availableClasses,
-                                            HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> gtvs, ClassLoader classLoader) throws ClassNotFoundException {
+    private static List<Pair> getSuperTypes(
+      ClassOrInterface forType,
+      Collection<ClassOrInterface> availableClasses,
+      HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> gtvs,
+      ClassLoader classLoader,
+      PlaceholderRegistry placeholderRegistry
+    ) throws ClassNotFoundException {
         List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
         //Die GTVs, die in forType hinzukommen:
         HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> newGTVs = new HashMap<>();
@@ -146,7 +163,7 @@ public class FCGenerator {
             if(superClass.getClassName().equals(ASTFactory.createObjectClass().getClassName())){
                 superTypes = Arrays.asList(new Pair(ASTFactory.createObjectType(), ASTFactory.createObjectType(), PairOperator.SMALLER));
             }else{
-                superTypes = getSuperTypes(superClass, availableClasses, newGTVs, classLoader);
+                superTypes = getSuperTypes(superClass, availableClasses, newGTVs, classLoader, placeholderRegistry);
             }
 
             retList.add(ret);
@@ -201,7 +218,7 @@ public class FCGenerator {
         }
 
     }
-
+    
     /**
      * Tauscht die GTVs in einem Typ gegen die entsprechenden Typen in der übergebenen Map aus auf den Argumenten der Argumente.
      * Hier sind Wildcards zulässig
@@ -247,5 +264,5 @@ public class FCGenerator {
         }
 
     }
-
+    
 }

src/main/java/de/dhbwstuttgart/parser/SyntaxTreeGenerator/StatementGenerator.java

@@ -1,5 +1,6 @@
 package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
 
+import de.dhbwstuttgart.parser.JavaTXParser;
 import java.lang.reflect.Modifier;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -149,11 +150,11 @@ public class StatementGenerator {
                     type = TypeGenerator.convert(fp.typeType(), reg, generics);
                 } else {
                 	type = methodparameters?
-                			TypePlaceholder.fresh(fp.getStart(), 1, false)
+                			TypePlaceholder.fresh(fp.getStart(), 1, false) 
                 			: TypePlaceholder.fresh(fp.getStart());
                 }
                 ret.add(new FormalParameter(paramName, type, fp.getStart()));
-                localVars.put(paramName, type);
+                localVars.put(paramName, type); 
             }
         }
         return new ParameterList(ret, ret.get(0).getOffset());
@@ -259,7 +260,7 @@ public class StatementGenerator {
             ret.setStatement();
             return ret;
         default:
-            System.out.println(stmt.getClass());
+            JavaTXParser.logger.info(stmt.getClass());
             throw new NotImplementedException();
         }
     }

src/main/java/de/dhbwstuttgart/parser/SyntaxTreeGenerator/SyntacticSugar.java

@@ -1,7 +1,9 @@
 package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
 
+import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.syntaxtree.AbstractASTWalker;
+import de.dhbwstuttgart.syntaxtree.Constructor;
 import de.dhbwstuttgart.syntaxtree.statement.*;
 
 import java.util.List;

src/main/java/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java

@@ -14,7 +14,12 @@ import de.dhbwstuttgart.parser.scope.JavaClassRegistry;
 import de.dhbwstuttgart.syntaxtree.GenericDeclarationList;
 import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
-import de.dhbwstuttgart.syntaxtree.type.*;
+import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
+import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
+import de.dhbwstuttgart.syntaxtree.type.RefType;
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import org.antlr.v4.runtime.Token;
 
 import java.util.ArrayList;
@@ -69,7 +74,7 @@ public class TypeGenerator {
                 throw new NotImplementedException();
             }
         } else if (!typeContext.LBRACK().isEmpty()) { // ArrayType über eckige Klammer prüfen
-            // System.out.println(unannTypeContext.getText());
+            // JavaTXParser.logger.info(unannTypeContext.getText());
             throw new NotImplementedException();
         }
         /*

src/main/java/de/dhbwstuttgart/parser/scope/GatherNames.java

@@ -164,4 +164,4 @@ public class GatherNames {
 		}
 		return pkgName;
 	}
-}
+}

src/main/java/de/dhbwstuttgart/parser/scope/JavaClassRegistry.java

@@ -2,10 +2,7 @@ package de.dhbwstuttgart.parser.scope;
 
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 
 /**
  * Speichert die Klassen f<>r einen bestimmten Projektscope
@@ -65,4 +62,4 @@ public class JavaClassRegistry {
     public int getNumberOfGenerics(String name) {
         return existingClasses.get(new JavaClassName(name));
     }
-}
+}

src/main/java/de/dhbwstuttgart/server/ServerTaskLogger.java

@@ -0,0 +1,41 @@
+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 {
+
+  private final WebSocket webSocket;
+  private final SocketServer socketServer;
+  private final LogLevel customLogLevel;
+
+  public ServerTaskLogger(WebSocket webSocket, SocketServer socketServer, LogLevel customLogLevel) {
+    this.webSocket = webSocket;
+    this.socketServer = socketServer;
+    this.customLogLevel = customLogLevel;
+  }
+
+  @Override
+  public boolean isLogLevelActive(LogLevel logLevel) {
+    return logLevel.isHigherOrEqualTo(customLogLevel);
+  }
+
+  @Override
+  protected void print(String s, LogLevel logLevel) {
+    String coloredPrefix = this.getPrefix(logLevel);
+    if (logLevel.isHigherOrEqualTo(LogLevel.ERROR)) {
+      socketServer.sendError(webSocket, coloredPrefix + s, false);
+    }
+    else {
+      socketServer.sendMessage(webSocket, coloredPrefix + s);
+    }
+  }
+
+  @Override
+  protected void write(String s) {
+    // under no circumstances write anything to a file
+  }
+
+}

src/main/java/de/dhbwstuttgart/server/SocketClient.java

@@ -1,20 +1,25 @@
 package de.dhbwstuttgart.server;
 
 import com.fasterxml.jackson.core.JsonProcessingException;
-import de.dhbwstuttgart.server.packet.ErrorPacket;
+import de.dhbwstuttgart.core.ConsoleInterface;
+import de.dhbwstuttgart.server.packet.IClientToServerPacket;
 import de.dhbwstuttgart.server.packet.IPacket;
-import de.dhbwstuttgart.server.packet.InvalidPacket;
-import de.dhbwstuttgart.server.packet.MessagePacket;
+import de.dhbwstuttgart.server.packet.IServerToClientPacket;
 import de.dhbwstuttgart.server.packet.PacketContainer;
 import de.dhbwstuttgart.server.packet.UnifyRequestPacket;
 import de.dhbwstuttgart.server.packet.UnifyResultPacket;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import de.dhbwstuttgart.typeinference.constraints.Pair;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
-import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
+import de.dhbwstuttgart.typeinference.unify.UnifyContext;
+import de.dhbwstuttgart.typeinference.unify.model.FiniteClosure;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
+import de.dhbwstuttgart.util.Logger;
 import java.net.URI;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CountDownLatch;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -28,35 +33,34 @@ import org.java_websocket.handshake.ServerHandshake;
  */
 public class SocketClient extends WebSocketClient {
 
-  // use a latch to wait until the connection is closed by the remote host
-  private final CountDownLatch closeLatch = new CountDownLatch(1);
-  // temporarily: The received unify result packet
-  private UnifyResultPacket unifyResultPacket = null;
+  public static Logger logger = new Logger("SocketClient");
 
-  public SocketClient(String url) {
-    super(URI.create(url));
-    // make sure, the url is in a valid format
+  /**
+   * The singleton object
+   */
+  private static SocketClient socketClient = null;
+
+  /**
+   * List of futures that are still waiting to be fulfilled
+   */
+  private final Map<String, SocketFuture<?>> responseFutures = new HashMap<>();
+
+  private SocketClient(String url) {
+    super(
+      URI.create(url), // target url
+      //SocketServer.perMessageDeflateDraft, // enable compression
+      Map.of( // headers
+        "packetProtocolVersion", SocketServer.packetProtocolVersion
+      )
+    );
+
+    // make sure the url is in a valid format
     final String regex = "^wss?://(\\w+(\\.\\w+)?)*:(\\d+)$";
     final Matcher matcher = Pattern.compile(regex).matcher(url);
     if (!matcher.find()) {
       throw new RuntimeException("Provided string \"" + url + "\" is not a valid server URL! Use pattern ws(s?)://<host.name>:<port>");
     }
-  }
 
-  public SocketClient(String host, int port, boolean secure) {
-    super(URI.create(String.format("%s://%s:%d/", secure ? "wss" : "ws", host, port)));
-  }
-
-  /**
-   * The main method for connecting, requesting and waiting for the server to unify.
-   * This is synchronized to prevent multiple webSockets connections at the moment, but it is not called from any
-   * thread except the main thread right now and is not necessary at all, probably. Maybe remove it later
-   */
-  synchronized public List<ResultSet> execute(
-    IFiniteClosure finiteClosure,
-    ConstraintSet<Pair> constraints,
-    ConstraintSet<UnifyPair> unifyConstraints
-  ) {
     try {
       // wait for the connection to be set up
       this.connectBlocking();
@@ -64,80 +68,135 @@ public class SocketClient extends WebSocketClient {
       if (this.getReadyState() != ReadyState.OPEN) {
         throw new RuntimeException("WebSocket Client could not connect to remote host at " + this.uri);
       }
-
-      // send the unify task request
-      UnifyRequestPacket packet = UnifyRequestPacket.create(finiteClosure, constraints, unifyConstraints);
-      String json = PacketContainer.serialize(packet);
-      this.send(json);
-
-      // block the thread, until the connection is closed by the remote host (usually after sending the results)
-      this.waitUntilClosed();
-      // wait for the connection to fully close
-      this.closeBlocking();
     } catch (InterruptedException exception) {
-      System.err.println("Interrupted: " + exception);
-      this.notifyAll();
-      throw new RuntimeException("Remote unification failed: " + exception);
-    } catch (JsonProcessingException exception) {
-      System.err.println("JSON processing exception: " + exception);
-      this.notifyAll();
-      throw new RuntimeException("Remote unification failed: " + exception);
+      throw new RuntimeException(exception);
     }
 
-    // detect error cases, in which no error was thrown, but also no result was sent back from the server
-    if (this.unifyResultPacket == null) {
-      throw new RuntimeException("Did not receive server response but closed connection already");
-    }
+    // add a shutdown hook to close the connection when the process ends or is stopped by a SIGINT signal
+    Runtime.getRuntime().addShutdownHook(new Thread(this::close));
+  }
 
-    return unifyResultPacket.getResultSet();
+  private SocketClient(String host, int port, boolean secure) throws InterruptedException {
+    this(String.format("%s://%s:%d/", secure ? "wss" : "ws", host, port));
   }
 
   /**
-   *  Specific client-side implementations to handle incomming packets
+   * Singleton access method, creates one if none is available
+   *
+   * @return The one and only socketClient
+   */
+  private static SocketClient initializeClient() {
+    if (socketClient == null) {
+      socketClient = new SocketClient(ConsoleInterface.unifyServerUrl.get());
+    }
+    return socketClient;
+  }
+
+  /**
+   * Send a packet to the server (connection will be created, if none is found) and return a future
+   * for the response packet
+   */
+  synchronized public static <T extends IServerToClientPacket> SocketFuture<T> execute(IClientToServerPacket<T> packet) {
+    SocketClient client = initializeClient();
+
+    /*
+     * Create a future that will be associated with the packet and eventually completed
+     */
+    SocketFuture<T> future = packet.getFuture();
+    if (!future.isDone()) {
+      client.responseFutures.put(future.futureId, future);
+    }
+
+    /*
+     * Establish connection, if not already done.
+     * Serialize the packet and send it to the server.
+     * Return the future to be handled by the caller.
+     */
+    try {
+      String json = PacketContainer.serialize(packet);
+      client.send(json);
+    } catch (Exception exception) {
+      logger.exception(exception);
+      throw new RuntimeException("Exception occurred in server connection: ", exception);
+    }
+
+    return future;
+  }
+
+  /**
+   * Shortcut for waiting and retrieving the response immediately
+   *
+   * @param packet The packet to send
+   * @param <T>    The type of response packet to await
+   * @return The response packet, once it is received
+   */
+  public static <T extends IServerToClientPacket> T executeAndGet(IClientToServerPacket<T> packet) {
+    return SocketClient.execute(packet).get();
+  }
+
+  /**
+   * Specific client-side implementations to handle incoming packets
    */
   protected void handleReceivedPacket(IPacket packet) {
-    if (packet instanceof InvalidPacket) {
-      System.err.println("[socket] " + ((InvalidPacket) packet).error);
-    } else if (packet instanceof MessagePacket) {
-      System.out.println("[socket] " + ((MessagePacket) packet).message);
-    } else if (packet instanceof ErrorPacket) {
-      System.err.println("[socket] " + ((ErrorPacket) packet).error);
-    } else if (packet instanceof UnifyResultPacket) {
-      System.out.println("[socket] Received unify result");
-      unifyResultPacket = (UnifyResultPacket) packet;
+    if (!(packet instanceof IServerToClientPacket serverToClientPacket)) {
+      System.err.println("Received package of invalid type + " + packet.getClass().getName());
+      this.close();
+      return;
+    }
+
+    serverToClientPacket.onHandle(this.getConnection(), this);
+  }
+
+  /**
+   * Complete a registered future, so it can be handled by whoever executed the creator task
+   *
+   * @param id      The associated id for this future
+   * @param trigger The object triggering the completion
+   */
+  public void completeResponseFuture(String id, IServerToClientPacket trigger) {
+    SocketFuture<?> future = this.responseFutures.remove(id);
+    if (future == null) return;
+    if (!future.accept(trigger)) {
+      throw new RuntimeException("Packet " + trigger.getClass().getName() + " tried to complete future, but was not allowed to");
+    }
+  }
+
+  public static void closeIfOpen() {
+    if (socketClient != null && socketClient.isOpen()) {
+      socketClient.close();
     }
   }
 
   @Override
   public void onOpen(ServerHandshake handshakedata) {
-    System.out.println("Connected to server with status " + handshakedata.getHttpStatus());
+    logger.success("Connected to server with status " + handshakedata.getHttpStatus());
   }
 
   @Override
   public void onMessage(String message) {
-    // System.out.println("received: " + message);
+    // logger.info("received: " + message);
     IPacket packet = PacketContainer.deserialize(message);
     this.handleReceivedPacket(packet);
   }
 
   @Override
   public void onClose(int code, String reason, boolean remote) {
-    System.out.println(
+    logger.info(
       "Disconnected from server " +
         "with code " + code + " " +
         (reason.isEmpty() ? "" : "and reason " + reason + " ") +
         "(closed by remote: " + remote + ")"
     );
-    this.closeLatch.countDown();
+
+    if (!this.responseFutures.isEmpty()) {
+      throw new RuntimeException("Server closed before all required tasks were answered");
+    }
   }
 
   @Override
   public void onError(Exception e) {
-    System.out.println("Error: " + e.getMessage());
-    e.printStackTrace();
+    logger.exception(e);
+    throw new RuntimeException(e);
   }
 
-  public void waitUntilClosed() throws InterruptedException {
-    closeLatch.await();
-  }
 }

src/main/java/de/dhbwstuttgart/server/SocketData.java

@@ -1,17 +0,0 @@
-package de.dhbwstuttgart.server;
-
-/**
- * The data that is associated server-side with any connected client.
- * This makes it possible to store information that can be mapped to any existing connection.
- */
-public class SocketData {
-
-  public final String id;
-  // used for the timeout of 10 seconds, until an unused open connection is automatically closed
-  public boolean hasSentTask = false;
-
-  public SocketData(String id) {
-    this.id = id;
-  }
-
-}

src/main/java/de/dhbwstuttgart/server/SocketFuture.java

@@ -0,0 +1,48 @@
+package de.dhbwstuttgart.server;
+
+import de.dhbwstuttgart.server.packet.IServerToClientPacket;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+
+public class SocketFuture<T extends IServerToClientPacket> extends CompletableFuture<T> {
+
+  public final String futureId = UUID.randomUUID().toString();
+
+  public final List<Class<T>> allowedTriggers;
+
+  public SocketFuture(List<Class<T>> allowedTriggers) {
+    this.allowedTriggers = allowedTriggers;
+  }
+
+  public boolean accept(IServerToClientPacket trigger) {
+    if (this.allowedTriggers.contains(trigger.getClass())) {
+      this.complete((T)trigger);
+      return true;
+    }
+    return false;
+  }
+
+  @Override
+  public T get() {
+    try {
+      return super.get();
+    }
+    catch (InterruptedException | ExecutionException exception) {
+      throw new RuntimeException(exception);
+    }
+  }
+
+  /**
+   * Special case where the future is immediately fulfilled without a response package similar to
+   * <code>CompletableFuture.completedFuture()</code> but without a value
+   */
+  public static <R extends IServerToClientPacket> SocketFuture<R> completedFuture() {
+    SocketFuture<R> dummyFuture = new SocketFuture<>(new ArrayList<>(0));
+    dummyFuture.complete(null);
+    return dummyFuture;
+  }
+
+}

src/main/java/de/dhbwstuttgart/server/SocketServer.java

@@ -1,65 +1,119 @@
 package de.dhbwstuttgart.server;
 
+import com.fasterxml.jackson.core.JsonProcessingException;
+import de.dhbwstuttgart.server.packet.ErrorPacket;
+import de.dhbwstuttgart.server.packet.IClientToServerPacket;
 import de.dhbwstuttgart.server.packet.IPacket;
 import de.dhbwstuttgart.server.packet.MessagePacket;
 import de.dhbwstuttgart.server.packet.PacketContainer;
-import de.dhbwstuttgart.server.packet.UnifyRequestPacket;
-import de.dhbwstuttgart.server.packet.UnifyResultPacket;
-import de.dhbwstuttgart.typeinference.TypeInference;
-import de.dhbwstuttgart.typeinference.result.ResultSet;
-import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
+import de.dhbwstuttgart.util.Logger;
 import java.net.InetSocketAddress;
-import java.util.List;
+import java.util.Collections;
 import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Executor;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.SynchronousQueue;
+import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
 import org.java_websocket.WebSocket;
+import org.java_websocket.drafts.Draft;
+import org.java_websocket.drafts.Draft_6455;
+import org.java_websocket.extensions.permessage_deflate.PerMessageDeflateExtension;
 import org.java_websocket.handshake.ClientHandshake;
 import org.java_websocket.server.WebSocketServer;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 public class SocketServer extends WebSocketServer {
 
-  private static final Logger log = LoggerFactory.getLogger(SocketServer.class);
+  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.
+   * This will prevent errors when the server version and client version do not match.
+   */
+  public static final String packetProtocolVersion = "1";
+
+  // create an executor for tasks that will always keep at least one task around
+  private final ThreadPoolExecutor taskExecutor = new ThreadPoolExecutor(1, Integer.MAX_VALUE,60L, TimeUnit.SECONDS, new SynchronousQueue<>());
+  // create an executor for scheduling timeouts
+  private final ScheduledExecutorService timeoutExecutor = Executors.newSingleThreadScheduledExecutor();
 
   public SocketServer(int port) {
     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);
+        webSocket.close();
+      }
+      this.stop();
+      taskExecutor.shutdown();
+      timeoutExecutor.shutdown();
+    } catch (InterruptedException exception) {
+      // we are shutting down anyway
+    }
   }
 
   @Override
   public void onOpen(WebSocket webSocket, ClientHandshake clientHandshake) {
-    System.out.println("New connection: " + webSocket.getResourceDescriptor());
-    webSocket.setAttachment(new SocketData(UUID.randomUUID().toString()));
+    String ppv = clientHandshake.getFieldValue("packetProtocolVersion");
+    if (!ppv.equals(packetProtocolVersion)) {
+      this.sendError(webSocket,
+        "Mismatch in packet protocol version! Client (you): \"" + ppv + "\" and Server (me): \"" + packetProtocolVersion + "\"",
+        true
+      );
+      webSocket.close(1);
+      return;
+    }
+
+    SocketData socketData = new SocketData(webSocket);
+    logger.info("New connection: " + socketData.id + " (with ppv " + ppv + ")");
 
     try {
       sendMessage(webSocket, "Welcome to the server!");
 
-      // wait 10 seconds for the client to send a task and close the connection, if nothing has been received until then
-      ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
-      Runnable task = () -> {
-        if (webSocket.<SocketData>getAttachment().hasSentTask || !webSocket.isOpen()) {
-          return;
-        }
-        sendMessage(webSocket, "No task received after 10 seconds. Closing connection...");
-        webSocket.close();
-      };
-      executor.schedule(task, 10, TimeUnit.SECONDS);
-      executor.shutdown();
+      // 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().totalTasks.get() > 0 || !webSocket.isOpen()) {
+            return;
+          }
+          sendMessage(webSocket, "No task received after " + secondsUntilTimeout + " seconds. Closing connection...");
+          webSocket.close();
+        },
+        secondsUntilTimeout,
+        TimeUnit.SECONDS
+      );
 
       // and finally, when your program wants to exit
     } catch (Exception e) {
-      log.error("e: ", e);
+      logger.exception(e);
       webSocket.close(1, e.getMessage());
     }
   }
 
   @Override
   public void onClose(WebSocket webSocket, int code, String reason, boolean remote) {
-    System.out.println("Connection closed: " + webSocket.getResourceDescriptor());
-    System.out.println(
-      "Disconnected client " + webSocket.getResourceDescriptor() + " " +
+    SocketData socketData = webSocket.getAttachment();
+    logger.info("Connection closed: " + socketData.id);
+    logger.info(
+      "Disconnected client " + socketData.id + " " +
         "with code " + code + " " +
         (reason.isEmpty() ? "" : "and reason " + reason + " ") +
         "(closed by client: " + remote + ")"
@@ -69,19 +123,28 @@ public class SocketServer extends WebSocketServer {
 
   @Override
   public void onMessage(WebSocket webSocket, String s) {
-    // System.out.println("Received: " + s.substring(0, 50));
+    // logger.info("Received: " + s.substring(0, 50));
     IPacket reconstructedPacket = PacketContainer.deserialize(s);
-    this.onPacketReceived(webSocket, reconstructedPacket);
+    try {
+      this.onPacketReceived(webSocket, reconstructedPacket);
+    } catch (JsonProcessingException e) {
+      logger.exception(e);
+      this.log(webSocket, "Error on processing incoming package: " + e.getMessage());
+    }
   }
 
   @Override
   public void onError(WebSocket webSocket, Exception e) {
-    webSocket.close();
+    if (webSocket != null) {
+      log(webSocket, e.getMessage());
+      webSocket.close();
+    }
+    logger.exception(e);
   }
 
   @Override
   public void onStart() {
-    System.out.println("Websocket server started");
+    logger.success("Websocket server started on port " + this.getPort());
   }
 
   /**
@@ -89,50 +152,84 @@ public class SocketServer extends WebSocketServer {
    */
   public void sendMessage(WebSocket webSocket, String text) {
     try {
-      MessagePacket message = new MessagePacket();
-      message.message = text;
+      MessagePacket message = MessagePacket.create(text);
       webSocket.send(PacketContainer.serialize(message));
     } catch (Exception e) {
       System.err.println("Failed to send message: " + text);
-      System.err.println(e);
+      logger.exception(e);
     }
   }
 
   /**
-   *  The server-side implementation on how to handle certain packets when received
+   * A shorthand method for sending error messages to the client
    */
-  private void onPacketReceived(WebSocket webSocket, IPacket packet) {
-    if (packet instanceof UnifyRequestPacket unifyRequestPacket) {
+  public void sendError(WebSocket webSocket, String text, boolean isFatal) {
+    try {
+      ErrorPacket error = ErrorPacket.create(text, isFatal);
+      webSocket.send(PacketContainer.serialize(error));
+    } catch (Exception e) {
+      logger.exception(e);
+      log(webSocket, "Failed to send error: " + text);
+    }
+  }
 
-      // TODO: this static property will be a problem once we send more than one request per server and
-      //  should be replaced by a dynamic object property
-      PlaceholderType.EXISTING_PLACEHOLDERS.clear();
-      sendMessage(webSocket, "You requested a unify! Please wait until I calculated everything...");
-      System.out.println("Client " + webSocket.<SocketData>getAttachment().id + " requested a unification. Starting now...");
-      webSocket.<SocketData>getAttachment().hasSentTask = true;
-
-      try {
-        // start the unification algorithm from the received data
-        List<ResultSet> result = TypeInference.executeWithoutContext(
-          unifyRequestPacket.retrieveFiniteClosure(),
-          unifyRequestPacket.retrieveConstraints(),
-          unifyRequestPacket.retrieveUnifyConstraints()
-        );
-        System.out.println("Finished unification for client " + webSocket.<SocketData>getAttachment().id);
-        sendMessage(webSocket, "Unification finished. Found " + result.size() + " result sets");
-
-        if (webSocket.isOpen()) {
-          UnifyResultPacket resultPacket = UnifyResultPacket.create(result);
-          webSocket.send(PacketContainer.serialize(resultPacket));
-        }
-      } catch (Exception e) {
-        System.err.println(e);
-        log.error("e: ", e);
-      }
+  /**
+   * The server-side implementation on how to handle certain packets when received
+   */
+  private void onPacketReceived(WebSocket webSocket, IPacket packet) throws JsonProcessingException {
+    SocketData socketData = webSocket.getAttachment();
 
+    // limit the number of tasks per connection
+    if (socketData.totalTasks.get() >= maxTasksPerSession) {
+      sendError(webSocket, "Exceeded the maximum amount of " + maxTasksPerSession + " tasks per session", true);
       webSocket.close();
-    } else {
+      return;
+    }
+
+    // only allow packets that are meant to be handled by the server
+    if (!(packet instanceof IClientToServerPacket<?> clientToServerPacket)) {
       sendMessage(webSocket, "The package of type " + packet.getClass().getName() + " is not handled by the server!");
+      return;
+    }
+
+    // update the socket data
+    socketData.unhandledTasks.incrementAndGet();
+    socketData.totalTasks.incrementAndGet();
+
+    // add the packet to the queue so it can be started by the worker
+    CompletableFuture.runAsync(() -> {
+      clientToServerPacket.onHandle(webSocket, this);
+      int remainingUnhandledTasks = socketData.unhandledTasks.decrementAndGet();
+
+      if (socketData.closeIfNoTasksLeft) {
+        // if the websocket has 0 unhandled Tasks, close the connection
+        if (remainingUnhandledTasks <= 0) {
+          sendMessage(webSocket, "All requested tasks finished! Closing connection...");
+          webSocket.close();
+        }
+      }
+    }, taskExecutor);
+  }
+
+  public void log(WebSocket webSocket, String msg) {
+    String socketId = (webSocket == null) ? "???" : webSocket.<SocketData>getAttachment().id;
+    logger.info("[" + socketId + "] " + msg);
+  }
+
+  /**
+   * The data that is associated server-side with any connected client.
+   * This makes it possible to store information that can be mapped to any existing connection.
+   */
+  public static class SocketData {
+
+    public final String id;
+    public final AtomicInteger unhandledTasks = new AtomicInteger(0);
+    public final AtomicInteger totalTasks = new AtomicInteger(0);
+    public boolean closeIfNoTasksLeft = false;
+
+    public SocketData(WebSocket webSocket) {
+      this.id = UUID.randomUUID().toString();
+      webSocket.setAttachment(this);
     }
   }
 }

src/main/java/de/dhbwstuttgart/server/packet/DebugPacket.java

@@ -0,0 +1,35 @@
+package de.dhbwstuttgart.server.packet;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import de.dhbwstuttgart.server.SocketClient;
+import de.dhbwstuttgart.server.SocketFuture;
+import de.dhbwstuttgart.server.SocketServer;
+import de.dhbwstuttgart.server.packet.dataContainers.serialized.ISerialNode;
+import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialList;
+import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialMap;
+import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialUUID;
+import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialValue;
+import org.java_websocket.WebSocket;
+
+public class DebugPacket implements IClientToServerPacket.Void, IServerToClientPacket {
+
+  public SerialUUID a1;
+  public SerialUUID a2;
+  public SerialMap b1;
+  public SerialMap b2;
+  public SerialList<? extends ISerialNode> c1;
+  public SerialList<? extends ISerialNode> c2;
+  public SerialValue<?> d1;
+  public SerialValue<?> d2;
+
+  @JsonIgnore
+  public void onHandle(WebSocket webSocket, SocketClient socketClient) {}
+
+  @JsonIgnore
+  public void onHandle(WebSocket webSocket, SocketServer socketServer) {}
+
+  @JsonIgnore
+  public SocketFuture<IServerToClientPacket> getFuture() {
+    return SocketFuture.completedFuture();
+  }
+}

src/main/java/de/dhbwstuttgart/server/packet/ErrorPacket.java

@@ -1,14 +1,36 @@
 package de.dhbwstuttgart.server.packet;
 
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import de.dhbwstuttgart.server.SocketClient;
+import de.dhbwstuttgart.server.SocketFuture;
+import de.dhbwstuttgart.server.SocketServer;
+import org.java_websocket.WebSocket;
+
 /**
  * A packet to send simple error messages between the client and the server
  */
-public class ErrorPacket implements IPacket {
+public class ErrorPacket implements IServerToClientPacket {
 
   /**
-   * The error endpoint for messages from the server, that should be logged out outputted
+   * The error endpoint for messages from the server that should be logged out as errors and possibly abort the process
    */
   public String error;
+  public boolean isFatal;
+
+  @JsonIgnore
+  public static ErrorPacket create(String error, boolean isFatal) {
+    ErrorPacket packet = new ErrorPacket();
+    packet.error = error;
+    packet.isFatal = isFatal;
+    return packet;
+  }
 
 
+  @JsonIgnore
+  public void onHandle(WebSocket webSocket, SocketClient socketClient) {
+    SocketClient.logger.exception(new RuntimeException(this.error));
+    if (this.isFatal) {
+      socketClient.close(1, "Received fatal error from server");
+    }
+  }
 }

src/main/java/de/dhbwstuttgart/server/packet/IClientToServerPacket.java

@@ -0,0 +1,26 @@
+package de.dhbwstuttgart.server.packet;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import de.dhbwstuttgart.server.SocketFuture;
+import de.dhbwstuttgart.server.SocketServer;
+import org.java_websocket.WebSocket;
+
+/**
+ * A packet that will be sent to the server. Use <code>Void</code> Sub-Interface for packets without response
+ *
+ * @param <T>   The response packet that will fulfill the future.
+ */
+public interface IClientToServerPacket<T extends IServerToClientPacket> extends IPacket {
+
+  @JsonIgnore
+  void onHandle(WebSocket webSocket, SocketServer socketServer);
+
+  @JsonIgnore
+  SocketFuture<T> getFuture();
+
+  /**
+   * Special case, where the packet will remain unanswered by the server
+   */
+  interface Void extends IClientToServerPacket<IServerToClientPacket> {}
+}
+

src/main/java/de/dhbwstuttgart/server/packet/IPacket.java

@@ -1,18 +1,12 @@
 package de.dhbwstuttgart.server.packet;
 
 /**
- * The shared interface for all packet of the server connection.
+ * The shared interface for all packet of the client-server connection.
  * A packet must always:
  * - Have a default / no-parameter constructor
  * - Have only serializable public properties (or disable them via jackson annotations)
- * A packet should have, for easy usage and consisteny:
- * - a static create() method
  *
  */
 public interface IPacket {
 
-  interface IDataContainer<T> {
-    T toObject();
-  }
-
 }

src/main/java/de/dhbwstuttgart/server/packet/IServerToClientPacket.java

@@ -0,0 +1,12 @@
+package de.dhbwstuttgart.server.packet;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import de.dhbwstuttgart.server.SocketClient;
+import org.java_websocket.WebSocket;
+
+public interface IServerToClientPacket extends IPacket {
+
+  @JsonIgnore
+  void onHandle(WebSocket webSocket, SocketClient socketClient);
+
+}

src/main/java/de/dhbwstuttgart/server/packet/InvalidPacket.java

@@ -1,13 +1,35 @@
 package de.dhbwstuttgart.server.packet;
 
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import de.dhbwstuttgart.server.SocketClient;
+import de.dhbwstuttgart.server.SocketFuture;
+import de.dhbwstuttgart.server.SocketServer;
+import org.java_websocket.WebSocket;
+
 /**
- * A fallback packet that is generated, if the received json could not be mapped to an existing package
+ * A fallback packet that is generated if the received JSON could not be mapped to an existing package
  */
-public class InvalidPacket implements IPacket {
+public class InvalidPacket implements IClientToServerPacket.Void, IServerToClientPacket {
 
   /**
    * If available, the error that caused this package to appear
    */
   public String error = "<unknown error>";
 
+
+  @JsonIgnore
+  public void onHandle(WebSocket webSocket, SocketClient socketClient) {
+    SocketClient.logger.error("InvalidPacket: " + this.error);
+  }
+
+  @JsonIgnore
+  public void onHandle(WebSocket webSocket, SocketServer socketServer) {
+    socketServer.log(webSocket, "InvalidPacket: " + this.error);
+  }
+
+  @JsonIgnore
+  public SocketFuture<IServerToClientPacket> getFuture() {
+    return SocketFuture.completedFuture();
+  }
+
 }

src/main/java/de/dhbwstuttgart/server/packet/MessagePacket.java

@@ -1,13 +1,40 @@
 package de.dhbwstuttgart.server.packet;
 
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import de.dhbwstuttgart.server.SocketClient;
+import de.dhbwstuttgart.server.SocketFuture;
+import de.dhbwstuttgart.server.SocketServer;
+import org.java_websocket.WebSocket;
+
 /**
  * A packet to send simple informational messages between the client and the server
  */
-public class MessagePacket implements IPacket {
+public class MessagePacket implements IClientToServerPacket.Void, IServerToClientPacket {
 
   /**
-   * The informational message from the server, that should be logged out outputted
+   * The informational message from the server that should be logged out outputted
    */
   public String message;
 
+  @JsonIgnore
+  public static MessagePacket create(String message) {
+    MessagePacket packet = new MessagePacket();
+    packet.message = message;
+    return packet;
+  }
+
+  @JsonIgnore
+  public void onHandle(WebSocket webSocket, SocketClient socketClient) {
+    SocketClient.logger.info("SocketMessage: " + this.message);
+  }
+
+  @JsonIgnore
+  public void onHandle(WebSocket webSocket, SocketServer socketServer) {
+    socketServer.log(webSocket, this.message);
+  }
+
+  @JsonIgnore
+  public SocketFuture<IServerToClientPacket> getFuture() {
+    return SocketFuture.completedFuture();
+  }
 }

src/main/java/de/dhbwstuttgart/server/packet/PacketContainer.java

@@ -3,6 +3,7 @@ package de.dhbwstuttgart.server.packet;
 import com.fasterxml.jackson.annotation.JsonInclude;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import de.dhbwstuttgart.util.Logger;
 
 /**
  * A wrapper for the packet to ensure correct serialization/deserialization and make it possible to detect the matching
@@ -16,20 +17,22 @@ public class PacketContainer {
 
   /*
    * The available packet types. The one type that is represented in the JSON should always be the ONLY non-null value.
-   * They have to be private (for the moment) to let jackson fill them in while deserializing
+   * They have to be public (for the moment) to let jackson fill them in while deserializing
    */
   public ErrorPacket errorPacket = null;
   public MessagePacket messagePacket = null;
   public InvalidPacket invalidPacket = null;
   public UnifyRequestPacket unifyRequestPacket = null;
   public UnifyResultPacket unifyResultPacket = null;
+  public DebugPacket debugPacket = null;
+  public SetAutoclosePacket setAutoclosePacket = null;
 
 
   /**
    * Generate the JSON string for the given packet
    *
    * @param packet The packet to serialize
-   * @return The json representation of the packet
+   * @return The JSON representation of the packet
    */
   public static String serialize(IPacket packet) throws JsonProcessingException {
     objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
@@ -43,7 +46,13 @@ public class PacketContainer {
       container.unifyRequestPacket = (UnifyRequestPacket) packet;
     else if (packet instanceof UnifyResultPacket)
       container.unifyResultPacket = (UnifyResultPacket) packet;
+    else if (packet instanceof DebugPacket)
+      container.debugPacket = (DebugPacket) packet;
+    else if (packet instanceof SetAutoclosePacket)
+      container.setAutoclosePacket = (SetAutoclosePacket) packet;
     // Add new packets here and in the deserialize method
+    else
+      throw new RuntimeException("Cannot map packet to any known packet class");
 
     return objectMapper.writeValueAsString(container);
   }
@@ -70,10 +79,15 @@ public class PacketContainer {
         return container.unifyRequestPacket;
       if (container.unifyResultPacket != null)
         return container.unifyResultPacket;
+      if (container.debugPacket != null)
+        return container.debugPacket;
+      if (container.setAutoclosePacket != null)
+        return container.setAutoclosePacket;
       // Add new packets here and in the serialize method
 
       throw new RuntimeException("Cannot map received json to any known packet class");
     } catch (Exception e) {
+      (new Logger()).exception(e);
       InvalidPacket packet = new InvalidPacket();
       packet.error = e.getMessage();
       return packet;

src/main/java/de/dhbwstuttgart/server/packet/SetAutoclosePacket.java

@@ -0,0 +1,32 @@
+package de.dhbwstuttgart.server.packet;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import de.dhbwstuttgart.server.SocketClient;
+import de.dhbwstuttgart.server.SocketFuture;
+import de.dhbwstuttgart.server.SocketServer;
+import org.java_websocket.WebSocket;
+
+/**
+ * Normally, a connection stays open until either the client or the server process ends.
+ * Send this packet to inform the server that the connection can be closed once all tasks are done
+ */
+public class SetAutoclosePacket implements IClientToServerPacket.Void {
+
+  public int dummyProperty = 1;
+
+  @JsonIgnore
+  public static SetAutoclosePacket create() {
+    return new SetAutoclosePacket();
+  }
+
+  @JsonIgnore
+  public void onHandle(WebSocket webSocket, SocketServer socketServer) {
+    webSocket.<SocketServer.SocketData>getAttachment().closeIfNoTasksLeft = true;
+    socketServer.log(webSocket, "Marked connection as autoclose");
+  }
+
+  @JsonIgnore
+  public SocketFuture<IServerToClientPacket> getFuture() {
+    return SocketFuture.completedFuture();
+  }
+}

src/main/java/de/dhbwstuttgart/server/packet/UnifyRequestPacket.java

@@ -1,48 +1,164 @@
 package de.dhbwstuttgart.server.packet;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
-import de.dhbwstuttgart.server.packet.dataContainers.SerializedFiniteClosure;
-import de.dhbwstuttgart.server.packet.dataContainers.SerializedPairConstraintSet;
-import de.dhbwstuttgart.server.packet.dataContainers.SerializedUnifyConstraintSet;
+import de.dhbwstuttgart.core.ConsoleInterface;
+import de.dhbwstuttgart.server.ServerTaskLogger;
+import de.dhbwstuttgart.server.SocketFuture;
+import de.dhbwstuttgart.server.SocketServer;
+import de.dhbwstuttgart.server.packet.dataContainers.KeyStorage;
+import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialList;
+import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialMap;
+import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialValue;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import de.dhbwstuttgart.typeinference.constraints.Pair;
+import de.dhbwstuttgart.typeinference.unify.PlaceholderRegistry;
+import de.dhbwstuttgart.typeinference.unify.TypeUnify;
+import de.dhbwstuttgart.typeinference.unify.UnifyContext;
+import de.dhbwstuttgart.typeinference.unify.UnifyResultListenerImpl;
+import de.dhbwstuttgart.typeinference.unify.UnifyResultModel;
+import de.dhbwstuttgart.typeinference.unify.UnifyTaskModel;
 import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
+import de.dhbwstuttgart.typeinference.unify.model.FiniteClosure;
+import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
+import de.dhbwstuttgart.typeinference.unify.model.UnifyType;
+import de.dhbwstuttgart.util.Logger;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.concurrent.ForkJoinPool;
+import org.java_websocket.WebSocket;
 
 /**
  * A packet to send all required data for the unification algorithm to the server and request the unification
  */
-public class UnifyRequestPacket implements IPacket {
+public class UnifyRequestPacket implements IClientToServerPacket<UnifyResultPacket> {
 
-  public SerializedFiniteClosure finiteClosure;
-  public SerializedPairConstraintSet constraints;
-  public SerializedUnifyConstraintSet unifyConstraints;
+  public SerialMap finiteClosure;
+  public SerialMap constraintSet;
+  public SerialMap unifyConstraintSet;
+  public SerialMap serialKeyStorage;
+  public SerialValue<?> placeholders;
+  public SerialList<SerialMap> factoryplaceholders;
+  public String futureId;
+  public int logLevel;
+
+  @JsonIgnore
+  private KeyStorage keyStorage = new KeyStorage();
+  @JsonIgnore
+  private boolean keyStorageLoaded = false;
 
   public static UnifyRequestPacket create(
-    IFiniteClosure finiteClosure,
-    ConstraintSet<Pair> constraints,
-    ConstraintSet<UnifyPair> unifyConstraints
+    FiniteClosure finiteClosure,
+    ConstraintSet<Pair> constraintSet,
+    ConstraintSet<UnifyPair> unifyConstraintSet,
+    PlaceholderRegistry placeholderRegistry
   ) {
     UnifyRequestPacket packet = new UnifyRequestPacket();
-    packet.finiteClosure = SerializedFiniteClosure.create(finiteClosure);
-    packet.constraints = SerializedPairConstraintSet.create(constraints);
-    packet.unifyConstraints = SerializedUnifyConstraintSet.create(unifyConstraints);
+    // store constraint and finite closure
+    packet.finiteClosure = finiteClosure.toSerial(packet.keyStorage);
+    packet.constraintSet = constraintSet.toSerial(packet.keyStorage);
+    packet.unifyConstraintSet = unifyConstraintSet.toSerial(packet.keyStorage);
+    // store placeholder registry
+    var serialRegistry = placeholderRegistry.toSerial(packet.keyStorage);
+    packet.placeholders = serialRegistry.getValue("ph");
+    packet.factoryplaceholders = serialRegistry.getList("factoryPh").assertListOfMaps();
+    // store referenced objects separately
+    packet.serialKeyStorage = packet.keyStorage.toSerial(packet.keyStorage);
+    packet.logLevel = ConsoleInterface.logLevel.getValue();
     return packet;
   }
 
+
   @JsonIgnore
-  public IFiniteClosure retrieveFiniteClosure() {
-    return this.finiteClosure.toObject();
+  public void loadKeyStorage(UnifyContext context) {
+    if (!keyStorageLoaded) {
+      keyStorageLoaded = true;
+      keyStorage = KeyStorage.fromSerial(this.serialKeyStorage, context);
+    }
   }
 
   @JsonIgnore
-  public ConstraintSet<Pair> retrieveConstraints() {
-    return this.constraints.toObject();
+  private FiniteClosure retrieveFiniteClosure(UnifyContext context) {
+    this.loadKeyStorage(context);
+    return FiniteClosure.fromSerial(this.finiteClosure, context, keyStorage);
   }
 
   @JsonIgnore
-  public ConstraintSet<UnifyPair> retrieveUnifyConstraints() {
-    return this.unifyConstraints.toObject();
+  private ConstraintSet<Pair> retrieveConstraintSet(UnifyContext context) {
+    this.loadKeyStorage(context);
+    return ConstraintSet.fromSerial(this.constraintSet, context, Pair.class, keyStorage);
+  }
+
+  @JsonIgnore
+  private ConstraintSet<UnifyPair> retrieveUnifyConstraintSet(UnifyContext context) {
+    this.loadKeyStorage(context);
+    return ConstraintSet.fromSerial(this.unifyConstraintSet, context, UnifyPair.class, keyStorage);
+  }
+
+  @JsonIgnore
+  public void onHandle(WebSocket webSocket, SocketServer socketServer) {
+    socketServer.sendMessage(webSocket, "You requested a unify! Please wait until I calculated everything...");
+    socketServer.log(webSocket, "Client requested a unification. Starting now...");
+
+    try {
+      var placeholderRegistry = new PlaceholderRegistry();
+      ArrayList<String> existingPlaceholders = (ArrayList) this.placeholders.getOf(ArrayList.class);
+      existingPlaceholders.forEach(placeholderRegistry::addPlaceholder);
+
+      Logger logger = new ServerTaskLogger(
+        webSocket,
+        socketServer,
+        Logger.LogLevel.fromValue(
+          Math.max(this.logLevel, Logger.LogLevel.INFO.getValue())
+        )
+      );
+      var unifyContext = new UnifyContext(logger, true,
+        new UnifyResultModel(new ConstraintSet<>(), new FiniteClosure(new HashSet<>(), logger, placeholderRegistry)),
+        new UnifyTaskModel(), ForkJoinPool.commonPool(), placeholderRegistry
+      );
+
+      this.factoryplaceholders.stream()
+        .map(p -> (PlaceholderType)UnifyType.fromSerial(p, unifyContext))
+        .forEach(placeholderRegistry.UnifyTypeFactory_PLACEHOLDERS::add);
+
+
+      // start the unification algorithm from the received data
+      IFiniteClosure finiteClosure = this.retrieveFiniteClosure(unifyContext);
+      ConstraintSet<Pair> constraintSet = this.retrieveConstraintSet(unifyContext);
+      ConstraintSet<UnifyPair> unifyConstraintSet = this.retrieveUnifyConstraintSet(unifyContext);
+
+      var resultModel = new UnifyResultModel(constraintSet, finiteClosure);
+      UnifyResultListenerImpl resultListener = new UnifyResultListenerImpl();
+      resultModel.addUnifyResultListener(resultListener);
+
+      TypeUnify.unifyParallel(
+        unifyConstraintSet.getUndConstraints(),
+        unifyConstraintSet.getOderConstraints(),
+        finiteClosure,
+        unifyContext.newWithResultModel(resultModel)
+      );
+
+      var resultSets = resultListener.getResults();
+
+      socketServer.log(webSocket, "Finished unification");
+      socketServer.sendMessage(webSocket, "Unification finished. Found " + resultSets.size() + " result sets");
+
+      if (webSocket.isOpen()) {
+        UnifyResultPacket resultPacket = UnifyResultPacket.create(resultSets, futureId);
+        webSocket.send(PacketContainer.serialize(resultPacket));
+      }
+    } catch (Exception e) {
+      SocketServer.logger.exception(e);
+      socketServer.log(webSocket, e.getMessage());
+    }
+  }
+
+  @JsonIgnore
+  public SocketFuture<UnifyResultPacket> getFuture() {
+    var future = new SocketFuture<>(List.of(UnifyResultPacket.class));
+    futureId = future.futureId;
+    return future;
   }
 
 }

src/main/java/de/dhbwstuttgart/server/packet/UnifyResultPacket.java

@@ -1,27 +1,45 @@
 package de.dhbwstuttgart.server.packet;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
-import de.dhbwstuttgart.server.packet.dataContainers.SerializedResultSet;
+import de.dhbwstuttgart.server.SocketClient;
+import de.dhbwstuttgart.server.packet.dataContainers.KeyStorage;
+import de.dhbwstuttgart.server.packet.dataContainers.serialized.ISerialNode;
+import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialList;
+import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialMap;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
-import java.util.Arrays;
+import de.dhbwstuttgart.typeinference.unify.UnifyContext;
 import java.util.List;
+import org.java_websocket.WebSocket;
 
 /**
  * A packet to send all calculated data from the unification algorithm back to the client
  */
-public class UnifyResultPacket implements IPacket {
+public class UnifyResultPacket implements IServerToClientPacket {
 
-  public SerializedResultSet[] results;
+  public SerialList<ISerialNode> results;
+  public SerialMap keyStorage;
+  public String futureId;
 
-  public static UnifyResultPacket create(List<ResultSet> resultSets) {
+  public static UnifyResultPacket create(List<ResultSet> resultSets, String futureId) {
     UnifyResultPacket serialized = new UnifyResultPacket();
-    serialized.results = resultSets.stream().map(SerializedResultSet::create).toArray(SerializedResultSet[]::new);
+    KeyStorage keyStorage = new KeyStorage();
+    serialized.results = SerialList.fromMapped(resultSets, resultSet -> resultSet.toSerial(keyStorage));
+    serialized.keyStorage = keyStorage.toSerial(keyStorage);
+    serialized.futureId = futureId;
     return serialized;
   }
 
   @JsonIgnore
-  public List<ResultSet> getResultSet() {
-    return Arrays.stream(this.results).map(SerializedResultSet::toObject).toList();
+  public List<ResultSet> getResultSet(UnifyContext context) {
+    return this.results.assertListOfMaps().stream()
+      .map(resultData -> ResultSet.fromSerial(resultData, context)).toList();
   }
 
+  @JsonIgnore
+  public void onHandle(WebSocket webSocket, SocketClient socketClient) {
+    SocketClient.logger.info("Received unify result");
+    socketClient.completeResponseFuture(futureId, this);
+  }
+
+
 }

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/ISerializableData.java

@@ -0,0 +1,16 @@
+package de.dhbwstuttgart.server.packet.dataContainers;
+
+import de.dhbwstuttgart.exceptions.NotImplementedException;
+import de.dhbwstuttgart.server.packet.dataContainers.serialized.ISerialNode;
+import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialMap;
+import de.dhbwstuttgart.typeinference.unify.UnifyContext;
+
+public interface ISerializableData {
+
+  public abstract ISerialNode toSerial(KeyStorage keyStorage);
+
+  public static Object fromSerial(SerialMap data, UnifyContext context) {
+    throw new NotImplementedException("Missing implementation of \"fromSerial\" for a serializable element");
+  }
+
+}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/KeyStorage.java

@@ -0,0 +1,103 @@
+package de.dhbwstuttgart.server.packet.dataContainers;
+
+import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialMap;
+import de.dhbwstuttgart.typeinference.unify.UnifyContext;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class KeyStorage implements ISerializableData {
+
+  /**
+   *  Store a unique identifier for every element, so it can be referenced in the json
+   */
+  protected AtomicInteger identifierCount = new AtomicInteger();
+  /**
+   *  Store the serialized element per identifier when serializing
+   */
+  protected SerialMap serializedElements = new SerialMap();
+  /**
+   *  Store the unserialized element per identifier when unserializing
+   */
+  protected Map<String, ISerializableData> unserializedElements = new HashMap<>();
+
+
+  /**
+   *  Retrieve or generate a new identifier for a constraint
+   */
+  public String getIdentifier() {
+    return this.identifierCount.incrementAndGet() + "_";
+  }
+
+  /**
+   *  Checks if the given element identifier belongs to an element that was already serialized
+   */
+  public boolean isAlreadySerialized(String identifier) {
+    return this.serializedElements.containsKey(identifier);
+  }
+
+  /**
+   *  Checks if the given element identifier belongs to a element that was already unserialized
+   */
+  public boolean isAlreadyUnserialized(String identifier) {
+    return this.unserializedElements.containsKey(identifier);
+  }
+
+  /**
+   *  Register a serialized element to prevent it from being serialized again
+   */
+  public void putSerialized(String identifier, SerialMap serializedElement) {
+    this.serializedElements.put(identifier, serializedElement);
+  }
+
+  /**
+   *  Retrieve a serialized element
+   */
+  public SerialMap getSerialized(String identifier) {
+    if (!this.serializedElements.containsKey(identifier)) {
+      throw new RuntimeException("No serialized element of identifier " + identifier + " available to get");
+    }
+    return this.serializedElements.getMap(identifier);
+  }
+
+  /**
+   *  Register an unserialized element to prevent it from being unserialized again
+   */
+  public void putUnserialized(String identifier, ISerializableData element) {
+    this.unserializedElements.put(identifier, element);
+  }
+
+  /**
+   *  Retrieve an unserialized element
+   */
+  public <T extends ISerializableData> T getUnserialized(String identifier, Class<T> target) {
+    if (!this.unserializedElements.containsKey(identifier)) {
+      throw new RuntimeException("No unserialized element of identifier " + identifier + " available to get");
+    }
+    var element = this.unserializedElements.get(identifier);
+    if (target.isInstance(element)) {
+      return (T) element;
+    }
+    throw new RuntimeException("Failed to get unserialized element from KeyStorage. Expected instance of " +
+      target.getName() + " but found " + element.getClass().getName());
+  }
+
+  @Override
+  public SerialMap toSerial(KeyStorage keyStorage) {
+    SerialMap serialized = new SerialMap();
+    serialized.put("serializedElements", this.serializedElements);
+    return serialized;
+  }
+
+  public static KeyStorage fromSerial(SerialMap data, UnifyContext context) {
+    var serializedConstraintsData = data.getMap("serializedElements");
+    var constraintContext = new KeyStorage();
+    for (var entry : serializedConstraintsData.entrySet()) {
+      if (entry.getValue() instanceof SerialMap valueMap) {
+        constraintContext.putSerialized(entry.getKey(), valueMap);
+      }
+    }
+    return constraintContext;
+  }
+
+}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/SerializedFiniteClosure.java

@@ -1,30 +0,0 @@
-package de.dhbwstuttgart.server.packet.dataContainers;
-
-import de.dhbwstuttgart.server.packet.IPacket;
-import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
-import de.dhbwstuttgart.typeinference.unify.model.FiniteClosure;
-import java.util.Arrays;
-import java.util.HashSet;
-
-/**
- * Serializable container of
- *
- * @see IFiniteClosure
- */
-public class SerializedFiniteClosure implements IPacket.IDataContainer<IFiniteClosure> {
-  public SerializedUnifyPair[] pairs;
-
-  public static SerializedFiniteClosure create(IFiniteClosure finiteClosure) {
-    SerializedFiniteClosure fc = new SerializedFiniteClosure();
-    fc.pairs = finiteClosure.getPairs().stream().map(SerializedUnifyPair::create).toArray(SerializedUnifyPair[]::new);
-    return fc;
-  }
-
-  @Override
-  public IFiniteClosure toObject() {
-    return new FiniteClosure(
-      new HashSet<>(Arrays.stream(pairs).map(SerializedUnifyPair::toObject).toList()),
-      null
-    );
-  }
-}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/SerializedPair.java

@@ -1,37 +0,0 @@
-package de.dhbwstuttgart.server.packet.dataContainers;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import de.dhbwstuttgart.server.packet.IPacket;
-import de.dhbwstuttgart.typeinference.constraints.Pair;
-import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
-
-/**
- * Serializable container of
- *
- * @see Pair
- */
-public class SerializedPair implements IPacket.IDataContainer<Pair> {
-
-  @JsonProperty("o")
-  public PairOperator operator;
-  public SerializedTokenWrapper ta1;
-  public SerializedTokenWrapper ta2;
-
-
-  public static SerializedPair create(Pair pair) {
-    SerializedPair sPair = new SerializedPair();
-    sPair.operator = pair.GetOperator();
-    sPair.ta1 = SerializedTokenWrapper.create(pair.TA1);
-    sPair.ta2 = SerializedTokenWrapper.create(pair.TA2);
-    return sPair;
-  }
-
-  @Override
-  public Pair toObject() {
-    return new Pair(
-      ta1.toObject(),
-      ta2.toObject(),
-      operator
-    );
-  }
-}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/SerializedPairConstraint.java

@@ -1,82 +0,0 @@
-package de.dhbwstuttgart.server.packet.dataContainers;
-
-import com.fasterxml.jackson.annotation.JsonInclude;
-import com.fasterxml.jackson.annotation.JsonProperty;
-import de.dhbwstuttgart.server.packet.IPacket;
-import de.dhbwstuttgart.typeinference.constraints.Constraint;
-import de.dhbwstuttgart.typeinference.constraints.Pair;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.HashSet;
-
-/**
- * Serializable container of
- *
- * @see Constraint<Pair>
- */
-@JsonInclude(JsonInclude.Include.NON_NULL)
-public class SerializedPairConstraint implements IPacket.IDataContainer<Constraint<Pair>> {
-
-  // serialize recursive structure
-  public static final HashMap<Constraint<Pair>, String> UNIQUE_CONSTRAINT_KEY_MAP = new HashMap<>();
-  public static final HashMap<String, SerializedPairConstraint> UNIQUE_CONSTRAINT_MAP = new HashMap<>();
-  // deserialize recursive structure
-  private static final HashMap<String, Constraint<Pair>> UNIQUE_OBJECT_MAP = new HashMap<>();
-
-  @JsonProperty("i")
-  public boolean isInherited;
-  @JsonProperty("u")
-  public String uniqueKey;
-  @JsonProperty("e")
-  public String extendedConstraint = null;
-  @JsonProperty("m")
-  public SerializedPair[] methodSignatureConstraint;
-  @JsonProperty("c")
-  public SerializedPair[] constraintElements;
-
-
-  public static SerializedPairConstraint create(Constraint<Pair> constraint) {
-    final String uniqueKey = UNIQUE_CONSTRAINT_KEY_MAP.getOrDefault(constraint, "_" + UNIQUE_CONSTRAINT_MAP.size());
-
-    if (UNIQUE_CONSTRAINT_MAP.containsKey(uniqueKey)) {
-      return UNIQUE_CONSTRAINT_MAP.get(uniqueKey);
-    }
-
-    SerializedPairConstraint pairConstraint = new SerializedPairConstraint();
-    pairConstraint.uniqueKey = uniqueKey;
-    UNIQUE_CONSTRAINT_KEY_MAP.put(constraint, uniqueKey);
-    UNIQUE_CONSTRAINT_MAP.put(uniqueKey, pairConstraint);
-
-    pairConstraint.constraintElements = constraint.stream().map(SerializedPair::create).toArray(SerializedPair[]::new);
-    pairConstraint.isInherited = constraint.isInherited();
-    pairConstraint.methodSignatureConstraint = constraint.getmethodSignatureConstraint().stream().map(SerializedPair::create).toArray(SerializedPair[]::new);
-    if (constraint.getExtendConstraint() != null) {
-      pairConstraint.extendedConstraint = SerializedPairConstraint.create(constraint.getExtendConstraint()).uniqueKey;
-    }
-
-    return pairConstraint;
-  }
-
-  @Override
-  public Constraint<Pair> toObject() {
-    if (UNIQUE_OBJECT_MAP.containsKey(uniqueKey)) {
-      return UNIQUE_OBJECT_MAP.get(uniqueKey);
-    }
-
-    Constraint<Pair> constraint = new Constraint<>();
-    UNIQUE_OBJECT_MAP.put(uniqueKey, constraint);
-
-    constraint.addAll(Arrays.stream(constraintElements).map(SerializedPair::toObject).toList());
-    constraint.setIsInherited(isInherited);
-    constraint.setmethodSignatureConstraint(new HashSet<>(
-      Arrays.stream(methodSignatureConstraint).map(SerializedPair::toObject).toList()
-    ));
-    SerializedPairConstraint extendedConstraint = this.extendedConstraint == null ? null :
-      SerializedPairConstraint.UNIQUE_CONSTRAINT_MAP.get(this.extendedConstraint);
-    if (extendedConstraint != null) {
-      constraint.setExtendConstraint(extendedConstraint.toObject());
-    }
-
-    return constraint;
-  }
-}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/SerializedPairConstraintSet.java

@@ -1,60 +0,0 @@
-package de.dhbwstuttgart.server.packet.dataContainers;
-
-import de.dhbwstuttgart.server.packet.IPacket;
-import de.dhbwstuttgart.typeinference.constraints.Constraint;
-import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
-import de.dhbwstuttgart.typeinference.constraints.Pair;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-/**
- * Serializable container of
- *
- * @see ConstraintSet<Pair>
- */
-public class SerializedPairConstraintSet implements IPacket.IDataContainer<ConstraintSet<Pair>> {
-
-  public SerializedPair[] undConstraints;
-  public SerializedPairConstraint[][] oderConstraints;
-  public Map<String, SerializedPairConstraint> uniqueConstraintMap = new HashMap<>();
-
-  public static SerializedPairConstraintSet create(ConstraintSet<Pair> constraints) {
-    SerializedPairConstraintSet constraintSet = new SerializedPairConstraintSet();
-
-    constraintSet.undConstraints = constraints.getUndConstraints().stream().map(SerializedPair::create).toArray(SerializedPair[]::new);
-    constraintSet.oderConstraints = constraints.getOderConstraints().stream().map(consSet ->
-      consSet.stream().map(SerializedPairConstraint::create).toArray(SerializedPairConstraint[]::new)
-    ).toArray(SerializedPairConstraint[][]::new);
-
-    // add all the gathered constraints to a serializable property
-    constraintSet.uniqueConstraintMap.putAll(SerializedPairConstraint.UNIQUE_CONSTRAINT_MAP);
-
-    return constraintSet;
-  }
-
-  @Override
-  public ConstraintSet<Pair> toObject() {
-    ConstraintSet<Pair> consSet = new ConstraintSet<>();
-
-    // read all the constraints from the serializable property
-    SerializedPairConstraint.UNIQUE_CONSTRAINT_MAP.putAll(this.uniqueConstraintMap);
-
-    Constraint<Pair> undCons = new Constraint<>();
-    undCons.addAll(Arrays.stream(undConstraints).map(SerializedPair::toObject).toList());
-    consSet.addAllUndConstraint(undCons);
-
-    List<Set<Constraint<Pair>>> oderCons = new ArrayList<>(Arrays.stream(oderConstraints).map(cons ->
-      new HashSet<>(
-        Arrays.stream(cons).map(SerializedPairConstraint::toObject).toList()
-      )
-    ).toList());
-    consSet.addAllOderConstraint(oderCons);
-
-    return consSet;
-  }
-}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/SerializedResultPairWrapper.java

@@ -1,63 +0,0 @@
-package de.dhbwstuttgart.server.packet.dataContainers;
-
-import com.fasterxml.jackson.annotation.JsonInclude;
-import com.fasterxml.jackson.annotation.JsonProperty;
-import de.dhbwstuttgart.server.packet.IPacket;
-import de.dhbwstuttgart.server.packet.dataContainers.resultPairs.SerializedPairNoResult;
-import de.dhbwstuttgart.server.packet.dataContainers.resultPairs.SerializedPairTPHEqualTPH;
-import de.dhbwstuttgart.server.packet.dataContainers.resultPairs.SerializedPairTPHequalRefTypeOrWildcardType;
-import de.dhbwstuttgart.server.packet.dataContainers.resultPairs.SerializedPairTPHsmallerTPH;
-import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.typeinference.result.PairNoResult;
-import de.dhbwstuttgart.typeinference.result.PairTPHEqualTPH;
-import de.dhbwstuttgart.typeinference.result.PairTPHequalRefTypeOrWildcardType;
-import de.dhbwstuttgart.typeinference.result.PairTPHsmallerTPH;
-import de.dhbwstuttgart.typeinference.result.ResultPair;
-
-/**
- * Serializable container of
- *
- * @see ResultPair
- */
-@JsonInclude(JsonInclude.Include.NON_NULL)
-public class SerializedResultPairWrapper implements IPacket.IDataContainer<ResultPair<RefTypeOrTPHOrWildcardOrGeneric, RefTypeOrTPHOrWildcardOrGeneric>> {
-
-  @JsonProperty("nr")
-  public SerializedPairNoResult noResult = null;
-  @JsonProperty("teo")
-  public SerializedPairTPHequalRefTypeOrWildcardType tphEqualOther = null;
-  @JsonProperty("tet")
-  public SerializedPairTPHEqualTPH tphEqualTph = null;
-  @JsonProperty("tst")
-  public SerializedPairTPHsmallerTPH tphSmallerTPH = null;
-
-
-  public static <A extends RefTypeOrTPHOrWildcardOrGeneric, B extends RefTypeOrTPHOrWildcardOrGeneric> SerializedResultPairWrapper create(ResultPair<A, B> pair) {
-    SerializedResultPairWrapper serialized = new SerializedResultPairWrapper();
-
-    if (pair instanceof PairNoResult noResult)
-      serialized.noResult = SerializedPairNoResult.create(noResult);
-    else if (pair instanceof PairTPHequalRefTypeOrWildcardType tphEqualOther)
-      serialized.tphEqualOther = SerializedPairTPHequalRefTypeOrWildcardType.create(tphEqualOther);
-    else if (pair instanceof PairTPHEqualTPH tphEqualTph)
-      serialized.tphEqualTph = SerializedPairTPHEqualTPH.create(tphEqualTph);
-    else if (pair instanceof PairTPHsmallerTPH tphSmallerTPH)
-      serialized.tphSmallerTPH = SerializedPairTPHsmallerTPH.create(tphSmallerTPH);
-
-    return serialized;
-  }
-
-  @Override
-  @SuppressWarnings("rawtypes") // this is not optimal, but we have to conform to interface specifications
-  public ResultPair toObject() {
-    if (noResult != null)
-      return noResult.toObject();
-    else if (tphEqualOther != null)
-      return tphEqualOther.toObject();
-    else if (tphEqualTph != null)
-      return tphEqualTph.toObject();
-    else if (tphSmallerTPH != null)
-      return tphSmallerTPH.toObject();
-    return null;
-  }
-}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/SerializedResultSet.java

@@ -1,31 +0,0 @@
-package de.dhbwstuttgart.server.packet.dataContainers;
-
-import de.dhbwstuttgart.server.packet.IPacket;
-import de.dhbwstuttgart.typeinference.result.ResultSet;
-import java.util.Arrays;
-import java.util.HashSet;
-
-/**
- * Serializable container of
- *
- * @see ResultSet
- */
-public class SerializedResultSet implements IPacket.IDataContainer<ResultSet> {
-
-  public SerializedResultPairWrapper[] results;
-
-  public static SerializedResultSet create(ResultSet resultSet) {
-    SerializedResultSet serialized = new SerializedResultSet();
-    serialized.results = resultSet.results.stream().map(SerializedResultPairWrapper::create).toArray(SerializedResultPairWrapper[]::new);
-    return serialized;
-  }
-
-  public ResultSet toObject() {
-    return new ResultSet(
-      new HashSet<>(
-        Arrays.stream(this.results).map(SerializedResultPairWrapper::toObject).toList()
-      )
-    );
-  }
-
-}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/SerializedTokenWrapper.java

@@ -1,72 +0,0 @@
-package de.dhbwstuttgart.server.packet.dataContainers;
-
-import com.fasterxml.jackson.annotation.JsonInclude;
-import com.fasterxml.jackson.annotation.JsonProperty;
-import de.dhbwstuttgart.server.packet.IPacket;
-import de.dhbwstuttgart.server.packet.dataContainers.token.SerializedExtendsWildcardType;
-import de.dhbwstuttgart.server.packet.dataContainers.token.SerializedGenericRefType;
-import de.dhbwstuttgart.server.packet.dataContainers.token.SerializedPlaceholderType;
-import de.dhbwstuttgart.server.packet.dataContainers.token.SerializedRefType;
-import de.dhbwstuttgart.server.packet.dataContainers.token.SerializedSuperWildcardType;
-import de.dhbwstuttgart.server.packet.dataContainers.token.SerializedVoidType;
-import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
-import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
-import de.dhbwstuttgart.syntaxtree.type.RefType;
-import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
-import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
-import de.dhbwstuttgart.syntaxtree.type.Void;
-
-/**
- * Serializable container of
- *
- * @see RefTypeOrTPHOrWildcardOrGeneric
- */
-@JsonInclude(JsonInclude.Include.NON_NULL)
-public class SerializedTokenWrapper implements IPacket.IDataContainer<RefTypeOrTPHOrWildcardOrGeneric> {
-
-  @JsonProperty("ew")
-  public SerializedExtendsWildcardType extendsWildcardType = null;
-  @JsonProperty("gr")
-  public SerializedGenericRefType genericRefType = null;
-  @JsonProperty("p")
-  public SerializedPlaceholderType placeholderType = null;
-  @JsonProperty("r")
-  public SerializedRefType refType = null;
-  @JsonProperty("sw")
-  public SerializedSuperWildcardType superWildcardType = null;
-  @JsonProperty("v")
-  public SerializedVoidType voidType = null;
-
-
-  public static SerializedTokenWrapper create(RefTypeOrTPHOrWildcardOrGeneric type) {
-    SerializedTokenWrapper wrapper = new SerializedTokenWrapper();
-
-    if (type instanceof ExtendsWildcardType)
-      wrapper.extendsWildcardType = SerializedExtendsWildcardType.create((ExtendsWildcardType) type);
-    else if (type instanceof GenericRefType)
-      wrapper.genericRefType = SerializedGenericRefType.create((GenericRefType) type);
-    else if (type instanceof TypePlaceholder)
-      wrapper.placeholderType = SerializedPlaceholderType.create((TypePlaceholder) type);
-    else if (type instanceof Void)
-      wrapper.voidType = SerializedVoidType.create((Void) type);
-    else if (type instanceof RefType)
-      wrapper.refType = SerializedRefType.create((RefType) type);
-    else if (type instanceof SuperWildcardType)
-      wrapper.superWildcardType = SerializedSuperWildcardType.create((SuperWildcardType) type);
-
-    return wrapper;
-  }
-
-
-  @Override
-  public RefTypeOrTPHOrWildcardOrGeneric toObject() {
-    if (extendsWildcardType != null) return extendsWildcardType.toObject();
-    if (genericRefType != null) return genericRefType.toObject();
-    if (placeholderType != null) return placeholderType.toObject();
-    if (refType != null) return refType.toObject();
-    if (superWildcardType != null) return superWildcardType.toObject();
-    if (voidType != null) return voidType.toObject();
-    return null;
-  }
-}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/SerializedUnifyConstraintSet.java

@@ -1,49 +0,0 @@
-package de.dhbwstuttgart.server.packet.dataContainers;
-
-import de.dhbwstuttgart.server.packet.IPacket;
-import de.dhbwstuttgart.typeinference.constraints.Constraint;
-import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
-import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
-/**
- * Serializable container of
- *
- * @see ConstraintSet<UnifyPair>
- */
-public class SerializedUnifyConstraintSet implements IPacket.IDataContainer<ConstraintSet<UnifyPair>> {
-
-  public SerializedUnifyPair[] undConstraints;
-  public SerializedUnifyPairConstraint[][] oderConstraints;
-
-  public static SerializedUnifyConstraintSet create(ConstraintSet<UnifyPair> unifyCons) {
-    SerializedUnifyConstraintSet constraintSet = new SerializedUnifyConstraintSet();
-    constraintSet.undConstraints = unifyCons.getUndConstraints().stream().map(SerializedUnifyPair::create).toArray(SerializedUnifyPair[]::new);
-    constraintSet.oderConstraints = unifyCons.getOderConstraints().stream().map(constraints ->
-      constraints.stream().map(SerializedUnifyPairConstraint::create).toArray(SerializedUnifyPairConstraint[]::new)
-    ).toArray(SerializedUnifyPairConstraint[][]::new);
-    return constraintSet;
-  }
-
-  @Override
-  public ConstraintSet<UnifyPair> toObject() {
-    ConstraintSet<UnifyPair> consSet = new ConstraintSet<>();
-
-    Constraint<UnifyPair> undCons = new Constraint<>();
-    undCons.addAll(Arrays.stream(undConstraints).map(SerializedUnifyPair::toObject).toList());
-    consSet.addAllUndConstraint(undCons);
-
-    List<Set<Constraint<UnifyPair>>> oderCons = new ArrayList<>(Arrays.stream(oderConstraints).map(oderConsSet ->
-      new HashSet<>(
-        Arrays.stream(oderConsSet).map(SerializedUnifyPairConstraint::toObject).toList()
-      )
-    ).toList());
-    consSet.addAllOderConstraint(oderCons);
-
-    return consSet;
-  }
-}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/SerializedUnifyPair.java

@@ -1,32 +0,0 @@
-package de.dhbwstuttgart.server.packet.dataContainers;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import de.dhbwstuttgart.server.packet.IPacket;
-import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
-import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
-
-/**
- * Serializable container of
- *
- * @see UnifyPair
- */
-public class SerializedUnifyPair implements IPacket.IDataContainer<UnifyPair> {
-
-  public SerializedUnifyTypeWrapper lhs;
-  public SerializedUnifyTypeWrapper rhs;
-  @JsonProperty("o")
-  public PairOperator operator;
-
-  public static SerializedUnifyPair create(UnifyPair unifyPair) {
-    SerializedUnifyPair pair = new SerializedUnifyPair();
-    pair.lhs = SerializedUnifyTypeWrapper.create(unifyPair.getLhsType());
-    pair.rhs = SerializedUnifyTypeWrapper.create(unifyPair.getRhsType());
-    pair.operator = unifyPair.getPairOp();
-    return pair;
-  }
-
-  @Override
-  public UnifyPair toObject() {
-    return new UnifyPair(lhs.toObject(), rhs.toObject(), operator);
-  }
-}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/SerializedUnifyPairConstraint.java

@@ -1,52 +0,0 @@
-package de.dhbwstuttgart.server.packet.dataContainers;
-
-import com.fasterxml.jackson.annotation.JsonInclude;
-import com.fasterxml.jackson.annotation.JsonProperty;
-import de.dhbwstuttgart.server.packet.IPacket;
-import de.dhbwstuttgart.typeinference.constraints.Constraint;
-import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
-import java.util.Arrays;
-import java.util.HashSet;
-
-/**
- * Serializable container of
- *
- * @see Constraint<UnifyPair>
- */
-@JsonInclude(JsonInclude.Include.NON_NULL)
-public class SerializedUnifyPairConstraint implements IPacket.IDataContainer<Constraint<UnifyPair>> {
-
-  @JsonProperty("i")
-  public boolean isInherited;
-  @JsonProperty("ec")
-  public SerializedUnifyPairConstraint extendedConstraint = null;
-  @JsonProperty("p")
-  public SerializedUnifyPair[] methodSignatureConstraints;
-  @JsonProperty("c")
-  public SerializedUnifyPair[] constraintElements;
-
-
-  public static SerializedUnifyPairConstraint create(Constraint<UnifyPair> constraint) {
-    SerializedUnifyPairConstraint cons = new SerializedUnifyPairConstraint();
-    cons.constraintElements = constraint.stream().map(SerializedUnifyPair::create).toArray(SerializedUnifyPair[]::new);
-    cons.isInherited = constraint.isInherited();
-    if (constraint.getExtendConstraint() != null) {
-      cons.extendedConstraint = SerializedUnifyPairConstraint.create(constraint.getExtendConstraint());
-    }
-    cons.methodSignatureConstraints = constraint.getmethodSignatureConstraint().stream().map(SerializedUnifyPair::create).toArray(SerializedUnifyPair[]::new);
-    return cons;
-  }
-
-  @Override
-  public Constraint<UnifyPair> toObject() {
-    Constraint<UnifyPair> cons = new Constraint<>();
-
-    cons.addAll(Arrays.stream(constraintElements).map(SerializedUnifyPair::toObject).toList());
-    cons.setIsInherited(isInherited);
-    if (extendedConstraint != null) {
-      cons.setExtendConstraint(extendedConstraint.toObject());
-    }
-    cons.setmethodSignatureConstraint(new HashSet<>(Arrays.stream(methodSignatureConstraints).map(SerializedUnifyPair::toObject).toList()));
-    return cons;
-  }
-}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/SerializedUnifyTypeWrapper.java

@@ -1,65 +0,0 @@
-package de.dhbwstuttgart.server.packet.dataContainers;
-
-import com.fasterxml.jackson.annotation.JsonInclude;
-import com.fasterxml.jackson.annotation.JsonProperty;
-import de.dhbwstuttgart.server.packet.IPacket;
-import de.dhbwstuttgart.server.packet.dataContainers.unifyType.SerializedExtendsType;
-import de.dhbwstuttgart.server.packet.dataContainers.unifyType.SerializedFunNType;
-import de.dhbwstuttgart.server.packet.dataContainers.unifyType.SerializedPlaceholderType;
-import de.dhbwstuttgart.server.packet.dataContainers.unifyType.SerializedReferenceType;
-import de.dhbwstuttgart.server.packet.dataContainers.unifyType.SerializedSuperType;
-import de.dhbwstuttgart.typeinference.unify.model.ExtendsType;
-import de.dhbwstuttgart.typeinference.unify.model.FunNType;
-import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
-import de.dhbwstuttgart.typeinference.unify.model.ReferenceType;
-import de.dhbwstuttgart.typeinference.unify.model.SuperType;
-import de.dhbwstuttgart.typeinference.unify.model.UnifyType;
-
-/**
- * Serializable container of
- *
- * @see UnifyType
- */
-@JsonInclude(JsonInclude.Include.NON_NULL)
-public class SerializedUnifyTypeWrapper implements IPacket.IDataContainer<UnifyType> {
-
-  @JsonProperty("e")
-  public SerializedExtendsType extendsType = null;
-  @JsonProperty("s")
-  public SerializedSuperType superType = null;
-  @JsonProperty("r")
-  public SerializedReferenceType referenceType = null;
-  @JsonProperty("f")
-  public SerializedFunNType funNType = null;
-  @JsonProperty("p")
-  public SerializedPlaceholderType placeholderType = null;
-
-
-  public static SerializedUnifyTypeWrapper create(UnifyType unifyType) {
-    SerializedUnifyTypeWrapper wrapper = new SerializedUnifyTypeWrapper();
-
-    if (unifyType instanceof ExtendsType)
-      wrapper.extendsType = SerializedExtendsType.create((ExtendsType) unifyType);
-    else if (unifyType instanceof SuperType)
-      wrapper.superType = SerializedSuperType.create((SuperType) unifyType);
-    else if (unifyType instanceof ReferenceType)
-      wrapper.referenceType = SerializedReferenceType.create((ReferenceType) unifyType);
-    else if (unifyType instanceof FunNType)
-      wrapper.funNType = SerializedFunNType.create((FunNType) unifyType);
-    else if (unifyType instanceof PlaceholderType)
-      wrapper.placeholderType = SerializedPlaceholderType.create((PlaceholderType) unifyType);
-
-    return wrapper;
-  }
-
-
-  @Override
-  public UnifyType toObject() {
-    if (extendsType != null) return extendsType.toObject();
-    if (superType != null) return superType.toObject();
-    if (referenceType != null) return referenceType.toObject();
-    if (funNType != null) return funNType.toObject();
-    if (placeholderType != null) return placeholderType.toObject();
-    return null;
-  }
-}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/resultPairs/SerializedPairNoResult.java

@@ -1,38 +0,0 @@
-package de.dhbwstuttgart.server.packet.dataContainers.resultPairs;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import de.dhbwstuttgart.server.packet.IPacket;
-import de.dhbwstuttgart.server.packet.dataContainers.SerializedTokenWrapper;
-import de.dhbwstuttgart.typeinference.result.PairNoResult;
-
-/**
- * Serializable container of
- *
- * @see PairNoResult
- */
-public class SerializedPairNoResult implements IPacket.IDataContainer<PairNoResult> {
-
-  @JsonProperty("l")
-  public SerializedTokenWrapper left;
-  @JsonProperty("r")
-  public SerializedTokenWrapper right;
-
-  /**
-   * Use a static create method to leave the default constructor and simplify list conversions
-   */
-  public static SerializedPairNoResult create(PairNoResult pair) {
-    SerializedPairNoResult serialized = new SerializedPairNoResult();
-    serialized.left = SerializedTokenWrapper.create(pair.getLeft());
-    serialized.right = SerializedTokenWrapper.create(pair.getRight());
-    return serialized;
-  }
-
-  @Override
-  public PairNoResult toObject() {
-    return new PairNoResult(
-      left.toObject(),
-      right.toObject()
-    );
-  }
-
-}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/resultPairs/SerializedPairTPHEqualTPH.java

@@ -1,34 +0,0 @@
-package de.dhbwstuttgart.server.packet.dataContainers.resultPairs;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import de.dhbwstuttgart.server.packet.IPacket;
-import de.dhbwstuttgart.server.packet.dataContainers.token.SerializedPlaceholderType;
-import de.dhbwstuttgart.typeinference.result.PairTPHEqualTPH;
-
-/**
- * Serializable container of
- *
- * @see PairTPHEqualTPH
- */
-public class SerializedPairTPHEqualTPH implements IPacket.IDataContainer<PairTPHEqualTPH> {
-
-  @JsonProperty("l")
-  public SerializedPlaceholderType left;
-  @JsonProperty("r")
-  public SerializedPlaceholderType right;
-
-  public static SerializedPairTPHEqualTPH create(PairTPHEqualTPH pair) {
-    SerializedPairTPHEqualTPH serialized = new SerializedPairTPHEqualTPH();
-    serialized.left = SerializedPlaceholderType.create(pair.getLeft());
-    serialized.right = SerializedPlaceholderType.create(pair.getRight());
-    return serialized;
-  }
-
-  @Override
-  public PairTPHEqualTPH toObject() {
-    return new PairTPHEqualTPH(
-      left.toObject(),
-      right.toObject()
-    );
-  }
-}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/resultPairs/SerializedPairTPHequalRefTypeOrWildcardType.java

@@ -1,36 +0,0 @@
-package de.dhbwstuttgart.server.packet.dataContainers.resultPairs;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import de.dhbwstuttgart.server.packet.IPacket;
-import de.dhbwstuttgart.server.packet.dataContainers.SerializedTokenWrapper;
-import de.dhbwstuttgart.server.packet.dataContainers.token.SerializedPlaceholderType;
-import de.dhbwstuttgart.typeinference.result.PairTPHequalRefTypeOrWildcardType;
-
-/**
- * Serializable container of
- *
- * @see PairTPHequalRefTypeOrWildcardType
- */
-public class SerializedPairTPHequalRefTypeOrWildcardType implements IPacket.IDataContainer<PairTPHequalRefTypeOrWildcardType> {
-
-  @JsonProperty("l")
-  public SerializedPlaceholderType left;
-  @JsonProperty("r")
-  public SerializedTokenWrapper right;
-
-  public static SerializedPairTPHequalRefTypeOrWildcardType create(PairTPHequalRefTypeOrWildcardType pair) {
-    SerializedPairTPHequalRefTypeOrWildcardType serialized = new SerializedPairTPHequalRefTypeOrWildcardType();
-    serialized.left = SerializedPlaceholderType.create(pair.left);
-    serialized.right = SerializedTokenWrapper.create(pair.right);
-    return serialized;
-  }
-
-  @Override
-  public PairTPHequalRefTypeOrWildcardType toObject() {
-    return new PairTPHequalRefTypeOrWildcardType(
-      left.toObject(),
-      right.toObject()
-    );
-  }
-
-}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/resultPairs/SerializedPairTPHsmallerTPH.java

@@ -1,34 +0,0 @@
-package de.dhbwstuttgart.server.packet.dataContainers.resultPairs;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import de.dhbwstuttgart.server.packet.IPacket;
-import de.dhbwstuttgart.server.packet.dataContainers.token.SerializedPlaceholderType;
-import de.dhbwstuttgart.typeinference.result.PairTPHsmallerTPH;
-
-/**
- * Serializable container of
- *
- * @see PairTPHsmallerTPH
- */
-public class SerializedPairTPHsmallerTPH implements IPacket.IDataContainer<PairTPHsmallerTPH> {
-
-  @JsonProperty("l")
-  public SerializedPlaceholderType left;
-  @JsonProperty("r")
-  public SerializedPlaceholderType right;
-
-  public static SerializedPairTPHsmallerTPH create(PairTPHsmallerTPH pair) {
-    SerializedPairTPHsmallerTPH serialized = new SerializedPairTPHsmallerTPH();
-    serialized.left = SerializedPlaceholderType.create(pair.left);
-    serialized.right = SerializedPlaceholderType.create(pair.right);
-    return serialized;
-  }
-
-  @Override
-  public PairTPHsmallerTPH toObject() {
-    return new PairTPHsmallerTPH(
-      left.toObject(),
-      right.toObject()
-    );
-  }
-}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/serialized/ISerialNode.java

@@ -0,0 +1,31 @@
+package de.dhbwstuttgart.server.packet.dataContainers.serialized;
+
+import com.fasterxml.jackson.annotation.JsonSubTypes;
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+
+
+/**
+ * Use the following classes for an intermediate serialized tree structure
+ */
+@JsonTypeInfo(
+  use = JsonTypeInfo.Id.NAME,
+  include = JsonTypeInfo.As.PROPERTY,
+  property = "_t"
+)
+@JsonSubTypes({
+  @JsonSubTypes.Type(value = SerialMap.class, name = "m"),
+  @JsonSubTypes.Type(value = SerialList.class, name = "l"),
+  @JsonSubTypes.Type(value = SerialValue.class, name = "v"),
+  @JsonSubTypes.Type(value = SerialUUID.class, name = "u")
+})
+public interface ISerialNode {
+
+  default <T extends ISerialNode> T assertType(Class<T> type) {
+    if (type.isInstance(this)) {
+      return (T) this;
+    }
+    throw new RuntimeException("Expected ISerialNode to be of type " + type.getName()
+      + " but found " + this.getClass().getName() + " instead");
+  }
+
+}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/serialized/SerialList.java

@@ -0,0 +1,74 @@
+package de.dhbwstuttgart.server.packet.dataContainers.serialized;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+public class SerialList<I extends ISerialNode> extends ArrayList<I> implements ISerialNode {
+  public SerialList() {}
+  public SerialList(Collection<I> data) {
+    this.addAll(data);
+  }
+  public SerialList(Stream<I> data) {
+    this(data.toList());
+  }
+  public SerialList(I[] data) {
+    this(Arrays.stream(data).toList());
+  }
+
+  @SafeVarargs
+  @JsonIgnore
+  public static <A extends ISerialNode> ArrayList<A> from(A ...values) {
+    ArrayList<A> list = new SerialList<>();
+    Collections.addAll(list, values);
+    return list;
+  }
+  @JsonIgnore
+  public static <A,B extends ISerialNode> SerialList<B> fromMapped(Stream<A> data, Function<A,B> mapper) {
+    return new SerialList<>(data.map(mapper).toList());
+  }
+  @JsonIgnore
+  public static <A,B extends ISerialNode> SerialList<B> fromMapped(Collection<A> data, Function<A,B> mapper) {
+    return SerialList.fromMapped(data.stream(), mapper);
+  }
+  @JsonIgnore
+  public static <A,B extends ISerialNode> SerialList<B> fromMapped(A[] data, Function<A,B> mapper) {
+    return SerialList.fromMapped(Arrays.stream(data), mapper);
+  }
+
+  @JsonIgnore
+  public SerialList<SerialMap> assertListOfMaps() {
+    if (this.isEmpty() || this.get(0) instanceof SerialMap) {
+      return (SerialList<SerialMap>) this;
+    }
+    throw new RuntimeException("Required List to contain SerialMap elements but condition failed");
+  }
+
+  @JsonIgnore
+  public SerialList<SerialList<?>> assertListOfLists() {
+    if (this.isEmpty() || this.get(0) instanceof SerialList) {
+      return (SerialList<SerialList<?>>) this;
+    }
+    throw new RuntimeException("Required List to contain SerialList elements but condition failed");
+  }
+
+  @JsonIgnore
+  public SerialList<SerialValue<?>> assertListOfValues() {
+    if (this.isEmpty() || this.get(0) instanceof SerialValue) {
+      return (SerialList<SerialValue<?>>) this;
+    }
+    throw new RuntimeException("Required List to contain SerialValue elements but condition failed");
+  }
+
+  @JsonIgnore
+  public SerialList<SerialUUID> assertListOfUUIDs() {
+    if (this.isEmpty() || this.get(0) instanceof SerialUUID) {
+      return (SerialList<SerialUUID>) this;
+    }
+    throw new RuntimeException("Required List to contain SerialUUID elements but condition failed");
+  }
+}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/serialized/SerialMap.java

@@ -0,0 +1,84 @@
+package de.dhbwstuttgart.server.packet.dataContainers.serialized;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+public class SerialMap extends HashMap<String, ISerialNode> implements ISerialNode {
+
+  public SerialMap() {
+    super();
+  }
+
+  public SerialMap(Map<String, ISerialNode> data) {
+    super(data);
+  }
+
+  @JsonIgnore
+  public void put(String key, Boolean value) {
+    this.put(key, new SerialValue<>(value));
+  }
+
+  @JsonIgnore
+  public void put(String key, String value) {
+    this.put(key, new SerialValue<>(value));
+  }
+
+  @JsonIgnore
+  public void put(String key, Number value) {
+    this.put(key, new SerialValue<>(value));
+  }
+
+  @JsonIgnore
+  private <T> T get(String key, Class<T> expectedType) {
+    if (!this.containsKey(key)) {
+      throw new RuntimeException("Missing required value " + key + " in ObjectMap");
+    }
+    var element = this.get(key);
+    if (element != null && element.getClass() != expectedType) {
+      throw new RuntimeException(
+        "Required value " + key + " to be of type " + expectedType.getName() + " but found " + element.getClass().getName()
+      );
+    }
+    return (T)element;
+  }
+
+  @JsonIgnore
+  public SerialList<?> getList(String key) {
+    return this.get(key, SerialList.class);
+  }
+
+  @Nullable
+  @JsonIgnore
+  public SerialList<?> getListOrNull(String key) {
+    return this.containsKey(key) ? this.getList(key) : null;
+  }
+
+  @JsonIgnore
+  public SerialMap getMap(String key) {
+    return this.get(key, SerialMap.class);
+  }
+
+  @Nullable
+  @JsonIgnore
+  public SerialMap getMapOrNull(String key) {
+    return this.containsKey(key) ? this.getMap(key) : null;
+  }
+
+  @JsonIgnore
+  public SerialValue<?> getValue(String key) {
+    return this.get(key, SerialValue.class);
+  }
+
+  @JsonIgnore
+  public SerialUUID getUUID(String key) {
+    return this.get(key, SerialUUID.class);
+  }
+
+  @Nullable
+  @JsonIgnore
+  public SerialUUID getUUIDOrNull(String key) {
+    return this.containsKey(key) ? this.getUUID(key) : null;
+  }
+}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/serialized/SerialUUID.java

@@ -0,0 +1,13 @@
+package de.dhbwstuttgart.server.packet.dataContainers.serialized;
+
+public class SerialUUID implements ISerialNode {
+
+  public String uuid;
+
+  public SerialUUID() {}
+
+  public SerialUUID(String uuid) {
+    this.uuid = uuid;
+  }
+
+}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/serialized/SerialValue.java

@@ -0,0 +1,28 @@
+package de.dhbwstuttgart.server.packet.dataContainers.serialized;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+
+public class SerialValue<T> implements ISerialNode {
+  public T value;
+  public static final SerialValue<Object> NULL = new SerialValue<>(null);
+
+  public SerialValue() {}
+
+  public SerialValue(T value) {
+    this.value = value;
+  }
+
+  @JsonIgnore
+  public <A> SerialValue<A> assertValueOf(Class<A> targetClass) {
+    if (this.value == null || targetClass.isInstance(this.value)) {
+      return (SerialValue<A>) this;
+    }
+    throw new RuntimeException("Required Value to contain " + targetClass.getName() + " value but condition failed on" +
+      " type " + this.value.getClass().getName());
+  }
+
+  @JsonIgnore
+  public <A> A getOf(Class<A> targetClass) {
+    return this.assertValueOf(targetClass).value;
+  }
+}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/token/SerializedExtendsWildcardType.java

@@ -1,29 +0,0 @@
-package de.dhbwstuttgart.server.packet.dataContainers.token;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import de.dhbwstuttgart.parser.NullToken;
-import de.dhbwstuttgart.server.packet.IPacket;
-import de.dhbwstuttgart.server.packet.dataContainers.SerializedTokenWrapper;
-import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
-
-/**
- * Serializable container of
- *
- * @see ExtendsWildcardType
- */
-public class SerializedExtendsWildcardType implements IPacket.IDataContainer<ExtendsWildcardType> {
-
-  @JsonProperty("e")
-  public SerializedTokenWrapper extendsType;
-
-  public static SerializedExtendsWildcardType create(ExtendsWildcardType extendsWildcardType) {
-    SerializedExtendsWildcardType type = new SerializedExtendsWildcardType();
-    type.extendsType = SerializedTokenWrapper.create(extendsWildcardType.getInnerType());
-    return type;
-  }
-
-  @Override
-  public ExtendsWildcardType toObject() {
-    return new ExtendsWildcardType(extendsType.toObject(), new NullToken());
-  }
-}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/token/SerializedGenericRefType.java

@@ -1,28 +0,0 @@
-package de.dhbwstuttgart.server.packet.dataContainers.token;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import de.dhbwstuttgart.parser.NullToken;
-import de.dhbwstuttgart.server.packet.IPacket;
-import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
-
-/**
- * Serializable container of
- *
- * @see GenericRefType
- */
-public class SerializedGenericRefType implements IPacket.IDataContainer<GenericRefType> {
-
-  @JsonProperty("n")
-  public String name;
-
-  public static SerializedGenericRefType create(GenericRefType genericRefType) {
-    SerializedGenericRefType serialized = new SerializedGenericRefType();
-    serialized.name = genericRefType.getParsedName();
-    return serialized;
-  }
-
-  @Override
-  public GenericRefType toObject() {
-    return new GenericRefType(name, new NullToken());
-  }
-}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/token/SerializedPlaceholderType.java

@@ -1,27 +0,0 @@
-package de.dhbwstuttgart.server.packet.dataContainers.token;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import de.dhbwstuttgart.server.packet.IPacket;
-import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
-
-/**
- * Serializable container of
- *
- * @see TypePlaceholder
- */
-public class SerializedPlaceholderType implements IPacket.IDataContainer<TypePlaceholder> {
-
-  @JsonProperty("n")
-  public String name;
-
-  public static SerializedPlaceholderType create(TypePlaceholder typePlaceholder) {
-    SerializedPlaceholderType serialized = new SerializedPlaceholderType();
-    serialized.name = typePlaceholder.getName();
-    return serialized;
-  }
-
-  @Override
-  public TypePlaceholder toObject() {
-    return (TypePlaceholder) TypePlaceholder.of(name);
-  }
-}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/token/SerializedRefType.java

@@ -1,40 +0,0 @@
-package de.dhbwstuttgart.server.packet.dataContainers.token;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import de.dhbwstuttgart.parser.NullToken;
-import de.dhbwstuttgart.parser.scope.JavaClassName;
-import de.dhbwstuttgart.server.packet.IPacket;
-import de.dhbwstuttgart.server.packet.dataContainers.SerializedTokenWrapper;
-import de.dhbwstuttgart.syntaxtree.type.RefType;
-import java.util.Arrays;
-
-/**
- * Serializable container of
- *
- * @see RefType
- */
-public class SerializedRefType implements IPacket.IDataContainer<RefType> {
-
-  @JsonProperty("n")
-  public String name;
-  @JsonProperty("p")
-  public SerializedTokenWrapper[] parameters;
-
-  public static SerializedRefType create(RefType refType) {
-    SerializedRefType serialized = new SerializedRefType();
-
-    serialized.name = refType.getName().toString();
-    serialized.parameters = refType.getParaList().stream().map(SerializedTokenWrapper::create).toArray(SerializedTokenWrapper[]::new);
-
-    return serialized;
-  }
-
-  @Override
-  public RefType toObject() {
-    return new RefType(
-      new JavaClassName(name),
-      Arrays.stream(parameters).map(SerializedTokenWrapper::toObject).toList(),
-      new NullToken()
-    );
-  }
-}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/token/SerializedSuperWildcardType.java

@@ -1,30 +0,0 @@
-package de.dhbwstuttgart.server.packet.dataContainers.token;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import de.dhbwstuttgart.parser.NullToken;
-import de.dhbwstuttgart.server.packet.IPacket;
-import de.dhbwstuttgart.server.packet.dataContainers.SerializedTokenWrapper;
-import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
-
-/**
- * Serializable container of
- *
- * @see SuperWildcardType
- */
-public class SerializedSuperWildcardType implements IPacket.IDataContainer<SuperWildcardType> {
-
-  @JsonProperty("s")
-  public SerializedTokenWrapper superType;
-
-  public static SerializedSuperWildcardType create(SuperWildcardType superWildcardType) {
-    SerializedSuperWildcardType type = new SerializedSuperWildcardType();
-    type.superType = SerializedTokenWrapper.create(superWildcardType.getInnerType());
-    type.superType = SerializedTokenWrapper.create(superWildcardType.getInnerType());
-    return type;
-  }
-
-  @Override
-  public SuperWildcardType toObject() {
-    return new SuperWildcardType(superType.toObject(), new NullToken());
-  }
-}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/token/SerializedVoidType.java

@@ -1,24 +0,0 @@
-package de.dhbwstuttgart.server.packet.dataContainers.token;
-
-import de.dhbwstuttgart.parser.NullToken;
-import de.dhbwstuttgart.server.packet.IPacket;
-import de.dhbwstuttgart.syntaxtree.type.Void;
-
-/**
- * Serializable container of
- *
- * @see Void
- */
-public class SerializedVoidType implements IPacket.IDataContainer<Void> {
-
-  public int i = 0;
-
-  public static SerializedVoidType create(Void voidType) {
-    return new SerializedVoidType();
-  }
-
-  @Override
-  public Void toObject() {
-    return new Void(new NullToken());
-  }
-}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/unifyType/SerializedExtendsType.java

@@ -1,26 +0,0 @@
-package de.dhbwstuttgart.server.packet.dataContainers.unifyType;
-
-import de.dhbwstuttgart.server.packet.IPacket;
-import de.dhbwstuttgart.typeinference.unify.model.ExtendsType;
-
-/**
- * Serializable container of
- *
- * @see ExtendsType
- */
-public class SerializedExtendsType extends SerializedWildcardType implements IPacket.IDataContainer<ExtendsType> {
-
-  public static SerializedExtendsType create(ExtendsType extendsType) {
-    SerializedExtendsType type = new SerializedExtendsType();
-    type.readWildcardTypeValues(extendsType);
-    return type;
-  }
-
-  @Override
-  public ExtendsType toObject() {
-    return new ExtendsType(
-      this.wildcardedType.toObject()
-    );
-  }
-
-}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/unifyType/SerializedFunNType.java

@@ -1,32 +0,0 @@
-package de.dhbwstuttgart.server.packet.dataContainers.unifyType;
-
-import de.dhbwstuttgart.server.packet.IPacket;
-import de.dhbwstuttgart.server.packet.dataContainers.SerializedUnifyTypeWrapper;
-import de.dhbwstuttgart.typeinference.unify.model.FunNType;
-import de.dhbwstuttgart.typeinference.unify.model.TypeParams;
-import java.util.Arrays;
-
-/**
- * Serializable container of
- *
- * @see FunNType
- */
-public class SerializedFunNType extends SerializedUnifyType implements IPacket.IDataContainer<FunNType> {
-
-
-  public static SerializedFunNType create(FunNType funN) {
-    SerializedFunNType type = new SerializedFunNType();
-    type.readUnifyTypeValues(funN);
-    return type;
-  }
-
-  @Override
-  public FunNType toObject() {
-    return FunNType.getFunNType(
-      new TypeParams(
-        Arrays.stream(this.params).map(SerializedUnifyTypeWrapper::toObject).toList()
-      )
-    );
-  }
-
-}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/unifyType/SerializedPlaceholderType.java

@@ -1,38 +0,0 @@
-package de.dhbwstuttgart.server.packet.dataContainers.unifyType;
-
-import de.dhbwstuttgart.server.packet.IPacket;
-import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
-
-/**
- * Serializable container of
- *
- * @see PlaceholderType
- */
-public class SerializedPlaceholderType extends SerializedUnifyType implements IPacket.IDataContainer<PlaceholderType> {
-
-  public boolean isGenerated;
-  public boolean isInnerType;
-  public int variance;
-  public byte orCons;
-
-
-  public static SerializedPlaceholderType create(PlaceholderType placeholder) {
-    SerializedPlaceholderType type = new SerializedPlaceholderType();
-    type.readUnifyTypeValues(placeholder);
-    type.isGenerated = placeholder.isGenerated();
-    type.isInnerType = placeholder.isInnerType();
-    type.variance = placeholder.getVariance();
-    type.orCons = placeholder.getOrCons();
-    return type;
-  }
-
-  @Override
-  public PlaceholderType toObject() {
-    PlaceholderType placeholderType = new PlaceholderType(this.name, this.isGenerated);
-    placeholderType.setInnerType(this.isInnerType);
-    placeholderType.setVariance(this.variance);
-    placeholderType.setOrCons(this.orCons);
-    return placeholderType;
-  }
-
-}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/unifyType/SerializedReferenceType.java

@@ -1,37 +0,0 @@
-package de.dhbwstuttgart.server.packet.dataContainers.unifyType;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import de.dhbwstuttgart.server.packet.IPacket;
-import de.dhbwstuttgart.server.packet.dataContainers.SerializedUnifyTypeWrapper;
-import de.dhbwstuttgart.typeinference.unify.model.ReferenceType;
-import de.dhbwstuttgart.typeinference.unify.model.TypeParams;
-import java.util.Arrays;
-
-/**
- * Serializable container of
- *
- * @see ReferenceType
- */
-public class SerializedReferenceType extends SerializedUnifyType implements IPacket.IDataContainer<ReferenceType> {
-
-  @JsonProperty("gt")
-  public boolean genericTypeVar;
-
-  public static SerializedReferenceType create(ReferenceType referenceType) {
-    SerializedReferenceType type = new SerializedReferenceType();
-    type.readUnifyTypeValues(referenceType);
-    type.genericTypeVar = referenceType.isGenTypeVar();
-    return type;
-  }
-
-  @Override
-  public ReferenceType toObject() {
-    ReferenceType referenceType = new ReferenceType(this.name, this.genericTypeVar);
-    return (ReferenceType) referenceType.setTypeParams(
-      new TypeParams(
-        Arrays.stream(this.params).map(SerializedUnifyTypeWrapper::toObject).toList()
-      )
-    );
-  }
-
-}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/unifyType/SerializedSuperType.java

@@ -1,26 +0,0 @@
-package de.dhbwstuttgart.server.packet.dataContainers.unifyType;
-
-import de.dhbwstuttgart.server.packet.IPacket;
-import de.dhbwstuttgart.typeinference.unify.model.SuperType;
-
-/**
- * Serializable container of
- *
- * @see SuperType
- */
-public class SerializedSuperType extends SerializedWildcardType implements IPacket.IDataContainer<SuperType> {
-
-  public static SerializedSuperType create(SuperType superType) {
-    SerializedSuperType type = new SerializedSuperType();
-    type.readWildcardTypeValues(superType);
-    return type;
-  }
-
-  @Override
-  public SuperType toObject() {
-    return new SuperType(
-      this.wildcardedType.toObject()
-    );
-  }
-
-}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/unifyType/SerializedUnifyType.java

@@ -1,24 +0,0 @@
-package de.dhbwstuttgart.server.packet.dataContainers.unifyType;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import de.dhbwstuttgart.server.packet.dataContainers.SerializedUnifyTypeWrapper;
-import de.dhbwstuttgart.typeinference.unify.model.UnifyType;
-import java.util.Arrays;
-
-/**
- * Serializable abstract container of
- *
- * @see UnifyType
- */
-abstract class SerializedUnifyType {
-
-  @JsonProperty("n")
-  public String name;
-  @JsonProperty("p")
-  public SerializedUnifyTypeWrapper[] params = new SerializedUnifyTypeWrapper[]{};
-
-  public void readUnifyTypeValues(UnifyType unifyType) {
-    name = unifyType.getName();
-    params = Arrays.stream(unifyType.getTypeParams().get()).map(SerializedUnifyTypeWrapper::create).toArray(SerializedUnifyTypeWrapper[]::new);
-  }
-}

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/unifyType/SerializedWildcardType.java

@@ -1,20 +0,0 @@
-package de.dhbwstuttgart.server.packet.dataContainers.unifyType;
-
-import de.dhbwstuttgart.server.packet.dataContainers.SerializedUnifyTypeWrapper;
-import de.dhbwstuttgart.typeinference.unify.model.WildcardType;
-
-/**
- * Serializable abstract container of
- *
- * @see WildcardType
- */
-abstract class SerializedWildcardType extends SerializedUnifyType {
-
-  public SerializedUnifyTypeWrapper wildcardedType;
-
-  public void readWildcardTypeValues(WildcardType wildcardType) {
-    this.readUnifyTypeValues(wildcardType);
-    wildcardedType = SerializedUnifyTypeWrapper.create(wildcardType.getWildcardedType());
-  }
-
-}

src/main/java/de/dhbwstuttgart/syntaxtree/AbstractASTWalker.java

@@ -349,4 +349,4 @@ public abstract class AbstractASTWalker implements ASTVisitor {
         ternary.iftrue.accept(this);
         ternary.iffalse.accept(this);
     }
-}
+}

src/main/java/de/dhbwstuttgart/syntaxtree/Constructor.java

@@ -4,6 +4,7 @@ import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.syntaxtree.statement.Statement;
 import de.dhbwstuttgart.syntaxtree.statement.Super;
 import de.dhbwstuttgart.syntaxtree.statement.SuperCall;
+import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.syntaxtree.type.Void;
 import org.antlr.v4.runtime.Token;

src/main/java/de/dhbwstuttgart/syntaxtree/FieldDeclaration.java

@@ -1,9 +1,10 @@
 package de.dhbwstuttgart.syntaxtree;
 
 import de.dhbwstuttgart.syntaxtree.statement.Expression;
-import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import org.antlr.v4.runtime.Token;
 
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+
 /**
  * Eine Feldinitialisation steht für eine Felddeklaration mit gleichzeitiger Wertzuweisung
  * Beispiel: 'public Feld FeldVar = FeldWert;'
@@ -24,4 +25,4 @@ public class FieldDeclaration extends Field{
     }
 
 
-}
+}

src/main/java/de/dhbwstuttgart/syntaxtree/GenericDeclarationList.java

@@ -1,12 +1,12 @@
 package de.dhbwstuttgart.syntaxtree;
 
-import com.google.common.collect.Lists;
 import org.antlr.v4.runtime.Token;
 
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Objects;
+import com.google.common.collect.Lists;
+
+import de.dhbwstuttgart.parser.NullToken;
+
+import java.util.*;
 
 
 /**

src/main/java/de/dhbwstuttgart/syntaxtree/GenericTypeVar.java

@@ -1,6 +1,7 @@
 package de.dhbwstuttgart.syntaxtree;
 
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+
 import org.antlr.v4.runtime.Token;
 
 import java.util.ArrayList;

src/main/java/de/dhbwstuttgart/syntaxtree/Method.java

@@ -3,14 +3,17 @@ package de.dhbwstuttgart.syntaxtree;
 import java.util.ArrayList;
 import java.util.Objects;
 
-import de.dhbwstuttgart.core.IItemWithOffset;
 import de.dhbwstuttgart.parser.NullToken;
-import de.dhbwstuttgart.syntaxtree.statement.Block;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
+import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
+import de.dhbwstuttgart.typeinference.typeAlgo.TYPE;
+import de.dhbwstuttgart.typeinference.typeAlgo.TYPEStmt;
 import org.antlr.v4.runtime.Token;
 
-import java.util.ArrayList;
+import de.dhbwstuttgart.core.IItemWithOffset;
+import de.dhbwstuttgart.syntaxtree.statement.Block;
 
 /**
  * Stellt eine Methode dar. Problem: Parser kann nicht zwischen Methode und
@@ -31,7 +34,7 @@ public class Method extends SyntaxTreeNode implements IItemWithOffset, TypeScope
 	private final RefTypeOrTPHOrWildcardOrGeneric returnType;
 	public final Boolean isInherited; 
 	public final Boolean isImplemented;
-
+	
 	/*
 	 * its Constraints
 	 * eingefuegt PL 2021-02-15
@@ -107,10 +110,10 @@ public class Method extends SyntaxTreeNode implements IItemWithOffset, TypeScope
 	public int hashCode() {
 		return Objects.hash(name, parameterlist, returnType);
 	}
-
+	
 	@Override
 	public String toString() {
 		return name;
-
+	
 	}
 }

src/main/java/de/dhbwstuttgart/syntaxtree/SourceFile.java

@@ -5,11 +5,8 @@ import java.util.*;
 
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
-
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
+import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
+import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
 //import sun.security.x509.X509CertInfo;
 
 public class SourceFile extends SyntaxTreeNode {

src/main/java/de/dhbwstuttgart/syntaxtree/SyntaxTree.java

@@ -0,0 +1,8 @@
+package de.dhbwstuttgart.syntaxtree;
+
+import de.dhbwstuttgart.util.Logger;
+
+public class SyntaxTree {
+
+  public static Logger logger = new Logger("SyntaxTree");
+}

src/main/java/de/dhbwstuttgart/syntaxtree/SyntaxTreeNode.java

@@ -1,6 +1,10 @@
 package de.dhbwstuttgart.syntaxtree;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import de.dhbwstuttgart.core.IItemWithOffset;
+import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
 import org.antlr.v4.runtime.Token;
 //import org.antlr.v4.runtime.misc.Pair;
 
@@ -16,4 +20,4 @@ public abstract class SyntaxTreeNode implements IItemWithOffset{
     }
 
     public abstract void accept(ASTVisitor visitor);
-}
+}

src/main/java/de/dhbwstuttgart/syntaxtree/TypeScope.java

@@ -2,9 +2,11 @@ package de.dhbwstuttgart.syntaxtree;
 
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 
+import java.util.Collection;
+
 
 public interface TypeScope {
     Iterable<? extends GenericTypeVar> getGenerics();
 
     RefTypeOrTPHOrWildcardOrGeneric getReturnType();
-}
+}

src/main/java/de/dhbwstuttgart/syntaxtree/factory/ASTFactory.java

@@ -26,10 +26,6 @@ import org.objectweb.asm.*;
 import org.objectweb.asm.signature.SignatureReader;
 import org.objectweb.asm.signature.SignatureVisitor;
 
-import java.lang.reflect.Constructor;
-import java.lang.reflect.*;
-import java.util.*;
-
 /**
  * Anmerkung: Die ASTFactory Methoden, welche ASTBäume aus java.lang.Class Objekten generieren, können davon ausgehen, dass alle Imports und Typnamen korrekt sind und müssen diese nicht überprüfen.
  */
@@ -115,9 +111,9 @@ public class ASTFactory {
 			else {
 				Boolean isImplemented = false;
 				isImplemented = Arrays.stream(jreClass.getInterfaces()).
-									   reduce(false,
+									   reduce(false, 
 											  (x,y) -> {
-												  try {
+												  try { 
 													  y.getDeclaredMethod(method.getName(), method.getParameterTypes());
 													  return true;
 												  }
@@ -126,24 +122,24 @@ public class ASTFactory {
 												  }},
 											  (x,y) -> (x || y)
 											 );
-
+					
 			    if (isImplemented) {
 			    	methoden.add(createMethod(method, signature, jreClass, false, true));
 			    }
 			    else {
-			    	if (Modifier.isAbstract(jreClass.getSuperclass().getModifiers())) {
+			    	if (Modifier.isAbstract(jreClass.getSuperclass().getModifiers())) {	
 			    		try {
 			    			jreClass.getSuperclass().getDeclaredMethod(method.getName(), method.getParameterTypes());
 			    			methoden.add(createMethod(method, signature, jreClass, false, true));
 			    		}
-			    		catch (java.lang.NoSuchMethodException e) {
-								methoden.add(createMethod(method, signature, jreClass, false, false));
+			    		catch (java.lang.NoSuchMethodException e) { 
+								methoden.add(createMethod(method, signature, jreClass, false, false));	
 			    		}
 			    	}
 			    	else {
 			    		methoden.add(createMethod(method, signature, jreClass, false, false));
 			    	}
-
+			    	
 			    }
 		}}
 		for (java.lang.reflect.Method method : allInheritedMethods) {
@@ -157,11 +153,11 @@ public class ASTFactory {
 		int modifier = jreClass.getModifiers();
 		boolean isInterface = jreClass.isInterface();
 		List<Annotation> aLA;
-		boolean isFunctionalInterface =
-				(aLA = Arrays.asList(jreClass.getAnnotations())).size() > 0 &&
-				aLA.get(0) instanceof FunctionalInterface ?
-						true :
-						false;
+		boolean isFunctionalInterface = 
+				(aLA = Arrays.asList(jreClass.getAnnotations())).size() > 0 && 
+				aLA.get(0) instanceof FunctionalInterface ? 
+						true : 
+						false; 
 		// see: https://stackoverflow.com/questions/9934774/getting-generic-parameter-from-supertype-class
 		ParameterizedType parameterSuperClass = null;
 		Type tempSuperClass = jreClass.getGenericSuperclass();
@@ -468,25 +464,25 @@ public class ASTFactory {
 
 	/*
 	 * public Constructor createEmptyConstructor(Class parent){ Block block = new Block(); block.setType(new de.dhbwstuttgart.syntaxtree.type.Void(block, 0)); block.statements.add(new SuperCall(block));
-	 *
+	 * 
 	 * return ASTFactory.createConstructor(parent, new ParameterList(), block); }
-	 *
+	 * 
 	 * public static Constructor createConstructor(Class superClass, ParameterList paralist, Block block){ block.parserPostProcessing(superClass);
-	 *
+	 * 
 	 * Method method = ASTFactory.createMethod("<init>", paralist, block, superClass); method.setType(new de.dhbwstuttgart.syntaxtree.type.Void(block, 0));
-	 *
+	 * 
 	 * return new Constructor(method, superClass); }
-	 *
+	 * 
 	 * public static Class createClass(String className, RefType type, Modifiers modifiers, Menge supertypeGenPara, SourceFile parent) { // TODO bytecode createClass //String name, RefType superClass, Modifiers modifiers, Menge<String> supertypeGenPara Class generatedClass = new Class(className, type, modifiers, supertypeGenPara); generatedClass.addField(ASTFactory.createEmptyConstructor(generatedClass));
-	 *
+	 * 
 	 * generatedClass.parserPostProcessing(parent);
-	 *
+	 * 
 	 * return generatedClass; }
-	 *
+	 * 
 	 * public static Class createObject(){ return createClass(java.lang.Object.class); }
-	 *
+	 * 
 	 * public static Class createInterface(String className, RefType superClass, Modifiers modifiers, Menge supertypeGenPara, SourceFile parent){ Class generatedClass = new Class(new JavaClassName(className), new ArrayList<Method>(), new ArrayList<Field>(), modifiers, true, superClass, new ArrayList<RefType>(), new GenericDeclarationList(), -1); generatedClass.parserPostProcessing(parent); return generatedClass; }
-	 *
+	 * 
 	 * public static RefType createObjectType(){ return createObjectClass().getType(); }
 	 */
-}
+}

src/main/java/de/dhbwstuttgart/syntaxtree/factory/NameGenerator.java

@@ -1,5 +1,8 @@
 package de.dhbwstuttgart.syntaxtree.factory;
 
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.core.JavaTXServer;
+
 public class NameGenerator {
 
     private static String strNextName = "A";
@@ -26,7 +29,11 @@ public class NameGenerator {
     
         // n�chster Name berechnen und in strNextName speichern        
         inc( strNextName.length() - 1 );
-        
+
+        if (JavaTXServer.isRunning) {
+            throw new RuntimeException("Using the NameGenerator on a server is not allowed");
+        }
+        JavaTXCompiler.defaultClientPlaceholderRegistry.addPlaceholder(strReturn);
         return strReturn;        
     }