sort resultsets before printing them to the console to enhance comparability between results

modified:   ../src/main/java/de/dhbwstuttgart/core/JavaTXCompiler.java
	modified:   ../src/test/java/TestComplete.java

.gitea/workflows/build_and_test.yml

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

independentTest.sh

@@ -1,40 +0,0 @@
-#!/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

@@ -12,57 +12,37 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 	<url>http://maven.apache.org</url>
 	<dependencies>
 		<dependency>
-			<groupId>junit</groupId>
+			<groupId>org.junit.jupiter</groupId>
-			<artifactId>junit</artifactId>
+			<artifactId>junit-jupiter-api</artifactId>
-			<version>4.13.2</version>
+			<version>5.13.2</version>
 			<scope>test</scope>
 		</dependency>
 		<!-- https://mvnrepository.com/artifact/org.antlr/antlr4 -->
 		<dependency>
 			<groupId>org.antlr</groupId>
 			<artifactId>antlr4</artifactId>
-			<version>4.11.1</version>
+			<version>4.13.2</version>
 		</dependency>
 		<dependency>
 			<groupId>commons-io</groupId>
 			<artifactId>commons-io</artifactId>
-			<version>2.16.1</version>
+			<version>2.19.0</version>
 		</dependency>
 		<dependency>
 			<groupId>io.github.classgraph</groupId>
 			<artifactId>classgraph</artifactId>
-			<version>4.8.172</version>
+			<version>4.8.180</version>
 		</dependency>
 		<dependency>
 			<groupId>com.google.guava</groupId>
 			<artifactId>guava</artifactId>
-			<version>33.2.0-jre</version>
+			<version>33.4.8-jre</version>
 		</dependency>
 		<!-- https://mvnrepository.com/artifact/org.ow2.asm/asm -->
 		<dependency>
 			<groupId>org.ow2.asm</groupId>
 			<artifactId>asm</artifactId>
-			<version>9.5</version>
+			<version>9.8</version>
-		</dependency>
-		<dependency>
-			<groupId>org.java-websocket</groupId>
-			<artifactId>Java-WebSocket</artifactId>
-			<version>1.5.2</version>
-		</dependency>
-		<dependency>
-			<groupId>org.slf4j</groupId>
-			<artifactId>slf4j-simple</artifactId>
-			<version>1.7.25</version>
-		</dependency>
-		<dependency>
-			<groupId>com.fasterxml.jackson.core</groupId>
-			<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>
 
@@ -71,17 +51,17 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-compiler-plugin</artifactId>
-				<version>3.11.0</version>
+				<version>3.14.0</version>
 				<configuration>
 					<compilerArgs>--enable-preview</compilerArgs>
-                    <source>23</source>
+                    <source>24</source>
-                    <target>23</target>
+                    <target>24</target>
                 </configuration>
 			</plugin>
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-surefire-plugin</artifactId>
-				<version>3.1.0</version>
+				<version>3.5.3</version>
 				<configuration>
 					<redirectTestOutputToFile>true</redirectTestOutputToFile>
 					<reportsDirectory>${project.build.directory}/test-reports</reportsDirectory>
@@ -97,7 +77,7 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 			<plugin>
 				<groupId>org.antlr</groupId>
 				<artifactId>antlr4-maven-plugin</artifactId>
-				<version>4.11.1</version>
+				<version>4.13.2</version>
 				<executions>
 					<execution>
 						<id>antlr</id>
@@ -110,7 +90,7 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-jar-plugin</artifactId>
-				<version>3.3.0</version>
+				<version>3.4.2</version>
 				<configuration>
 					<archive>
 						<manifest>
@@ -158,4 +138,4 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 			<url>file:///${project.basedir}/maven-repository/</url>
 		</repository>
 	</distributionManagement>
-</project>
+</project>

resources/LaufzeitTests/DeeplyNested.jav

@@ -1,51 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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/Bug363.jav

@@ -0,0 +1,22 @@
+import java.lang.String;
+
+
+public class Bug363 {
+  uncurry (f){
+    return x -> f.apply(x);
+  }
+
+  uncurry (f){
+    return (x, y) -> f.apply(x).apply(y);
+  }
+
+  uncurry (f){
+    return (x, y, z) -> f.apply(x).apply(y).apply(z);
+  }
+
+  public test(){
+    var f = x -> y -> z -> x + y + z;
+    var g = uncurry(f);
+    return g.apply("A", "B", "C"); // Outputs: 6
+  }
+}

resources/bytecode/javFiles/Bug364.jav

@@ -0,0 +1,8 @@
+import java.lang.String;
+
+public class Bug364{
+  public main(){
+    var f = x -> y -> z -> x + y + z;
+    return f.apply("A").apply("B").apply("C");
+  }
+}

resources/bytecode/javFiles/Bug365.jav

@@ -0,0 +1,20 @@
+import java.lang.String;
+
+public class Bug365{
+  swap(f){
+    return x -> y -> f.apply(y).apply(x);
+  }
+
+  swap(f){
+    return x -> y -> z -> f.apply(z).apply(y).apply(x);
+  }
+
+  public ex1() {
+    var func = x -> y -> z -> x + y + z;
+    return func.apply("A").apply("B").apply("C");
+  }
+  public ex2() {
+    var func = x -> y -> z -> x + y + z;
+    return swap(func).apply("A").apply("B").apply("C");
+  }
+}

resources/bytecode/javFiles/Bug366.jav

@@ -0,0 +1,12 @@
+import java.lang.Integer;
+
+public class Bug366 {
+    public static lambda() {
+        return (a, b) -> a + b;
+    }
+
+    public static test() {
+        var l = lambda();
+        return l.apply(10, 20);
+    }
+}

resources/bytecode/javFiles/Merge2.jav

@@ -1,17 +0,0 @@
-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));
-    }
-    
-}

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

@@ -8,20 +8,18 @@ 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 java.util.stream.Collectors;
 
 import static org.objectweb.asm.Opcodes.*;
 import static de.dhbwstuttgart.target.tree.expression.TargetBinaryOp.*;
 import static de.dhbwstuttgart.target.tree.expression.TargetLiteral.*;
 
 public class Codegen {
-    public static Logger logger = new Logger("codegen");
-
     private final TargetStructure clazz;
     private final ClassWriter cw;
     public final String className;
@@ -87,14 +85,16 @@ public class Codegen {
         int localCounter;
         MethodVisitor mv;
         TargetType returnType;
+        boolean isStatic = false;
 
         Stack<BreakEnv> breakStack = new Stack<>();
         Stack<Integer> switchResultValue = new Stack<>();
 
-        State(TargetType returnType, MethodVisitor mv, int localCounter) {
+        State(TargetType returnType, MethodVisitor mv, int localCounter, boolean isStatic) {
             this.returnType = returnType;
             this.mv = mv;
             this.localCounter = localCounter;
+            this.isStatic = isStatic;
         }
 
         void enterScope() {
@@ -760,6 +760,16 @@ public class Codegen {
         }
     }
 
+    private static TargetType removeGenerics(TargetType param) {
+        return switch (param) {
+            case null -> null;
+            case TargetFunNType funNType -> new TargetFunNType(funNType.name(), funNType.funNParams(), List.of(), funNType.returnArguments());
+            case TargetRefType refType -> new TargetRefType(refType.name());
+            case TargetGenericType targetGenericType -> TargetType.Object;
+            default -> param;
+        };
+    }
+
     private void generateLambdaExpression(State state, TargetLambdaExpression lambda) {
         var mv = state.mv;
 
@@ -771,7 +781,8 @@ public class Codegen {
 
         var parameters = new ArrayList<>(lambda.captures());
         parameters.addAll(signature.parameters());
-        var implSignature = new TargetMethod.Signature(Set.of(), parameters, lambda.signature().returnType());
+        parameters = parameters.stream().map(param -> param.withType(removeGenerics(param.pattern().type()))).collect(Collectors.toCollection(ArrayList::new));
+        var implSignature = new TargetMethod.Signature(Set.of(), parameters, removeGenerics(lambda.signature().returnType()));
 
         TargetMethod impl;
         if (lambdas.containsKey(lambda)) {
@@ -779,21 +790,22 @@ public class Codegen {
         } else {
             var name = "lambda$" + lambdaCounter++;
 
-            impl = new TargetMethod(0, name, lambda.block(), implSignature, null);
+            impl = new TargetMethod(state.isStatic ? ACC_STATIC : 0, name, lambda.block(), implSignature, null);
-            generateMethod(impl);
+            generateMethod(impl, state);
             lambdas.put(lambda, impl);
         }
 
         var mt = MethodType.methodType(CallSite.class, MethodHandles.Lookup.class, String.class, MethodType.class, MethodType.class, MethodHandle.class, MethodType.class);
 
         var bootstrap = new Handle(H_INVOKESTATIC, "java/lang/invoke/LambdaMetafactory", "metafactory", mt.toMethodDescriptorString(), false);
-        var handle = new Handle(H_INVOKEVIRTUAL, clazz.getName(), impl.name(), implSignature.getDescriptor(), false);
+        var handle = new Handle(state.isStatic ? H_INVOKESTATIC : H_INVOKEVIRTUAL, clazz.getName(), impl.name(), implSignature.getDescriptor(), false);
 
         var params = new ArrayList<TargetType>();
-        params.add(new TargetRefType(clazz.qualifiedName().getClassName()));
+        if(!state.isStatic) params.add(new TargetRefType(clazz.qualifiedName().getClassName()));
         params.addAll(lambda.captures().stream().map(mp -> mp.pattern().type()).toList());
 
-        mv.visitVarInsn(ALOAD, 0);
+        if (!state.isStatic)
+            mv.visitVarInsn(ALOAD, 0);
         for (var index = 0; index < lambda.captures().size(); index++) {
             var capture = lambda.captures().get(index);
             var pattern = (TargetTypePattern) capture.pattern();
@@ -1320,7 +1332,7 @@ public class Codegen {
                 types.add(Type.getObjectType(guard.inner().type().getInternalName()));
                 // TODO Same here we need to evaluate constant;
             } else {
-                logger.info(label);
+                System.out.println(label);
                 throw new NotImplementedException();
             }
         }
@@ -1521,7 +1533,7 @@ public class Codegen {
         MethodVisitor mv = cw.visitMethod(ACC_PUBLIC | ACC_STATIC, "<clinit>", "()V", null, null);
         mv.visitCode();
 
-        var state = new State(null, mv, 0);
+        var state = new State(null, mv, 0, true);
         generate(state, constructor.block());
 
         mv.visitInsn(RETURN);
@@ -1535,7 +1547,7 @@ public class Codegen {
             mv.visitAttribute(new JavaTXSignatureAttribute(constructor.getTXSignature()));
         
         mv.visitCode();
-        var state = new State(null, mv, 1);
+        var state = new State(null, mv, 1, false);
         for (var param : constructor.parameters()) {
             var pattern = param.pattern();
             if (pattern instanceof TargetTypePattern tp)
@@ -1581,8 +1593,11 @@ public class Codegen {
             }
         }
     }
-
     private void generateMethod(TargetMethod method) {
+        generateMethod(method, null);
+    }
+
+    private void generateMethod(TargetMethod method, State parent) {
         var access = method.access();
         if (method.block() == null)
             access |= ACC_ABSTRACT;
@@ -1597,7 +1612,10 @@ public class Codegen {
 
         if (method.block() != null) {
             mv.visitCode();
-            var state = new State(method.signature().returnType(), mv, method.isStatic() ? 0 : 1);
+            var state = new State(method.signature().returnType(), mv, method.isStatic() ? 0 : 1, method.isStatic());
+            if (parent != null) {
+                state.scope.parent = parent.scope;
+            }
             var offset = 1;
             for (var param : method.signature().parameters()) {
                 state.createVariable(param.pattern().name(), param.pattern().type());
@@ -1607,6 +1625,8 @@ public class Codegen {
                     bindLocalVariables(state, cp, offset);
                 offset++;
             }
+            //if (parent != null) System.out.println("parent: " + parent.scope.locals.keySet());
+            //System.out.println(state.scope.locals.keySet());
             generate(state, method.block());
             if (method.signature().returnType() == null)
                 mv.visitInsn(RETURN);
@@ -1713,7 +1733,7 @@ public class Codegen {
 
             // Generate wrapper method
             var mv = cw2.visitMethod(ACC_PUBLIC, toMethod.name, toDescriptor, null, null);
-            var state = new State(null, mv, 0);
+            var state = new State(null, mv, 0, false);
 
             mv.visitVarInsn(ALOAD, 0);
             mv.visitFieldInsn(GETFIELD, className, "wrapped", pair.from.toDescriptor());
@@ -1745,7 +1765,7 @@ public class Codegen {
                 converter.classLoader.findClass(className);
             } catch (ClassNotFoundException e) {
                 try {
-                    converter.classLoader.loadClass(bytes);
+                    converter.classLoader.loadClass(className, bytes);
                 } catch (LinkageError ignored) {}
             }
         }

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

@@ -39,6 +39,10 @@ public class FunNGenerator {
         public final List<TargetType> inParams;
         public final List<TargetType> realParams;
 
+        public GenericParameters(TargetFunNType funNType) {
+            this(funNType.funNParams(), funNType.returnArguments());
+        }
+
         public GenericParameters(List<TargetType> params, int numReturns) {
             this.realParams = params;
             this.inParams = flattenTypeParams(params);
@@ -120,7 +124,7 @@ public class FunNGenerator {
             superFunNMethodDescriptor.append(")V");
         }
 
-        Codegen.logger.info(superFunNMethodSignature);
+        System.out.println(superFunNMethodSignature);
 
         ClassWriter classWriter = new ClassWriter(0);
         MethodVisitor methodVisitor;

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

@@ -1,81 +1,46 @@
 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.*;
-
 public class ConsoleInterface {
+	private static final String directory = System.getProperty("user.dir");
 
-  /**
+	public static void main(String[] args) throws IOException, ClassNotFoundException {
-   * Leave the argument configurations here for the rest of the code to read
+		List<File> input = new ArrayList<>();
-   */
+		List<File> classpath = new ArrayList<>();
-  public static Logger.LogLevel logLevel = Logger.LogLevel.ERROR;
+        String outputPath = null;
-  public static boolean writeLogFiles = false;
+		Iterator<String> it = Arrays.asList(args).iterator();
-  public static Optional<String> unifyServerUrl = Optional.empty();
+        if(args.length == 0){
-
+            System.out.println("No input files given. Get help with --help");
-  public static void main(String[] args) throws IOException, ClassNotFoundException {
+            System.exit(1);
-    List<File> input = new ArrayList<>();
+        }else if(args.length == 1 && args[0].equals("--help")){
-    List<File> classpath = new ArrayList<>();
+            System.out.println("Usage: javatx [OPTION]... [FILE]...\n" +
-    String outputPath = null;
+                    "\t-cp\tSet Classpath\n" +
-    Iterator<String> it = Arrays.asList(args).iterator();
+                    "\t-d\tSet destination directory");
-    Optional<Integer> serverPort = Optional.empty();
+            System.exit(1);
-
-    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 if (arg.equals("--server-mode")) {
+		while(it.hasNext()){
-        serverPort = Optional.of(Integer.parseInt(it.next()));
+            String arg = it.next();
-      } else if (arg.equals("--unify-server")) {
+            if(arg.equals("-d")){
-        unifyServerUrl = Optional.of(it.next());
+                outputPath = it.next();
-      } else if (arg.equals("--write-logs")) {
+            }else if(arg.startsWith("-d")) {
-        ConsoleInterface.writeLogFiles = true;
+                outputPath = arg.substring(2);
-      } else if (arg.startsWith("-v")) {
+            }else if(arg.equals("-cp") || arg.equals("-classpath")){
-        logLevel = switch (arg) {
+                String[] cps = it.next().split(":");
-          case "-v" -> Logger.LogLevel.WARNING;
+                for(String cp : cps){
-          case "-vv" -> Logger.LogLevel.INFO;
+                    classpath.add(new File(cp));
-          case "-vvv" -> Logger.LogLevel.DEBUG;
+                }
-          default -> throw new IllegalArgumentException("Argument " + arg + " is not a valid verbosity level");
+            }else{
-        };
+                input.add(new File(arg));
-      } else {
+            }
-        input.add(new File(arg));
+        }
-      }
+		JavaTXCompiler compiler = new JavaTXCompiler(input, classpath, outputPath != null ? new File(outputPath) : null);
-    }
+		//compiler.typeInference();
-
+		compiler.generateBytecode();
-    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

@@ -12,11 +12,6 @@ import de.dhbwstuttgart.parser.SyntaxTreeGenerator.SyntaxTreeGenerator;
 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;
@@ -24,7 +19,6 @@ 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;
@@ -41,13 +35,10 @@ 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.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;
@@ -58,7 +49,6 @@ 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;
@@ -71,17 +61,14 @@ 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;
-	public final Map<File, SourceFile> sourceFiles = new HashMap<>();
+    public final Map<File, SourceFile> sourceFiles = new HashMap<>();
 
-	public volatile UnifyTaskModel usedTasks = new UnifyTaskModel();
+    Boolean log = false; //gibt an ob ein Log-File nach System.getProperty("user.dir")+""/logFiles/"" geschrieben werden soll?
-	public final DirectoryClassLoader classLoader;
+    public volatile UnifyTaskModel usedTasks = new UnifyTaskModel();
+    public final DirectoryClassLoader classLoader;
 
 	public final List<File> classPath;
 	private final File outputPath;
@@ -89,9 +76,14 @@ public class JavaTXCompiler {
 	public DirectoryClassLoader getClassLoader() {
 		return classLoader;
 	}
-
+   
 	public JavaTXCompiler(File sourceFile) throws IOException, ClassNotFoundException {
-		this(Collections.singletonList(sourceFile), List.of(), new File("."));
+		this(Arrays.asList(sourceFile), List.of(), new File("."));
+	}
+
+	public JavaTXCompiler(File sourceFile, Boolean log) throws IOException, ClassNotFoundException {
+		this(sourceFile);
+		this.log = log;
 	}
 
 	public JavaTXCompiler(List<File> sourceFiles) throws IOException, ClassNotFoundException {
@@ -99,11 +91,6 @@ 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
@@ -313,51 +300,52 @@ public class JavaTXCompiler {
 		Set<Set<UnifyPair>> results = new HashSet<>();
 		UnifyResultModel urm = null;
 		// urm.addUnifyResultListener(resultListener);
-		logFile = logFile == null ? new FileWriter("log_" + sourceFiles.keySet().iterator().next().getName()) : logFile;
+		try {
-		Logger logger = new Logger(logFile, "TypeInferenceAsync");
+			logFile = logFile == null ? new FileWriter(new File("log_" + sourceFiles.keySet().iterator().next().getName())) : logFile;
-		UnifyContext context = new UnifyContext(logger, true, urm, usedTasks, defaultClientPlaceholderRegistry);
+			IFiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses, logFile, getClassLoader(), this);
+			System.out.println(finiteClosure);
+			urm = new UnifyResultModel(cons, finiteClosure);
+			urm.addUnifyResultListener(resultListener);
+			ConstraintSet<UnifyPair> unifyCons = UnifyTypeFactory.convert(this, cons);
 
-		IFiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses, logger, getClassLoader(), this, context.placeholderRegistry());
+			Function<UnifyPair, UnifyPair> distributeInnerVars = x -> {
-		logger.info(finiteClosure.toString());
+				UnifyType lhs, rhs;
-		urm = new UnifyResultModel(cons, finiteClosure);
+				if (((lhs = x.getLhsType()) instanceof PlaceholderType) && ((rhs = x.getRhsType()) instanceof PlaceholderType) && (((PlaceholderType) lhs).isInnerType() || ((PlaceholderType) rhs).isInnerType())) {
-		urm.addUnifyResultListener(resultListener);
+					((PlaceholderType) lhs).setInnerType(true);
-		ConstraintSet<UnifyPair> unifyCons = UnifyTypeFactory.convert(this, cons, context.placeholderRegistry());
+					((PlaceholderType) rhs).setInnerType(true);
+				}
+				return x;
 
-		Function<UnifyPair, UnifyPair> distributeInnerVars = x -> {
+			};
-			UnifyType lhs, rhs;
+			logFile.write(unifyCons.toString());
-			if (((lhs = x.getLhsType()) instanceof PlaceholderType) && ((rhs = x.getRhsType()) instanceof PlaceholderType) && (((PlaceholderType) lhs).isInnerType() || ((PlaceholderType) rhs).isInnerType())) {
+			unifyCons = unifyCons.map(distributeInnerVars);
-				((PlaceholderType) lhs).setInnerType(true);
+			logFile.write(unifyCons.toString());
-				((PlaceholderType) rhs).setInnerType(true);
+			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));
 			}
-			return x;
+			logFile.flush();
+			Set<PlaceholderType> varianceTPHold;
+			Set<PlaceholderType> varianceTPH = new HashSet<>();
+			varianceTPH = varianceInheritanceConstraintSet(unifyCons);
 
-		};
+			/*
-		logger.debug(unifyCons.toString());
+			 * 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 &&
-		unifyCons = unifyCons.map(distributeInnerVars);
+			 * ((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));
-		logger.debug(unifyCons.toString());
+			 */
-		// Set<Set<UnifyPair>> results = new HashSet<>(); Nach vorne gezogen
+
-		logger.debug("FC:\\" + finiteClosure.toString() + "\n");
+			// Set<Set<UnifyPair>> result = unify.unifySequential(xConsSet, finiteClosure,
-		for (SourceFile f : this.sourceFiles.values()) {
+			// logFile, log);
-			logger.debug(ASTTypePrinter.print(f));
+			// 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");
 		}
-		// 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;
 	}
 
@@ -377,108 +365,108 @@ public class JavaTXCompiler {
 
 		final ConstraintSet<Pair> cons = getConstraints(file);
 		Set<Set<UnifyPair>> results = new HashSet<>();
-		PlaceholderRegistry placeholderRegistry = new PlaceholderRegistry();
+		try {
+			var logFolder = new File(System.getProperty("user.dir") + "/logFiles/");
+			if (log) logFolder.mkdirs();
+			Writer logFile = log ? new FileWriter(new File(logFolder, "log_" + sourceFiles.keySet().iterator().next().getName())) : new OutputStreamWriter(new NullOutputStream());
+			IFiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses.stream().toList(), logFile, classLoader, this);
+			System.out.println(finiteClosure);
+			ConstraintSet<UnifyPair> unifyCons = UnifyTypeFactory.convert(this, cons);
+			System.out.println("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;
 
-		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");
 
-		FiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses.stream().toList(), logger, classLoader, this, placeholderRegistry);
+			logFile.write("Unify:" + unifyCons.toString());
-		logger.info(finiteClosure.toString());
+			System.out.println("Unify:" + unifyCons.toString());
-		ConstraintSet<UnifyPair> unifyCons = UnifyTypeFactory.convert(this, cons, placeholderRegistry);
+			unifyCons = unifyCons.map(distributeInnerVars);
-		logger.info("xxx1");
+			logFile.write("\nUnify_distributeInnerVars: " + unifyCons.toString());
-		Function<UnifyPair, UnifyPair> distributeInnerVars = x -> {
+			TypeUnify unify = new TypeUnify();
-			UnifyType lhs, rhs;
+			// Set<Set<UnifyPair>> results = new HashSet<>(); Nach vorne gezogen
-			if (((lhs = x.getLhsType()) instanceof PlaceholderType) && ((rhs = x.getRhsType()) instanceof PlaceholderType) && (((PlaceholderType) lhs).isInnerType() || ((PlaceholderType) rhs).isInnerType())) {
+			logFile.write("FC:\\" + finiteClosure.toString() + "\n");
-				((PlaceholderType) lhs).setInnerType(true);
+			logFile.write(ASTTypePrinter.print(sf));
-				((PlaceholderType) rhs).setInnerType(true);
+			System.out.println(ASTTypePrinter.print(sf));
+			logFile.flush();
+			List<UnifyPair> andConstraintsSorted = unifyCons.getUndConstraints().stream()
+					.sorted(Comparator.comparing(UnifyPair::getPairOp).thenComparing(UnifyPair::getLhsType, Comparator.comparing(UnifyType::getName)))
+					.collect(Collectors.toList());
+
+			System.out.println(andConstraintsSorted);
+
+			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))
+			 */;
+			if (resultmodel) {
+				/* UnifyResultModel Anfang */
+				UnifyResultModel urm = new UnifyResultModel(cons, finiteClosure);
+				UnifyResultListenerImpl li = new UnifyResultListenerImpl();
+				urm.addUnifyResultListener(li);
+				unify.unifyParallel(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, logFile, log, urm, usedTasks);
+				//System.out.println("RESULT Final: " + li.getResults());
+				var finalResults = li.getResults().stream().sorted().toList();
+				int i = 0;
+				System.out.println("RESULT Final: ");
+				for (var result : finalResults){
+					System.out.println("Result: " + i++);
+					System.out.println(result.getSortedResults());
+				}
+				System.out.println("Constraints for Generated Generics: " + " ???");
+				logFile.write("RES_FINAL: " + li.getResults().toString() + "\n");
+				logFile.flush();
+				return li.getResults();
 			}
-			return x;
+			/* UnifyResultModel End */
+			else {
+				// Set<Set<UnifyPair>> result = unify.unify(unifyCons.getUndConstraints(),
+				// oderConstraints, finiteClosure, logFile, log, new UnifyResultModel(cons,
+				// finiteClosure));
+				Set<Set<UnifyPair>> result = unify.unifyOderConstraints(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, logFile, log, new UnifyResultModel(cons, finiteClosure), usedTasks);
+				System.out.println("RESULT: " + result);
+				logFile.write("RES: " + result.toString() + "\n");
+				logFile.flush();
+				results.addAll(result);
 
-		};
+				results = results.stream().map(x -> {
-
+					Optional<Set<UnifyPair>> res = new RuleSet().subst(x.stream().map(y -> {
-		logger.debug("Unify:" + unifyCons.toString());
+						if (y.getPairOp() == PairOperator.SMALLERDOTWC)
-		logger.info("Unify:" + unifyCons.toString());
+							y.setPairOp(PairOperator.EQUALSDOT);
-		unifyCons = unifyCons.map(distributeInnerVars);
+						return y; // alle Paare a <.? b erden durch a =. b ersetzt
-		logger.debug("\nUnify_distributeInnerVars: " + unifyCons.toString());
+					}).collect(Collectors.toCollection(HashSet::new)));
-		// Set<Set<UnifyPair>> results = new HashSet<>(); Nach vorne gezogen
+					if (res.isPresent()) {// wenn subst ein Erg liefert wurde was veraendert
-		logger.debug("FC:\\" + finiteClosure.toString() + "\n");
+						return new TypeUnifyTask().applyTypeUnificationRules(res.get(), finiteClosure);
-		logger.debug(ASTTypePrinter.print(sf));
+					} else
-		logger.info(ASTTypePrinter.print(sf));
+						return x; // wenn nichts veraendert wurde wird x zurueckgegeben
-		// logFile.flush();
+				}).collect(Collectors.toCollection(HashSet::new));
-		logger.info("Unify nach Oder-Constraints-Anpassung:" + unifyCons.toString());
+				System.out.println("RESULT Final: " + results);
-		Set<PlaceholderType> varianceTPHold;
+				System.out.println("Constraints for Generated Generics: " + " ???");
-		Set<PlaceholderType> varianceTPH = new HashSet<>();
+				logFile.write("RES_FINAL: " + results.toString() + "\n");
-		varianceTPH = varianceInheritanceConstraintSet(unifyCons);
+				logFile.flush();
-
+				logFile.write("PLACEHOLDERS: " + PlaceholderType.EXISTING_PLACEHOLDERS);
-		/*
+				logFile.flush();
-		 * 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));
+		} catch (IOException e) {
-		 */
+			System.err.println("kein LogFile");
-
-		// 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 results.stream().map((unifyPairs -> new ResultSet(UnifyTypeFactory.convert(unifyPairs, Pair.generateTPHMap(cons))))).collect(Collectors.toList());
-			/* 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 {
-			// 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());
 	}
 
 	/**
@@ -610,6 +598,10 @@ 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;
@@ -651,12 +643,12 @@ public class JavaTXCompiler {
 			var codegen = new Codegen(converter.convert(clazz), this, converter);
 			var code = codegen.generate();
 			generatedClasses.put(clazz.getClassName(), code);
-			converter.auxiliaries.forEach((name, source) -> {
-				generatedClasses.put(new JavaClassName(name), source);
-			});
 		}
 		generatedGenerics.put(sf, converter.javaGenerics());
 		converter.generateFunNTypes();
+		converter.auxiliaries.forEach((name, source) -> {
+			generatedClasses.put(new JavaClassName(name), source);
+		});
 		return generatedClasses;
 	}
 
@@ -664,15 +656,15 @@ public class JavaTXCompiler {
 		FileOutputStream output;
 		for (JavaClassName name : classFiles.keySet()) {
 			byte[] bytecode = classFiles.get(name);
-			defaultLogger.info("generating " + name + ".class file ...");
+			System.out.println("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();
-			defaultLogger.info(outputFile.toString());
+			System.out.println(outputFile);
 			output = new FileOutputStream(outputFile);
 			output.write(bytecode);
 			output.close();
-			defaultLogger.success(name + ".class file generated");
+			System.out.println(name + ".class file generated");
 		}
 	}
 

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

@@ -1,31 +0,0 @@
-package de.dhbwstuttgart.core;
-
-import de.dhbwstuttgart.server.SocketServer;
-
-public class JavaTXServer {
-
-  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/ByteArrayClassLoader.java

@@ -1,13 +0,0 @@
-package de.dhbwstuttgart.environment;
-
-public class ByteArrayClassLoader extends ClassLoader implements IByteArrayClassLoader {
-    @Override
-    public Class _defineClass(String name, byte[] code, int i, int length) throws ClassFormatError {
-        return defineClass(name, code, i, length);
-    }
-
-    @Override
-    public Class<?> findClass(String name) throws ClassNotFoundException {
-        return super.findClass(name);
-    }
-}

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

@@ -6,18 +6,22 @@ import java.nio.file.Path;
 
 public interface IByteArrayClassLoader {
 
-    Class loadClass(String path) throws ClassNotFoundException;
+    Class<?> loadClass(String path) throws ClassNotFoundException;
 
-    default Class loadClass(byte[] code) {
+    default Class<?> loadClass(byte[] code) {
-        return this._defineClass(null, code, 0, code.length);
+        return this.loadClass(null, code);
     }
 
-    default Class loadClass(Path path) throws IOException {
+    default Class<?> loadClass(String name, byte[] code) {
+        return this._defineClass(name, code, 0, code.length);
+    }
+
+    default Class<?> loadClass(Path path) throws IOException {
         var code = Files.readAllBytes(path);
         return this._defineClass(null, code, 0, code.length);
     }
 
     public Class<?> findClass(String name) throws ClassNotFoundException;
 
-    Class _defineClass(String name, byte[] code, int i, int length) throws ClassFormatError;
+    Class<?> _defineClass(String name, byte[] code, int i, int length) throws ClassFormatError;
 }

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

@@ -1,11 +0,0 @@
-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,7 +7,6 @@ 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;
@@ -18,9 +17,6 @@ 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,25 +1,4 @@
 package de.dhbwstuttgart.parser;
 
-import de.dhbwstuttgart.server.packet.dataContainers.ISerializableData;
+public record SourceLoc(String file, int line) {
-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/FCGenerator.java

@@ -12,7 +12,6 @@ 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.PlaceholderRegistry;
 import de.dhbwstuttgart.typeinference.unify.model.*;
 
 import java.util.*;
@@ -27,21 +26,16 @@ public class FCGenerator {
      *
      * @param availableClasses - Alle geparsten Klassen
      */
-    public static Set<UnifyPair> toUnifyFC(JavaTXCompiler compiler, Collection<ClassOrInterface> availableClasses, ClassLoader classLoader, PlaceholderRegistry placeholderRegistry) throws ClassNotFoundException {
+    public static Set<UnifyPair> toUnifyFC(JavaTXCompiler compiler, Collection<ClassOrInterface> availableClasses, ClassLoader classLoader) throws ClassNotFoundException {
-        return toFC(
+        return toFC(availableClasses, classLoader).stream().map(t -> UnifyTypeFactory.convert(compiler, t)).collect(Collectors.toSet());
-          availableClasses,
-          classLoader,
-          placeholderRegistry
-        ).stream().map(t -> UnifyTypeFactory.convert(compiler, t, placeholderRegistry))
-          .collect(Collectors.toSet());
     }
 
-    public static Set<Pair> toFC(Collection<ClassOrInterface> availableClasses, ClassLoader classLoader, PlaceholderRegistry placeholderRegistry) throws ClassNotFoundException {
+    public static Set<Pair> toFC(Collection<ClassOrInterface> availableClasses, ClassLoader classLoader) 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, placeholderRegistry);
+        	List<Pair> newPairs = getSuperTypes(cly, availableClasses, gtvs, classLoader);
             pairs.addAll(newPairs);
             
             //For all Functional Interfaces FI: FunN$$<... args auf dem Functional Interface ...> <. FI is added to FC 
@@ -81,13 +75,8 @@ public class FCGenerator {
      * @param forType
      * @return
      */
-    private static List<Pair> getSuperTypes(
+    private static List<Pair> getSuperTypes(ClassOrInterface forType, Collection<ClassOrInterface> availableClasses, ClassLoader classLoader) throws ClassNotFoundException {
-      ClassOrInterface forType,
+        return getSuperTypes(forType, availableClasses, new HashMap<>(), classLoader);
-      Collection<ClassOrInterface> availableClasses,
-      ClassLoader classLoader,
-      PlaceholderRegistry placeholderRegistry
-    ) throws ClassNotFoundException {
-        return getSuperTypes(forType, availableClasses, new HashMap<>(), classLoader, placeholderRegistry);
     }
 
     /**
@@ -98,13 +87,8 @@ public class FCGenerator {
      * @return
      * @throws ClassNotFoundException
      */
-    private static List<Pair> getSuperTypes(
+    private static List<Pair> getSuperTypes(ClassOrInterface forType, Collection<ClassOrInterface> availableClasses,
-      ClassOrInterface forType,
+                                            HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> gtvs, ClassLoader classLoader) throws ClassNotFoundException {
-      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<>();
@@ -163,7 +147,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, placeholderRegistry);
+                superTypes = getSuperTypes(superClass, availableClasses, newGTVs, classLoader);
             }
 
             retList.add(ret);

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

@@ -1,6 +1,5 @@
 package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
 
-import de.dhbwstuttgart.parser.JavaTXParser;
 import java.lang.reflect.Modifier;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -260,7 +259,7 @@ public class StatementGenerator {
             ret.setStatement();
             return ret;
         default:
-            JavaTXParser.logger.info(stmt.getClass());
+            System.out.println(stmt.getClass());
             throw new NotImplementedException();
         }
     }
@@ -1100,9 +1099,9 @@ public class StatementGenerator {
             block = lambdaGenerator.convert(expression.lambdaBody().block(), true);
         }
         List<RefTypeOrTPHOrWildcardOrGeneric> funNParams = new ArrayList<>();
-        funNParams.add(TypePlaceholder.fresh(expression.getStart()));// ret-Type
+        funNParams.add(TypePlaceholder.fresh(expression.getStart(), -1, false));// ret-Type
         params.getFormalparalist().forEach(formalParameter -> // Für jeden Parameter einen TPH anfügen:
-        funNParams.add(TypePlaceholder.fresh(expression.getStart())));
+        	funNParams.add(TypePlaceholder.fresh(expression.getStart(), 1, false)));
         RefTypeOrTPHOrWildcardOrGeneric lambdaType = TypePlaceholder.fresh(expression.getStart());
         // RefType lambdaType = new
         // RefType(reg.getName("Fun"+params.getFormalparalist().size()),

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

@@ -74,7 +74,7 @@ public class TypeGenerator {
                 throw new NotImplementedException();
             }
         } else if (!typeContext.LBRACK().isEmpty()) { // ArrayType über eckige Klammer prüfen
-            // JavaTXParser.logger.info(unannTypeContext.getText());
+            // System.out.println(unannTypeContext.getText());
             throw new NotImplementedException();
         }
         /*

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

@@ -7,7 +7,7 @@ import java.util.*;
 /**
  * Speichert die Klassen f<>r einen bestimmten Projektscope
  */
-public class JavaClassRegistry {
+public class JavaClassRegistry{
     final Map<JavaClassName, Integer> existingClasses = new HashMap<>();
 
     public JavaClassRegistry(Map<String, Integer> initialNames) {
@@ -22,6 +22,10 @@ public class JavaClassRegistry {
         }
     }
 
+    public Set<JavaClassName> getAllClassNames(){
+        return existingClasses.keySet();
+    }
+
     public void addName(String className, int numberOfGenerics) {
         existingClasses.put(new JavaClassName(className), numberOfGenerics);
     }

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

@@ -1,41 +0,0 @@
-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,202 +0,0 @@
-package de.dhbwstuttgart.server;
-
-import com.fasterxml.jackson.core.JsonProcessingException;
-import de.dhbwstuttgart.core.ConsoleInterface;
-import de.dhbwstuttgart.server.packet.IClientToServerPacket;
-import de.dhbwstuttgart.server.packet.IPacket;
-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.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;
-import org.java_websocket.client.WebSocketClient;
-import org.java_websocket.enums.ReadyState;
-import org.java_websocket.handshake.ServerHandshake;
-
-
-/**
- * The Client-side of the websocket
- */
-public class SocketClient extends WebSocketClient {
-
-  public static Logger logger = new Logger("SocketClient");
-
-  /**
-   * 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>");
-    }
-
-    try {
-      // wait for the connection to be set up
-      this.connectBlocking();
-      // make sure the connection has been established successfully
-      if (this.getReadyState() != ReadyState.OPEN) {
-        throw new RuntimeException("WebSocket Client could not connect to remote host at " + this.uri);
-      }
-    } catch (InterruptedException exception) {
-      throw new RuntimeException(exception);
-    }
-
-    // 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));
-  }
-
-  private SocketClient(String host, int port, boolean secure) throws InterruptedException {
-    this(String.format("%s://%s:%d/", secure ? "wss" : "ws", host, port));
-  }
-
-  /**
-   * 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 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) {
-    logger.success("Connected to server with status " + handshakedata.getHttpStatus());
-  }
-
-  @Override
-  public void onMessage(String message) {
-    // logger.info("received: " + message);
-    IPacket packet = PacketContainer.deserialize(message);
-    this.handleReceivedPacket(packet);
-  }
-
-  @Override
-  public void onClose(int code, String reason, boolean remote) {
-    logger.info(
-      "Disconnected from server " +
-        "with code " + code + " " +
-        (reason.isEmpty() ? "" : "and reason " + reason + " ") +
-        "(closed by remote: " + remote + ")"
-    );
-
-    if (!this.responseFutures.isEmpty()) {
-      throw new RuntimeException("Server closed before all required tasks were answered");
-    }
-  }
-
-  @Override
-  public void onError(Exception e) {
-    logger.exception(e);
-    throw new RuntimeException(e);
-  }
-
-}

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

@@ -1,48 +0,0 @@
-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,235 +0,0 @@
-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.util.Logger;
-import java.net.InetSocketAddress;
-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;
-
-public class SocketServer extends WebSocketServer {
-
-  public static Logger logger = new Logger("SocketServer");
-  public static final int maxTasksPerSession = 100;
-  private static boolean serverRunning = false;
-
-  /**
-   * Increase this every time a breaking change to the server communication is done.
-   * 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) {
-    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
-      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) {
-      logger.exception(e);
-      webSocket.close(1, e.getMessage());
-    }
-  }
-
-  @Override
-  public void onClose(WebSocket webSocket, int code, String reason, boolean remote) {
-    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 + ")"
-    );
-
-  }
-
-  @Override
-  public void onMessage(WebSocket webSocket, String s) {
-    // logger.info("Received: " + s.substring(0, 50));
-    IPacket reconstructedPacket = PacketContainer.deserialize(s);
-    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) {
-    if (webSocket != null) {
-      log(webSocket, e.getMessage());
-      webSocket.close();
-    }
-    logger.exception(e);
-  }
-
-  @Override
-  public void onStart() {
-    logger.success("Websocket server started on port " + this.getPort());
-  }
-
-  /**
-   * A shorthand method for sending informational messages to the client
-   */
-  public void sendMessage(WebSocket webSocket, String text) {
-    try {
-      MessagePacket message = MessagePacket.create(text);
-      webSocket.send(PacketContainer.serialize(message));
-    } catch (Exception e) {
-      System.err.println("Failed to send message: " + text);
-      logger.exception(e);
-    }
-  }
-
-  /**
-   * A shorthand method for sending error messages to the client
-   */
-  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);
-    }
-  }
-
-  /**
-   * 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();
-      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

@@ -1,35 +0,0 @@
-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,36 +0,0 @@
-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 IServerToClientPacket {
-
-  /**
-   * 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

@@ -1,26 +0,0 @@
-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,12 +0,0 @@
-package de.dhbwstuttgart.server.packet;
-
-/**
- * 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)
- *
- */
-public interface IPacket {
-
-}

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

@@ -1,12 +0,0 @@
-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,35 +0,0 @@
-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
- */
-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,40 +0,0 @@
-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 IClientToServerPacket.Void, IServerToClientPacket {
-
-  /**
-   * 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

@@ -1,98 +0,0 @@
-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
- * packet type for deserialization.
- */
-@JsonInclude(JsonInclude.Include.NON_NULL)
-public class PacketContainer {
-
-  // The jackson serializer / deserializer tool
-  private static final ObjectMapper objectMapper = new ObjectMapper();
-
-  /*
-   * 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 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
-   */
-  public static String serialize(IPacket packet) throws JsonProcessingException {
-    objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
-    PacketContainer container = new PacketContainer();
-
-    if (packet instanceof ErrorPacket)
-      container.errorPacket = (ErrorPacket) packet;
-    else if (packet instanceof MessagePacket)
-      container.messagePacket = (MessagePacket) packet;
-    else if (packet instanceof UnifyRequestPacket)
-      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);
-  }
-
-  /**
-   * Use the JSON string to generate the matching packet object
-   *
-   * @param json The serialized representation of a packet container
-   * @return The deserialized Packet object
-   */
-  public static IPacket deserialize(String json) {
-    objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
-
-    try {
-      PacketContainer container = objectMapper.readValue(json, PacketContainer.class);
-
-      if (container.errorPacket != null)
-        return container.errorPacket;
-      if (container.messagePacket != null)
-        return container.messagePacket;
-      if (container.invalidPacket != null)
-        return container.invalidPacket;
-      if (container.unifyRequestPacket != null)
-        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

@@ -1,32 +0,0 @@
-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,164 +0,0 @@
-package de.dhbwstuttgart.server.packet;
-
-import com.fasterxml.jackson.annotation.JsonIgnore;
-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 IClientToServerPacket<UnifyResultPacket> {
-
-  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(
-    FiniteClosure finiteClosure,
-    ConstraintSet<Pair> constraintSet,
-    ConstraintSet<UnifyPair> unifyConstraintSet,
-    PlaceholderRegistry placeholderRegistry
-  ) {
-    UnifyRequestPacket packet = new UnifyRequestPacket();
-    // 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 void loadKeyStorage(UnifyContext context) {
-    if (!keyStorageLoaded) {
-      keyStorageLoaded = true;
-      keyStorage = KeyStorage.fromSerial(this.serialKeyStorage, context);
-    }
-  }
-
-  @JsonIgnore
-  private FiniteClosure retrieveFiniteClosure(UnifyContext context) {
-    this.loadKeyStorage(context);
-    return FiniteClosure.fromSerial(this.finiteClosure, context, keyStorage);
-  }
-
-  @JsonIgnore
-  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,45 +0,0 @@
-package de.dhbwstuttgart.server.packet;
-
-import com.fasterxml.jackson.annotation.JsonIgnore;
-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 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 IServerToClientPacket {
-
-  public SerialList<ISerialNode> results;
-  public SerialMap keyStorage;
-  public String futureId;
-
-  public static UnifyResultPacket create(List<ResultSet> resultSets, String futureId) {
-    UnifyResultPacket serialized = new UnifyResultPacket();
-    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(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

@@ -1,16 +0,0 @@
-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

@@ -1,103 +0,0 @@
-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/serialized/ISerialNode.java

@@ -1,31 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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/syntaxtree/SyntaxTree.java

@@ -1,8 +0,0 @@
-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/factory/NameGenerator.java

@@ -1,8 +1,5 @@
 package de.dhbwstuttgart.syntaxtree.factory;
 
-import de.dhbwstuttgart.core.JavaTXCompiler;
-import de.dhbwstuttgart.core.JavaTXServer;
-
 public class NameGenerator {
 
     private static String strNextName = "A";
@@ -29,11 +26,7 @@ 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;        
     }
 

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

@@ -1,8 +1,5 @@
 package de.dhbwstuttgart.syntaxtree.factory;
 
-import de.dhbwstuttgart.syntaxtree.SyntaxTree;
-import de.dhbwstuttgart.typeinference.unify.PlaceholderRegistry;
-import de.dhbwstuttgart.util.Logger;
 import java.io.Writer;
 import java.lang.reflect.Modifier;
 import java.util.*;
@@ -34,13 +31,9 @@ import org.antlr.v4.runtime.Token;
 
 public class UnifyTypeFactory {
 	
-    public static FiniteClosure generateFC(
+	private static ArrayList<PlaceholderType> PLACEHOLDERS = new ArrayList<>(); 
-      List<ClassOrInterface> fromClasses,
+
-      Logger logger,
+    public static FiniteClosure generateFC(List<ClassOrInterface> fromClasses, Writer logFile, ClassLoader classLoader, JavaTXCompiler compiler) throws ClassNotFoundException {
-      ClassLoader classLoader,
-      JavaTXCompiler compiler,
-      PlaceholderRegistry placeholderRegistry
-    ) throws ClassNotFoundException {
         /*
         Die transitive Hülle muss funktionieren.
         Man darf schreiben List<A> extends AL<A>
@@ -51,7 +44,7 @@ public class UnifyTypeFactory {
         Generell dürfen sie immer die gleichen Namen haben.
         TODO: die transitive Hülle bilden
          */
-        return new FiniteClosure(FCGenerator.toUnifyFC(compiler, fromClasses, classLoader, placeholderRegistry), logger, compiler, placeholderRegistry);
+        return new FiniteClosure(FCGenerator.toUnifyFC(compiler, fromClasses, classLoader), logFile, compiler);
     }
 
     public static UnifyPair generateSmallerPair(UnifyType tl, UnifyType tr, SourceLoc location){
@@ -74,23 +67,23 @@ public class UnifyTypeFactory {
      * Convert from
      * ASTType -> UnifyType
      */
-    public static UnifyType convert(JavaTXCompiler compiler, RefTypeOrTPHOrWildcardOrGeneric t, Boolean innerType, PlaceholderRegistry placeholderRegistry){
+    public static UnifyType convert(JavaTXCompiler compiler, RefTypeOrTPHOrWildcardOrGeneric t, Boolean innerType){
         if (t instanceof GenericRefType){
-            return UnifyTypeFactory.convert(compiler, (GenericRefType)t, innerType, placeholderRegistry);
+            return UnifyTypeFactory.convert(compiler, (GenericRefType)t, innerType);
         } else if (t instanceof TypePlaceholder){
-            return UnifyTypeFactory.convert(compiler, (TypePlaceholder)t, innerType, placeholderRegistry);
+            return UnifyTypeFactory.convert(compiler, (TypePlaceholder)t, innerType);
         } else if (t instanceof ExtendsWildcardType){
-            return UnifyTypeFactory.convert(compiler, (ExtendsWildcardType)t, innerType, placeholderRegistry);
+            return UnifyTypeFactory.convert(compiler, (ExtendsWildcardType)t, innerType);
         } else if (t instanceof SuperWildcardType) {
-            return UnifyTypeFactory.convert(compiler, (SuperWildcardType) t, innerType, placeholderRegistry);
+            return UnifyTypeFactory.convert(compiler, (SuperWildcardType) t, innerType);
         } else if (t instanceof RefType){
-            return UnifyTypeFactory.convert(compiler, (RefType)t, innerType, placeholderRegistry);
+            return UnifyTypeFactory.convert(compiler, (RefType)t, innerType);
         }
         //Es wurde versucht ein Typ umzuwandeln, welcher noch nicht von der Factory abgedeckt ist
         throw new NotImplementedException("Der Typ "+t+" kann nicht umgewandelt werden");
     }
 
-    public static UnifyType convert(JavaTXCompiler compiler, RefType t, Boolean innerType, PlaceholderRegistry placeholderRegistry){
+    public static UnifyType convert(JavaTXCompiler compiler, RefType t, Boolean innerType){
         //Check if it is a FunN Type:
         Pattern p = Pattern.compile("Fun(\\d+)[$][$]");
         Matcher m = p.matcher(t.getName().toString());
@@ -98,76 +91,76 @@ public class UnifyTypeFactory {
         if(b){
             Integer N = Integer.valueOf(m.group(1));
             if((N + 1) == t.getParaList().size()){
-                return convertFunN(compiler, t.getParaList(), false, placeholderRegistry);
+                return convertFunN(compiler, t.getParaList(), false);
             }
         }
         UnifyType ret;
         List<UnifyType> params = new ArrayList<>();
         if (t.getParaList() != null) {
             for (RefTypeOrTPHOrWildcardOrGeneric pT : t.getParaList()) {
-                params.add(UnifyTypeFactory.convert(compiler, pT, true, placeholderRegistry));
+                params.add(UnifyTypeFactory.convert(compiler, pT, true));
             }
         }
 
         var clazz = compiler.getClass(t.getName());
         if (clazz != null && clazz.isInterface() && clazz.isFunctionalInterface()) {
             var method = clazz.getMethods().stream().filter(x -> Modifier.isAbstract(x.modifier)).findFirst().orElseThrow();
-            var methodParams = method.getParameterList().getFormalparalist().stream().map(x -> convert(compiler, x.getType(), true, placeholderRegistry)).toList();
+            var methodParams = method.getParameterList().getFormalparalist().stream().map(x -> convert(compiler, x.getType(), true)).toList();
             var generics = StreamSupport.stream(clazz.getGenerics().spliterator(), false).map(GenericTypeVar::getName).toList();
-            return new FunInterfaceType(t.getName().toString(), new TypeParams(params), methodParams, convert(compiler, method.getReturnType(), true, placeholderRegistry), generics);
+            return new FunInterfaceType(t.getName().toString(), new TypeParams(params), methodParams, convert(compiler, method.getReturnType(), true), generics);
         }
 
         return new ReferenceType(t.getName().toString(),new TypeParams(params));
     }
 
-    public static UnifyType convertFunN(JavaTXCompiler compiler, List<RefTypeOrTPHOrWildcardOrGeneric> paraList, Boolean innerType, PlaceholderRegistry placeholderRegistry){
+    public static UnifyType convertFunN(JavaTXCompiler compiler, List<RefTypeOrTPHOrWildcardOrGeneric> paraList, Boolean innerType){
         UnifyType ret;
         List<UnifyType> params = new ArrayList<>();
         if(paraList != null && paraList.size() > 0){
             for(RefTypeOrTPHOrWildcardOrGeneric pT : paraList){
-                params.add(UnifyTypeFactory.convert(compiler, pT, false, placeholderRegistry));
+                params.add(UnifyTypeFactory.convert(compiler, pT, false));
             }
         }
         ret = FunNType.getFunNType(new TypeParams(params));
         return ret;
     }
 
-    public static UnifyType convert(JavaTXCompiler compiler, TypePlaceholder tph, Boolean innerType, PlaceholderRegistry placeholderRegistry) {
+    public static UnifyType convert(JavaTXCompiler compiler, TypePlaceholder tph, Boolean innerType){
     	if (tph.getName().equals("AFR")) {
-          SyntaxTree.logger.info("XXX"+innerType);
+    		System.out.println("XXX"+innerType);
     	}
-    	PlaceholderType ntph = new PlaceholderType(tph.getName(), tph.getVariance(), placeholderRegistry);
+    	PlaceholderType ntph = new PlaceholderType(tph.getName(), tph.getVariance());
     	ntph.setVariance(tph.getVariance());
     	ntph.setOrCons(tph.getOrCons());
     	ntph.setWildcardtable(tph.getWildcardtable());
-    	int in = placeholderRegistry.UnifyTypeFactory_PLACEHOLDERS.indexOf(ntph);
+    	int in = PLACEHOLDERS.indexOf(ntph);
 		if (in == -1) {
-        placeholderRegistry.UnifyTypeFactory_PLACEHOLDERS.add(ntph);
+			PLACEHOLDERS.add(ntph);
 			ntph.setInnerType(innerType);
 			return ntph;
 		}
 		else {
-			 PlaceholderType oldpht = placeholderRegistry.UnifyTypeFactory_PLACEHOLDERS.get(in);
+			 PlaceholderType oldpht = PLACEHOLDERS.get(in);
 			 oldpht.setInnerType(oldpht.isInnerType() || innerType);
 			 return oldpht;
 		}
     }
 
-    public static UnifyType convert(JavaTXCompiler compiler, GenericRefType t, Boolean innerType, PlaceholderRegistry placeholderRegistry){
+    public static UnifyType convert(JavaTXCompiler compiler, GenericRefType t, Boolean innerType){
         return new ReferenceType(t.getParsedName(), true);
     }
 
-    public static UnifyType convert(JavaTXCompiler compiler, WildcardType t, Boolean innerType, PlaceholderRegistry placeholderRegistry){
+    public static UnifyType convert(JavaTXCompiler compiler, WildcardType t, Boolean innerType){
         if(t.isExtends())
-            return new ExtendsType(UnifyTypeFactory.convert(compiler, t.getInnerType(), false, placeholderRegistry));
+            return new ExtendsType(UnifyTypeFactory.convert(compiler, t.getInnerType(), false));
         else if(t.isSuper())
-            return new SuperType(UnifyTypeFactory.convert(compiler, t.getInnerType(), false, placeholderRegistry));
+            return new SuperType(UnifyTypeFactory.convert(compiler, t.getInnerType(), false));
         else throw new NotImplementedException();
     }
 
 
-    public static ConstraintSet<UnifyPair> convert(JavaTXCompiler compiler, ConstraintSet<Pair> constraints, PlaceholderRegistry placeholderRegistry) {
+    public static ConstraintSet<UnifyPair> convert(JavaTXCompiler compiler, ConstraintSet<Pair> constraints) {
-        return constraints.map(c -> UnifyTypeFactory.convert(compiler, c, placeholderRegistry));
+        return constraints.map(c -> UnifyTypeFactory.convert(compiler, c));
     }
 
     //NEVER USED
@@ -178,30 +171,30 @@ public class UnifyTypeFactory {
     //	return unifyPairConstraint;
     //}
 
-    public static UnifyPair convert(JavaTXCompiler compiler, Pair p, PlaceholderRegistry placeholderRegistry) {
+    public static UnifyPair convert(JavaTXCompiler compiler, Pair p) {
     	UnifyPair ret = null;
         if(p.GetOperator().equals(PairOperator.SMALLERDOT)) {
-             ret = generateSmallerDotPair(UnifyTypeFactory.convert(compiler, p.TA1, false, placeholderRegistry)
+             ret = generateSmallerDotPair(UnifyTypeFactory.convert(compiler, p.TA1, false)
-                    , UnifyTypeFactory.convert(compiler, p.TA2, false, placeholderRegistry), p.getLocation());
+                    , UnifyTypeFactory.convert(compiler, p.TA2, false), p.getLocation());
             //return ret;
         }else if(p.GetOperator().equals(PairOperator.SMALLERNEQDOT)) {
-             ret = generateSmallNotEqualDotPair(UnifyTypeFactory.convert(compiler, p.TA1, false, placeholderRegistry)
+             ret = generateSmallNotEqualDotPair(UnifyTypeFactory.convert(compiler, p.TA1, false)
-                    , UnifyTypeFactory.convert(compiler, p.TA2, false, placeholderRegistry), p.getLocation());
+                    , UnifyTypeFactory.convert(compiler, p.TA2, false), p.getLocation());
             //return ret;
         }else if(p.GetOperator().equals(PairOperator.EQUALSDOT)) {
-             ret = generateEqualDotPair(UnifyTypeFactory.convert(compiler, p.TA1, false, placeholderRegistry)
+             ret = generateEqualDotPair(UnifyTypeFactory.convert(compiler, p.TA1, false)
-                    , UnifyTypeFactory.convert(compiler, p.TA2, false, placeholderRegistry), p.getLocation());
+                    , UnifyTypeFactory.convert(compiler, p.TA2, false), p.getLocation());
             //return ret;
         }else if(p.GetOperator().equals(PairOperator.SMALLER)){
-            ret =  generateSmallerPair(UnifyTypeFactory.convert(compiler, p.TA1, false, placeholderRegistry),
+            ret =  generateSmallerPair(UnifyTypeFactory.convert(compiler, p.TA1, false),
-                    UnifyTypeFactory.convert(compiler, p.TA2, false, placeholderRegistry), p.getLocation());
+                    UnifyTypeFactory.convert(compiler, p.TA2, false), p.getLocation());
         }else            throw new NotImplementedException();
         UnifyType lhs, rhs;
         if (((lhs = ret.getLhsType()) instanceof PlaceholderType) 
         		&& ((PlaceholderType)lhs).isWildcardable() 
         		&&	(rhs = ret.getLhsType()) instanceof PlaceholderType) {
         	if (lhs.getName().equals("AQ")) {
-        		// SyntaxTree.logger.info("");
+        		System.out.println("");
         	}
         	((PlaceholderType)rhs).enableWildcardtable();
         }
@@ -210,7 +203,7 @@ public class UnifyTypeFactory {
         		&& ((PlaceholderType)rhs).isWildcardable()
         		&&	(lhs = ret.getLhsType()) instanceof PlaceholderType) {
         	if (rhs.getName().equals("AQ")) {
-        		// SyntaxTree.logger.info("");
+        		System.out.println("");
         	}
         	((PlaceholderType)lhs).enableWildcardtable();
         }
@@ -221,16 +214,16 @@ public class UnifyTypeFactory {
      * Convert from
      * UnifyType -> ASTType
      */
-    public static Set<ResultPair> convert(Set<UnifyPair> unifyPairSet, Map<String,TypePlaceholder> tphs, PlaceholderRegistry placeholderRegistry) {
+    public static Set<ResultPair> convert(Set<UnifyPair> unifyPairSet, Map<String,TypePlaceholder> tphs) {
         return unifyPairSet.stream().map(
-                unifyPair -> convert(unifyPair, tphs, placeholderRegistry))
+                unifyPair -> convert(unifyPair, tphs))
                         .collect(Collectors.toSet());
     }
 
-    public static ResultPair convert(UnifyPair mp, Map<String,TypePlaceholder> tphs, PlaceholderRegistry placeholderRegistry) {
+    public static ResultPair convert(UnifyPair mp, Map<String,TypePlaceholder> tphs) {
     	if (mp == null) { return null;} //kann bei basePairs passieren
-        RefTypeOrTPHOrWildcardOrGeneric tl = UnifyTypeFactory.convert(mp.getLhsType(), tphs, placeholderRegistry);
+        RefTypeOrTPHOrWildcardOrGeneric tl = UnifyTypeFactory.convert(mp.getLhsType(), tphs);
-        RefTypeOrTPHOrWildcardOrGeneric tr = UnifyTypeFactory.convert(mp.getRhsType(), tphs, placeholderRegistry);
+        RefTypeOrTPHOrWildcardOrGeneric tr = UnifyTypeFactory.convert(mp.getRhsType(), tphs);
         if(tl instanceof TypePlaceholder){
             if(tr instanceof TypePlaceholder) {
 
@@ -239,7 +232,7 @@ public class UnifyTypeFactory {
                     //Einfach ignorieren TODO: Das hier muss ausgebessert werden:
                     //return new PairTPHequalRefTypeOrWildcardType((TypePlaceholder)tl, ASTFactory.createObjectType());
                 }else{
-                    return new PairTPHsmallerTPH((TypePlaceholder)tl, (TypePlaceholder)tr, convert(mp.getBasePair(), tphs, placeholderRegistry));
+                    return new PairTPHsmallerTPH((TypePlaceholder)tl, (TypePlaceholder)tr, convert(mp.getBasePair(), tphs));
                 }
             }else if(tr instanceof RefType){
                 return new PairTPHequalRefTypeOrWildcardType((TypePlaceholder)tl, (RefType) tr);
@@ -251,51 +244,51 @@ public class UnifyTypeFactory {
         }else return new PairNoResult(tl, tr);//throw new NotImplementedException();
     }
 
-    public static RefTypeOrTPHOrWildcardOrGeneric convert(ReferenceType t, Map<String,TypePlaceholder> tphs, PlaceholderRegistry placeholderRegistry) {
+    public static RefTypeOrTPHOrWildcardOrGeneric convert(ReferenceType t, Map<String,TypePlaceholder> tphs) {
         if(JavaClassName.Void.equals(t.getName()))return new Void(new NullToken());
         if (t.isGenTypeVar()) return new GenericRefType(t.getName(),new NullToken());
-        RefType ret = new RefType(new JavaClassName(t.getName()),convert(t.getTypeParams(), tphs, placeholderRegistry),new NullToken());
+        RefType ret = new RefType(new JavaClassName(t.getName()),convert(t.getTypeParams(), tphs),new NullToken());
         return ret;
     }
 
-    public static RefTypeOrTPHOrWildcardOrGeneric convert(FunNType t, Map<String,TypePlaceholder> tphs, PlaceholderRegistry placeholderRegistry) {
+    public static RefTypeOrTPHOrWildcardOrGeneric convert(FunNType t, Map<String,TypePlaceholder> tphs) {
-        RefType ret = new RefType(new JavaClassName(t.getName()), convert(t.getTypeParams(), tphs, placeholderRegistry), new NullToken());
+        RefType ret = new RefType(new JavaClassName(t.getName()), convert(t.getTypeParams(), tphs), new NullToken());
         return ret;
     }
 
-    public static RefTypeOrTPHOrWildcardOrGeneric convert(SuperType t, Map<String,TypePlaceholder> tphs, PlaceholderRegistry placeholderRegistry) {
+    public static RefTypeOrTPHOrWildcardOrGeneric convert(SuperType t, Map<String,TypePlaceholder> tphs) {
-        RefTypeOrTPHOrWildcardOrGeneric innerType = convert(t.getSuperedType(), tphs, placeholderRegistry);
+        RefTypeOrTPHOrWildcardOrGeneric innerType = convert(t.getSuperedType(), tphs);
         return new SuperWildcardType(innerType, new NullToken());
     }
 
-    public static RefTypeOrTPHOrWildcardOrGeneric convert(ExtendsType t, Map<String,TypePlaceholder> tphs, PlaceholderRegistry placeholderRegistry) {
+    public static RefTypeOrTPHOrWildcardOrGeneric convert(ExtendsType t, Map<String,TypePlaceholder> tphs) {
-        RefTypeOrTPHOrWildcardOrGeneric innerType = convert(t.getExtendedType(), tphs, placeholderRegistry);
+        RefTypeOrTPHOrWildcardOrGeneric innerType = convert(t.getExtendedType(), tphs);
         return new ExtendsWildcardType(innerType, new NullToken());
     }
 
-    public static RefTypeOrTPHOrWildcardOrGeneric convert(PlaceholderType t, Map<String,TypePlaceholder> tphs, PlaceholderRegistry placeholderRegistry) {
+    public static RefTypeOrTPHOrWildcardOrGeneric convert(PlaceholderType t, Map<String,TypePlaceholder> tphs) {
         TypePlaceholder ret = tphs.get(t.getName());
         if(ret == null){ //Dieser TPH wurde vom Unifikationsalgorithmus erstellt
-            ret = TypePlaceholder.fresh(new NullToken(), placeholderRegistry);
+            ret = TypePlaceholder.fresh(new NullToken());
             tphs.put(t.getName(), ret);
         }
         ret.setVariance(t.getVariance());
         return ret;
     }
 
-    public static RefTypeOrTPHOrWildcardOrGeneric convert(UnifyType t, Map<String,TypePlaceholder> tphs, PlaceholderRegistry placeholderRegistry) {
+    public static RefTypeOrTPHOrWildcardOrGeneric convert(UnifyType t, Map<String,TypePlaceholder> tphs) {
-        if(t instanceof FunNType)return convert((FunNType) t, tphs, placeholderRegistry);
+        if(t instanceof FunNType)return convert((FunNType) t, tphs);
-        if(t instanceof ReferenceType)return convert((ReferenceType) t, tphs, placeholderRegistry);
+        if(t instanceof ReferenceType)return convert((ReferenceType) t, tphs);
-        if(t instanceof SuperType)return convert((SuperType) t, tphs, placeholderRegistry);
+        if(t instanceof SuperType)return convert((SuperType) t, tphs);
-        if(t instanceof ExtendsType)return convert((ExtendsType) t, tphs, placeholderRegistry);
+        if(t instanceof ExtendsType)return convert((ExtendsType) t, tphs);
-        if(t instanceof PlaceholderType)return convert((PlaceholderType) t, tphs, placeholderRegistry);
+        if(t instanceof PlaceholderType)return convert((PlaceholderType) t, tphs);
         throw new NotImplementedException("Der Typ "+t+" kann nicht umgewandelt werden");
     }
 
-    private static List<RefTypeOrTPHOrWildcardOrGeneric> convert(TypeParams typeParams, Map<String,TypePlaceholder> tphs, PlaceholderRegistry placeholderRegistry) {
+    private static List<RefTypeOrTPHOrWildcardOrGeneric> convert(TypeParams typeParams, Map<String,TypePlaceholder> tphs) {
         List<RefTypeOrTPHOrWildcardOrGeneric> ret = new ArrayList<>();
         for(UnifyType uT : typeParams){
-            RefTypeOrTPHOrWildcardOrGeneric toAdd = convert(uT, tphs, placeholderRegistry);
+            RefTypeOrTPHOrWildcardOrGeneric toAdd = convert(uT, tphs);
             ret.add(toAdd);
         }
         return ret;

src/main/java/de/dhbwstuttgart/syntaxtree/type/ExtendsWildcardType.java

@@ -1,13 +1,8 @@
 package de.dhbwstuttgart.syntaxtree.type;
 
 
-import de.dhbwstuttgart.parser.NullToken;
-import de.dhbwstuttgart.server.packet.dataContainers.ISerializableData;
-import de.dhbwstuttgart.server.packet.dataContainers.KeyStorage;
-import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialMap;
 import de.dhbwstuttgart.syntaxtree.ASTVisitor;
 import de.dhbwstuttgart.typeinference.result.ResultSetVisitor;
-import de.dhbwstuttgart.typeinference.unify.UnifyContext;
 import org.antlr.v4.runtime.Token;
 
 import java.util.Objects;
@@ -20,7 +15,7 @@ import java.util.Objects;
  * 
  */
 
-public class ExtendsWildcardType extends WildcardType implements ISerializableData {
+public class ExtendsWildcardType extends WildcardType{
 	
 	/**
 	* Author: Arne Lüdtke<br/>
@@ -73,22 +68,4 @@ public class ExtendsWildcardType extends WildcardType implements ISerializableDa
 		ExtendsWildcardType that = (ExtendsWildcardType) o;
 		return that.innerType.equals(this.innerType);
 	}
-
-	@Override
-	public SerialMap toSerial(KeyStorage keyStorage) {
-		SerialMap serialized = new SerialMap();
-		serialized.put("innerType", this.innerType.toSerial(keyStorage));
-
-		// create the wrapper and put this as the object
-		var serializedWrapper = super.toSerial(keyStorage).assertType(SerialMap.class);
-		serializedWrapper.put("object", serialized);
-		return serializedWrapper;
-	}
-
-	public static ExtendsWildcardType fromSerial(SerialMap data, UnifyContext context) {
-		return new ExtendsWildcardType(
-			RefTypeOrTPHOrWildcardOrGeneric.fromSerial(data.getMap("innerType"), context),
-			new NullToken()
-		);
-	}
 }

src/main/java/de/dhbwstuttgart/syntaxtree/type/GenericRefType.java

@@ -1,77 +1,57 @@
 package de.dhbwstuttgart.syntaxtree.type;
 
-import de.dhbwstuttgart.parser.NullToken;
-import de.dhbwstuttgart.server.packet.dataContainers.ISerializableData;
-import de.dhbwstuttgart.server.packet.dataContainers.KeyStorage;
-import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialMap;
 import de.dhbwstuttgart.syntaxtree.ASTVisitor;
 import de.dhbwstuttgart.typeinference.result.ResultSetVisitor;
-import de.dhbwstuttgart.typeinference.unify.UnifyContext;
 import org.antlr.v4.runtime.Token;
 
 import java.util.Objects;
 
-public class GenericRefType extends RefTypeOrTPHOrWildcardOrGeneric implements ISerializableData {
+public class GenericRefType extends RefTypeOrTPHOrWildcardOrGeneric
-  private String name;
+{
+    private String name;
 
-  public GenericRefType(String name, Token offset) {
+    public GenericRefType(String name, Token offset)
-    super(offset);
+    {
-    this.name = name;
+        super(offset);
-  }
+        this.name = name;
+    }
 
-  public String getParsedName() {
+    public String getParsedName(){
-    return name.toString();
+        return name.toString();
-  }
+    }
 
-  @Override
+    @Override
-  public void accept(ASTVisitor visitor) {
+    public void accept(ASTVisitor visitor) {
-    visitor.visit(this);
+        visitor.visit(this);
-  }
+    }
 
-  @Override
+    @Override
-  public <A> A acceptTV(TypeVisitor<A> visitor) {
+    public <A> A acceptTV(TypeVisitor<A> visitor) {
-    return visitor.visit(this);
+        return visitor.visit(this);
-  }
+    }
 
-  @Override
+    @Override
-  public void accept(ResultSetVisitor visitor) {
+    public void accept(ResultSetVisitor visitor) {
-    visitor.visit(this);
+        visitor.visit(this);
-  }
+    }
 
-  @Override
+    @Override
-  public boolean equals(Object o) {
+    public boolean equals(Object o) {
-    if (this == o) return true;
+        if (this == o) return true;
-    if (o == null || getClass() != o.getClass()) return false;
+        if (o == null || getClass() != o.getClass()) return false;
-    GenericRefType that = (GenericRefType) o;
+        GenericRefType that = (GenericRefType) o;
-    return name.equals(that.name);
+        return name.equals(that.name);
-  }
+    }
 
-  @Override
+    @Override
-  public int hashCode() {
+    public int hashCode() {
-    return Objects.hash(name);
+        return Objects.hash(name);
-  }
+    }
 
-  @Override
+    @Override
-  public String toString() {
+	public String toString()
-    return "GTV " + this.name;
+	{
-  }
+		 return "GTV " + this.name;
-
+	}
-  @Override
-  public SerialMap toSerial(KeyStorage keyStorage) {
-    SerialMap serialized = new SerialMap();
-    serialized.put("name", this.name);
-
-    // create the wrapper and put this as the object
-    var serializedWrapper = super.toSerial(keyStorage).assertType(SerialMap.class);
-    serializedWrapper.put("object", serialized);
-    return serializedWrapper;
-  }
-
-  public static GenericRefType fromSerial(SerialMap data, UnifyContext context) {
-    return new GenericRefType(
-      data.getValue("name").getOf(String.class),
-      new NullToken()
-    );
-  }
 }
 

src/main/java/de/dhbwstuttgart/syntaxtree/type/RefType.java

@@ -1,15 +1,8 @@
 package de.dhbwstuttgart.syntaxtree.type;
 
-import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
-import de.dhbwstuttgart.server.packet.dataContainers.ISerializableData;
-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.syntaxtree.ASTVisitor;
 import de.dhbwstuttgart.typeinference.result.ResultSetVisitor;
-import de.dhbwstuttgart.typeinference.unify.UnifyContext;
 import org.antlr.v4.runtime.Token;
 
 import java.util.ArrayList;
@@ -18,137 +11,122 @@ import java.util.List;
 import java.util.Objects;
 
 
-public class RefType extends RefTypeOrTPHOrWildcardOrGeneric implements ISerializableData {
+public class RefType extends RefTypeOrTPHOrWildcardOrGeneric
-  protected final JavaClassName name;
+{
-  protected final List<RefTypeOrTPHOrWildcardOrGeneric> parameter;
+	protected final JavaClassName name;
-  /**
+    protected final List<RefTypeOrTPHOrWildcardOrGeneric> parameter;
-   * Ist primitiveFlag auf true, muss beim Codegen dieser Reftype durch
+    /**
-   * den primitiven Datentyp ersetzt werden
+     * Ist primitiveFlag auf true, muss beim Codegen dieser Reftype durch
-   * <p>
+     * den primitiven Datentyp ersetzt werden
-   * Bsp: java.lang.Integer mit Flag wird dann zu [int]
+     *
-   */
+     * Bsp: java.lang.Integer mit Flag wird dann zu [int]
-  boolean primitiveFlag = false; // TODO Should be final
+     */
+    boolean primitiveFlag = false; // TODO Should be final
 
-  public RefType(JavaClassName fullyQualifiedName, Token offset) {
+    public RefType(JavaClassName fullyQualifiedName, Token offset)
-    this(fullyQualifiedName, new ArrayList<>(), offset);
+    {
-  }
+        this(fullyQualifiedName, new ArrayList<>(), offset);
-
-  public boolean isPrimitive() {
-    return primitiveFlag;
-  }
-
-  @Override
-  public String toString() {
-    String params = "";
-    if (parameter.size() > 0) {
-      params += "<";
-      Iterator<RefTypeOrTPHOrWildcardOrGeneric> it = parameter.iterator();
-      while (it.hasNext()) {
-        RefTypeOrTPHOrWildcardOrGeneric param = it.next();
-        params += param.toString();
-        if (it.hasNext()) params += ", ";
-      }
-      params += ">";
-    }
-    return this.name.toString() + params;
-  }
-
-  @Override
-  public int hashCode() {
-    return this.name.hashCode();//Nur den Name hashen. Sorgt für langsame, aber funktionierende HashMaps
-  }
-
-  public RefType(JavaClassName fullyQualifiedName, List<RefTypeOrTPHOrWildcardOrGeneric> parameter, Token offset) {
-    this(fullyQualifiedName, parameter, offset, false);
-  }
-
-  public RefType(JavaClassName fullyQualifiedName, List<RefTypeOrTPHOrWildcardOrGeneric> parameter, Token offset, boolean primitiveFlag) {
-    super(offset);
-    this.name = (fullyQualifiedName);
-    this.parameter = parameter;
-    this.primitiveFlag = primitiveFlag;
-  }
-
-  public JavaClassName getName() {
-    return name;
-  }
-
-  public List<RefTypeOrTPHOrWildcardOrGeneric> getParaList() {
-    if (this.parameter == null) return new ArrayList<>();
-    return this.parameter;
-  }
-
-  /**
-   * Author: Jrg Buerle<br/>
-   *
-   * @return
-   */
-  public boolean equals(Object obj) {
-    if (!(obj instanceof RefType refObj)) {
-      return false;
     }
 
-    if (!Objects.equals(this.name, refObj.name)) return false;
+    public boolean isPrimitive() {
-    boolean ret = true;
+        return primitiveFlag;
+    }
 
-    //if(!(super.equals(obj))) PL 2020-03-12 muss vll. einkommentiert werden
+    @Override
-    //	return false;
+    public String toString(){
-
+        String params = "";
-    if (parameter == null || parameter.size() == 0) {
+        if(parameter.size()>0){
-      ret &= (refObj.getParaList() == null || refObj.getParaList().isEmpty());
+            params += "<";
-    } else {
+            Iterator<RefTypeOrTPHOrWildcardOrGeneric> it = parameter.iterator();
-      if (refObj.getParaList() == null) {
+            while(it.hasNext()){
-        ret = false;
+                RefTypeOrTPHOrWildcardOrGeneric param = it.next();
-      } else if (parameter.size() != refObj.getParaList().size()) {
+                params += param.toString();
-        ret = false;
+                if(it.hasNext())params += ", ";
-      } else {
+            }
-        for (int i = 0; i < parameter.size(); i++) {
+            params += ">";
-          ret &= parameter.get(i).equals(refObj.getParaList().get(i));
         }
-      }
+        return this.name.toString() + params;
     }
-    return ret;
 
-  }
+    @Override
+	public int hashCode() {
+        return this.name.hashCode();//Nur den Name hashen. Sorgt für langsame, aber funktionierende HashMaps
+	}
 
+    public RefType(JavaClassName fullyQualifiedName, List<RefTypeOrTPHOrWildcardOrGeneric> parameter, Token offset) {
+        this(fullyQualifiedName, parameter, offset, false);
+    }
 
-  @Override
+    public RefType(JavaClassName fullyQualifiedName, List<RefTypeOrTPHOrWildcardOrGeneric> parameter, Token offset, boolean primitiveFlag) {
-  public void accept(ASTVisitor visitor) {
+        super(offset);
-    visitor.visit(this);
+        this.name = (fullyQualifiedName);
-  }
+        this.parameter = parameter;
+        this.primitiveFlag = primitiveFlag;
+    }
 
-  @Override
+    public JavaClassName getName()
-  public <A> A acceptTV(TypeVisitor<A> visitor) {
+    {
-    return visitor.visit(this);
+        return name;
-  }
+    }
 
-  @Override
+    public List<RefTypeOrTPHOrWildcardOrGeneric> getParaList(){
-  public void accept(ResultSetVisitor visitor) {
+    	if(this.parameter==null)return new ArrayList<>();
-    visitor.visit(this);
+    	return this.parameter;
-  }
+    }
 
-  @Override
+    /**
-  public ISerialNode toSerial(KeyStorage keyStorage) {
+     * Author: Jrg Buerle<br/>
-    SerialMap serialized = new SerialMap();
+     * @return
-    serialized.put("isPrimitive", this.primitiveFlag);
+     */
-    serialized.put("name", this.name.toString());
+    public boolean equals(Object obj)
-    serialized.put("parameters", SerialList.fromMapped(this.parameter, param -> param.toSerial(keyStorage)));
+    {
+        if(obj instanceof RefType){
+            if (!Objects.equals(this.name, ((RefType) obj).name)) return false;
+            boolean ret = true;
+            
+            //if(!(super.equals(obj))) PL 2020-03-12 muss vll. einkommentiert werden   
+            //	return false;
+            
+            if(parameter==null || parameter.size()==0){
+                ret &= (((RefType)obj).getParaList()==null || ((RefType)obj).getParaList().size()==0);
+            }
+            else{
+                if(((RefType)obj).getParaList()==null){
+                    ret = false;
+                }
+                else if(parameter.size() != ((RefType)obj).getParaList().size())
+                {
+                	ret = false;
+                }
+                else
+                {
+                	for(int i = 0; i<parameter.size(); i++)
+                	{
+                		ret &= parameter.get(i).equals(((RefType)obj).getParaList().get(i));
+                	}
+                }
+            }
+            return ret;
+        }
+        else{
+            return false;
+        }
+    }
+    	
 
-    // create the wrapper and put this as the object
+    @Override
-    var serializedWrapper = super.toSerial(keyStorage).assertType(SerialMap.class);
+    public void accept(ASTVisitor visitor) {
-    serializedWrapper.put("object", serialized);
+        visitor.visit(this);
-    return serializedWrapper;
+    }
-  }
 
-  public static RefType fromSerial(SerialMap data, UnifyContext context) {
+    @Override
-    return new RefType(
+    public <A> A acceptTV(TypeVisitor<A> visitor) {
-      new JavaClassName(data.getValue("name").getOf(String.class)),
+        return visitor.visit(this);
-      data.getList("parameters").assertListOfMaps().stream()
+    }
-        .map(param -> RefTypeOrTPHOrWildcardOrGeneric.fromSerial(param, context))
+
-        .toList(),
+    @Override
-      new NullToken(),
+    public void accept(ResultSetVisitor visitor) {
-      data.getValue("isPrimitive").getOf(Boolean.class)
+        visitor.visit(this);
-    );
+    }
-  }
 }
 

src/main/java/de/dhbwstuttgart/syntaxtree/type/RefTypeOrTPHOrWildcardOrGeneric.java

@@ -1,17 +1,11 @@
 package de.dhbwstuttgart.syntaxtree.type;
 
-import de.dhbwstuttgart.server.packet.dataContainers.ISerializableData;
-import de.dhbwstuttgart.server.packet.dataContainers.KeyStorage;
-import de.dhbwstuttgart.server.packet.dataContainers.serialized.ISerialNode;
-import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialMap;
-import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialValue;
 import de.dhbwstuttgart.syntaxtree.ASTVisitor;
 import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
 import de.dhbwstuttgart.typeinference.result.ResultSetVisitor;
-import de.dhbwstuttgart.typeinference.unify.UnifyContext;
 import org.antlr.v4.runtime.Token;
 
-public abstract class RefTypeOrTPHOrWildcardOrGeneric extends SyntaxTreeNode implements ISerializableData {
+public abstract class RefTypeOrTPHOrWildcardOrGeneric extends SyntaxTreeNode{
     public RefTypeOrTPHOrWildcardOrGeneric(Token offset) {
         super(offset);
     }
@@ -24,26 +18,5 @@ public abstract class RefTypeOrTPHOrWildcardOrGeneric extends SyntaxTreeNode imp
     
     @Override
     public abstract boolean equals(Object o);
-
+    
-    @Override
-    public ISerialNode toSerial(KeyStorage keyStorage) {
-        SerialMap serialized = new SerialMap();
-        serialized.put("type", this.getClass().getSimpleName());
-          // we only insert null for the object and expect the child classes to call this and override the value with themselves
-        serialized.put("object", SerialValue.NULL);
-        return serialized;
-    }
-
-    public static RefTypeOrTPHOrWildcardOrGeneric fromSerial(SerialMap data, UnifyContext context) {
-        String type = data.getValue("type").getOf(String.class);
-        SerialMap object = data.getMap("object");
-
-        if      (type.equals(ExtendsWildcardType.class.getSimpleName()))    return ExtendsWildcardType.fromSerial(object, context);
-        else if (type.equals(GenericRefType.class.getSimpleName()))         return GenericRefType.fromSerial(object, context);
-        else if (type.equals(SuperWildcardType.class.getSimpleName()))      return SuperWildcardType.fromSerial(object, context);
-        else if (type.equals(RefType.class.getSimpleName()))                return RefType.fromSerial(object, context);
-        else if (type.equals(Void.class.getSimpleName()))                   return Void.fromSerial(object, context);
-        else if (type.equals(TypePlaceholder.class.getSimpleName()))        return TypePlaceholder.fromSerial(object, context);
-        else throw new RuntimeException("Could not unserialize class of unhandled type " + type);
-    }
 }

src/main/java/de/dhbwstuttgart/syntaxtree/type/SuperWildcardType.java

@@ -1,13 +1,9 @@
 package de.dhbwstuttgart.syntaxtree.type;
 
 
-import de.dhbwstuttgart.parser.NullToken;
-import de.dhbwstuttgart.server.packet.dataContainers.ISerializableData;
-import de.dhbwstuttgart.server.packet.dataContainers.KeyStorage;
-import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialMap;
 import de.dhbwstuttgart.syntaxtree.ASTVisitor;
+import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
 import de.dhbwstuttgart.typeinference.result.ResultSetVisitor;
-import de.dhbwstuttgart.typeinference.unify.UnifyContext;
 import org.antlr.v4.runtime.Token;
 
 import java.util.Objects;
@@ -20,7 +16,7 @@ import java.util.Objects;
  * 
  */
 
-public class SuperWildcardType extends WildcardType implements ISerializableData {
+public class SuperWildcardType extends WildcardType{
 
 	/**
 	* Author: Arne Lüdtke<br/>
@@ -84,22 +80,4 @@ public class SuperWildcardType extends WildcardType implements ISerializableData
 		SuperWildcardType that = (SuperWildcardType) o;
 		return that.innerType.equals(this.innerType);
 	}
-
-	@Override
-	public SerialMap toSerial(KeyStorage keyStorage) {
-		SerialMap serialized = new SerialMap();
-		serialized.put("innerType", this.innerType.toSerial(keyStorage));
-
-		// create the wrapper and put this as the object
-		var serializedWrapper = super.toSerial(keyStorage).assertType(SerialMap.class);
-		serializedWrapper.put("object", serialized);
-		return serializedWrapper;
-	}
-
-	public static SuperWildcardType fromSerial(SerialMap data, UnifyContext context) {
-		return new SuperWildcardType(
-			RefTypeOrTPHOrWildcardOrGeneric.fromSerial(data.getMap("innerType"), context),
-			new NullToken()
-		);
-	}
 }

src/main/java/de/dhbwstuttgart/syntaxtree/type/TypePlaceholder.java

@@ -1,12 +1,9 @@
 package de.dhbwstuttgart.syntaxtree.type;
-import de.dhbwstuttgart.server.packet.dataContainers.ISerializableData;
+import java.util.Hashtable;
-import de.dhbwstuttgart.server.packet.dataContainers.KeyStorage;
-import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialMap;
-import de.dhbwstuttgart.typeinference.unify.PlaceholderRegistry;
-import de.dhbwstuttgart.typeinference.unify.UnifyContext;
 
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.syntaxtree.ASTVisitor;
+import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
 import de.dhbwstuttgart.syntaxtree.factory.NameGenerator;
 import de.dhbwstuttgart.typeinference.result.ResultSetVisitor;
 import org.antlr.v4.runtime.Token;
@@ -19,7 +16,7 @@ import org.antlr.v4.runtime.Token;
  * @author J�rg B�uerle
  * @version $Date: 2013/06/19 12:45:37 $
  */
-public class TypePlaceholder extends RefTypeOrTPHOrWildcardOrGeneric implements ISerializableData
+public class TypePlaceholder extends RefTypeOrTPHOrWildcardOrGeneric
 {
 	private final String name;
 	
@@ -68,12 +65,7 @@ public class TypePlaceholder extends RefTypeOrTPHOrWildcardOrGeneric implements
     public static TypePlaceholder fresh(Token position){
 		return new TypePlaceholder(NameGenerator.makeNewName(), position, 0, true);
     }
-
+    
-  public static TypePlaceholder fresh(Token position, PlaceholderRegistry placeholderRegistry){
-    String newName = placeholderRegistry.generateFreshPlaceholderName();
-    return new TypePlaceholder(newName, position, 0, true);
-  }
-
     public static TypePlaceholder fresh(Token position, int variance, boolean wildcardable){
 		return new TypePlaceholder(NameGenerator.makeNewName(), position, variance, wildcardable);
     }
@@ -147,26 +139,4 @@ public class TypePlaceholder extends RefTypeOrTPHOrWildcardOrGeneric implements
 	public Boolean getWildcardtable() {
 		return wildcardable;
 	}
-
-  @Override
-  public SerialMap toSerial(KeyStorage keyStorage) {
-    SerialMap serialized = new SerialMap();
-    serialized.put("name", this.name);
-    serialized.put("variance", this.variance);
-    serialized.put("wildcardable", this.wildcardable);
-
-    // create the wrapper and put this as the object
-    var serializedWrapper = super.toSerial(keyStorage).assertType(SerialMap.class);
-    serializedWrapper.put("object", serialized);
-    return serializedWrapper;
-  }
-
-  public static TypePlaceholder fromSerial(SerialMap data, UnifyContext context) {
-    return new TypePlaceholder(
-      data.getValue("name").getOf(String.class),
-      new NullToken(),
-      data.getValue("variance").getOf(Integer.class),
-      data.getValue("wildcardable").getOf(Boolean.class)
-    );
-  }
 }

src/main/java/de/dhbwstuttgart/syntaxtree/type/Void.java

@@ -1,32 +1,14 @@
 package de.dhbwstuttgart.syntaxtree.type;
 
-import de.dhbwstuttgart.parser.NullToken;
-import de.dhbwstuttgart.server.packet.dataContainers.ISerializableData;
-import de.dhbwstuttgart.server.packet.dataContainers.KeyStorage;
-import de.dhbwstuttgart.server.packet.dataContainers.serialized.ISerialNode;
-import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialMap;
-import de.dhbwstuttgart.typeinference.unify.UnifyContext;
 import org.antlr.v4.runtime.Token;
 
 import de.dhbwstuttgart.parser.scope.JavaClassName;
 
 
-public class Void extends RefType implements ISerializableData
+public class Void extends RefType
 {
     public Void(Token offset) {
         super(JavaClassName.Void, offset);
     }
-
-    @Override
-    public ISerialNode toSerial(KeyStorage keyStorage) {
-        // create the wrapper and put this as the object
-        var serializedWrapper = super.toSerial(keyStorage).assertType(SerialMap.class);
-        serializedWrapper.put("object", new SerialMap());
-        return serializedWrapper;
-    }
-
-    public static Void fromSerial(SerialMap data, UnifyContext context) {
-        return new Void(new NullToken());
-    }
 }
 

src/main/java/de/dhbwstuttgart/target/Target.java

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

src/main/java/de/dhbwstuttgart/target/generate/ASTToTargetAST.java

@@ -2,7 +2,6 @@ package de.dhbwstuttgart.target.generate;
 
 import de.dhbwstuttgart.bytecode.FunNGenerator;
 import de.dhbwstuttgart.core.JavaTXCompiler;
-import de.dhbwstuttgart.environment.ByteArrayClassLoader;
 import de.dhbwstuttgart.environment.IByteArrayClassLoader;
 import de.dhbwstuttgart.exceptions.DebugException;
 import de.dhbwstuttgart.parser.NullToken;
@@ -12,7 +11,6 @@ import de.dhbwstuttgart.syntaxtree.Record;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 import de.dhbwstuttgart.syntaxtree.statement.*;
 import de.dhbwstuttgart.syntaxtree.type.*;
-import de.dhbwstuttgart.target.Target;
 import de.dhbwstuttgart.target.tree.*;
 import de.dhbwstuttgart.target.tree.expression.*;
 import de.dhbwstuttgart.target.tree.type.*;
@@ -67,11 +65,11 @@ public class ASTToTargetAST {
     public IByteArrayClassLoader classLoader;
     protected SourceFile sourceFile;
 
-    public ASTToTargetAST(List<ResultSet> resultSets) {
+    public ASTToTargetAST(List<ResultSet> resultSets, IByteArrayClassLoader classLoader) {
-        this(null, resultSets);
+        this(null, resultSets, classLoader);
     }
-    public ASTToTargetAST(JavaTXCompiler compiler, List<ResultSet> resultSets) {
+    public ASTToTargetAST(JavaTXCompiler compiler, List<ResultSet> resultSets, IByteArrayClassLoader classLoader) {
-        this(compiler, resultSets, null, new ByteArrayClassLoader());
+        this(compiler, resultSets, null, classLoader);
     }
 
     public ASTToTargetAST(JavaTXCompiler compiler, List<ResultSet> resultSets, SourceFile sourceFile, IByteArrayClassLoader classLoader) {
@@ -338,10 +336,10 @@ public class ASTToTargetAST {
 
         var result = r0.stream().map(l -> l.stream().toList()).toList();
 
-        Target.logger.info("============== OUTPUT ==============");
+        System.out.println("============== OUTPUT ==============");
         for (var l : result) {
-            for (var m : l) Target.logger.info(m.name() + " " + m.getSignature());
+            for (var m : l) System.out.println(m.name() + " " + m.getSignature());
-            Target.logger.info("");
+            System.out.println();
         }
         return result;
     }
@@ -782,7 +780,15 @@ public class ASTToTargetAST {
         return TargetFunNType.fromParams(params, filteredParams, gep.getReturnType() != null ? 1 : 0);
     }
 
+    private FunNGenerator.GenericParameters convertToParameters(TargetFunNType input) {
+        return null;
+    }
+
     private boolean isSubtype(TargetType test, TargetType other) {
+        if (other.equals(TargetType.Object)) return true;
+        if (test instanceof TargetFunNType tfun && other instanceof TargetFunNType ofun)
+            return isSubtype(new FunNGenerator.GenericParameters(tfun), new FunNGenerator.GenericParameters(ofun));
+
         var testClass = compiler.getClass(new JavaClassName(test.name()));
         var otherClass = compiler.getClass(new JavaClassName(other.name()));
         if (testClass == null) return false;
@@ -819,14 +825,6 @@ public class ASTToTargetAST {
                 .toList();
 
             var code = FunNGenerator.generateSpecializedBytecode(gep, superInterfaces);
-
-            try {
-                classLoader.findClass(entry.getKey());
-            } catch (ClassNotFoundException e) {
-                try {
-                    classLoader.loadClass(code);
-                } catch (LinkageError ignored) {}
-            }
             auxiliaries.put(entry.getKey(), code);
         }
     }
@@ -857,7 +855,7 @@ public class ASTToTargetAST {
                             classLoader.findClass(superClassName);
                         } catch (ClassNotFoundException e) {
                             try {
-                                classLoader.loadClass(code);
+                                classLoader.loadClass(superClassName, code);
                             } catch (LinkageError ignored) {}
                         }
                         auxiliaries.put(superClassName, code);

src/main/java/de/dhbwstuttgart/target/generate/GenerateGenerics.java

@@ -1,12 +1,10 @@
 package de.dhbwstuttgart.target.generate;
 
-import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.syntaxtree.*;
 import de.dhbwstuttgart.syntaxtree.statement.*;
 import de.dhbwstuttgart.syntaxtree.type.*;
 import de.dhbwstuttgart.syntaxtree.type.Void;
-import de.dhbwstuttgart.target.Target;
 import de.dhbwstuttgart.target.tree.type.TargetGenericType;
 import de.dhbwstuttgart.target.tree.type.TargetType;
 import de.dhbwstuttgart.typeinference.result.PairTPHEqualTPH;
@@ -140,17 +138,17 @@ public abstract class GenerateGenerics {
         this.astToTargetAST = astToTargetAST;
         for (var constraint : constraints.results) {
             if (constraint instanceof PairTPHsmallerTPH p) {
-                Target.logger.info(p.left + " " + p.left.getVariance());
+                System.out.println(p.left + " " + p.left.getVariance());
                 simplifiedConstraints.add(new PairLT(new TPH(p.left), new TPH(p.right)));
             } else if (constraint instanceof PairTPHEqualTPH p) {
                 equality.put(p.getLeft(), p.getRight());
             } else if (constraint instanceof PairTPHequalRefTypeOrWildcardType p) {
-                Target.logger.info(p.left + " = " + p.right);
+                System.out.println(p.left + " = " + p.right);
                 concreteTypes.put(new TPH(p.left), p.right);
             }
         }
 
-        Target.logger.info("Simplified constraints: " + simplifiedConstraints);
+        System.out.println("Simplified constraints: " + simplifiedConstraints);
     }
 
     /*public record GenericsState(Map<TPH, RefTypeOrTPHOrWildcardOrGeneric> concreteTypes, Map<TypePlaceholder, TypePlaceholder> equality) {}
@@ -250,7 +248,7 @@ public abstract class GenerateGenerics {
                 equality.put(entry.getKey(), to);
             }
         }
-        Target.logger.info(from + " -> " + to + " " + from.getVariance());
+        System.out.println(from + " -> " + to + " " + from.getVariance());
         //from.setVariance(to.getVariance());
         equality.put(from, to);
         referenced.remove(new TPH(from));
@@ -319,7 +317,7 @@ public abstract class GenerateGenerics {
                     Set<TPH> T2s = new HashSet<>();
                     findTphs(superType, T2s);
 
-                    Target.logger.info("T1s: " + T1s + " T2s: " + T2s);
+                    System.out.println("T1s: " + T1s + " T2s: " + T2s);
                     //Ende
 
                     superType = methodCall.receiverType;
@@ -334,7 +332,7 @@ public abstract class GenerateGenerics {
                             var optMethod = astToTargetAST.findMethod(owner, methodCall.name, methodCall.signatureArguments().stream().map(astToTargetAST::convert).toList());
                             if (optMethod.isEmpty()) return;
                             var method2 = optMethod.get();
-                            Target.logger.info("In: " + method.getName() + " Method: " + method2.getName());
+                            System.out.println("In: " + method.getName() + " Method: " + method2.getName());
                             var generics = family(owner, method2);
 
                             // transitive and
@@ -367,7 +365,7 @@ public abstract class GenerateGenerics {
                                                     if (!T1s.contains(R1) || !T2s.contains(R2)) continue;
 
                                                     var newPair = new PairLT(R1, R2);
-                                                    Target.logger.info("New pair: " + newPair);
+                                                    System.out.println("New pair: " + newPair);
                                                     newPairs.add(newPair);
 
                                                     if (!containsRelation(result, newPair))
@@ -569,7 +567,7 @@ public abstract class GenerateGenerics {
     Set<Pair> generics(ClassOrInterface owner, Method method) {
         if (computedGenericsOfMethods.containsKey(method)) {
             var cached = computedGenericsOfMethods.get(method);
-            Target.logger.info("Cached " + method.getName() + ": " + cached);
+            System.out.println("Cached " + method.getName() + ": " + cached);
             return cached;
         }
 
@@ -598,7 +596,7 @@ public abstract class GenerateGenerics {
 
         normalize(result, classGenerics, usedTphs);
 
-        Target.logger.info(this.getClass().getSimpleName() + " " + method.name + ": " + result);
+        System.out.println(this.getClass().getSimpleName() + " " + method.name + ": " + result);
         return result;
     }
 
@@ -677,7 +675,7 @@ public abstract class GenerateGenerics {
 
         normalize(javaResult, null, referencedByClass);
 
-        Target.logger.info(this.getClass().getSimpleName() + " Class " + classOrInterface.getClassName().getClassName() + ": " + javaResult);
+        System.out.println(this.getClass().getSimpleName() + " Class " + classOrInterface.getClassName().getClassName() + ": " + javaResult);
         return javaResult;
     }
 
@@ -728,7 +726,7 @@ public abstract class GenerateGenerics {
                     if (!added) break;
                 }
 
-                Target.logger.info(chain + " " + chain.stream().map(e -> e.resolve().getVariance()).toList());
+                System.out.println(chain + " " + chain.stream().map(e -> e.resolve().getVariance()).toList());
                 var variance = chain.get(0).resolve().getVariance();
                 if (variance != 1) continue;
                 var index = 0;
@@ -766,7 +764,7 @@ public abstract class GenerateGenerics {
         }
 
         for (var pair : elementsToAddToEquality) {
-            Target.logger.info(pair);
+            System.out.println(pair);
             addToEquality(pair.left, pair.right, referenced);
         }
     }
@@ -919,11 +917,11 @@ public abstract class GenerateGenerics {
                     }
                 }
                 if (infima.size() > 1) {
-                    Target.logger.info(infima);
+                    System.out.println(infima);
                     for (var pair : infima) {
                         var returnTypes = findTypeVariables(method.getReturnType());
                         var chain = findConnectionToReturnType(returnTypes, input, new HashSet<>(), pair.left);
-                        Target.logger.info("Find: " + pair.left + " " + chain);
+                        System.out.println("Find: " + pair.left + " " + chain);
                         chain.remove(pair.left);
                         if (chain.size() > 0) {
                             for (var tph : chain)
@@ -961,8 +959,8 @@ public abstract class GenerateGenerics {
                         }
                     }
                     newTph.setVariance(variance);
-                    Target.logger.info(infima + " " + infima.stream().map(i -> i.right.resolve().getVariance()).toList());
+                    System.out.println(infima + " " + infima.stream().map(i -> i.right.resolve().getVariance()).toList());
-                    Target.logger.info("Infima new TPH " + newTph + " variance " + variance);
+                    System.out.println("Infima new TPH " + newTph + " variance " + variance);
 
                     //referenced.add(newTph);
                     addToPairs(input, new PairLT(left, new TPH(newTph)));

src/main/java/de/dhbwstuttgart/target/generate/StatementToTargetExpression.java

@@ -1,5 +1,6 @@
 package de.dhbwstuttgart.target.generate;
 
+import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.exceptions.DebugException;
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
@@ -7,15 +8,14 @@ import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.syntaxtree.*;
 import de.dhbwstuttgart.syntaxtree.statement.*;
 import de.dhbwstuttgart.syntaxtree.type.*;
-import de.dhbwstuttgart.target.Target;
 import de.dhbwstuttgart.target.tree.MethodParameter;
 import de.dhbwstuttgart.target.tree.TargetMethod;
 import de.dhbwstuttgart.target.tree.expression.*;
 import de.dhbwstuttgart.target.tree.type.*;
 
 import java.lang.reflect.Modifier;
+import java.sql.Array;
 import java.util.*;
-import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.stream.Collectors;
 import java.util.stream.StreamSupport;
 
@@ -33,54 +33,71 @@ public class StatementToTargetExpression implements ASTVisitor {
         throw new NotImplementedException();
     }
 
+    private class LambdaCaptureFinder extends TracingStatementVisitor {
+
+        // TODO The same mechanism is implemented in Codegen, maybe use it from there?
+        final Stack<Set<String>> localVariables = new Stack<>();
+        private final List<MethodParameter> parameters;
+        private final List<MethodParameter> captures;
+
+        LambdaCaptureFinder(List<MethodParameter> parameters, List<MethodParameter> captures) {
+            localVariables.push(new HashSet<>());
+            this.parameters = parameters;
+            this.captures = captures;
+        }
+
+        boolean hasLocalVar(String name) {
+            for (var localVariables : this.localVariables) {
+                if (localVariables.contains(name))
+                    return true;
+            }
+            return false;
+        }
+
+        @Override
+        public void visit(Block block) {
+            localVariables.push(new HashSet<>());
+            super.visit(block);
+            localVariables.pop();
+        }
+
+        @Override
+        public void visit(LocalVar localVar) {
+            super.visit(localVar);
+            var capture = new MethodParameter(new TargetTypePattern(converter.convert(localVar.getType()), localVar.name));
+            if (!hasLocalVar(localVar.name) && !parameters.contains(capture) && !captures.contains(capture))
+                captures.add(capture);
+        }
+
+        @Override
+        public void visit(LocalVarDecl varDecl) {
+            var localVariables = this.localVariables.peek();
+            localVariables.add(varDecl.getName());
+        }
+
+        @Override
+        public void visit(LambdaExpression lambda) {
+            var newCaptures = new ArrayList<MethodParameter>();
+            var captureFinder = new LambdaCaptureFinder(createParameters(lambda), newCaptures);
+            lambda.methodBody.accept(captureFinder);
+            newCaptures.removeAll(parameters);
+            captures.addAll(newCaptures);
+        }
+    }
+
+    private List<MethodParameter> createParameters(LambdaExpression lambda) {
+        return StreamSupport.stream(lambda.params.spliterator(), false)
+            .map(p -> (FormalParameter) p)
+            .map(p -> new MethodParameter(new TargetTypePattern(converter.convert(p.getType()), p.getName())))
+            .toList();
+    }
+
     @Override
     public void visit(LambdaExpression lambdaExpression) {
-        var parameters = StreamSupport.stream(lambdaExpression.params.spliterator(), false)
+        var parameters = createParameters(lambdaExpression);
-                .map(p -> (FormalParameter) p)
-                .map(p -> new MethodParameter(new TargetTypePattern(converter.convert(p.getType()), p.getName())))
-                .toList();
-
         List<MethodParameter> captures = new ArrayList<>();
-        lambdaExpression.methodBody.accept(new TracingStatementVisitor() {
+        var visitor = new LambdaCaptureFinder(parameters, captures);
-            // TODO The same mechanism is implemented in Codegen, maybe use it from there?
+        lambdaExpression.methodBody.accept(visitor);
-            final Stack<Set<String>> localVariables = new Stack<>();
-            {
-                localVariables.push(new HashSet<>());
-            }
-
-            boolean hasLocalVar(String name) {
-                for (var localVariables : this.localVariables) {
-                    if (localVariables.contains(name))
-                        return true;
-                }
-                return false;
-            }
-
-            @Override
-            public void visit(Block block) {
-                localVariables.push(new HashSet<>());
-                super.visit(block);
-                localVariables.pop();
-            }
-
-            @Override
-            public void visit(LocalVar localVar) {
-                super.visit(localVar);
-                var capture = new MethodParameter(new TargetTypePattern(converter.convert(localVar.getType()), localVar.name));
-                if (!hasLocalVar(localVar.name) && !parameters.contains(capture) && !captures.contains(capture))
-                    captures.add(capture);
-            }
-
-            @Override
-            public void visit(LocalVarDecl varDecl) {
-                var localVariables = this.localVariables.peek();
-                localVariables.add(varDecl.getName());
-            }
-
-            @Override
-            public void visit(LambdaExpression lambda) {
-            } // Don't look at lambda expressions
-        });
 
         TargetMethod.Signature signature = new TargetMethod.Signature(Set.of(), parameters, converter.convert(lambdaExpression.getReturnType()));;
         var tpe = converter.convert(lambdaExpression.getType());
@@ -121,7 +138,7 @@ public class StatementToTargetExpression implements ASTVisitor {
 
     @Override
     public void visit(BoolExpression bool) {
-        Target.logger.info("BoolExpression");
+        System.out.println("BoolExpression");
     }
 
     @Override
@@ -219,22 +236,6 @@ public class StatementToTargetExpression implements ASTVisitor {
         if (methodCall.receiver instanceof ExpressionReceiver expressionReceiver && expressionReceiver.expr instanceof This) {
             if (receiverClass == null) throw new DebugException("Class " + receiverName + " does not exist!");
             var thisMethod = converter.findMethod(receiverClass, methodCall.name, signature);
-            if (thisMethod.isEmpty()) {
-                Target.logger.error("Expected: " + receiverClass.getClassName() + "." + methodCall.name + "(" +
-                  signature.stream().map(TargetType::toSignature).collect(Collectors.joining())+ ")" );
-
-                AtomicBoolean hasM = new AtomicBoolean(false);
-                receiverClass.getMethods().forEach(m -> {
-                    if (Objects.equals(m.getName(), methodCall.name)) {
-                        hasM.set(true);
-                        Target.logger.error("But only has: " + m.name + "(" +
-                          m.getParameterList().getFormalparalist().stream().map(t -> t.getType().toString()).collect(Collectors.joining())+ ")" );
-                    }
-                });
-                if (!hasM.get())
-                    Target.logger.error("But does not contain method at all");
-            }
-
             ClassOrInterface finalReceiverClass = receiverClass;
             foundMethod = thisMethod.orElseGet(() -> findMethod(finalReceiverClass.getSuperClass().getName(), methodCall.name, signature).orElseThrow());
         } else if (!isFunNType) {
@@ -251,7 +252,7 @@ public class StatementToTargetExpression implements ASTVisitor {
             isInterface = receiverClass.isInterface();
         }
 
-        Target.logger.info(argList);
+        System.out.println(argList);
         result = new TargetMethodCall(converter.convert(methodCall.getType()), returnType, argList, converter.convert(methodCall.receiver), methodCall.getArgumentList().getArguments().stream().map(converter::convert).toList(), receiverType, methodCall.name, isStatic, isInterface, isPrivate);
     }
 

src/main/java/de/dhbwstuttgart/typeinference/assumptions/FunNClass.java

@@ -9,8 +9,13 @@ import de.dhbwstuttgart.syntaxtree.Method;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 import de.dhbwstuttgart.syntaxtree.factory.NameGenerator;
 import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
+import de.dhbwstuttgart.syntaxtree.type.RefType;
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 
+import org.antlr.v4.runtime.Token;
 
+import javax.swing.text.html.Option;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;

src/main/java/de/dhbwstuttgart/typeinference/assumptions/MethodAssumption.java

@@ -19,11 +19,11 @@ public class MethodAssumption extends Assumption{
     private ClassOrInterface receiver;
     private RefTypeOrTPHOrWildcardOrGeneric retType;
     List<? extends RefTypeOrTPHOrWildcardOrGeneric> params;
-    private final boolean isInherited;
+    private final Boolean isInherited;
-    private final boolean isOverridden;
+    private final Boolean isOverridden;
 
     public MethodAssumption(ClassOrInterface receiver, RefTypeOrTPHOrWildcardOrGeneric retType,
-                            List<? extends RefTypeOrTPHOrWildcardOrGeneric> params, TypeScope scope, boolean isInherited, boolean isOverridden){
+                            List<? extends RefTypeOrTPHOrWildcardOrGeneric> params, TypeScope scope, Boolean isInherited, Boolean isOverridden){
         super(scope);
         this.receiver = receiver;
         this.retType = retType;
@@ -73,11 +73,11 @@ public class MethodAssumption extends Assumption{
         return TYPEStmt.getReceiverType(receiver, resolver);
     }
     
-    public boolean isInherited() {
+    public Boolean isInherited() {
     	return isInherited;
     }
     
-    public boolean isOverridden() {
+    public Boolean isOverridden() {
     	return isOverridden;
     }
 }

src/main/java/de/dhbwstuttgart/typeinference/constraints/Constraint.java

@@ -1,171 +1,81 @@
 package de.dhbwstuttgart.typeinference.constraints;
 
-import de.dhbwstuttgart.server.packet.dataContainers.ISerializableData;
-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.server.packet.dataContainers.serialized.SerialUUID;
-import de.dhbwstuttgart.typeinference.unify.UnifyContext;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 
-import java.util.ArrayList;
+import java.util.Collection;
 import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Optional;
 import java.util.Set;
-import java.util.function.Function;
-import java.util.stream.Collectors;
-import javax.annotation.Nullable;
 
-public class Constraint<A extends IConstraintElement> extends HashSet<A> implements ISerializableData {
+public class Constraint<A> extends HashSet<A> implements Comparable<Constraint<A>> {
-  private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
-  private boolean isInherited = false;//wird beides nur für die Method-Constraints benoetigt
+	private Boolean isInherited = false;//wird beides nur für die Method-Constraints benoetigt
-  private boolean isImplemented = false;
+	private Boolean isImplemented = false;
+	
+	/*
+	 * wird verwendet um bei der Codegenerierung die richtige Methoden - Signatur
+	 * auszuwaehlen 
+	 */
+	/*private*/ Set<A> methodSignatureConstraint = new HashSet<>();
+	
+	private Constraint<A> extendConstraint = null;
+	
+	public Constraint() {
+		super();
+	}
+	
+	public Constraint(Boolean isInherited, Boolean isImplemented) {
+		this.isInherited = isInherited;
+		this.isImplemented = isImplemented;
+	}
+	
+	public Constraint(Boolean isInherited, Boolean isImplemented, Constraint<A> extendConstraint, Set<A> methodSignatureConstraint) {
+		this.isInherited = isInherited;
+		this.isImplemented = isImplemented;
+		this.extendConstraint = extendConstraint;
+		this.methodSignatureConstraint = methodSignatureConstraint;
+	}
+	
+	public void setIsInherited(Boolean isInherited) {
+		this.isInherited = isInherited;
+	}
+	
+	public Boolean isInherited() {
+		return isInherited;
+	}
+	
+	public Boolean isImplemented() {
+		return isImplemented;
+	}
+	
+	public Constraint<A> getExtendConstraint() {
+		return extendConstraint;
+	}
+	
+	public void setExtendConstraint(Constraint<A> c) {
+		extendConstraint = c;
+	}
+	
+	public Set<A> getmethodSignatureConstraint() {
+		return methodSignatureConstraint;
+	}
+	
+	public void setmethodSignatureConstraint(Set<A> c) {
+		methodSignatureConstraint = c;
+	}
 
-  /*
+	public String toString() {
-   * wird verwendet um bei der Codegenerierung die richtige Methoden - Signatur
+		return super.toString() + "\nisInherited = " + isInherited + " isOveridden = " + isImplemented
-   * auszuwaehlen
+				+ methodSignatureConstraint
-   */
+				//" + extendsContraint: "  + (extendConstraint != null ? extendConstraint.toStringBase() : "null" ) 
-  /*private*/ Set<A> methodSignatureConstraint = new HashSet<>();
+				+ "\n" ;
-
+	}
-  private Constraint<A> extendConstraint = null;
+	
-
+	public String toStringBase() {
-  public Constraint() {
+		return super.toString();
-    super();
+	}
-  }
-
-  public Constraint(int initialCapacity) {
-    super(initialCapacity);
-  }
-
-  public Constraint(boolean isInherited, boolean isImplemented) {
-    this.isInherited = isInherited;
-    this.isImplemented = isImplemented;
-  }
-
-  public Constraint(boolean isInherited, boolean isImplemented, Constraint<A> extendConstraint, Set<A> methodSignatureConstraint) {
-    this.isInherited = isInherited;
-    this.isImplemented = isImplemented;
-    this.extendConstraint = extendConstraint;
-    this.methodSignatureConstraint = methodSignatureConstraint;
-  }
-
-  public void setIsInherited(boolean isInherited) {
-    this.isInherited = isInherited;
-  }
-
-  public boolean isInherited() {
-    return isInherited;
-  }
-
-  public boolean isImplemented() {
-    return isImplemented;
-  }
-
-  public Constraint<A> getExtendConstraint() {
-    return extendConstraint;
-  }
-
-  public void setExtendConstraint(Constraint<A> c) {
-    extendConstraint = c;
-  }
-
-  public Set<A> getmethodSignatureConstraint() {
-    return methodSignatureConstraint;
-  }
-
-  public void setmethodSignatureConstraint(Set<A> c) {
-    methodSignatureConstraint = c;
-  }
-
-  public <B extends IConstraintElement> Constraint<B> createdMapped(Function<A,B> mapper) {
-    Constraint<B> result = new Constraint<>(this.size());
-    for (A element : this) {
-      result.add(mapper.apply(element));
-    }
-    return result;
-  }
-
-  public String toString() {
-    return super.toString() + "\nisInherited = " + isInherited
-      + " isOveridden = " + isImplemented
-      + " msc[" + methodSignatureConstraint.size() + "] = " + methodSignatureConstraint
-      //" + extendsContraint: "  + (extendConstraint != null ? extendConstraint.toStringBase() : "null" )
-      + "\n";
-  }
-
-  public String toStringBase() {
-    return super.toString();
-  }
-
-  private String serialUUID = null;
-
-  @Override
-  public SerialUUID toSerial(KeyStorage keyStorage) {
-    final String uuid = serialUUID == null ? keyStorage.getIdentifier() : serialUUID;
-    if (serialUUID == null) serialUUID = uuid;
-
-    if (!keyStorage.isAlreadySerialized(uuid)) {
-      SerialMap serialized = new SerialMap();
-      keyStorage.putSerialized(uuid, serialized);
-      serialized.put("isInherited", isInherited);
-      serialized.put("isImplemented", isImplemented);
-      serialized.put("extendedConstraint", extendConstraint == null ? null :
-        extendConstraint.toSerial(keyStorage));
-      Function<A, ISerialNode> pairMapper = pair -> {
-        if (pair instanceof Pair simplePair) return simplePair.toSerial(keyStorage);
-        if (pair instanceof UnifyPair unifyPair) return unifyPair.toSerial(keyStorage);
-        throw new RuntimeException("No serialization is supported for type " + pair.getClass().getName());
-      };
-      serialized.put("methodSignatureConstraint", methodSignatureConstraint == null ? null :
-        SerialList.fromMapped(methodSignatureConstraint, pairMapper));
-      serialized.put("setElements", SerialList.fromMapped(this, pairMapper));
-    }
-
-    // return only the unique key
-    return new SerialUUID(uuid);
-  }
-
-  public static <T extends IConstraintElement> Constraint<T> fromSerial(SerialUUID serialUUID, UnifyContext context, Class<T> target, KeyStorage keyStorage) {
-    String uuid = serialUUID.uuid;
-
-    if (!keyStorage.isAlreadyUnserialized(uuid)) {
-      Constraint<T> constraint = new Constraint<>();
-      // immediately add the object to the context to prevent infinite recursion
-      keyStorage.putUnserialized(uuid, constraint);
-
-      // retrieve the serialized data und start unserializing it
-      SerialMap data = keyStorage.getSerialized(uuid);
-      constraint.isInherited = data.getValue("isInherited").getOf(Boolean.class);
-      constraint.isImplemented = data.getValue("isImplemented").getOf(Boolean.class);
-      constraint.extendConstraint = Optional.ofNullable(data.getUUIDOrNull("extendedConstraint"))
-        .map(v -> Constraint.fromSerial(v, context, target, keyStorage))
-        .orElse(null);
-
-      // to convert the maps back to elements, we sadly have to do some assumptions about the generic types...
-      Function<ISerialNode, T> pairUnmapper = pairData -> {
-        if (target == Pair.class && pairData instanceof SerialMap pairMap) {
-          return (T) Pair.fromSerial(pairMap, context);
-        }
-        if (target == UnifyPair.class && pairData instanceof SerialUUID pairUUID) {
-          return (T) UnifyPair.fromSerial(pairUUID, context, keyStorage);
-        }
-        throw new RuntimeException("No serialization is supported for target type " + target.getName());
-      };
-
-      constraint.methodSignatureConstraint =
-        Optional.ofNullable(data.getListOrNull("methodSignatureConstraint"))
-          .map(l -> l.stream().map(pairUnmapper).collect(Collectors.toSet()))
-          .orElse(null);
-      constraint.addAll(
-        data.getList("setElements")
-          .stream().map(pairUnmapper).toList());
-    }
-
-    return keyStorage.getUnserialized(uuid, Constraint.class);
-  }
 
+	@Override
+	public int compareTo(Constraint<A> o) {
+		return this.toString().compareTo(o.toString());
+	}
 }

src/main/java/de/dhbwstuttgart/typeinference/constraints/ConstraintSet.java

@@ -1,80 +1,63 @@
 package de.dhbwstuttgart.typeinference.constraints;
 
 
-import de.dhbwstuttgart.server.packet.dataContainers.ISerializableData;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
-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.typeinference.unify.GuavaSetOperations;
-import de.dhbwstuttgart.typeinference.unify.UnifyContext;
+import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 
-import de.dhbwstuttgart.typeinference.unify.model.FiniteClosure;
 import java.util.*;
 import java.util.function.BinaryOperator;
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
-public class ConstraintSet<A extends IConstraintElement> implements ISerializableData {
+public class ConstraintSet<A> {
-  Constraint<A> undConstraints = new Constraint<>();
+    Constraint<A> undConstraints = new Constraint<>();
-  List<Set<Constraint<A>>> oderConstraints = new ArrayList<>();
+    List<Set<Constraint<A>>> oderConstraints = new ArrayList<>();
 
-  public void addUndConstraint(A p) {
+    public void addUndConstraint(A p){
-    undConstraints.add(p);
+        undConstraints.add(p);
-  }
+    }
 
-  public void addOderConstraint(Set<Constraint<A>> methodConstraints) {
+    public void addOderConstraint(Set<Constraint<A>> methodConstraints) {
-    oderConstraints.add(methodConstraints);
+        oderConstraints.add(methodConstraints);
-  }
+    }
 
-  public void addAllUndConstraint(Constraint<A> allUndConstraints) {
+    public void addAllUndConstraint(Constraint<A> allUndConstraints){
-    undConstraints.addAll(allUndConstraints);
+        undConstraints.addAll(allUndConstraints);
-  }
+    }
+    
+    public void addAllOderConstraint(List<Set<Constraint<A>>> allOderConstraints){
+        this.oderConstraints.addAll(allOderConstraints);
+    }
+    
+    public void addAll(ConstraintSet constraints) {
+        this.addAllUndConstraint(constraints.undConstraints);
+        this.addAllOderConstraint(constraints.oderConstraints);
+    }
 
-  public void addAllOderConstraint(List<Set<Constraint<A>>> allOderConstraints) {
+    @Override
-    this.oderConstraints.addAll(allOderConstraints);
+    public String toString(){
-  }
+    	BinaryOperator<String> b = (x,y) -> x+y;
+        return "\nUND:" + this.undConstraints.toString() + "\n" + 
+    		   "ODER:" + this.oderConstraints.stream().reduce("", (x,y) -> x.toString()+ "\n"  +y, b);
+        		//cartesianProduct().toString();
+    }
 
-  public void addAll(ConstraintSet constraints) {
+    public Set<List<Constraint<A>>> cartesianProduct(){
-    this.addAllUndConstraint(constraints.undConstraints);
+        Set<Constraint<A>> toAdd = new HashSet<>();
-    this.addAllOderConstraint(constraints.oderConstraints);
+        toAdd.add(undConstraints);
-  }
+        List<Set<Constraint<A>>> allConstraints = new ArrayList<>();
+        allConstraints.add(toAdd);
+        allConstraints.addAll(oderConstraints);
+        return new GuavaSetOperations().cartesianProduct(allConstraints);
+    }
 
-  @Override
+    public <B> ConstraintSet<B> map(Function<? super A, ? extends B> o) {
-  public String toString() {
+    	Hashtable<Constraint<A>,Constraint<B>> CSA2CSB = new Hashtable<>();
-    BinaryOperator<String> b = (x, y) -> x + y;
+        ConstraintSet<B> ret = new ConstraintSet<>();
-    return "\nUND:\n" + this.undConstraints.toString() +
+        ret.undConstraints = undConstraints.stream().map(o).collect(Collectors.toCollection(Constraint<B>::new));
-      "ODER:" + this.oderConstraints.stream().reduce("", (x, y) -> x + "\n\t" + y, b) +
+        List<Set<Constraint<B>>> newOder = new ArrayList<>();
-      "\n";
-    //cartesianProduct().toString();
-  }
-
-  @Override
-  public boolean equals(Object obj) {
-    if (!(obj instanceof ConstraintSet<?> other)) return false;
-    return Objects.equals(undConstraints, other.undConstraints)
-      && Objects.equals(oderConstraints, other.oderConstraints);
-  }
-
-  @Override
-  public int hashCode() {
-    return Objects.hash(undConstraints, oderConstraints);
-  }
-
-  public Set<List<Constraint<A>>> cartesianProduct() {
-    Set<Constraint<A>> toAdd = new HashSet<>();
-    toAdd.add(undConstraints);
-    List<Set<Constraint<A>>> allConstraints = new ArrayList<>();
-    allConstraints.add(toAdd);
-    allConstraints.addAll(oderConstraints);
-    return new GuavaSetOperations().cartesianProduct(allConstraints);
-  }
-
-  public <B extends IConstraintElement> ConstraintSet<B> map(Function<? super A, ? extends B> o) {
-    Hashtable<Constraint<A>, Constraint<B>> CSA2CSB = new Hashtable<>();
-    ConstraintSet<B> ret = new ConstraintSet<>();
-    ret.undConstraints = undConstraints.stream().map(o).collect(Collectors.toCollection(Constraint<B>::new));
-    List<Set<Constraint<B>>> newOder = new ArrayList<>();
         /*
         for(Set<Constraint<A>> oderConstraint : oderConstraints){
         	oderConstraint.forEach(as -> {
@@ -85,25 +68,25 @@ public class ConstraintSet<A extends IConstraintElement> implements ISerializabl
             	CSA2CSB.put(as, newConst);} );
         }
         */
-
+        
-    for (Set<Constraint<A>> oderConstraint : oderConstraints) {
+        for(Set<Constraint<A>> oderConstraint : oderConstraints){
-      newOder.add(
+            newOder.add(
-        oderConstraint.stream().map((Constraint<A> as) -> {
+                    oderConstraint.stream().map((Constraint<A> as) -> {
-
+                    	
-          Constraint<B> newConst = as.stream()
+                    	Constraint<B> newConst = as.stream()
-            .map(o)
+                    			.map(o)
-            .collect(Collectors.toCollection((
+                    			.collect(Collectors.toCollection((
-              () -> new Constraint<B>(as.isInherited(),
+                    					() -> new Constraint<B> (as.isInherited(),
-                as.isImplemented(),
+                    											 as.isImplemented(),
-                (as.getExtendConstraint() != null)
+                    											 (as.getExtendConstraint() != null)
-                  ? as.getExtendConstraint().stream().map(o).collect(Collectors.toCollection(Constraint::new))
+                    											     ? as.getExtendConstraint().stream().map(o).collect(Collectors.toCollection(Constraint::new))
-                  : null,
+                    											     : null,
-                as.getmethodSignatureConstraint().stream().map(o).collect(Collectors.toCollection(HashSet::new))))
+                    							                 as.getmethodSignatureConstraint().stream().map(o).collect(Collectors.toCollection(HashSet::new)))) 
-            ));
+                    			));                    							
-
+                    	
-          //CSA2CSB.put(as, newConst);
+                    	//CSA2CSB.put(as, newConst);
-
+                    	
-          return newConst;
+                    	return newConst;
                     	
                     	/*
                     	Constraint<B> bs = CSA2CSB.get(as);
@@ -112,60 +95,36 @@ public class ConstraintSet<A extends IConstraintElement> implements ISerializabl
                     	}
                     	return bs;
                     	*/
-        }).collect(Collectors.toSet())
+                    }).collect(Collectors.toSet())
-      );
+            );
+        }
+        
+        ret.oderConstraints = newOder;
+        return ret;
     }
-
+    
-    ret.oderConstraints = newOder;
+    public void forEach (Consumer<? super A> c) {
-    return ret;
+        undConstraints.stream().forEach(c);
-  }
+        for(Set<Constraint<A>> oderConstraint : oderConstraints){
-
+            oderConstraint.parallelStream().forEach((Constraint<A> as) ->
-  public void forEach(Consumer<? super A> c) {
+                            as.stream().forEach(c));
-    undConstraints.stream().forEach(c);
+        }
-    for (Set<Constraint<A>> oderConstraint : oderConstraints) {
-      oderConstraint.parallelStream().forEach((Constraint<A> as) ->
-        as.stream().forEach(c));
     }
-  }
+    
-
+    public Set<A> getAll () {
-  public Set<A> getAll() {
+    	Set<A> ret = new HashSet<>();
-    Set<A> ret = new HashSet<>(undConstraints);
+        ret.addAll(undConstraints);
-    for (Set<Constraint<A>> oderConstraint : oderConstraints) {
+        for(Set<Constraint<A>> oderConstraint : oderConstraints){
-      oderConstraint.parallelStream().forEach(ret::addAll);
+            oderConstraint.parallelStream().forEach((Constraint<A> as) -> ret.addAll(as));
+        }
+        return ret;
+    }
+    
+    public List<Set<Constraint<A>>> getOderConstraints() {
+    	return oderConstraints;
+    }
+    
+    public Set<A> getUndConstraints() {
+    	return undConstraints;
     }
-    return ret;
-  }
-
-  public List<Set<Constraint<A>>> getOderConstraints() {
-    return oderConstraints;
-  }
-
-  public Set<A> getUndConstraints() {
-    return undConstraints;
-  }
-
-  @Override
-  public SerialMap toSerial(KeyStorage keyStorage) {
-    SerialMap serialized = new SerialMap();
-    serialized.put("undConstraints", undConstraints.toSerial(keyStorage));
-    serialized.put("oderConstraints", SerialList.fromMapped(oderConstraints, oderConstraintSet ->
-      SerialList.fromMapped(oderConstraintSet, oderConstraint ->
-        oderConstraint.toSerial(keyStorage))
-    ));
-    return serialized;
-  }
-
-  public static <T extends IConstraintElement> ConstraintSet<T> fromSerial(SerialMap data, UnifyContext context, Class<T> target, KeyStorage keyStorage) {
-    ConstraintSet<T> constraintSet = new ConstraintSet<>();
-
-    constraintSet.undConstraints = Constraint.fromSerial(data.getUUID("undConstraints"), context, target, keyStorage);
-    constraintSet.oderConstraints = data.getList("oderConstraints").assertListOfLists().stream()
-      .map(oderConstraintSetData -> oderConstraintSetData.assertListOfUUIDs().stream()
-        .map(oderConstraintData -> Constraint.fromSerial(oderConstraintData, context, target, keyStorage))
-        .collect(Collectors.toSet())
-      ).toList();
-
-    return constraintSet;
-  }
-
 }

src/main/java/de/dhbwstuttgart/typeinference/constraints/IConstraintElement.java

@@ -1,4 +0,0 @@
-package de.dhbwstuttgart.typeinference.constraints;
-
-public interface IConstraintElement {
-}

src/main/java/de/dhbwstuttgart/typeinference/constraints/Pair.java

@@ -1,70 +1,72 @@
 package de.dhbwstuttgart.typeinference.constraints;
-
-import de.dhbwstuttgart.server.packet.dataContainers.ISerializableData;
-import de.dhbwstuttgart.server.packet.dataContainers.KeyStorage;
-import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialMap;
-import de.dhbwstuttgart.typeinference.unify.UnifyContext;
 import java.io.Serializable;
 import java.util.HashMap;
 import java.util.Map;
 
+import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.SourceLoc;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
+import org.antlr.v4.runtime.Token;
 
 
-public class Pair implements Serializable, IConstraintElement, ISerializableData {
+public class Pair implements Serializable
-  public final RefTypeOrTPHOrWildcardOrGeneric TA1;
+{
-  public final RefTypeOrTPHOrWildcardOrGeneric TA2;
+    public final RefTypeOrTPHOrWildcardOrGeneric TA1;
+    public final RefTypeOrTPHOrWildcardOrGeneric TA2;
 
-  private SourceLoc location;
+    private SourceLoc location;
 
-  private PairOperator eOperator = PairOperator.SMALLER;
+    private PairOperator eOperator = PairOperator.SMALLER;
-  private boolean noUnification = false;
+    private Boolean noUnification = false;
+    
 
+    private Pair(RefTypeOrTPHOrWildcardOrGeneric TA1, RefTypeOrTPHOrWildcardOrGeneric TA2 )
+    {
+        this.TA1 = TA1;
+        this.TA2 = TA2;
+        if(TA1 == null || TA2 == null)
+            throw new NullPointerException();
+        eOperator = PairOperator.SMALLER;
+    }
 
-  private Pair(RefTypeOrTPHOrWildcardOrGeneric TA1, RefTypeOrTPHOrWildcardOrGeneric TA2) {
+    public Pair(RefTypeOrTPHOrWildcardOrGeneric TA1, RefTypeOrTPHOrWildcardOrGeneric TA2, PairOperator eOp)
-    this.TA1 = TA1;
+    {
-    this.TA2 = TA2;
+        // Konstruktor
-    if (TA1 == null || TA2 == null)
+        this(TA1,TA2);
-      throw new NullPointerException();
+        this.eOperator = eOp;
-    eOperator = PairOperator.SMALLER;
+    }
-  }
 
-  public Pair(RefTypeOrTPHOrWildcardOrGeneric TA1, RefTypeOrTPHOrWildcardOrGeneric TA2, PairOperator eOp) {
+    public Pair(RefTypeOrTPHOrWildcardOrGeneric TA1, RefTypeOrTPHOrWildcardOrGeneric TA2, PairOperator e0p, SourceLoc location) {
-    // Konstruktor
+        this(TA1, TA2, e0p);
-    this(TA1, TA2);
+        this.location = location;
-    this.eOperator = eOp;
+    }
-  }
+    
+    public Pair(RefTypeOrTPHOrWildcardOrGeneric TA1, RefTypeOrTPHOrWildcardOrGeneric TA2, PairOperator eOp, Boolean noUnification)
+    {
+        // Konstruktor
+        this(TA1,TA2);
+        this.eOperator = eOp;
+        this.noUnification = noUnification;
+    }
 
-  public Pair(RefTypeOrTPHOrWildcardOrGeneric TA1, RefTypeOrTPHOrWildcardOrGeneric TA2, PairOperator e0p, SourceLoc location) {
+    public SourceLoc getLocation() {
-    this(TA1, TA2, e0p);
+        return this.location;
-    this.location = location;
+    }
-  }
+    
-
+    public String toString()
-  public Pair(RefTypeOrTPHOrWildcardOrGeneric TA1, RefTypeOrTPHOrWildcardOrGeneric TA2, PairOperator eOp, boolean noUnification) {
+    {
-    // Konstruktor
+        // otth: Gibt ein Paar als String aus --> zum Debuggen und Vergleichen
-    this(TA1, TA2);
+        String strElement1 = "NULL";
-    this.eOperator = eOp;
+        String strElement2 = "NULL";
-    this.noUnification = noUnification;
+        String Operator = "<.";
-  }
+        
-
+        if( TA1 != null )
-  public SourceLoc getLocation() {
+             strElement1 = TA1.toString();
-    return this.location;
+    
-  }
+        if( TA2 != null )
-
+           strElement2 = TA2.toString();
-  public String toString() {
-    // otth: Gibt ein Paar als String aus --> zum Debuggen und Vergleichen
-    String strElement1 = "NULL";
-    String strElement2 = "NULL";
-    String Operator = "<.";
-
-    if (TA1 != null)
-      strElement1 = TA1.toString();
-
-    if (TA2 != null)
-      strElement2 = TA2.toString();
         
        /* PL ausskommentiert 2018-05-24
         if(OperatorEqual())
@@ -74,104 +76,80 @@ public class Pair implements Serializable, IConstraintElement, ISerializableData
         if(OperatorSmallerExtends())
         	Operator = "<?";
         	*/
+        
+        return "\n(" + strElement1 + " " + eOperator.toString() + " " + strElement2 + ")";
+        
+       /*- Equals: " + bEqual*/
+    }
 
-    return "\n(P: " + strElement1 + " " + eOperator.toString() + " " + strElement2 + ")";
+    /**
+     * <br/>Author: J�rg B�uerle
+     * @param obj
+     * @return
+     */
+    public boolean equals(Object obj)
+    {
+        boolean ret = true;
+        ret &= (obj instanceof Pair);
+        if(!ret)return ret;
+        ret &= ((Pair)obj).TA1.equals(this.TA1);
+        ret &= ((Pair)obj).TA2.equals(this.TA2);
+        return ret;
+    }
 
-    /*- Equals: " + bEqual*/
+    /**
-  }
+	* Author: Arne Lüdtke<br/>
+	* Abfrage, ob Operator vom Typ Equal ist.
+	*/
+    public boolean OperatorEqual()
+    {
+    	return eOperator == PairOperator.EQUALSDOT;
+    }
+    
+    /**
+	* Author: Arne Lüdtke<br/>
+	* Abfrage, ob Operator vom Typ Smaller ist.
+	*/
+    public boolean OperatorSmaller()
+    {
+    	return eOperator == PairOperator.SMALLER;
+    }
+    
+    /**
+	* Author: Arne Lüdtke<br/>
+	* Abfrage, ob Operator vom Typ SmallerExtends ist.
+	*/
+    public boolean OperatorSmallerExtends()
+    {
+    	return eOperator == PairOperator.SMALLERDOTWC;
+    }
+    
+    /**
+	* Author: Arne Lüdtke<br/>
+	* Gibt den Operator zurück.
+	*/
+    public PairOperator GetOperator()
+    {
+    	return eOperator;
+    }
 
-  /**
+    public boolean OperatorSmallerDot() {
-   * <br/>Author: J�rg B�uerle
+        return eOperator == PairOperator.SMALLERDOT;
-   *
+    }
-   * @param obj
+    
-   * @return
+    
-   */
+    static public Map<String, TypePlaceholder> generateTPHMap(ConstraintSet<Pair> constraints) {
-  public boolean equals(Object obj) {
+        HashMap<String, TypePlaceholder> ret = new HashMap<>();
-    return (
+        constraints.map((Pair p) -> {
-      (obj instanceof Pair pairObj) &&
+            if (p.TA1 instanceof TypePlaceholder) {
-        pairObj.TA1.equals(this.TA1) &&
+                ret.put(((TypePlaceholder) p.TA1).getName(), (TypePlaceholder) p.TA1);
-        pairObj.TA2.equals(this.TA2)
+            }
-    );
+            if (p.TA2 instanceof TypePlaceholder) {
-  }
+                ret.put(((TypePlaceholder) p.TA2).getName(), (TypePlaceholder) p.TA2);
-
+            }
-  /**
+            return null;
-   * Author: Arne Lüdtke<br/>
+        });
-   * Abfrage, ob Operator vom Typ Equal ist.
+        return ret;
-   */
+    }
-  public boolean OperatorEqual() {
-    return eOperator == PairOperator.EQUALSDOT;
-  }
-
-  /**
-   * Author: Arne Lüdtke<br/>
-   * Abfrage, ob Operator vom Typ Smaller ist.
-   */
-  public boolean OperatorSmaller() {
-    return eOperator == PairOperator.SMALLER;
-  }
-
-  /**
-   * Author: Arne Lüdtke<br/>
-   * Abfrage, ob Operator vom Typ SmallerExtends ist.
-   */
-  public boolean OperatorSmallerExtends() {
-    return eOperator == PairOperator.SMALLERDOTWC;
-  }
-
-  /**
-   * Author: Arne Lüdtke<br/>
-   * Gibt den Operator zurück.
-   */
-  public PairOperator GetOperator() {
-    return eOperator;
-  }
-
-  public boolean OperatorSmallerDot() {
-    return eOperator == PairOperator.SMALLERDOT;
-  }
-
-
-  static public Map<String, TypePlaceholder> generateTPHMap(ConstraintSet<Pair> constraints) {
-    HashMap<String, TypePlaceholder> ret = new HashMap<>();
-    constraints.map((Pair p) -> {
-      if (p.TA1 instanceof TypePlaceholder) {
-        ret.put(((TypePlaceholder) p.TA1).getName(), (TypePlaceholder) p.TA1);
-      }
-      if (p.TA2 instanceof TypePlaceholder) {
-        ret.put(((TypePlaceholder) p.TA2).getName(), (TypePlaceholder) p.TA2);
-      }
-      return null;
-    });
-    return ret;
-  }
-
-  @Override
-  public SerialMap toSerial(KeyStorage keyStorage) {
-    // because toString() will output TA1 and TA2 recursively, we can ignore potential infinite recursion here too
-    SerialMap serialized = new SerialMap();
-    serialized.put("ta1", this.TA1.toSerial(keyStorage));
-    serialized.put("ta2", this.TA2.toSerial(keyStorage));
-    serialized.put("op", this.eOperator.toString());
-    serialized.put("noUnification", this.noUnification ? 1 : 0);
-    serialized.put("location", this.location == null ? null : this.location.toSerial(keyStorage));
-    return serialized;
-  }
-
-  public static Pair fromSerial(SerialMap data, UnifyContext context) {
-    String op = data.getValue("op").getOf(String.class);
-    SerialMap ta1 = data.getMap("ta1");
-    SerialMap ta2 = data.getMap("ta2");
-    boolean noUnification = data.getValue("noUnification").getOf(Integer.class) == 1;
-    SerialMap location = data.getMapOrNull("location");
-
-    var pair = new Pair(
-      RefTypeOrTPHOrWildcardOrGeneric.fromSerial(ta1, context),
-      RefTypeOrTPHOrWildcardOrGeneric.fromSerial(ta2, context),
-      PairOperator.fromString(op),
-      noUnification
-    );
-    if (location != null) pair.location = SourceLoc.fromSerial(location);
-    return pair;
-  }
 }
 // ino.end

src/main/java/de/dhbwstuttgart/typeinference/result/PairNoResult.java

@@ -1,19 +1,15 @@
 package de.dhbwstuttgart.typeinference.result;
 
 import de.dhbwstuttgart.exceptions.NotImplementedException;
-import de.dhbwstuttgart.server.packet.dataContainers.ISerializableData;
-import de.dhbwstuttgart.server.packet.dataContainers.KeyStorage;
-import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialMap;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.typeinference.unify.UnifyContext;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 
 /**
  * enthaelt alle Paare, die in einem Ergebnis nicht vorkommen koennen
  * sie sind noetig fuer origPairs in PairTPHsmallerTPH, da hier auch
  * Paare vorkommen koennen die keine Result sind (z.B. bei FunN$$)
  */
-public class PairNoResult extends ResultPair<RefTypeOrTPHOrWildcardOrGeneric, RefTypeOrTPHOrWildcardOrGeneric>
+public class PairNoResult extends ResultPair<RefTypeOrTPHOrWildcardOrGeneric, RefTypeOrTPHOrWildcardOrGeneric>{
-implements ISerializableData {
     //public final TypePlaceholder left;
     //public final TypePlaceholder right;
     
@@ -21,7 +17,7 @@ implements ISerializableData {
      * urspruengliches Paar aus diesem dieses Resultpair erzeugt wurde
      * wichtig fuer generated Generics
      */
-    ResultPair<?,?> origPair;
+    ResultPair origPair;
 
     public PairNoResult(RefTypeOrTPHOrWildcardOrGeneric left, RefTypeOrTPHOrWildcardOrGeneric right){
         super(left, right);
@@ -33,24 +29,4 @@ implements ISerializableData {
     	throw new NotImplementedException();
         //visitor.visit(this);
     }
-
-    @Override
-    public SerialMap toSerial(KeyStorage keyStorage) {
-        SerialMap serialized = new SerialMap();
-        serialized.put("left", this.getLeft().toSerial(keyStorage));
-        serialized.put("right", this.getRight().toSerial(keyStorage));
-        // create the wrapper and put this as the object
-        var serializedWrapper = super.toSerial(keyStorage);
-        serializedWrapper.put("object", serialized);
-        return serializedWrapper;
-    }
-
-    public static PairNoResult fromSerial2(SerialMap data, UnifyContext context) {
-        SerialMap left = data.getMap("left");
-        SerialMap right = data.getMap("right");
-        return new PairNoResult(
-          RefTypeOrTPHOrWildcardOrGeneric.fromSerial(left, context),
-          RefTypeOrTPHOrWildcardOrGeneric.fromSerial(right, context)
-        );
-    }
 }

src/main/java/de/dhbwstuttgart/typeinference/result/PairTPHEqualTPH.java

@@ -1,13 +1,9 @@
 package de.dhbwstuttgart.typeinference.result;
 
-import de.dhbwstuttgart.server.packet.dataContainers.ISerializableData;
-import de.dhbwstuttgart.server.packet.dataContainers.KeyStorage;
-import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialMap;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
-import de.dhbwstuttgart.typeinference.unify.UnifyContext;
 
-public class PairTPHEqualTPH extends ResultPair<TypePlaceholder, TypePlaceholder> implements ISerializableData {
+public class PairTPHEqualTPH extends ResultPair<TypePlaceholder, TypePlaceholder> {
     public PairTPHEqualTPH(TypePlaceholder tl, TypePlaceholder tr) {
         super(tl, tr);
     }
@@ -16,24 +12,4 @@ public class PairTPHEqualTPH extends ResultPair<TypePlaceholder, TypePlaceholder
     public void accept(ResultPairVisitor visitor) {
         visitor.visit(this);
     }
-
-    @Override
-    public SerialMap toSerial(KeyStorage keyStorage) {
-        SerialMap serialized = new SerialMap();
-        serialized.put("left", this.getLeft().toSerial(keyStorage));
-        serialized.put("right", this.getRight().toSerial(keyStorage));
-        // create the wrapper and put this as the object
-        var serializedWrapper = super.toSerial(keyStorage);
-        serializedWrapper.put("object", serialized);
-        return serializedWrapper;
-    }
-
-    public static PairTPHEqualTPH fromSerial2(SerialMap data, UnifyContext context) {
-        SerialMap left = data.getMap("left");
-        SerialMap right = data.getMap("right");
-        return new PairTPHEqualTPH(
-          (TypePlaceholder) RefTypeOrTPHOrWildcardOrGeneric.fromSerial(left, context),
-          (TypePlaceholder) RefTypeOrTPHOrWildcardOrGeneric.fromSerial(right, context)
-        );
-    }
 }

src/main/java/de/dhbwstuttgart/typeinference/result/PairTPHequalRefTypeOrWildcardType.java

@@ -1,17 +1,13 @@
 package de.dhbwstuttgart.typeinference.result;
 
-import de.dhbwstuttgart.server.packet.dataContainers.ISerializableData;
+import de.dhbwstuttgart.syntaxtree.type.RefType;
-import de.dhbwstuttgart.server.packet.dataContainers.KeyStorage;
-import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialMap;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
-import de.dhbwstuttgart.typeinference.unify.UnifyContext;
 
 /**
  * Steht für A =. RefType
  */
-public class PairTPHequalRefTypeOrWildcardType extends ResultPair<TypePlaceholder, RefTypeOrTPHOrWildcardOrGeneric>
+public class PairTPHequalRefTypeOrWildcardType extends ResultPair{
-implements ISerializableData {
     public final TypePlaceholder left;
     public final RefTypeOrTPHOrWildcardOrGeneric right;
 
@@ -30,24 +26,4 @@ implements ISerializableData {
     public String toString() {
     	return "(" + left.toString() + " = " + right.toString() + ")";
     }
-
-    @Override
-    public SerialMap toSerial(KeyStorage keyStorage) {
-        SerialMap serialized = new SerialMap();
-        serialized.put("left", this.getLeft().toSerial(keyStorage));
-        serialized.put("right", this.getRight().toSerial(keyStorage));
-        // create the wrapper and put this as the object
-        var serializedWrapper = super.toSerial(keyStorage);
-        serializedWrapper.put("object", serialized);
-        return serializedWrapper;
-    }
-
-    public static PairTPHequalRefTypeOrWildcardType fromSerial2(SerialMap data, UnifyContext context) {
-        SerialMap left = data.getMap("left");
-        SerialMap right = data.getMap("right");
-        return new PairTPHequalRefTypeOrWildcardType(
-          (TypePlaceholder)RefTypeOrTPHOrWildcardOrGeneric.fromSerial(left, context),
-          RefTypeOrTPHOrWildcardOrGeneric.fromSerial(right, context)
-        );
-    }
 }

src/main/java/de/dhbwstuttgart/typeinference/result/PairTPHsmallerTPH.java

@@ -1,17 +1,12 @@
 package de.dhbwstuttgart.typeinference.result;
 
-import de.dhbwstuttgart.server.packet.dataContainers.ISerializableData;
-import de.dhbwstuttgart.server.packet.dataContainers.KeyStorage;
-import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialMap;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
-import de.dhbwstuttgart.typeinference.unify.UnifyContext;
 
 /**
  * Steht für: A <. B
  */
-public class PairTPHsmallerTPH extends ResultPair<TypePlaceholder,TypePlaceholder>
+public class PairTPHsmallerTPH extends ResultPair{
-  implements ISerializableData {
     public final TypePlaceholder left;
     public final TypePlaceholder right;
     
@@ -19,7 +14,7 @@ public class PairTPHsmallerTPH extends ResultPair<TypePlaceholder,TypePlaceholde
      * urspruengliches Paar aus diesem dieses Resultpair erzeugt wurde
      * wichtig fuer generated Generics
      */
-    ResultPair<?,?> origPair;
+    ResultPair origPair;
 
     public PairTPHsmallerTPH(TypePlaceholder left, TypePlaceholder right){
         super(left, right);
@@ -27,7 +22,7 @@ public class PairTPHsmallerTPH extends ResultPair<TypePlaceholder,TypePlaceholde
         this.right = right;
     }
 
-    public PairTPHsmallerTPH(TypePlaceholder left, TypePlaceholder right, ResultPair<?,?> origPair){
+    public PairTPHsmallerTPH(TypePlaceholder left, TypePlaceholder right, ResultPair origPair){
     	this(left, right);
     	this.origPair = origPair;
     }
@@ -41,24 +36,4 @@ public class PairTPHsmallerTPH extends ResultPair<TypePlaceholder,TypePlaceholde
     public String toString() {
     	return "(" + left.toString() + " < " + right.toString() + ")";
     }
-
-    @Override
-    public SerialMap toSerial(KeyStorage keyStorage) {
-        SerialMap serialized = new SerialMap();
-        serialized.put("left", this.getLeft().toSerial(keyStorage));
-        serialized.put("right", this.getRight().toSerial(keyStorage));
-        // create the wrapper and put this as the object
-        var serializedWrapper = super.toSerial(keyStorage);
-        serializedWrapper.put("object", serialized);
-        return serializedWrapper;
-    }
-
-    public static PairTPHsmallerTPH fromSerial2(SerialMap data, UnifyContext context) {
-        SerialMap left = data.getMap("left");
-        SerialMap right = data.getMap("right");
-        return new PairTPHsmallerTPH(
-          (TypePlaceholder) RefTypeOrTPHOrWildcardOrGeneric.fromSerial(left, context),
-          (TypePlaceholder) RefTypeOrTPHOrWildcardOrGeneric.fromSerial(right, context)
-        );
-    }
 }

src/main/java/de/dhbwstuttgart/typeinference/result/ResultPair.java

@@ -1,17 +1,11 @@
 package de.dhbwstuttgart.typeinference.result;
 
-import de.dhbwstuttgart.server.packet.dataContainers.ISerializableData;
-import de.dhbwstuttgart.server.packet.dataContainers.KeyStorage;
-import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialMap;
-import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialValue;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.typeinference.unify.UnifyContext;
 
 /**
  * Paare, welche das Unifikationsergebnis darstellen
  */
-public abstract class ResultPair<A extends RefTypeOrTPHOrWildcardOrGeneric,B extends RefTypeOrTPHOrWildcardOrGeneric>
+public abstract class ResultPair<A extends RefTypeOrTPHOrWildcardOrGeneric, B extends RefTypeOrTPHOrWildcardOrGeneric> implements Comparable<ResultPair<A,B>> {
-implements ISerializableData {
     private final A left;
     private final B right;
 
@@ -65,34 +59,13 @@ implements ISerializableData {
 		return true;
 	}
 
-
 	@Override
-	public SerialMap toSerial(KeyStorage keyStorage) {
+	public int compareTo(ResultPair<A, B> o) {
-		SerialMap serialized = new SerialMap();
+		if (o == null) {
-		String type = switch (this) {
+			return 1; // this is greater than null
-      case PairNoResult _ -> "pnr";
+		}
-      case PairTPHEqualTPH _ -> "ptet";
-      case PairTPHsmallerTPH _ -> "ptst";
-      case PairTPHequalRefTypeOrWildcardType _ -> "ptertwt";
-      default -> throw new RuntimeException("No type defined for ResultPair of class " + this.getClass().getName());
-    };
-    serialized.put("type", type);
-		// we only insert null for the object and expect the child classes to call this and override the value with themselves
-		serialized.put("object", SerialValue.NULL);
-		return serialized;
-	}
 
-	public static <A extends RefTypeOrTPHOrWildcardOrGeneric,B extends RefTypeOrTPHOrWildcardOrGeneric> ResultPair<A,B>
+		return o.left.toString().compareTo(this.left.toString());
-	fromSerial(SerialMap data, UnifyContext context) {
-		String type = data.getValue("type").getOf(String.class);
-		SerialMap object = data.getMap("object");
-
-    return switch (type) {
-      case "pnr" -> (ResultPair) PairNoResult.fromSerial2(object, context);
-      case "ptet" -> (ResultPair) PairTPHEqualTPH.fromSerial2(object, context);
-      case "ptst" -> (ResultPair) PairTPHsmallerTPH.fromSerial2(object, context);
-      case "ptertwt" -> (ResultPair) PairTPHequalRefTypeOrWildcardType.fromSerial2(object, context);
-      default -> throw new RuntimeException("Could not unserialize class of unhandled type " + type);
-    };
 	}
+   
 }

src/main/java/de/dhbwstuttgart/typeinference/result/ResultSet.java

@@ -1,16 +1,8 @@
 package de.dhbwstuttgart.typeinference.result;
 
-import com.google.common.collect.Ordering;
+import java.util.Collections;
-import de.dhbwstuttgart.server.packet.dataContainers.ISerializableData;
-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.typeinference.unify.TypeUnifyTaskHelper;
-import de.dhbwstuttgart.typeinference.unify.UnifyContext;
-import de.dhbwstuttgart.util.Logger;
-import java.util.ArrayList;
-import java.util.Comparator;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Set;
 
 import de.dhbwstuttgart.exceptions.NotImplementedException;
@@ -20,179 +12,167 @@ 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 java.util.stream.Collectors;
 
 @SuppressWarnings("rawtypes")
-public class ResultSet implements ISerializableData {
+public class ResultSet implements Comparable<ResultSet>{
 
-  public final Set<ResultPair> results;
+    public final Set<ResultPair> results;
-  public Set<ResultPair<TypePlaceholder, TypePlaceholder>> genIns;
+    public Set<ResultPair<TypePlaceholder, TypePlaceholder>> genIns;
 
-  public ResultSet(Set<ResultPair> set) {
+    public ResultSet(Set<ResultPair> set){
-    this.results = set;
+        this.results = set;
-    this.genIns = TypeUnifyTaskHelper.getPresizedHashSet(results.size());
+        this.genIns = new HashSet<>();
-    results.forEach(x -> {
+        results.forEach(x -> { if (x instanceof PairTPHsmallerTPH) { this.genIns.add(x);}} );
-      if (x instanceof PairTPHsmallerTPH) {
-        this.genIns.add(x);
-      }
-    });
-  }
-
-  public boolean contains(ResultPair toCheck) {
-    return this.results.contains(toCheck);
-  }
-
-  public void remove(ResultPair toCheck) {
-    results.remove(toCheck);
-  }
-
-  public ResolvedType resolveType(RefTypeOrTPHOrWildcardOrGeneric type) {
-    if (type instanceof TypePlaceholder)
-      return new Resolver(this).resolve((TypePlaceholder) type);
-    if (type instanceof GenericRefType) return new ResolvedType(type, new HashSet<>());
-    if (type instanceof RefType) {
-      RelatedTypeWalker related = new RelatedTypeWalker(null, this);
-      type.accept(related);
-      return new ResolvedType(type, related.relatedTPHs);
-    } else {
-      throw new NotImplementedException();
-      //return new ResolvedType(type,new HashSet<>());
     }
-  }
 
-  public String toString() {
+    public List<ResultPair> getSortedResults() {
-    var results = new ArrayList<>(this.results);
+    	return results.stream().sorted().toList();
-    results.sort(
+    }
-      Comparator
+    
-        .comparingInt((ResultPair o) -> o.getLeft().toString().length())
+    public boolean contains(ResultPair toCheck) {
-        .thenComparing(o -> o.getLeft().toString())
+    	return this.results.contains(toCheck);
-        .thenComparingInt(o -> o.getRight().toString().length())
+    }
-        .thenComparing(o -> o.getRight().toString())
+    
-    );
+    public void remove(ResultPair toCheck) {
-    return results.toString();
+    	results.remove(toCheck);
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    if (o instanceof ResultSet other) {
-      // sort both result lists
-      var thisElements = new ArrayList<>(this.results);
-      thisElements.sort(Ordering.usingToString());
-      var otherElements = new ArrayList<>(other.results);
-      otherElements.sort(Ordering.usingToString());
-
-      return thisElements.equals(otherElements);
-    } else {
-      return false;
     }
-  }
 
-  @Override
+    public ResolvedType resolveType(RefTypeOrTPHOrWildcardOrGeneric type) {
-  public int hashCode() {
+        if(type instanceof TypePlaceholder)
-    return results.hashCode();
+            return new Resolver(this).resolve((TypePlaceholder)type);
-  }
+        if(type instanceof GenericRefType)return new ResolvedType(type, new HashSet<>());
+        if(type instanceof RefType) {
+            RelatedTypeWalker related = new RelatedTypeWalker(null, this);
+            type.accept(related);
+            return new ResolvedType(type, related.relatedTPHs);
+        } else {
+            throw new NotImplementedException();
+            //return new ResolvedType(type,new HashSet<>());
+        }
+    }
 
-  @Override
+    public String toString() {
-  public SerialMap toSerial(KeyStorage keyStorage) {
+    	return results.toString();
-    SerialMap serialized = new SerialMap();;
+    }
-    serialized.put("results", SerialList.fromMapped(results, result -> result.toSerial(keyStorage)));
-    return serialized;
-  }
 
-  public static ResultSet fromSerial(SerialMap data, UnifyContext context) {
+	@Override
-    var resultsData = data.getList("results").assertListOfMaps();
+	public boolean equals(Object o) {
-    return new ResultSet(resultsData.stream().map(resultData -> ResultPair.fromSerial(resultData, context)).collect(Collectors.toSet()));
+		if (o instanceof ResultSet) {
-  }
+			ResultSet other = (ResultSet)o;
+			return this.results.equals(other.results);
+		} else {
+			return false;
+		}
+	}
+
+	@Override
+	public int hashCode() {
+		return results.hashCode();
+	}
+
+    @Override
+    public int compareTo(ResultSet o) {
+        List<ResultPair> thisSorted = this.getSortedResults();
+        List<ResultPair> otherSorted = o.getSortedResults();
+        int sizeCompare = Integer.compare(thisSorted.size(), otherSorted.size());
+        if (sizeCompare != 0) return sizeCompare;
+
+        for (int i = 0; i < thisSorted.size(); i++) {
+            int cmp = thisSorted.get(i).compareTo(otherSorted.get(i));
+            if (cmp != 0) return cmp;
+        }
+
+        return 0;
+    }
 }
 
 class Resolver implements ResultSetVisitor {
-  private final ResultSet result;
+    private final ResultSet result;
-  private TypePlaceholder toResolve;
+    private TypePlaceholder toResolve;
-  private RefTypeOrTPHOrWildcardOrGeneric resolved;
+    private RefTypeOrTPHOrWildcardOrGeneric resolved;
-  private final Set<GenericInsertPair> additionalTPHs = new HashSet<>();
+    private final Set<GenericInsertPair> additionalTPHs = new HashSet<>();
-  private ResultPair<?, ?> currentPair;
+    private ResultPair<?,?> currentPair;
 
-  public static Logger logger = new Logger("Resolver");
+    public Resolver(ResultSet resultPairs){
-
+        this.result = resultPairs;
-  public Resolver(ResultSet resultPairs) {
-    this.result = resultPairs;
-  }
-
-  public ResolvedType resolve(TypePlaceholder tph) {
-    toResolve = tph;
-    resolved = null;
-    logger.info(tph.toString());
-    for (ResultPair<?, ?> resultPair : result.results) {
-      if (resultPair instanceof PairTPHEqualTPH && ((PairTPHEqualTPH) resultPair).getLeft().equals(toResolve)) {
-        currentPair = resultPair;
-        return resolve(((PairTPHEqualTPH) resultPair).getRight());
-      }
-    }
-    for (ResultPair<?, ?> resultPair : result.results) {
-      currentPair = resultPair;
-      resultPair.accept(this);
-    }
-    if (resolved == null) {//TPH kommt nicht im Result vor:
-      resolved = tph;
     }
 
-    ResolvedType result = new ResolvedType(resolved, additionalTPHs);//resolved;
+    public ResolvedType resolve(TypePlaceholder tph){
-    result.setResultPair(currentPair);
+        toResolve = tph;
-    return result;
+        resolved = null;
-  }
+        System.out.println(tph.toString());
+        for(ResultPair<?,?> resultPair : result.results) {
+            if(resultPair instanceof PairTPHEqualTPH && ((PairTPHEqualTPH) resultPair).getLeft().equals(toResolve)){
+            	currentPair = resultPair;
+                return resolve(((PairTPHEqualTPH) resultPair).getRight());
+            }
+        }
+        for(ResultPair<?,?> resultPair : result.results){
+        	currentPair = resultPair;
+            resultPair.accept(this);
+        }
+        if(resolved==null){//TPH kommt nicht im Result vor:
+            resolved = tph;
+        }
 
-  @Override
+        ResolvedType result = new ResolvedType(resolved, additionalTPHs);//resolved;
-  public void visit(PairTPHsmallerTPH p) {
+        result.setResultPair(currentPair);
-    currentPair = p;
+        return result;
-    if (p.left.equals(toResolve)) {
-      additionalTPHs.add(new GenericInsertPair(p.left, p.right));
-      additionalTPHs.addAll(new RelatedTypeWalker(p.right, result).relatedTPHs);
     }
-    if (p.right.equals(toResolve))
-      additionalTPHs.addAll(new RelatedTypeWalker(p.left, result).relatedTPHs);
-  }
 
-  @Override
+    @Override
-  public void visit(PairTPHequalRefTypeOrWildcardType p) {
+    public void visit(PairTPHsmallerTPH p) {
-    currentPair = p;
+    	currentPair = p;
-    if (p.left.equals(toResolve)) {
+        if(p.left.equals(toResolve)){
-      resolved = p.right;
+            additionalTPHs.add(new GenericInsertPair(p.left, p.right));
-      RelatedTypeWalker related = new RelatedTypeWalker(null, result);
+            additionalTPHs.addAll(new RelatedTypeWalker(p.right, result).relatedTPHs);
-      p.right.accept(related);
+        }
-      additionalTPHs.addAll(related.relatedTPHs);
+        if(p.right.equals(toResolve))
+            additionalTPHs.addAll(new RelatedTypeWalker(p.left, result).relatedTPHs);
     }
-  }
 
-  @Override
+    @Override
-  public void visit(PairTPHEqualTPH p) {
+    public void visit(PairTPHequalRefTypeOrWildcardType p) {
-    //Do nothing. Dieser Fall wird in der resolve-Methode abgefangen
+    	currentPair = p;
-  }
+        if(p.left.equals(toResolve)){
+            resolved = p.right;
+            RelatedTypeWalker related = new RelatedTypeWalker(null, result);
+            p.right.accept(related);
+            additionalTPHs.addAll(related.relatedTPHs);
+        }
+    }
 
-  @Override
+    @Override
-  public void visit(RefType refType) {
+    public void visit(PairTPHEqualTPH p) {
+        //Do nothing. Dieser Fall wird in der resolve-Methode abgefangen
+    }
 
-  }
+    @Override
+    public void visit(RefType refType) {
 
-  @Override
+    }
-  public void visit(GenericRefType genericRefType) {
 
-  }
+    @Override
+    public void visit(GenericRefType genericRefType) {
 
-  @Override
+    }
-  public void visit(SuperWildcardType superWildcardType) {
 
-  }
+    @Override
+    public void visit(SuperWildcardType superWildcardType) {
 
-  @Override
+    }
-  public void visit(TypePlaceholder typePlaceholder) {
 
-  }
+    @Override
+    public void visit(TypePlaceholder typePlaceholder) {
 
-  @Override
+    }
-  public void visit(ExtendsWildcardType extendsWildcardType) {
 
-  }
+    @Override
+    public void visit(ExtendsWildcardType extendsWildcardType) {
 
+    }
+    
+    
 
 }
 
@@ -202,150 +182,149 @@ class Resolver implements ResultSetVisitor {
 @SuppressWarnings("rawtypes")
 class TPHResolver implements ResultSetVisitor {
 
-  private final TypePlaceholder tph;
+    private final TypePlaceholder tph;
-  Set<GenericInsertPair> resolved = new HashSet<>();
+    Set<GenericInsertPair> resolved = new HashSet<>();
-  private final ResultSet resultSet;
+    private final ResultSet resultSet;
 
-  TPHResolver(TypePlaceholder tph, ResultSet resultSet) {
+    TPHResolver(TypePlaceholder tph, ResultSet resultSet){
-    this.resultSet = resultSet;
+        this.resultSet = resultSet;
-    this.tph = tph;
+        this.tph = tph;
-    for (ResultPair p : resultSet.results) {
+        for(ResultPair p : resultSet.results){
-      p.accept(this);
+            p.accept(this);
+        }
+        if(resolved.size() == 0){
+            resolved.add(new GenericInsertPair(tph, null));
+        }
     }
-    if (resolved.size() == 0) {
+
-      resolved.add(new GenericInsertPair(tph, null));
+    @Override
+    public void visit(PairTPHsmallerTPH p) {
+        if(p.left.equals(tph) || p.right.equals(tph)){
+            resolved.add(new GenericInsertPair(p.left, p.right));
+        }
     }
-  }
 
-  @Override
+    @Override
-  public void visit(PairTPHsmallerTPH p) {
+    public void visit(PairTPHequalRefTypeOrWildcardType p) {
-    if (p.left.equals(tph) || p.right.equals(tph)) {
+        TypePlaceholder otherSide = null;
-      resolved.add(new GenericInsertPair(p.left, p.right));
+        if(p.right.equals(tph)){
+            otherSide = p.left;
+        }
+        if(otherSide != null){
+            Set<ResultPair> newResultSet = new HashSet<>(this.resultSet.results);
+            newResultSet.remove(p);
+            resolved.addAll(new TPHResolver(otherSide, new ResultSet(newResultSet)).resolved);
+        }
     }
-  }
 
-  @Override
+    @Override
-  public void visit(PairTPHequalRefTypeOrWildcardType p) {
+    public void visit(PairTPHEqualTPH p) {
-    TypePlaceholder otherSide = null;
+        //ignorieren. Wird vom Resolver behandelt
-    if (p.right.equals(tph)) {
-      otherSide = p.left;
     }
-    if (otherSide != null) {
+
-      Set<ResultPair> newResultSet = new HashSet<>(this.resultSet.results);
+    @Override
-      newResultSet.remove(p);
+    public void visit(RefType refType) {
-      resolved.addAll(new TPHResolver(otherSide, new ResultSet(newResultSet)).resolved);
+
     }
-  }
 
-  @Override
+    @Override
-  public void visit(PairTPHEqualTPH p) {
+    public void visit(GenericRefType genericRefType) {
-    //ignorieren. Wird vom Resolver behandelt
-  }
 
-  @Override
+    }
-  public void visit(RefType refType) {
 
-  }
+    @Override
+    public void visit(SuperWildcardType superWildcardType) {
 
-  @Override
+    }
-  public void visit(GenericRefType genericRefType) {
 
-  }
+    @Override
+    public void visit(TypePlaceholder typePlaceholder) {
 
-  @Override
+    }
-  public void visit(SuperWildcardType superWildcardType) {
 
-  }
+    @Override
+    public void visit(ExtendsWildcardType extendsWildcardType) {
 
-  @Override
+    }
-  public void visit(TypePlaceholder typePlaceholder) {
-
-  }
-
-  @Override
-  public void visit(ExtendsWildcardType extendsWildcardType) {
-
-  }
 }
 
 @SuppressWarnings("rawtypes")
 class RelatedTypeWalker implements ResultSetVisitor {
 
-  final Set<GenericInsertPair> relatedTPHs = new HashSet<>();
+    final Set<GenericInsertPair> relatedTPHs = new HashSet<>();
-  private final TypePlaceholder toResolve;
+    private final TypePlaceholder toResolve;
-  private final ResultSet resultSet;
+    private final ResultSet resultSet;
 
-  /**
+    /**
-   * Läuft über das resultSet und speichert alle TPHs, welche mit start in Verbindung stehen
+     * Läuft über das resultSet und speichert alle TPHs, welche mit start in Verbindung stehen
-   *
+     * @param start - kann null sein, wenn der Walker für einen RefType benutzt wird
-   * @param start     - kann null sein, wenn der Walker für einen RefType benutzt wird
+     * @param resultSet
-   * @param resultSet
+     */
-   */
+    RelatedTypeWalker(TypePlaceholder start, ResultSet resultSet){
-  RelatedTypeWalker(TypePlaceholder start, ResultSet resultSet) {
+        this.toResolve = start;
-    this.toResolve = start;
+        this.resultSet = resultSet;
-    this.resultSet = resultSet;
+        int resolved = 0;
-    int resolved = 0;
+        do{
-    do {
+            resolved = relatedTPHs.size();
-      resolved = relatedTPHs.size();
+            for(ResultPair p : resultSet.results){
-      for (ResultPair p : resultSet.results) {
+                p.accept(this);
-        p.accept(this);
+                p.accept(this);
-        p.accept(this);
+            }
-      }
+        }while(resolved - relatedTPHs.size() > 0);
-    } while (resolved - relatedTPHs.size() > 0);
-  }
-
-  @Override
-  public void visit(PairTPHsmallerTPH p) {
-    if (p.getRight().equals(toResolve)) {
-      relatedTPHs.addAll(new TPHResolver(p.right, resultSet).resolved);
-      //relatedTPHs.addAll(new RelatedTypeWalker(p.right, resultSet).relatedTPHs);
     }
-    if (p.getLeft().equals(toResolve)) {
-      relatedTPHs.addAll(new TPHResolver(p.left, resultSet).resolved);
-      //relatedTPHs.addAll(new RelatedTypeWalker(p.left, resultSet).relatedTPHs);
-    }
-  }
 
-  @Override
+    @Override
-  public void visit(PairTPHequalRefTypeOrWildcardType p) {
+    public void visit(PairTPHsmallerTPH p) {
-    if (p.getLeft().equals(toResolve)) {
+        if(p.getRight().equals(toResolve)){
-      p.getRight().accept(this);
+            relatedTPHs.addAll(new TPHResolver(p.right, resultSet).resolved);
+            //relatedTPHs.addAll(new RelatedTypeWalker(p.right, resultSet).relatedTPHs);
+        }
+        if(p.getLeft().equals(toResolve)){
+            relatedTPHs.addAll(new TPHResolver(p.left, resultSet).resolved);
+            //relatedTPHs.addAll(new RelatedTypeWalker(p.left, resultSet).relatedTPHs);
+        }
     }
-  }
 
-  @Override
+    @Override
-  public void visit(PairTPHEqualTPH p) {
+    public void visit(PairTPHequalRefTypeOrWildcardType p) {
-    //Kann ignoriert werden. Diese Fälle werden vom Resolver behandelt
+        if(p.getLeft().equals(toResolve)){
-  }
+            p.getRight().accept(this);
+        }
+    }
+
+    @Override
+    public void visit(PairTPHEqualTPH p) {
+        //Kann ignoriert werden. Diese Fälle werden vom Resolver behandelt
+    }
 
     /*
     Die folgenden Funktionen fügen alle TPHs an die relatedTPHs an, denen sie begegnen:
     Das wird verwendet, wenn alle relatedTPHs aus den Parametern eines RefTypes angefügt werden sollen
      */
 
-  @Override
+    @Override
-  public void visit(RefType refType) {
+    public void visit(RefType refType) {
-    for (RefTypeOrTPHOrWildcardOrGeneric param : refType.getParaList()) {
+        for(RefTypeOrTPHOrWildcardOrGeneric param : refType.getParaList()){
-      param.accept(this);
+            param.accept(this);
+        }
     }
-  }
 
-  @Override
+    @Override
-  public void visit(SuperWildcardType superWildcardType) {
+    public void visit(SuperWildcardType superWildcardType) {
-    superWildcardType.getInnerType().accept(this);
+        superWildcardType.getInnerType().accept(this);
-  }
+    }
 
-  @Override
+    @Override
-  public void visit(TypePlaceholder typePlaceholder) {
+    public void visit(TypePlaceholder typePlaceholder) {
-    relatedTPHs.addAll(new TPHResolver(typePlaceholder, resultSet).resolved);
+        relatedTPHs.addAll(new TPHResolver(typePlaceholder, resultSet).resolved);
-  }
+    }
 
-  @Override
+    @Override
-  public void visit(ExtendsWildcardType extendsWildcardType) {
+    public void visit(ExtendsWildcardType extendsWildcardType) {
-    extendsWildcardType.getInnerType().accept(this);
+        extendsWildcardType.getInnerType().accept(this);
-  }
+    }
 
-  @Override
+    @Override
-  public void visit(GenericRefType genericRefType) {
+    public void visit(GenericRefType genericRefType) {
-  }
+    }
 }

src/main/java/de/dhbwstuttgart/typeinference/typeAlgo/TYPE.java

@@ -14,7 +14,6 @@ import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
 import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import de.dhbwstuttgart.typeinference.constraints.Pair;
-import de.dhbwstuttgart.typeinference.unify.TypeUnifyTaskHelper;
 import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
 import de.dhbwstuttgart.util.BiRelation;
 import org.antlr.v4.runtime.Token;
@@ -34,7 +33,7 @@ public class TYPE {
     public ConstraintSet getConstraints() {
         ConstraintSet ret = new ConstraintSet();
         for (ClassOrInterface cl : sf.KlassenVektor) {
-            Set<ClassOrInterface> allClasses = TypeUnifyTaskHelper.getPresizedHashSet(allAvailableClasses.size() + sf.availableClasses.size());
+            var allClasses = new HashSet<ClassOrInterface>();
             allClasses.addAll(allAvailableClasses);
             allClasses.addAll(sf.availableClasses);
             ret.addAll(getConstraintsClass(cl, new TypeInferenceInformation(allClasses)));
@@ -69,7 +68,7 @@ public class TYPE {
 
             for(SourceFile sourceFile : sfs){
                 for(JavaClassName importName : sourceFile.imports){
-                    context.logger().info(importName);
+                    System.out.println(importName);
                     try {
                         classes.add(ASTFactory.createClass(classLoader.loadClass(importName.toString())));
                     } catch (ClassNotFoundException e) {

src/main/java/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java

@@ -1,8 +1,6 @@
 //PL 2018-12-19: Merge chekcen
 package de.dhbwstuttgart.typeinference.typeAlgo;
 
-import de.dhbwstuttgart.typeinference.unify.PlaceholderRegistry;
-import de.dhbwstuttgart.typeinference.unify.TypeUnifyTaskHelper;
 import java.util.*;
 import java.util.stream.Collectors;
 
@@ -75,7 +73,7 @@ public class TYPEStmt implements StatementVisitor {
 
     @Override
     public void visit(LambdaExpression lambdaExpression) {
-        TypePlaceholder tphRetType = TypePlaceholder.fresh(new NullToken());
+        TypePlaceholder tphRetType = TypePlaceholder.fresh(new NullToken(), -1, false);
         List<RefTypeOrTPHOrWildcardOrGeneric> lambdaParams = lambdaExpression.params.getFormalparalist().stream().map((formalParameter -> formalParameter.getType())).collect(Collectors.toList());
         lambdaParams.add(tphRetType);
         // lambdaParams.add(0,tphRetType);
@@ -118,18 +116,17 @@ public class TYPEStmt implements StatementVisitor {
     @Override
     public void visit(FieldVar fieldVar) {
         fieldVar.receiver.accept(this);
-        List<FieldAssumption> fieldAssumptions = info.getFields(fieldVar.fieldVarName);
+        Set<Constraint> oderConstraints = new HashSet<>();
-        Set<Constraint> oderConstraints = TypeUnifyTaskHelper.getPresizedHashSet(fieldAssumptions.size());
 
 
-        for (FieldAssumption fieldAssumption : fieldAssumptions) {
+        for (FieldAssumption fieldAssumption : info.getFields(fieldVar.fieldVarName)) {
             Constraint constraint = new Constraint();
             GenericsResolver resolver = getResolverInstance();
             constraint.add(new Pair(fieldVar.receiver.getType(), fieldAssumption.getReceiverType(resolver), PairOperator.SMALLERDOT, loc(fieldVar.getOffset()))); // PL 2019-12-09: SMALLERDOT eingefuegt, EQUALSDOT entfernt, wenn ds Field privat ist muesste es EQUALSDOT lauten
             constraint.add(new Pair(fieldVar.getType(), fieldAssumption.getType(resolver), PairOperator.EQUALSDOT, loc(fieldVar.getOffset())));
             oderConstraints.add(constraint);
         }
-        if (oderConstraints.isEmpty())
+        if (oderConstraints.size() == 0)
             throw new TypeinferenceException("Kein Feld " + fieldVar.fieldVarName + " gefunden", fieldVar.getOffset());
         constraintsSet.addOderConstraint(oderConstraints);
     }
@@ -144,7 +141,7 @@ public class TYPEStmt implements StatementVisitor {
 
     @Override
     public void visit(ForEachStmt forEachStmt) {
-        var iterableType = new RefType(ASTFactory.createClass(java.lang.Iterable.class).getClassName(), List.of(new ExtendsWildcardType(forEachStmt.statement.getType(), new NullToken())), new NullToken());
+        var iterableType = new RefType(ASTFactory.createClass(java.lang.Iterable.class).getClassName(), Arrays.asList(new ExtendsWildcardType(forEachStmt.statement.getType(), new NullToken())), new NullToken());
         constraintsSet.addUndConstraint(new Pair(forEachStmt.expression.getType(), iterableType, PairOperator.SMALLERDOT, loc(forEachStmt.getOffset())));
         forEachStmt.statement.accept(this);
         forEachStmt.expression.accept(this);
@@ -192,7 +189,7 @@ public class TYPEStmt implements StatementVisitor {
         methodCall.receiver.accept(this);
         // Overloading:
         Set<Constraint<Pair>> methodConstraints = new HashSet<>();
-        for (MethodAssumption m : TYPEStmt.getMethods(methodCall.name, methodCall.arglist, info)) {
+        for (MethodAssumption m : this.getMethods(methodCall.name, methodCall.arglist, info)) {
             GenericsResolver resolver = getResolverInstance();
             Set<Constraint<Pair>> oneMethodConstraints = generateConstraint(methodCall, m, info, resolver);
             methodConstraints.addAll(oneMethodConstraints);
@@ -202,7 +199,7 @@ public class TYPEStmt implements StatementVisitor {
              * oneMethodConstraint.setExtendConstraint(extendsOneMethodConstraint); extendsOneMethodConstraint.setExtendConstraint(oneMethodConstraint); methodConstraints.add(extendsOneMethodConstraint);
              */
         }
-        if (methodConstraints.isEmpty()) {
+        if (methodConstraints.size() < 1) {
             throw new TypeinferenceException("Methode " + methodCall.name + " ist nicht vorhanden!", methodCall.getOffset());
         }
         constraintsSet.addOderConstraint(methodConstraints);
@@ -215,7 +212,7 @@ public class TYPEStmt implements StatementVisitor {
         for (MethodAssumption m : this.getConstructors(info, (RefType) methodCall.getType(), methodCall.getArgumentList())) {
             methodConstraints.add(generateConstructorConstraint(methodCall, m, info, getResolverInstance()));
         }
-        if (methodConstraints.isEmpty()) {
+        if (methodConstraints.size() < 1) {
             throw new TypeinferenceException("Konstruktor in Klasse " + methodCall.getType().toString() + " ist nicht vorhanden!", methodCall.getOffset());
         }
         constraintsSet.addOderConstraint(methodConstraints);
@@ -285,13 +282,8 @@ public class TYPEStmt implements StatementVisitor {
             // see: https://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.17
             // Expression muss zu Numeric Convertierbar sein. also von Numeric erben
             Constraint<Pair> numeric;
-            HashSet<JavaClassName> classNames = TypeUnifyTaskHelper.getPresizedHashSet(info.getAvailableClasses().size());
-            for (var classEl : info.getAvailableClasses()) {
-                classNames.add(classEl.getClassName());
-            }
-
             // PL eingefuegt 2018-07-17
-            if (classNames.contains(bytee.getName())) {
+            if (info.getAvailableClasses().stream().map(x -> x.getClassName()).collect(Collectors.toCollection(HashSet::new)).contains(bytee.getName())) {
                 numeric = new Constraint<>();
                 numeric.add(new Pair(binary.lexpr.getType(), bytee, PairOperator.SMALLERDOT, loc(binary.getOffset())));
                 numeric.add(new Pair(binary.rexpr.getType(), bytee, PairOperator.SMALLERDOT, loc(binary.getOffset())));
@@ -299,7 +291,7 @@ public class TYPEStmt implements StatementVisitor {
                 numericAdditionOrStringConcatenation.add(numeric);
             }
             // PL eingefuegt 2018-07-17
-            if (classNames.contains(shortt.getName())) {
+            if (info.getAvailableClasses().stream().map(x -> x.getClassName()).collect(Collectors.toCollection(HashSet::new)).contains(shortt.getName())) {
                 numeric = new Constraint<>();
                 numeric.add(new Pair(binary.lexpr.getType(), shortt, PairOperator.SMALLERDOT, loc(binary.getOffset())));
                 numeric.add(new Pair(binary.rexpr.getType(), shortt, PairOperator.SMALLERDOT, loc(binary.getOffset())));
@@ -307,7 +299,7 @@ public class TYPEStmt implements StatementVisitor {
                 numericAdditionOrStringConcatenation.add(numeric);
             }
             // PL eingefuegt 2018-07-17
-            if (classNames.contains(integer.getName())) {
+            if (info.getAvailableClasses().stream().map(x -> x.getClassName()).collect(Collectors.toCollection(HashSet::new)).contains(integer.getName())) {
                 numeric = new Constraint<>();
                 numeric.add(new Pair(binary.lexpr.getType(), integer, PairOperator.SMALLERDOT, loc(binary.getOffset())));
                 numeric.add(new Pair(binary.rexpr.getType(), integer, PairOperator.SMALLERDOT, loc(binary.getOffset())));
@@ -315,7 +307,7 @@ public class TYPEStmt implements StatementVisitor {
                 numericAdditionOrStringConcatenation.add(numeric);
             }
             // PL eingefuegt 2018-07-17
-            if (classNames.contains(longg.getName())) {
+            if (info.getAvailableClasses().stream().map(x -> x.getClassName()).collect(Collectors.toCollection(HashSet::new)).contains(longg.getName())) {
                 numeric = new Constraint<>();
                 numeric.add(new Pair(binary.lexpr.getType(), longg, PairOperator.SMALLERDOT, loc(binary.getOffset())));
                 numeric.add(new Pair(binary.rexpr.getType(), longg, PairOperator.SMALLERDOT, loc(binary.getOffset())));
@@ -323,7 +315,7 @@ public class TYPEStmt implements StatementVisitor {
                 numericAdditionOrStringConcatenation.add(numeric);
             }
             // PL eingefuegt 2018-07-17
-            if (classNames.contains(floatt.getName())) {
+            if (info.getAvailableClasses().stream().map(x -> x.getClassName()).collect(Collectors.toCollection(HashSet::new)).contains(floatt.getName())) {
                 numeric = new Constraint<>();
                 numeric.add(new Pair(binary.lexpr.getType(), floatt, PairOperator.SMALLERDOT, loc(binary.getOffset())));
                 numeric.add(new Pair(binary.rexpr.getType(), floatt, PairOperator.SMALLERDOT, loc(binary.getOffset())));
@@ -331,7 +323,7 @@ public class TYPEStmt implements StatementVisitor {
                 numericAdditionOrStringConcatenation.add(numeric);
             }
             // PL eingefuegt 2018-07-17
-            if (classNames.contains(doublee.getName())) {
+            if (info.getAvailableClasses().stream().map(x -> x.getClassName()).collect(Collectors.toCollection(HashSet::new)).contains(doublee.getName())) {
                 numeric = new Constraint<>();
                 numeric.add(new Pair(binary.lexpr.getType(), doublee, PairOperator.SMALLERDOT, loc(binary.getOffset())));
                 numeric.add(new Pair(binary.rexpr.getType(), doublee, PairOperator.SMALLERDOT, loc(binary.getOffset())));
@@ -346,7 +338,7 @@ public class TYPEStmt implements StatementVisitor {
 
             if (binary.operation.equals(BinaryExpr.Operator.ADD)) {
                 // Dann kann der Ausdruck auch das aneinanderfügen zweier Strings sein: ("a" + "b") oder (1 + 2)
-                if (classNames.contains(string.getName())) {
+                if (info.getAvailableClasses().stream().map(x -> x.getClassName()).collect(Collectors.toCollection(HashSet::new)).contains(string.getName())) {
                     Constraint<Pair> stringConcat = new Constraint<>();
                     stringConcat.add(new Pair(binary.lexpr.getType(), string, PairOperator.EQUALSDOT, loc(binary.getOffset())));
                     stringConcat.add(new Pair(binary.rexpr.getType(), string, PairOperator.EQUALSDOT, loc(binary.getOffset())));
@@ -354,7 +346,7 @@ public class TYPEStmt implements StatementVisitor {
                     numericAdditionOrStringConcatenation.add(stringConcat);
                 }
             }
-            if (numericAdditionOrStringConcatenation.isEmpty()) {
+            if (numericAdditionOrStringConcatenation.size() < 1) {
                 throw new TypeinferenceException("Kein Typ für " + binary.operation.toString() + " vorhanden", binary.getOffset());
             }
             constraintsSet.addOderConstraint(numericAdditionOrStringConcatenation);
@@ -643,6 +635,7 @@ public class TYPEStmt implements StatementVisitor {
             params.add(resolver.resolve(new GenericRefType(gtv.getName(), new NullToken())));
         }
         RefTypeOrTPHOrWildcardOrGeneric receiverType;
+        
         if (receiver instanceof FunNClass) {
             receiverType = new RefType(new JavaClassName(receiver.getClassName().toString() + "$$"), params, new NullToken()); // new FunN(params);
         } else {
@@ -701,8 +694,8 @@ public class TYPEStmt implements StatementVisitor {
 
         Set<Pair> methodSignatureConstraint = generatemethodSignatureConstraint(forMethod, assumption, info, resolver);
 
-        //context.logger().info("methodSignatureConstraint: " + methodSignatureConstraint);
+        //System.out.println("methodSignatureConstraint: " + methodSignatureConstraint);
-        //context.logger().info("methodConstraint: " + methodConstraint);
+        //System.out.println("methodConstraint: " + methodConstraint);
 
         methodConstraint.setmethodSignatureConstraint(methodSignatureConstraint);
         extendsMethodConstraint.setmethodSignatureConstraint(methodSignatureConstraint);
@@ -740,7 +733,7 @@ public class TYPEStmt implements StatementVisitor {
         }
 
         // Zuordnung von MethodCall.signature(ReturnType) zu dem ReturnType der ausgewaehlten Methode (assumption.returnType)
-        ret.add(new Pair(foMethod.signature.getLast(), assumption.getReturnType(), PairOperator.EQUALSDOT));
+        ret.add(new Pair(foMethod.signature.get(foMethod.signature.size() - 1), assumption.getReturnType(), PairOperator.EQUALSDOT));
         return ret;
     }
 
@@ -753,8 +746,8 @@ public class TYPEStmt implements StatementVisitor {
                 // funNParams.add(TypePlaceholder.fresh(new NullToken()));
                 funNParams.add(new GenericRefType(NameGenerator.makeNewName(), new NullToken()));
             }
-            funNParams.getLast();
+            funNParams.get(funNParams.size() - 1);
-            ret.add(new MethodAssumption(new FunNClass(funNParams), funNParams.getLast(), funNParams.subList(0, funNParams.size() - 1), new TypeScope() {
+            ret.add(new MethodAssumption(new FunNClass(funNParams), funNParams.get(funNParams.size() - 1), funNParams.subList(0, funNParams.size() - 1), new TypeScope() {
                 @Override
                 public Iterable<? extends GenericTypeVar> getGenerics() {
                     throw new NotImplementedException();
@@ -849,7 +842,7 @@ public class TYPEStmt implements StatementVisitor {
             for (var child : switchStmt.getBlocks()) {
                 for (var label : child.getLabels()) {
                     if (label.getPattern() == null) {
-                        //context.logger().info("DefaultCase");
+                        //System.out.println("DefaultCase");
                     } else {
                         constraintsSet.addUndConstraint(
                                 new Pair(
@@ -890,9 +883,13 @@ public class TYPEStmt implements StatementVisitor {
 
             child.getLabels().forEach(el -> {
                 if (el.getType() instanceof RefType) {
-                  if (el.getPattern() instanceof RecordPattern pattern) {
+                    var recType = el;
-                    recursivelyAddRecordConstraints(pattern);
+
-                  }
+                    if (el.getPattern() instanceof RecordPattern) {
+                        var pattern = (RecordPattern) recType.getPattern();
+                        recursivelyAddRecordConstraints(pattern);
+                    }
+
                 }
             });
 
@@ -908,13 +905,13 @@ public class TYPEStmt implements StatementVisitor {
 
         var allClasses = info.getAvailableClasses();
         var interestingClasses = allClasses.stream().filter(as -> as.getClassName().equals(((RefType) pattern.getType()).getName())).toList();
-        var constructors = interestingClasses.getFirst().getConstructors();
+        var constructors = interestingClasses.get(0).getConstructors();
 
         int counter = 0;
 
         for (var subPattern : pattern.getSubPattern()) {
             for (Constructor con : constructors) {
-                //context.logger().info("----------------------\n" + subPattern.getType() + " | " + con.getParameterList().getParameterAt(counter).getType() + "\n----------------------\n");
+                //System.out.println("----------------------\n" + subPattern.getType() + " | " + con.getParameterList().getParameterAt(counter).getType() + "\n----------------------\n");
                 constraintsSet.addUndConstraint(new Pair(subPattern.getType(), con.getParameterList().getParameterAt(counter).getType(), PairOperator.SMALLERDOT, loc(con.getParameterList().getParameterAt(counter).getOffset())));
             }
             if (subPattern instanceof RecordPattern) recursivelyAddRecordConstraints((RecordPattern) subPattern);

src/main/java/de/dhbwstuttgart/typeinference/unify/CancellableTask.java

@@ -1,91 +0,0 @@
-package de.dhbwstuttgart.typeinference.unify;
-
-import java.util.ArrayList;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.concurrent.ConcurrentLinkedQueue;
-import java.util.concurrent.RecursiveTask;
-import java.util.concurrent.atomic.AtomicBoolean;
-
-/**
- * An intermediate class for the recursive steps of the TypeUnifyTask:
- * This allows canceling parts of the recursion tree, instead of only  the whole execution as before. But in
- * order for that to work, all cancellable child tasks must be added when they are created
- *
- * @param <T>
- */
-public abstract class CancellableTask<T> extends RecursiveTask<T> {
-
-  private final AtomicBoolean executionCancelled = new AtomicBoolean(false);
-  private final List<CancellableTask<?>> childTasks = new LinkedList<>();
-  private CancellableTask<?> parentTask = null;
-
-  /**
-   * Set the execution for this task and all its (recursive) children to be canceled
-   */
-  protected void cancelExecution() {
-    // is this branch already canceled? Then do nothing
-    if (this.executionCancelled.getAndSet(true)) return;
-    this.cancelChildExecution();
-  }
-
-  private void cancelChildExecution() {
-    synchronized (this.childTasks) {
-      for (var childTask : childTasks) {
-        // no need to cancel a branch that is already finished
-        if (!childTask.isDone()) {
-          childTask.cancelExecution();
-        }
-      }
-    }
-  }
-
-  private void cancelChildExecutionAfter(CancellableTask<?> checkpointTask) {
-    boolean reachedCheckpoint = false;
-    int i = 0;
-    for (var childTask : childTasks) {
-      if (!reachedCheckpoint) {
-        reachedCheckpoint = childTask == checkpointTask;
-      }
-      else {
-        // no need to cancel a branch that is already finished
-        if (!childTask.isDone()) {
-          childTask.cancelExecution();
-        }
-        i++;
-      }
-    }
-    System.out.println("Skipped " + i + " younger siblings");
-  }
-
-  protected void cancelSiblingTasks() {
-    if (this.parentTask != null) {
-      boolean thisWasCancelledBefore = this.executionCancelled.get();
-      this.parentTask.cancelChildExecution();
-      this.executionCancelled.set(thisWasCancelledBefore);
-    }
-  }
-
-  public void cancelYoungerSiblingTasks() {
-    if (this.parentTask != null) {
-      this.parentTask.cancelChildExecutionAfter(this);
-    }
-  }
-
-  public Boolean isExecutionCancelled() {
-    return executionCancelled.get();
-  }
-
-  public void addChildTask(CancellableTask<?> childTask) {
-    this.childTasks.add(childTask);
-    childTask.setParentTask(this);
-    if (this.executionCancelled.get()) {
-      childTask.executionCancelled.set(true);
-    }
-  }
-
-  private void setParentTask(CancellableTask<?> parentTask) {
-    this.parentTask = parentTask;
-  }
-
-}

src/main/java/de/dhbwstuttgart/typeinference/unify/ConcurrentSetMergeTask.java

@@ -1,61 +0,0 @@
-package de.dhbwstuttgart.typeinference.unify;
-
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-import java.util.concurrent.RecursiveTask;
-
-public class ConcurrentSetMergeTask<T> extends RecursiveTask<Set<T>> {
-
-  public static <E> Set<E> merge(List<Set<E>> list) {
-    if (list.isEmpty()) {
-      return new HashSet<>();
-    }
-    var task = new ConcurrentSetMergeTask<>(list, 0, list.size());
-    return task.compute();
-  }
-
-  private static final int LIST_THRESHOLD = 3;
-  private static final int ELEMENT_THRESHOLD = 1000;
-
-  private final List<Set<T>> list;
-  private final int start;
-  private final int end;
-
-  private ConcurrentSetMergeTask(List<Set<T>> list, int start, int end) {
-    this.list = list;
-    this.start = start;
-    this.end = end;
-  }
-
-  @Override
-  protected Set<T> compute() {
-    int size = end - start;
-
-    int totalElements = 0;
-    for (int i = start+1; i < end; i++) {
-      totalElements += list.get(i).size();
-    }
-
-    // size will always be at least one
-    if (true || size <= LIST_THRESHOLD || totalElements < ELEMENT_THRESHOLD) {
-      Set<T> result = this.list.get(start);
-      for (int i = start+1; i < end; i++) {
-        result.addAll(list.get(i));
-      }
-      return result;
-    } else {
-      int mid = start + (size / 2);
-      ConcurrentSetMergeTask<T> leftTask = new ConcurrentSetMergeTask<>(list, start, mid);
-      ConcurrentSetMergeTask<T> rightTask = new ConcurrentSetMergeTask<>(list, mid, end);
-
-      leftTask.fork();
-      Set<T> rightResult = rightTask.compute();
-      Set<T> leftResult = leftTask.join();
-
-      // Merge results
-      leftResult.addAll(rightResult);
-      return leftResult;
-    }
-  }
-}

src/main/java/de/dhbwstuttgart/typeinference/unify/MartelliMontanariUnify.java

@@ -94,8 +94,8 @@ public class MartelliMontanariUnify implements IUnify {
 			// SUBST - Rule
 			if(lhsType instanceof PlaceholderType) {
 				mgu.add((PlaceholderType) lhsType, rhsType);
-				//PL 2018-04-01 nach checken, ob es richtig ist, dass keine Substitutionen uebergeben werden muessen.
+				//PL 2018-04-01 nach checken, ob es richtig ist, dass keine Substitutionen uebergeben werden muessen. 
-				termsList.replaceAll(mgu::apply);
+				termsList = termsList.stream().map(x -> mgu.apply(x)).collect(Collectors.toCollection(ArrayList::new));
 				idx = idx+1 == termsList.size() ? 0 : idx+1;
 				continue;
 			}

src/main/java/de/dhbwstuttgart/typeinference/unify/PlaceholderRegistry.java

@@ -1,84 +0,0 @@
-package de.dhbwstuttgart.typeinference.unify;
-
-import de.dhbwstuttgart.server.packet.dataContainers.ISerializableData;
-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.unify.model.PlaceholderType;
-import java.util.ArrayList;
-import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.atomic.AtomicInteger;
-
-/**
- * Calculate unique placeholder names
- */
-public class PlaceholderRegistry implements ISerializableData {
-
-  private final Set<String> existingPlaceholders = ConcurrentHashMap.newKeySet();
-  private final AtomicInteger placeholderCount = new AtomicInteger();
-  public ArrayList<PlaceholderType> UnifyTypeFactory_PLACEHOLDERS = new ArrayList<>();
-
-  /**
-   * Add a placeholder into the list of existing ones, as soon as a new PlaceholderType is created
-   *
-   * @param placeholderName The placeholder to add
-   */
-  public void addPlaceholder(String placeholderName) {
-    this.existingPlaceholders.add(placeholderName);
-  }
-
-  /**
-   * Generate a random placeholder name, that is unique to this context
-   *
-   * @return  The generated name
-   */
-  public String generateFreshPlaceholderName() {
-    String name;
-    do {
-      int pc = placeholderCount.incrementAndGet();
-      name = getUppercaseTokenFromInt(pc);
-    }
-    while (existingPlaceholders.contains(name));
-    this.addPlaceholder(name);
-    return name;
-  }
-
-  public PlaceholderRegistry deepClone() {
-    PlaceholderRegistry pr2 = new PlaceholderRegistry();
-    this.existingPlaceholders.forEach(pr2::addPlaceholder);
-    pr2.UnifyTypeFactory_PLACEHOLDERS.addAll(this.UnifyTypeFactory_PLACEHOLDERS);
-    pr2.placeholderCount.set(this.placeholderCount.get());
-    return pr2;
-  }
-
-  /**
-   * Generate a token that consists of uppercase letters and contains the given prefix and suffix from the value i
-   *
-   * @param i       The value that will be represented as a token
-   * @return        The generated token
-   */
-  private String getUppercaseTokenFromInt(int i) {
-    StringBuilder sb = new StringBuilder();
-    while (i >= 0) {
-      sb.append((char)(i % 26 + 65));
-      i = i / 26 - 1;
-    }
-    //sb.append(suffix);
-    return sb.toString();
-  }
-
-  @Override
-  public String toString() {
-    return this.existingPlaceholders.toString();
-  }
-
-  @Override
-  public SerialMap toSerial(KeyStorage keyStorage) {
-    SerialMap serialized = new SerialMap();
-    serialized.put("ph", new SerialValue<>(new ArrayList<>(this.existingPlaceholders)));
-    serialized.put("factoryPh", SerialList.fromMapped(this.UnifyTypeFactory_PLACEHOLDERS, t -> t.toSerial(keyStorage)));
-    return serialized;
-  }
-}

src/main/java/de/dhbwstuttgart/typeinference/unify/RuleSet.java

@@ -1,12 +1,10 @@
 package de.dhbwstuttgart.typeinference.unify;
 
-import de.dhbwstuttgart.util.Logger;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;
-import java.util.ListIterator;
 import java.util.Optional;
 import java.util.Queue;
 import java.util.Set;
@@ -14,16 +12,24 @@ import java.util.Stack;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
+import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.exceptions.DebugException;
+import de.dhbwstuttgart.syntaxtree.factory.UnifyTypeFactory;
+import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
+import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
 import de.dhbwstuttgart.typeinference.unify.interfaces.IRuleSet;
 import de.dhbwstuttgart.typeinference.unify.model.*;
 import de.dhbwstuttgart.typeinference.constraints.Constraint;
+import de.dhbwstuttgart.typeinference.unify.distributeVariance;
 
+import java.io.FileWriter;
 import java.io.IOException;
 import java.io.Writer;
 import java.io.OutputStreamWriter;
 
+import org.apache.commons.io.output.NullOutputStream;
+
 /**
  * Implementation of the type inference rules.
  * @author Florian Steurer
@@ -31,18 +37,15 @@ import java.io.OutputStreamWriter;
  */
 public class RuleSet implements IRuleSet{
 	
-	Logger logger;
+	Writer logFile;
-	final PlaceholderRegistry placeholderRegistry;
 	
-	public RuleSet(PlaceholderRegistry placeholderRegistry) {
+	public RuleSet() {
 		super();
-		logger = Logger.NULL_LOGGER;
+		logFile = new OutputStreamWriter(new NullOutputStream());
-		this.placeholderRegistry = placeholderRegistry;
 	}
 	
-	RuleSet(Logger logger, PlaceholderRegistry placeholderRegistry) {
+	RuleSet(Writer logFile) {
-		this.logger = logger;
+		this.logFile = logFile;
-		this.placeholderRegistry = placeholderRegistry;
 	}
 	
 	@Override
@@ -294,8 +297,8 @@ public class RuleSet implements IRuleSet{
 		
 		if(dFromFc == null || !dFromFc.getTypeParams().arePlaceholders() || dFromFc.getTypeParams().size() != cFromFc.getTypeParams().size())
 			return Optional.empty();
-		//context.logger().info("cFromFc: " + cFromFc);
+		//System.out.println("cFromFc: " + cFromFc);
-		//context.logger().info("dFromFc: " + dFromFc);
+		//System.out.println("dFromFc: " + dFromFc);
 		int[] pi = pi(cFromFc.getTypeParams(), dFromFc.getTypeParams());
 		
 		if(pi.length == 0)
@@ -504,17 +507,17 @@ public class RuleSet implements IRuleSet{
 		TypeParams typeDParams = typeD.getTypeParams();
 		TypeParams typeDgenParams = typeDgen.getTypeParams();
 		
-		//context.logger().info("Pair: " +pair);
+		//System.out.println("Pair: " +pair);
-		//context.logger().info("typeD: " +typeD);
+		//System.out.println("typeD: " +typeD);
-		//context.logger().info("typeDParams: " +typeDParams);
+		//System.out.println("typeDParams: " +typeDParams);
-		//context.logger().info("typeDgen: " +typeD);
+		//System.out.println("typeDgen: " +typeD);
-		//context.logger().info("typeDgenParams: " +typeDgenParams);
+		//System.out.println("typeDgenParams: " +typeDgenParams);
 		Unifier unif = Unifier.identity();
 		for(int i = 0; i < typeDParams.size(); i++) { 
-			//context.logger().info("ADAPT" +typeDgenParams);
+			//System.out.println("ADAPT" +typeDgenParams);
 			if (typeDgenParams.get(i) instanceof PlaceholderType) 
-				unif.add((PlaceholderType) typeDgenParams.get(i), typeDParams.get(i));
+			unif.add((PlaceholderType) typeDgenParams.get(i), typeDParams.get(i));
-			else logger.exception(new Exception("ERROR in adapt rule: cannot add non placeholder type"));
+			else System.out.println("ERROR");
 		}
 		return Optional.of(new UnifyPair(unif.apply(newLhs), typeDs, PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
 	}
@@ -649,17 +652,15 @@ public class RuleSet implements IRuleSet{
 	
 	@Override
 	public Optional<Set<UnifyPair>> subst(Set<UnifyPair> pairs, List<Set<Constraint<UnifyPair>>> oderConstraints) {
-		// Statistically, typeMap will fill up quickly and resize multiple times. To reduce this, we start with a higher capacity
+		HashMap<UnifyType, Integer> typeMap = new HashMap<>();
-		HashMap<UnifyType, Integer> typeMap = new HashMap<>(200);
 		
 		Stack<UnifyType> occuringTypes = new Stack<>();
-		occuringTypes.ensureCapacity(pairs.size() * 3);
+		
-
 		for(UnifyPair pair : pairs) {
 			occuringTypes.push(pair.getLhsType());
 			occuringTypes.push(pair.getRhsType());
 		}
-
+		
 		while(!occuringTypes.isEmpty()) {
 			UnifyType t1 = occuringTypes.pop();
 			if(!typeMap.containsKey(t1))
@@ -671,12 +672,12 @@ public class RuleSet implements IRuleSet{
 			if(t1 instanceof SuperType)
 				occuringTypes.push(((SuperType) t1).getSuperedType());
 			else
-				t1.getTypeParams().forEach(occuringTypes::push);
+				t1.getTypeParams().forEach(x -> occuringTypes.push(x));	
 		}
-		LinkedList<UnifyPair> result1 = new LinkedList<UnifyPair>(pairs);
+		Queue<UnifyPair> result1 = new LinkedList<UnifyPair>(pairs);
 		ArrayList<UnifyPair> result = new ArrayList<UnifyPair>();
 		boolean applied = false;
-
+		
 		while(!result1.isEmpty()) {
 			UnifyPair pair = result1.poll();
 			PlaceholderType lhsType = null;
@@ -694,30 +695,19 @@ public class RuleSet implements IRuleSet{
 					&& !((rhsType instanceof WildcardType) && ((WildcardType)rhsType).getWildcardedType().equals(lhsType))) //PL eigefuegt 2018-02-18
 			{
 				Unifier uni = new Unifier(lhsType,  rhsType);
-				// apply unifier to result and result1 in place
+				result = result.stream().map(x -> uni.apply(pair,x)).collect(Collectors.toCollection(ArrayList::new));
-				result.replaceAll(p -> uni.apply(pair, p));
+				result1 = result1.stream().map(x -> uni.apply(pair,x)).collect(Collectors.toCollection(LinkedList::new));
-				ListIterator<UnifyPair> result1Iterator = result1.listIterator();
+				
-				while (result1Iterator.hasNext()) {
-					UnifyPair x = result1Iterator.next();
-					result1Iterator.set(uni.apply(pair, x));
-				}
-
 				Function<? super Constraint<UnifyPair>,? extends Constraint<UnifyPair>> applyUni = b -> b.stream().map(
 						x -> uni.apply(pair,x)).collect(Collectors.toCollection((b.getExtendConstraint() != null)
 								? () -> new Constraint<UnifyPair>(
 										  b.isInherited(),
 										  b.isImplemented(),
-										  b.getExtendConstraint().createdMapped(x -> uni.apply(pair,x)),
+										  b.getExtendConstraint().stream().map(x -> uni.apply(pair,x)).collect(Collectors.toCollection(Constraint::new)),
 										  b.getmethodSignatureConstraint().stream().map(x -> uni.apply(pair,x)).collect(Collectors.toCollection(HashSet::new)))
 								: () -> new Constraint<UnifyPair>(b.isInherited(), b.isImplemented())
 									));
-				oderConstraints.replaceAll(oc -> {
+				oderConstraints.replaceAll(oc -> oc.stream().map(applyUni).collect(Collectors.toCollection(HashSet::new)));
-						HashSet<Constraint<UnifyPair>> mapped = new HashSet<>(oc.size());
-						for (var element : oc) {
-							mapped.add(applyUni.apply(element));
-						}
-						return mapped;
-				});
 				/*
 						oderConstraints = oderConstraints.stream().map(
 						a -> a.stream().map(applyUni
@@ -871,11 +861,14 @@ public class RuleSet implements IRuleSet{
         								   UnifyType r = x.getRhsType();
         								   if (r instanceof PlaceholderType) { ((PlaceholderType)r).disableWildcardtable(); }
 								     } );
-
+		try {
-		logger.debug(() -> "FUNgreater: " + pair);
+			logFile.write("FUNgreater: " + pair + "\n");
-		logger.debug(() -> "FUNred: " + result);
+				logFile.write("FUNred: " + result + "\n");
-
+				logFile.flush();
-
+			}
+		catch (IOException e) {
+			System.out.println("logFile-Error");
+		}
 		return Optional.of(result);
 	}
 	
@@ -941,15 +934,15 @@ public class RuleSet implements IRuleSet{
 
 		Set<UnifyPair> result = new HashSet<UnifyPair>();
 		
-		int variance = ((PlaceholderType)rhsType).getVariance();
+		Integer variance = ((PlaceholderType)rhsType).getVariance();
-		int inversVariance = distributeVariance.inverseVariance(variance);
+		Integer inversVariance = distributeVariance.inverseVariance(variance);
 		
 		UnifyType[] freshPlaceholders = new UnifyType[funNLhsType.getTypeParams().size()];
 		for(int i = 0; i < freshPlaceholders.length-1; i++) {
-			freshPlaceholders[i] = PlaceholderType.freshPlaceholder(placeholderRegistry);
+			freshPlaceholders[i] = PlaceholderType.freshPlaceholder();
 			((PlaceholderType)freshPlaceholders[i]).setVariance(inversVariance);
 		}
-		freshPlaceholders[freshPlaceholders.length-1] = PlaceholderType.freshPlaceholder(placeholderRegistry);
+		freshPlaceholders[freshPlaceholders.length-1] = PlaceholderType.freshPlaceholder();
 		((PlaceholderType)freshPlaceholders[freshPlaceholders.length-1]).setVariance(variance);
 		result.add(new UnifyPair(funNLhsType.getTypeParams().get(funNLhsType.getTypeParams().size()-1), freshPlaceholders[funNLhsType.getTypeParams().size()-1], PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
 		
@@ -960,14 +953,18 @@ public class RuleSet implements IRuleSet{
 		result.add(new UnifyPair(rhsType, funNLhsType.setTypeParams(new TypeParams(freshPlaceholders)), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
 		
 		result.stream().forEach(x -> { UnifyType l = x.getLhsType();
-									   if (l instanceof PlaceholderType) { ((PlaceholderType)l).disableWildcardtable(); }
+									   if (l instanceof PlaceholderType) { ((PlaceholderType)l).disableWildcardtable(); } 
 									   UnifyType r = x.getRhsType();
 									   if (r instanceof PlaceholderType) { ((PlaceholderType)r).disableWildcardtable(); }
 									 } );
-
+		try {
-		logger.debug(() -> "FUNgreater: " + pair);
+			logFile.write("FUNgreater: " + pair + "\n");
-		logger.debug(() -> "FUNgreater: " + result);
+			logFile.write("FUNgreater: " + result + "\n");
-
+			logFile.flush();
+		}
+	catch (IOException e) {
+		System.out.println("lofFile-Error");
+	}
 		return Optional.of(result);
 	}
 
@@ -986,15 +983,15 @@ public class RuleSet implements IRuleSet{
 
 		Set<UnifyPair> result = new HashSet<UnifyPair>();
 		
-		int variance = ((PlaceholderType)lhsType).getVariance();
+		Integer variance = ((PlaceholderType)lhsType).getVariance();
-		int inversVariance = distributeVariance.inverseVariance(variance);
+		Integer inversVariance = distributeVariance.inverseVariance(variance);
 		
 		UnifyType[] freshPlaceholders = new UnifyType[funNRhsType.getTypeParams().size()];
 		for(int i = 0; i < freshPlaceholders.length-1; i++) {
-			freshPlaceholders[i] = PlaceholderType.freshPlaceholder(placeholderRegistry);
+			freshPlaceholders[i] = PlaceholderType.freshPlaceholder();
 			((PlaceholderType)freshPlaceholders[i]).setVariance(inversVariance);
 		}
-		freshPlaceholders[freshPlaceholders.length-1] = PlaceholderType.freshPlaceholder(placeholderRegistry);
+		freshPlaceholders[freshPlaceholders.length-1] = PlaceholderType.freshPlaceholder();
 		((PlaceholderType)freshPlaceholders[freshPlaceholders.length-1]).setVariance(variance);
 		
 		result.add(new UnifyPair(freshPlaceholders[funNRhsType.getTypeParams().size()-1], funNRhsType.getTypeParams().get(funNRhsType.getTypeParams().size()-1), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
@@ -1006,15 +1003,18 @@ public class RuleSet implements IRuleSet{
 		result.add(new UnifyPair(lhsType, funNRhsType.setTypeParams(new TypeParams(freshPlaceholders)), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
 		
 		result.stream().forEach(x -> { UnifyType l = x.getLhsType();
-		   							   if (l instanceof PlaceholderType) { ((PlaceholderType)l).disableWildcardtable(); }
+		   							   if (l instanceof PlaceholderType) { ((PlaceholderType)l).disableWildcardtable(); } 
 		   							   UnifyType r = x.getRhsType();
 		   							   if (r instanceof PlaceholderType) { ((PlaceholderType)r).disableWildcardtable(); }
 									 } );
-
+		try {
-
+			logFile.write("FUNgreater: " + pair + "\n");
-		logger.debug(() -> "FUNgreater: " + pair);
+			logFile.write("FUNsmaller: " + result + "\n");
-		logger.debug(() -> "FUNsmaller: " + result);
+			logFile.flush();
-
+		}
+	catch (IOException e) {
+		System.out.println("lofFile-Error");
+	}
 		return Optional.of(result);
 	}
 
@@ -1051,7 +1051,7 @@ public class RuleSet implements IRuleSet{
 		if(isGen)
 			result.add(new UnifyPair(rhsType, lhsType, PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
 		else {
-			UnifyType freshTph = PlaceholderType.freshPlaceholder(placeholderRegistry);
+			UnifyType freshTph = PlaceholderType.freshPlaceholder();
 			result.add(new UnifyPair(rhsType, new ExtendsType(freshTph), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
 			result.add(new UnifyPair(extendedType, freshTph, PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
 		}
@@ -1079,7 +1079,7 @@ public class RuleSet implements IRuleSet{
 		if(isGen)
 			result.add(new UnifyPair(rhsType, lhsType, PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
 		else {
-			UnifyType freshTph = PlaceholderType.freshPlaceholder(placeholderRegistry);
+			UnifyType freshTph = PlaceholderType.freshPlaceholder();
 			result.add(new UnifyPair(rhsType, new SuperType(freshTph), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
 			Set<UnifyType> fBounded = pair.getfBounded();
 			fBounded.add(lhsType);

src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnify.java

@@ -1,65 +1,90 @@
 package de.dhbwstuttgart.typeinference.unify;
 
-import de.dhbwstuttgart.util.Logger;
+import java.io.FileWriter;
 import java.io.IOException;
+import java.io.Writer;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Set;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ForkJoinPool;
 
+import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.typeinference.constraints.Constraint;
+import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
+import de.dhbwstuttgart.typeinference.constraints.Pair;
 import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
+import de.dhbwstuttgart.typeinference.unify.model.FiniteClosure;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 
 public class TypeUnify {
-
+	
-	private TypeUnify() {}
-
-	private static <T> T joinFuture(CompletableFuture<T> future) {
-		try {
-			return future.get();
-		}
-		catch (InterruptedException | ExecutionException exception) {
-			throw new RuntimeException(exception);
-		}
-	}
-
 	/**
 	 * unify parallel ohne result modell
+	 * @param undConstrains
+	 * @param oderConstraints
+	 * @param fc
+	 * @param logFile
+	 * @param log
+	 * @param cons
+	 * @return
 	 */
-	public static Set<Set<UnifyPair>> unify(Set<UnifyPair> undConstrains, List<Set<Constraint<UnifyPair>>> oderConstraints, IFiniteClosure fc, UnifyContext unifyContext) {
+	public Set<Set<UnifyPair>> unify(Set<UnifyPair> undConstrains, List<Set<Constraint<UnifyPair>>> oderConstraints, IFiniteClosure fc, Writer logFile, Boolean log, UnifyResultModel ret, UnifyTaskModel usedTasks) {
-		ForkJoinPool pool = TypeUnify.createThreadPool(unifyContext.logger());
+		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, true, logFile, log, 0, ret, usedTasks);
-		UnifyContext context = unifyContext.newWithParallel(true).newWithExecutor(pool);
+		ForkJoinPool pool = new ForkJoinPool();
-		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, context, 0);
+		pool.invoke(unifyTask);
-		Set<Set<UnifyPair>> res = joinFuture(unifyTask.compute());
+		Set<Set<UnifyPair>> res =  unifyTask.join();
-
+		try {
-		unifyContext.logger().debug("\nnoShortendElements: " + TypeUnifyTask.noShortendElements + "\n");
+			logFile.write("\nnoShortendElements: " + unifyTask.noShortendElements + "\n");
+			logFile.flush();
+		}
+		catch (IOException e) {
+			System.err.println("no log-File");
+		}
 		return res;
 	}
 	
 	/**
 	 * unify asynchron mit Rückgabe UnifyResultModel ohne dass alle results gesammelt sind
+	 * @param undConstrains
+	 * @param oderConstraints
+	 * @param fc
+	 * @param logFile
+	 * @param log
+	 * @param cons
+	 * @param ret
+	 * @return
 	 */
-	public static UnifyResultModel unifyAsync(Set<UnifyPair> undConstrains, List<Set<Constraint<UnifyPair>>> oderConstraints, IFiniteClosure fc, UnifyContext unifyContext) {
+	public UnifyResultModel unifyAsync(Set<UnifyPair> undConstrains, List<Set<Constraint<UnifyPair>>> oderConstraints, IFiniteClosure fc, Writer logFile, Boolean log, UnifyResultModel ret, UnifyTaskModel usedTasks) {
-		ForkJoinPool pool = TypeUnify.createThreadPool(unifyContext.logger());
+		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, true, logFile, log, 0, ret, usedTasks);
-		UnifyContext context = unifyContext.newWithExecutor(pool);
+		ForkJoinPool pool = new ForkJoinPool();
-		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, context, 0);
+		pool.invoke(unifyTask);
-		unifyTask.compute();
+		return ret;
-		return unifyContext.resultModel();
 	}
-
+	
 	/**
 	 * unify parallel mit Rückgabe UnifyResultModel nachdem alle results gesammelt sind
+	 * @param undConstrains
+	 * @param oderConstraints
+	 * @param fc
+	 * @param logFile
+	 * @param log
+	 * @param cons
+	 * @param ret
+	 * @return
 	 */
-	public static Set<Set<UnifyPair>> unifyParallel(Set<UnifyPair> undConstrains, List<Set<Constraint<UnifyPair>>> oderConstraints, IFiniteClosure fc, UnifyContext unifyContext) {
+	public UnifyResultModel unifyParallel(Set<UnifyPair> undConstrains, List<Set<Constraint<UnifyPair>>> oderConstraints, IFiniteClosure fc, Writer logFile, Boolean log, UnifyResultModel ret, UnifyTaskModel usedTasks) {
-		ForkJoinPool pool = TypeUnify.createThreadPool(unifyContext.logger());
+		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, true, logFile, log, 0, ret, usedTasks);
-		UnifyContext context = unifyContext.newWithParallel(true).newWithExecutor(pool);
+		ForkJoinPool pool = new ForkJoinPool();
-		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, context, 0);
+		pool.invoke(unifyTask);
-		var result = joinFuture(unifyTask.compute());
+		Set<Set<UnifyPair>> res =  unifyTask.join();
-
+		try {
-		unifyContext.logger().debug("\nnoShortendElements: " + TypeUnifyTask.noShortendElements + "\n");
+			logFile.write("\nnoShortendElements: " + unifyTask.noShortendElements +"\n");
-		return result;
+			logFile.flush();
+		}
+		catch (IOException e) {
+			System.err.println("no log-File");
+		}
+		return ret;
 	}
 	
 	/*
@@ -72,22 +97,25 @@ public class TypeUnify {
 	
 	/**
 	 * unify sequentiell mit oderconstraints
+	 * @param undConstrains
+	 * @param oderConstraints
+	 * @param fc
+	 * @param logFile
+	 * @param log
+	 * @param cons
+	 * @return
 	 */
-	public static Set<Set<UnifyPair>> unifyOderConstraints(Set<UnifyPair> undConstrains, List<Set<Constraint<UnifyPair>>> oderConstraints, IFiniteClosure fc, UnifyContext unifyContext) {
+	public Set<Set<UnifyPair>> unifyOderConstraints(Set<UnifyPair> undConstrains, List<Set<Constraint<UnifyPair>>> oderConstraints, IFiniteClosure fc, Writer logFile, Boolean log, UnifyResultModel ret, UnifyTaskModel usedTasks) {
-		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, unifyContext.newWithParallel(false), 0);
+		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, false, logFile, log, 0, ret, usedTasks);
-		Set<Set<UnifyPair>> res = joinFuture(unifyTask.compute());
+		Set<Set<UnifyPair>> res = unifyTask.compute();
-		unifyContext.logger().debug("\nnoShortendElements: " + TypeUnifyTask.noShortendElements +"\n");
+		try {
+			logFile.write("\nnoShortendElements: " + unifyTask.noShortendElements +"\n");
+			logFile.flush();
+		}
+		catch (IOException e) {
+			System.err.println("no log-File");
+		}
 		return res;
 	}
 
-	private static ForkJoinPool createThreadPool(Logger logger) {
-		logger.info("Available processors: " + Runtime.getRuntime().availableProcessors());
-		return new ForkJoinPool(
-			Runtime.getRuntime().availableProcessors(),
-			ForkJoinPool.defaultForkJoinWorkerThreadFactory,
-			null,
-			false
-		);
-	}
-
 }

src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnify2Task.java

@@ -13,46 +13,54 @@ import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import de.dhbwstuttgart.typeinference.constraints.Pair;
 import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
-import java.util.concurrent.CompletableFuture;
 
 public class TypeUnify2Task extends TypeUnifyTask {
+       
+       Set<Set<UnifyPair>> setToFlatten;
+       Set<UnifyPair> methodSignatureConstraintUebergabe;
 
-  Set<Set<UnifyPair>> setToFlatten;
+       public TypeUnify2Task(Set<Set<UnifyPair>> setToFlatten, Set<UnifyPair> eq, List<Set<Constraint<UnifyPair>>> oderConstraints, Set<UnifyPair> nextSetElement, IFiniteClosure fc, boolean parallel, Writer logFile, Boolean log, int rekTiefe, UnifyResultModel urm, UnifyTaskModel usedTasks, Set<UnifyPair> methodSignatureConstraintUebergabe) {
-  Set<UnifyPair> methodSignatureConstraintUebergabe;
+               super(eq, oderConstraints, fc, parallel, logFile, log, rekTiefe, urm, usedTasks);
-
+               this.setToFlatten = setToFlatten;
-  public TypeUnify2Task(Set<Set<UnifyPair>> setToFlatten, Set<UnifyPair> eq, List<Set<Constraint<UnifyPair>>> oderConstraints, Set<UnifyPair> nextSetElement, IFiniteClosure fc, UnifyContext context, int rekTiefe, Set<UnifyPair> methodSignatureConstraintUebergabe) {
+               this.nextSetElement = nextSetElement;
-    super(eq, oderConstraints, fc, context, rekTiefe);
+               this.methodSignatureConstraintUebergabe = methodSignatureConstraintUebergabe;
-    this.setToFlatten = setToFlatten;
+       }
-    this.nextSetElement = nextSetElement;
+       
-    this.methodSignatureConstraintUebergabe = methodSignatureConstraintUebergabe;
+       Set<UnifyPair> getNextSetElement() {
-  }
+    	   return nextSetElement;
-
+       }
-  public Set<UnifyPair> getNextSetElement() {
+       
-    return nextSetElement;
+       @Override
-  }
+       protected Set<Set<UnifyPair>> compute() {
-
+               if (one) {
-  @Override
+                       System.out.println("two");
-  public CompletableFuture<Set<Set<UnifyPair>>> compute() {
+               }
-    if (one) {
+               one = true;
-      context.logger().info("two");
+               Set<Set<UnifyPair>> res = unify2(setToFlatten, eq, oderConstraintsField, fc, parallel, rekTiefeField, methodSignatureConstraintUebergabe);
-    }
-    one = true;
-    CompletableFuture<Set<Set<UnifyPair>>> res =
-      unify2(setToFlatten, eq, oderConstraintsField, fc, context.parallel(), rekTiefeField, methodSignatureConstraintUebergabe);
                /*if (isUndefinedPairSetSet(res)) { 
                        return new HashSet<>(); }
                else
-               */
+               */ 
-    //writeLog("xxx");
+               //writeLog("xxx");
-    //noOfThread--;
+               //noOfThread--;
-    if (this.isExecutionCancelled()) {
+               synchronized (usedTasks) {
-      return CompletableFuture.completedFuture(new HashSet<>());
+            	   if (this.myIsCancelled()) {
-    } else {
+   						return new HashSet<>();
-      return res;
+   					}
-    }
+   					else {
-  }
+   						return res;
+   					}
+   				}
+       	}
+       
+       public void closeLogFile() {
 
-  public void closeLogFile() {
+           try {
-    context.logger().close();
+				logFile.close();
-  }
+			}
+			catch (IOException ioE) {
+				System.err.println("no log-File" + thNo);
+			}
+           
+       }
 }

src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnifyTaskHelper.java

@@ -1,221 +0,0 @@
-package de.dhbwstuttgart.typeinference.unify;
-
-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 java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Optional;
-import java.util.Set;
-import java.util.function.Function;
-import java.util.stream.Collectors;
-
-/**
- * A collection of capsuled (and thus static) functions to split up large algorithms in TypeUnifyTask
- */
-public class TypeUnifyTaskHelper {
-
-  /**
-   * Filter all topLevelSets for those with a single element that contain only one pair:
-   *   a <. theta,
-   *   theta <. a or
-   *   a =. theta
-   */
-  public static Set<Set<UnifyPair>> getSingleElementSets(ArrayList<Set<? extends Set<UnifyPair>>> topLevelSets) {
-    return topLevelSets.stream()
-      .filter(x -> x.size() == 1)
-      .map(y -> y.stream().findFirst().get()).collect(Collectors.toSet());
-  }
-
-  /**
-   * Varianzbestimmung Anfang
-   * Oderconstraint, wenn entweder kein Basepair oder unterschiedliche Basepairs => oderConstraint = true;
-   * Varianz =  1 => Argumentvariable
-   * Varianz = -1 => Rückgabevariable
-   * Varianz =  0 => unklar
-   * Varianz =  2 => Operatoren oderConstraints
-   */
-  public static int calculateVariance(List<Set<UnifyPair>> nextSetasList) {
-    Optional<Integer> xi = nextSetasList.stream().map(x -> x.stream().filter(y -> (y.getLhsType() instanceof PlaceholderType && !(y.getRhsType() instanceof PlaceholderType)))
-        .filter(z -> ((PlaceholderType) z.getLhsType()).getVariance() != 0)
-        .map(c -> ((PlaceholderType) c.getLhsType()).getVariance())
-        .reduce((a, b) -> {
-          if (a.intValue() == b.intValue()) return a;
-          else return 0;
-        })) //2 kommt insbesondere bei Oder-Constraints vor
-      .filter(Optional::isPresent)
-      .map(Optional::get)
-      .findAny();
-
-    return xi.orElse(0);
-  }
-
-  /**
-   *
-   */
-  public static int calculateOderConstraintVariance(List<Set<UnifyPair>> nextSetAsList) {
-    Optional<Integer> optVariance =
-      nextSetAsList
-        .getFirst()
-        .stream()
-        .filter(x -> x.getGroundBasePair().getLhsType() instanceof PlaceholderType &&
-          !(x.getRhsType() instanceof PlaceholderType) &&
-          x.getPairOp() == PairOperator.EQUALSDOT)
-        .map(x ->
-          ((PlaceholderType) x.getGroundBasePair().getLhsType()).getVariance())
-        .reduce((n, m) -> (n != 0) ? n : m);
-
-    //Fuer Operatorenaufrufe wird variance auf 2 gesetzt.
-    //da kein Receiver existiert also kein x.getGroundBasePair().getLhsType() instanceof PlaceholderType
-    //Bei Varianz = 2 werden alle Elemente des Kartesischen Produkts abgearbeitet
-    return optVariance.orElse(2);
-  }
-
-
-  /**
-   * Find the first occurrence (if any) of a UnifyPair with operator EQUALSDOT while having
-   * one side equal to its base pair counterpart
-   */
-  public static Optional<UnifyPair> findEqualityConstrainedUnifyPair(Set<UnifyPair> nextSetElement) {
-    return nextSetElement.stream().filter(x ->
-        x.getPairOp()
-        .equals(PairOperator.EQUALSDOT))
-      .filter(x -> //Sicherstellen, dass bei a = ty a auch wirklich die gesuchte Typvariable ist
-        x.getLhsType()
-          .equals(x.getBasePair().getLhsType()) ||
-        x.getLhsType()
-          .equals(x.getBasePair().getRhsType())
-    ).findFirst();
-  }
-
-  /**
-   *  Find all unifyPairs, that associate the identified type variable of origPair with any concrete type. That means:
-   *  If "a = type" is in origPair, then we get all UnifyPairs that contain either "a < typeA" or "typeB < a"
-   */
-  public static Set<UnifyPair> findConstraintsWithSameTVAssociation(UnifyPair origPair, Set<Set<UnifyPair>> singleElementSets) {
-    UnifyType tyVar = origPair.getLhsType();
-    if (!(tyVar instanceof PlaceholderType)) {
-      tyVar = origPair.getRhsType();
-    }
-
-    UnifyType tyVarEF = tyVar;
-    return singleElementSets.stream()
-      .map(xx ->
-        xx.iterator().next())
-      .filter(x ->
-            (x.getLhsType().equals(tyVarEF) && !(x.getRhsType() instanceof PlaceholderType))
-            ||
-            (x.getRhsType().equals(tyVarEF) && !(x.getLhsType() instanceof PlaceholderType))
-      )
-      .collect(Collectors.toCollection(HashSet::new));
-  }
-
-  /**
-   *
-   */
-  public static boolean doesFirstNextSetHasSameBase(List<Set<UnifyPair>> nextSetAsList) {
-    if (nextSetAsList.isEmpty()) {
-      return false;
-    }
-
-    UnifyPair firstBasePair = null;
-
-    for (var unifyPair : nextSetAsList.getFirst().stream().toList()) {
-      var basePair = unifyPair.getBasePair();
-
-      // if any base pair is null, there is NOT always the same base!
-      if (basePair == null) {
-        return false;
-      }
-
-      if (firstBasePair == null) {
-        firstBasePair = basePair;
-      }
-      else if (!basePair.equals(firstBasePair)) {
-        return false;
-      }
-    }
-
-    return true;
-  }
-
-  /**
-   *  Extracts data from every element in the nested lists of results. What data depends on the given
-   *  extractor function
-   */
-  public static Set<UnifyPair> collectFromThreadResult (
-    Set<Set<UnifyPair>> currentThreadResult,
-    Function<UnifyPair, Set<UnifyPair>> extractor
-  ) {
-    return currentThreadResult.stream()
-      .map(b ->
-        b.stream()
-          .map(extractor)
-          .reduce((y, z) -> {
-            y.addAll(z);
-            return y;
-          })
-          .orElse(new HashSet<>()))
-      .reduce((y, z) -> {
-        y.addAll(z);
-        return y;
-      })
-      .orElse(new HashSet<>());
-  }
-
-  /**
-   *  Extract a list of PlaceholderTypes from a set of pairs, such that each resulting element:
-   *  - Is the LHS of a pair
-   *  - Is a PlaceholderType
-   *  - has a basePair Side that is a PlaceholderType with the same name
-   */
-  public static List<PlaceholderType> extractMatchingPlaceholderTypes(Set<UnifyPair> pairs) {
-    return pairs.stream()
-      .filter(x -> {
-        UnifyType lhs = x.getLhsType();
-        UnifyType baseLhs = x.getBasePair().getLhsType();
-        UnifyType baseRhs = x.getBasePair().getRhsType();
-        return (lhs instanceof PlaceholderType) &&
-          ((baseLhs instanceof PlaceholderType && lhs.getName().equals(baseLhs.getName())) ||
-            (baseRhs instanceof PlaceholderType && lhs.getName().equals(baseRhs.getName())));
-      })
-      .map(x -> (PlaceholderType) x.getLhsType())
-      .collect(Collectors.toCollection(ArrayList::new));
-  }
-
-
-  public static Set<UnifyPair> occursCheck(final Set<UnifyPair> eq) {
-    Set<UnifyPair> ocurrPairs = new HashSet<>(eq.size());
-    for (UnifyPair x : eq) {
-      UnifyType lhs = x.getLhsType();
-      UnifyType rhs = x.getRhsType();
-      if (lhs instanceof PlaceholderType lhsPlaceholder &&
-        !(rhs instanceof PlaceholderType) &&
-        rhs.getTypeParams().occurs(lhsPlaceholder))
-      {
-        x.setUndefinedPair();
-        ocurrPairs.add(x);
-      }
-    }
-    return ocurrPairs;
-  }
-
-
-  public static <T> HashSet<T> getPresizedHashSet(int minElements) {
-    if (minElements < 16) return new HashSet<>();
-    // HashSet and HashMap will resize at 75% load, so we account for that by multiplying with 1.5
-    int n = (int)(minElements * 1.5);
-    return new HashSet<>(n);
-  }
-
-  public static <S,T> HashMap<S,T> getPresizedHashMap(int minElements) {
-    if (minElements < 16) return new HashMap<>();
-    // HashSet and HashMap will resize at 75% load, so we account for that by multiplying with 1.5
-    int n = (int)(minElements * 1.5);
-    return new HashMap<>(n);
-  }
-
-}

src/main/java/de/dhbwstuttgart/typeinference/unify/UnifyContext.java

@@ -1,67 +0,0 @@
-package de.dhbwstuttgart.typeinference.unify;
-
-import de.dhbwstuttgart.util.Logger;
-import java.io.Writer;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.ForkJoinPool;
-
-public record UnifyContext(
-  // main logger of a unification
-  Logger logger,
-  // if the unify algorithm should run in parallel
-  boolean parallel,
-  // the model for storing calculated results
-  UnifyResultModel resultModel,
-  // the executor used for thread management in parallel execution
-  ExecutorService executor,
-  // a generator for new placeholders in this unify context
-  PlaceholderRegistry placeholderRegistry,
-  // a control structure to cancel the unification early
-  UnifyTaskModel usedTasks
-) {
-
-  public UnifyContext(
-    Logger logger,
-    boolean parallel,
-    UnifyResultModel resultModel,
-    UnifyTaskModel usedTasks,
-    ExecutorService executor,
-    PlaceholderRegistry placeholderRegistry
-  ) {
-    this(logger, parallel, resultModel, executor, placeholderRegistry, usedTasks);
-  }
-
-  public UnifyContext(
-    Logger logger,
-    boolean parallel,
-    UnifyResultModel resultModel,
-    UnifyTaskModel usedTasks,
-    PlaceholderRegistry placeholderRegistry
-  ) {
-    this(logger, parallel, resultModel, usedTasks, ForkJoinPool.commonPool(), placeholderRegistry);
-  }
-
-
-  /*
-   * Shortcuts for creating a similar context with some properties changed. This combined with the final properties
-   * causes the UnifyContext to be essentially handled as a
-   */
-
-  public UnifyContext newWithLogger(Logger logger) {
-    return new UnifyContext(logger, parallel, resultModel, executor, placeholderRegistry, usedTasks);
-  }
-
-  public UnifyContext newWithParallel(boolean parallel) {
-    if (this.parallel == parallel) return this;
-    return new UnifyContext(logger, parallel, resultModel, executor, placeholderRegistry, usedTasks);
-  }
-
-  public UnifyContext newWithExecutor(ExecutorService executor) {
-    return new UnifyContext(logger, parallel, resultModel, executor, placeholderRegistry, usedTasks);
-  }
-
-  public UnifyContext newWithResultModel(UnifyResultModel resultModel) {
-    return new UnifyContext(logger, parallel, resultModel, executor, placeholderRegistry, usedTasks);
-  }
-
-}

src/main/java/de/dhbwstuttgart/typeinference/unify/UnifyResultModel.java

@@ -36,19 +36,19 @@ public class UnifyResultModel {
 		listeners.remove(listenerToRemove);
 	}
 	
-	public void notify(Set<Set<UnifyPair>> eqPrimePrimeSet, UnifyContext context) {
+	public void notify(Set<Set<UnifyPair>> eqPrimePrimeSet) {
 		Set<Set<UnifyPair>> eqPrimePrimeSetRet = eqPrimePrimeSet.stream().map(x -> {
-			Optional<Set<UnifyPair>> res = new RuleSet(context.placeholderRegistry()).subst(x.stream().map(y -> {
+			Optional<Set<UnifyPair>> res = new RuleSet().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(), fc);
+				return new TypeUnifyTask().applyTypeUnificationRules(res.get(), fc);
 			}
 			else return x; //wenn nichts veraendert wurde wird x zurueckgegeben
 		}).collect(Collectors.toCollection(HashSet::new));
 		List<ResultSet> newResult = eqPrimePrimeSetRet.stream().map(unifyPairs ->
-           new ResultSet(UnifyTypeFactory.convert(unifyPairs, de.dhbwstuttgart.typeinference.constraints.Pair.generateTPHMap(cons), context.placeholderRegistry())))
+           new ResultSet(UnifyTypeFactory.convert(unifyPairs, de.dhbwstuttgart.typeinference.constraints.Pair.generateTPHMap(cons))))
            .collect(Collectors.toList());
 		UnifyResultEvent evt = new UnifyResultEvent(newResult);
 		

src/main/java/de/dhbwstuttgart/typeinference/unify/UnifyTaskModel.java

@@ -12,7 +12,7 @@ public class UnifyTaskModel {
     
     public synchronized void cancel() {
     	for(TypeUnifyTask t : usedTasks) {
-    		t.cancelExecution();
+    		t.myCancel(true);
     	}
     }
 }

src/main/java/de/dhbwstuttgart/typeinference/unify/cartesianproduct/ContravarianceCase.java

@@ -1,209 +0,0 @@
-package de.dhbwstuttgart.typeinference.unify.cartesianproduct;
-
-import de.dhbwstuttgart.typeinference.constraints.Constraint;
-import de.dhbwstuttgart.typeinference.unify.TypeUnify2Task;
-import de.dhbwstuttgart.typeinference.unify.TypeUnifyTask;
-import de.dhbwstuttgart.typeinference.unify.UnifyContext;
-import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
-import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
-import de.dhbwstuttgart.util.Tuple;
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Optional;
-import java.util.Set;
-import java.util.concurrent.CompletableFuture;
-import java.util.stream.Collectors;
-
-public class ContravarianceCase extends VarianceCase {
-
-  protected final int variance = 1;
-
-  protected ContravarianceCase(boolean isOderConstraint, TypeUnifyTask typeUnifyTask, UnifyContext context) {
-    super(isOderConstraint, typeUnifyTask, context);
-  }
-
-  @Override
-  public void selectNextData(
-    TypeUnifyTask typeUnifyTask,
-    List<Set<UnifyPair>> nextSetAsList,
-    Optional<UnifyPair> optOrigPair
-  ) {
-    a = typeUnifyTask.oup.max(nextSetAsList.iterator());
-    context.logger().debug("Max: a in " + variance + " " + a);
-    nextSetAsList.remove(a);
-    if (this.isOderConstraint) {
-      nextSetasListOderConstraints.add(((Constraint<UnifyPair>) a).getExtendConstraint());
-    }
-    context.logger().debug(() -> "nextSetasListOderConstraints 1: " + nextSetasListOderConstraints);
-
-    //Alle maximale Elemente in nextSetasListRest bestimmen
-    //nur für diese wird parallele Berechnung angestossen.
-    Set<UnifyPair> finalA = a;
-    nextSetasListRest = typeUnifyTask.oup.maxElements(
-      nextSetAsList.stream().filter(a_next -> typeUnifyTask.oup.compare(finalA, a_next) != 1).toList()
-    );
-  }
-
-
-  @Override
-  public CompletableFuture<ComputationResults> computeParallel(
-    Set<Set<UnifyPair>> elems,
-    Set<UnifyPair> eq,
-    List<Set<Constraint<UnifyPair>>> oderConstraints,
-    IFiniteClosure fc,
-    int rekTiefe,
-    Set<UnifyPair> methodSignatureConstraint,
-    List<Set<UnifyPair>> nextSetAsList,
-    Set<UnifyPair> sameEqSet,
-    Set<Set<UnifyPair>> result,
-    Set<Set<UnifyPair>> aParDef
-  ) {
-    Set<UnifyPair> newEqOrig = new HashSet<>(eq);
-    Set<Set<UnifyPair>> newElemsOrig = new HashSet<>(elems);
-    List<Set<Constraint<UnifyPair>>> newOderConstraintsOrig = new ArrayList<>(oderConstraints);
-    newElemsOrig.add(a);
-
-    /* FORK ANFANG */
-    TypeUnify2Task forkOrig = new TypeUnify2Task(newElemsOrig, newEqOrig, newOderConstraintsOrig, a, fc, context, rekTiefe, methodSignatureConstraint);
-    typeUnifyTask.addChildTask(forkOrig);
-    // schedule compute() on another thread
-    CompletableFuture<Set<Set<UnifyPair>>> forkOrigFuture = CompletableFuture.supplyAsync(forkOrig::compute, context.executor()).thenCompose(f -> f);
-    CompletableFuture<ComputationResults> resultValues = forkOrigFuture.thenApply(
-      (currentThreadResult) -> {
-        forkOrig.context.logger().debug("final Orig 1");
-        forkOrig.closeLogFile();
-        return new ComputationResults(currentThreadResult);
-      });
-
-    //forks.add(forkOrig);
-    if (typeUnifyTask.isExecutionCancelled()) {
-      return CompletableFuture.completedFuture(new ComputationResults());
-    }
-    /* FORK ENDE */
-
-    context.logger().debug("a in " + variance + " " + a);
-    context.logger().debug("nextSetasListRest: " + nextSetasListRest.toString());
-    while (!nextSetasListRest.isEmpty()) {
-      Set<UnifyPair> nSaL = nextSetasListRest.removeFirst();
-      nextSetAsList.remove(nSaL);
-      context.logger().debug("1 RM" + nSaL.toString());
-
-      if (!this.isOderConstraint) {
-        //ueberpruefung ob zu a =. ty \in nSaL in sameEqSet ein Widerspruch besteht
-        if (!sameEqSet.isEmpty() && !typeUnifyTask.checkNoContradiction(nSaL, sameEqSet, result)) {
-          TypeUnifyTask.noShortendElements++;
-          continue;
-        }
-      } else {
-        nextSetasListOderConstraints.add(((Constraint<UnifyPair>) nSaL).getExtendConstraint());
-      }
-      Set<UnifyPair> newEq = new HashSet<>(eq);
-      Set<Set<UnifyPair>> newElems = new HashSet<>(elems);
-      List<Set<Constraint<UnifyPair>>> newOderConstraints = new ArrayList<>(oderConstraints);
-      newElems.add(nSaL);
-      TypeUnify2Task fork = new TypeUnify2Task(newElems, newEq, newOderConstraints, nSaL, fc, context, rekTiefe, new HashSet<>(methodSignatureConstraint));
-      typeUnifyTask.addChildTask(fork);
-      // schedule compute() on another thread
-      CompletableFuture<Set<Set<UnifyPair>>> forkFuture = CompletableFuture.supplyAsync(fork::compute, context.executor()).thenCompose(f -> f);
-      resultValues = resultValues.thenCombine(forkFuture,
-        (prevResults, fork_res) -> {
-          if (typeUnifyTask.isExecutionCancelled()) {
-            return new ComputationResults();
-          }
-          context.logger().debug("fork_res: " + fork_res.toString());
-          context.logger().debug(Boolean.valueOf((typeUnifyTask.isUndefinedPairSetSet(fork_res))).toString());
-          prevResults.addForkResult(fork_res);
-          if (!typeUnifyTask.isUndefinedPairSetSet(fork_res)) {
-            aParDef.add(fork.getNextSetElement());
-          }
-          fork.context.logger().debug("final 1");
-          fork.closeLogFile();
-        return prevResults;
-        }
-      );
-
-      if (typeUnifyTask.isExecutionCancelled()) {
-        return CompletableFuture.completedFuture(new ComputationResults());
-      }
-    }
-
-    return resultValues;
-  }
-
-  @Override
-  public void applyComputedResults(
-    Set<Set<UnifyPair>> result,
-    Set<Set<UnifyPair>> currentThreadResult,
-    Set<UnifyPair> compResult,
-    Set<UnifyPair> compRes
-  ) {
-    int resOfCompare = typeUnifyTask.oup.compare(compResult, compRes);
-    if (resOfCompare == -1) {
-      context.logger().debug("Geloescht result: " + result);
-      result.clear();
-      result.addAll(currentThreadResult);
-    }
-    else if (resOfCompare == 0) {
-      result.addAll(currentThreadResult);
-    }
-    else if (resOfCompare == 1) {
-      context.logger().debug("Geloescht currentThreadResult: " + currentThreadResult);
-      //result = result;
-    }
-  }
-
-  @Override
-  public boolean eraseInvalidSets(
-    int rekTiefe,
-    Set<Set<UnifyPair>> aParDef,
-    List<Set<UnifyPair>> nextSetAsList
-  ) {
-    // context.logger().info("");
-    context.logger().debug("a: " + rekTiefe + " variance: " + variance + a.toString());
-    context.logger().debug("aParDef: " + aParDef.toString());
-    aParDef.add(a);
-    Iterator<Set<UnifyPair>> aParDefIt = aParDef.iterator();
-    if (this.isOderConstraint) {
-      nextSetAsList.removeAll(nextSetasListOderConstraints);
-      nextSetasListOderConstraints = new ArrayList<>();
-      context.logger().debug("Removed: " + nextSetasListOderConstraints);
-      while (aParDefIt.hasNext()) {
-        Set<UnifyPair> a_new = aParDefIt.next();
-        List<Set<UnifyPair>> smallerSetasList = typeUnifyTask.oup.smallerThan(a_new, nextSetAsList);
-        context.logger().debug("smallerSetasList: " + smallerSetasList);
-        List<Set<UnifyPair>> notInherited = smallerSetasList.stream()
-          .filter(x -> !((Constraint<UnifyPair>) x).isInherited() && !((Constraint<UnifyPair>) x).isImplemented())
-          .collect(Collectors.toCollection(ArrayList::new));
-        context.logger().debug("notInherited: " + notInherited + "\n");
-        List<Set<UnifyPair>> notErased = new ArrayList<>();
-        notInherited.forEach(x -> {
-          notErased.addAll(typeUnifyTask.oup.smallerEqThan(x, smallerSetasList));
-        });
-        List<Set<UnifyPair>> erased = new ArrayList<>(smallerSetasList);
-        context.logger().debug("notErased: " + notErased + "\n");
-        erased.removeAll(notErased);
-        nextSetAsList.removeAll(erased);
-
-        context.logger().debug("Removed: " + erased);
-
-        context.logger().debug("Not Removed: " + nextSetAsList);
-
-      }
-    } else {
-      while (aParDefIt.hasNext()) {
-        //nextSetasListIt = nextSetasList.iterator(); Sollte eingefuegt werden PL 2020-04-28
-        Set<UnifyPair> a_new = aParDefIt.next();
-        List<Set<UnifyPair>> erased = typeUnifyTask.oup.smallerEqThan(a_new, nextSetAsList);
-        nextSetAsList.removeAll(erased);
-
-        context.logger().debug("Removed: " + erased);
-
-        context.logger().debug("Not Removed: " + nextSetAsList);
-      }
-    }
-
-    return false;
-  }
-}

src/main/java/de/dhbwstuttgart/typeinference/unify/cartesianproduct/CovarianceCase.java

@@ -1,226 +0,0 @@
-package de.dhbwstuttgart.typeinference.unify.cartesianproduct;
-
-import de.dhbwstuttgart.typeinference.constraints.Constraint;
-import de.dhbwstuttgart.typeinference.unify.TypeUnify2Task;
-import de.dhbwstuttgart.typeinference.unify.TypeUnifyTask;
-import de.dhbwstuttgart.typeinference.unify.UnifyContext;
-import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
-import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
-import de.dhbwstuttgart.util.Tuple;
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Optional;
-import java.util.Set;
-import java.util.concurrent.CompletableFuture;
-import java.util.stream.Collectors;
-
-public class CovarianceCase extends VarianceCase {
-
-  protected final int variance = -1;
-
-  protected CovarianceCase(boolean isOderConstraint, TypeUnifyTask typeUnifyTask, UnifyContext context) {
-    super(isOderConstraint, typeUnifyTask, context);
-  }
-
-  @Override
-  public void selectNextData(
-    TypeUnifyTask typeUnifyTask,
-    List<Set<UnifyPair>> nextSetAsList,
-    Optional<UnifyPair> optOrigPair
-  ) {
-    a = typeUnifyTask.oup.min(nextSetAsList.iterator());
-    context.logger().debug(() -> "Min: a in " + variance + " " + a);
-    if (this.isOderConstraint) {
-      nextSetasListOderConstraints.add(((Constraint<UnifyPair>) a).getExtendConstraint());
-    }
-    context.logger().debug(() -> "nextSetasListOderConstraints -1: " + nextSetasListOderConstraints);
-    nextSetAsList.remove(a);
-
-    //Alle minimalen Elemente in nextSetasListRest bestimmen
-    //nur für diese wird parallele Berechnung angestossen.
-    Set<UnifyPair> finalA = a;
-    nextSetasListRest = typeUnifyTask.oup.minElements(
-      nextSetAsList.stream().filter(a_next -> typeUnifyTask.oup.compare(finalA, a_next) != -1).toList()
-    );
-  }
-
-
-  @Override
-  public CompletableFuture<ComputationResults> computeParallel(
-    Set<Set<UnifyPair>> elems,
-    Set<UnifyPair> eq,
-    List<Set<Constraint<UnifyPair>>> oderConstraints,
-    IFiniteClosure fc,
-    int rekTiefe,
-    Set<UnifyPair> methodSignatureConstraint,
-    List<Set<UnifyPair>> nextSetAsList,
-    Set<UnifyPair> sameEqSet,
-    Set<Set<UnifyPair>> result,
-    Set<Set<UnifyPair>> aParDef
-  ) {
-    Set<UnifyPair> newEqOrig = new HashSet<>(eq);
-    Set<Set<UnifyPair>> newElemsOrig = new HashSet<>(elems);
-    List<Set<Constraint<UnifyPair>>> newOderConstraintsOrig = new ArrayList<>(oderConstraints);
-    newElemsOrig.add(a);
-
-    /* FORK ANFANG */
-    TypeUnify2Task forkOrig = new TypeUnify2Task(newElemsOrig, newEqOrig, newOderConstraintsOrig, a, fc, context, rekTiefe, methodSignatureConstraint);
-    typeUnifyTask.addChildTask(forkOrig);
-    // schedule compute() on another thread
-    CompletableFuture<Set<Set<UnifyPair>>> forkOrigFuture = CompletableFuture.supplyAsync(forkOrig::compute, context.executor()).thenCompose(f -> f);
-    CompletableFuture<ComputationResults> resultValues = forkOrigFuture.thenApply(
-      (currentThreadResult) -> {
-        forkOrig.context.logger().debug("final Orig -1");
-        forkOrig.closeLogFile();
-        return new ComputationResults(currentThreadResult);
-      });
-
-    //forks.add(forkOrig);
-    if (typeUnifyTask.isExecutionCancelled()) {
-      return resultValues;
-    }
-    /* FORK ENDE */
-
-    context.logger().debug(() -> "a in " + variance + " " + a);
-    context.logger().debug(() -> "nextSetasListRest: " + nextSetasListRest.toString());
-
-    while (!nextSetasListRest.isEmpty()) {
-      Set<UnifyPair> nSaL = nextSetasListRest.removeFirst();
-      nextSetAsList.remove(nSaL);
-      context.logger().debug(() -> "-1 RM" + nSaL.toString());
-
-      if (!this.isOderConstraint) {
-        //ueberpruefung ob zu a =. ty \in nSaL in sameEqSet ein Widerspruch besteht
-        if (!sameEqSet.isEmpty() && !typeUnifyTask.checkNoContradiction(nSaL, sameEqSet, result)) {
-          TypeUnifyTask.noShortendElements++;
-          continue;
-        }
-      } else {
-        nextSetasListOderConstraints.add(((Constraint<UnifyPair>) nSaL).getExtendConstraint());
-      }
-      Set<UnifyPair> newEq = new HashSet<>(eq);
-      Set<Set<UnifyPair>> newElems = new HashSet<>(elems);
-      List<Set<Constraint<UnifyPair>>> newOderConstraints = new ArrayList<>(oderConstraints);
-      newElems.add(nSaL);
-      TypeUnify2Task fork = new TypeUnify2Task(newElems, newEq, newOderConstraints, nSaL, fc, context, rekTiefe, new HashSet<>(methodSignatureConstraint));
-      typeUnifyTask.addChildTask(fork);
-      // schedule compute() on another thread
-      CompletableFuture<Set<Set<UnifyPair>>> forkFuture = CompletableFuture.supplyAsync(fork::compute, context.executor()).thenCompose(f -> f);
-      resultValues = resultValues.thenCombine(forkFuture,
-        (prevResults, fork_res) -> {
-          if (typeUnifyTask.isExecutionCancelled()) {
-            return prevResults;
-          }
-          context.logger().debug(() -> "fork_res: " + fork_res.toString());
-          context.logger().debug(() -> Boolean.valueOf((typeUnifyTask.isUndefinedPairSetSet(fork_res))).toString());
-          prevResults.addForkResult(fork_res);
-          if (!typeUnifyTask.isUndefinedPairSetSet(fork_res)) {
-            aParDef.add(fork.getNextSetElement());
-          }
-          fork.context.logger().debug("final -1");
-          fork.closeLogFile();
-        return prevResults;
-        }
-      );
-
-      if (typeUnifyTask.isExecutionCancelled()) {
-        return resultValues;
-      }
-    }
-
-    return resultValues;
-  }
-
-
-  @Override
-  public void applyComputedResults(
-    Set<Set<UnifyPair>> result,
-    Set<Set<UnifyPair>> currentThreadResult,
-    Set<UnifyPair> compResult,
-    Set<UnifyPair> compRes
-  ) {
-    int resOfCompare = typeUnifyTask.oup.compare(compResult, compRes);
-    if (resOfCompare == 1) {
-      context.logger().debug(() -> "Geloescht result: " + result);
-      result.clear();
-      result.addAll(currentThreadResult);
-    } else if (resOfCompare == 0) {
-      result.addAll(currentThreadResult);
-    } else if (resOfCompare == -1) {
-      context.logger().debug(() -> "Geloescht currentThreadResult: " + currentThreadResult);
-      //result = result;
-    }
-  }
-
-  @Override
-  public boolean eraseInvalidSets(
-    int rekTiefe,
-    Set<Set<UnifyPair>> aParDef,
-    List<Set<UnifyPair>> nextSetAsList
-  ) {
-
-    // context.logger().info("");
-    context.logger().debug(() -> "a: " + rekTiefe + " variance: " + variance + a.toString());
-    context.logger().debug(() -> "aParDef: " + aParDef.toString());
-    aParDef.add(a);
-    Iterator<Set<UnifyPair>> aParDefIt = aParDef.iterator();
-    if (this.isOderConstraint) {
-      nextSetAsList.removeAll(nextSetasListOderConstraints);
-      context.logger().debug(() -> "Removed: " + nextSetasListOderConstraints);
-      nextSetasListOderConstraints = new ArrayList<>();
-      while (aParDefIt.hasNext()) {
-        Set<UnifyPair> a_new = aParDefIt.next();
-        List<Set<UnifyPair>> greaterSetasList = typeUnifyTask.oup.greaterThan(a_new, nextSetAsList);
-
-        //a_new muss hingefuegt werden, wenn es nicht vererbt ist, dann wird es spaeter wieder geloescht
-        if (!((Constraint<UnifyPair>) a_new).isInherited()) {
-          greaterSetasList.add(a_new);
-        }
-        List<Set<UnifyPair>> notInherited = greaterSetasList.stream()
-          .filter(x -> !((Constraint<UnifyPair>) x).isInherited())
-          .collect(Collectors.toCollection(ArrayList::new));
-        List<Set<UnifyPair>> notErased = new ArrayList<>();
-
-        //Wenn x nicht vererbt ist, beginnt beim naechstgroesseren Element die naechste Ueberladung
-        notInherited.forEach(x -> {
-          notErased.addAll(typeUnifyTask.oup.greaterEqThan(x, greaterSetasList));
-        });
-
-        //das kleineste Element ist das Element von dem a_new geerbt hat
-        //muss deshalb geloescht werden
-        Iterator<Set<UnifyPair>> notErasedIt = notErased.iterator();
-        if (notErasedIt.hasNext()) {
-          Set<UnifyPair> min = typeUnifyTask.oup.min(notErasedIt);
-          notErased.remove(min);
-          notErased.remove(((Constraint<UnifyPair>) min).getExtendConstraint());
-        }
-
-        List<Set<UnifyPair>> erased = new ArrayList<>(greaterSetasList);
-        erased.removeAll(notErased);
-        nextSetAsList.removeAll(erased);
-
-        context.logger().debug(() -> "Removed: " + erased);
-
-        context.logger().debug(() -> "Not Removed: " + nextSetAsList);
-
-      }
-    } else {
-      while (aParDefIt.hasNext()) {
-        //nextSetasListIt = nextSetasList.iterator(); Sollte eingefuegt werden PL 2020-04-28
-        Set<UnifyPair> a_new = aParDefIt.next();
-        List<Set<UnifyPair>> erased = typeUnifyTask.oup.greaterEqThan(a_new, nextSetAsList);
-
-        nextSetAsList.removeAll(erased);
-
-        context.logger().debug(() -> "Removed: " + erased);
-
-        context.logger().debug(() -> "Not Removed: " + nextSetAsList);
-      }
-    }
-
-    return false;
-  }
-
-}

src/main/java/de/dhbwstuttgart/typeinference/unify/cartesianproduct/InvarianceOrConstraintCase.java

@@ -1,132 +0,0 @@
-package de.dhbwstuttgart.typeinference.unify.cartesianproduct;
-
-import de.dhbwstuttgart.typeinference.constraints.Constraint;
-import de.dhbwstuttgart.typeinference.unify.TypeUnify2Task;
-import de.dhbwstuttgart.typeinference.unify.TypeUnifyTask;
-import de.dhbwstuttgart.typeinference.unify.UnifyContext;
-import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
-import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
-import de.dhbwstuttgart.util.Tuple;
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Optional;
-import java.util.Set;
-import java.util.concurrent.CompletableFuture;
-
-public class InvarianceOrConstraintCase extends VarianceCase {
-
-  // either for invariance or for oderConstraints
-  protected final int variance = 2;
-
-  protected InvarianceOrConstraintCase(boolean isOderConstraint, TypeUnifyTask typeUnifyTask, UnifyContext context) {
-    super(isOderConstraint, typeUnifyTask, context);
-  }
-
-  @Override
-  public void selectNextData(
-    TypeUnifyTask typeUnifyTask,
-    List<Set<UnifyPair>> nextSetAsList,
-    Optional<UnifyPair> optOrigPair
-
-  ) {
-    a = nextSetAsList.removeFirst();
-    //Fuer alle Elemente wird parallele Berechnung angestossen.
-    nextSetasListRest = new ArrayList<>(nextSetAsList);
-  }
-
-
-  @Override
-  public CompletableFuture<ComputationResults> computeParallel(
-    Set<Set<UnifyPair>> elems,
-    Set<UnifyPair> eq,
-    List<Set<Constraint<UnifyPair>>> oderConstraints,
-    IFiniteClosure fc,
-    int rekTiefe,
-    Set<UnifyPair> methodSignatureConstraint,
-    List<Set<UnifyPair>> nextSetAsList,
-    Set<UnifyPair> sameEqSet,
-    Set<Set<UnifyPair>> result,
-    Set<Set<UnifyPair>> aParDef
-  ) {
-    context.logger().debug("var2einstieg");
-    Set<TypeUnify2Task> forks = new HashSet<>();
-    Set<UnifyPair> newEqOrig = new HashSet<>(eq);
-    Set<Set<UnifyPair>> newElemsOrig = new HashSet<>(elems);
-    List<Set<Constraint<UnifyPair>>> newOderConstraintsOrig = new ArrayList<>(oderConstraints);
-    newElemsOrig.add(a);
-
-    /* FORK ANFANG */
-    TypeUnify2Task forkOrig = new TypeUnify2Task(newElemsOrig, newEqOrig, newOderConstraintsOrig, a, fc, context, rekTiefe, new HashSet<>(methodSignatureConstraint));
-    typeUnifyTask.addChildTask(forkOrig);
-    CompletableFuture<Set<Set<UnifyPair>>> forkOrigFuture = CompletableFuture.supplyAsync(forkOrig::compute, context.executor()).thenCompose(f -> f);
-    CompletableFuture<ComputationResults> resultValues = forkOrigFuture.thenApply((currentThreadResult) -> {
-      forkOrig.context.logger().debug("final Orig 2");
-      forkOrig.closeLogFile();
-      return new ComputationResults(currentThreadResult);
-    });
-
-    if (typeUnifyTask.isExecutionCancelled()) {
-      return resultValues;
-    }
-    /* FORK ENDE */
-
-    context.logger().debug(() -> "a in " + variance + " " + a);
-    context.logger().debug(() -> "nextSetasListRest: " + nextSetasListRest.toString());
-
-    //Fuer parallele Berechnung der Oder-Contraints wird methodSignature kopiert
-    //und jeweils die methodSignature von a bzw. nSaL wieder gelöscht, wenn es keine Lösung ist.
-    Set<UnifyPair> methodSignatureConstraintForParallel = new HashSet<>(methodSignatureConstraint);
-    Set<UnifyPair> nSaL = a;
-
-    while (!nextSetasListRest.isEmpty()) {
-      methodSignatureConstraintForParallel.removeAll(((Constraint<UnifyPair>) nSaL).getmethodSignatureConstraint());
-      nSaL = nextSetasListRest.removeFirst();
-      nextSetAsList.remove(nSaL); //PL einkommentiert 20-02-03
-      methodSignatureConstraintForParallel.addAll(((Constraint<UnifyPair>) nSaL).getmethodSignatureConstraint());
-      Set<UnifyPair> newEq = new HashSet<>(eq);
-      Set<Set<UnifyPair>> newElems = new HashSet<>(elems);
-      List<Set<Constraint<UnifyPair>>> newOderConstraints = new ArrayList<>(oderConstraints);
-      newElems.add(nSaL);
-      TypeUnify2Task fork = new TypeUnify2Task(newElems, newEq, newOderConstraints, nSaL, fc, context, rekTiefe, new HashSet<>(methodSignatureConstraintForParallel));
-      typeUnifyTask.addChildTask(fork);
-      CompletableFuture<Set<Set<UnifyPair>>> forkFuture = CompletableFuture.supplyAsync(fork::compute, context.executor()).thenCompose(f -> f);
-      resultValues = resultValues.thenCombine(forkFuture, (prevResults, fork_res) -> {
-        if (typeUnifyTask.isExecutionCancelled()) {
-          return prevResults;
-        }
-        prevResults.addForkResult(fork_res);
-        fork.context.logger().debug("final 2");
-        fork.closeLogFile();
-        return prevResults;
-      });
-
-      if (typeUnifyTask.isExecutionCancelled()) {
-        return resultValues;
-      }
-    }
-
-    return resultValues;
-  }
-
-  @Override
-  public void applyComputedResults(
-    Set<Set<UnifyPair>> result,
-    Set<Set<UnifyPair>> currentThreadResult,
-    Set<UnifyPair> compResult,
-    Set<UnifyPair> compRes
-  ) {
-    // Nothing
-  }
-
-  @Override
-  public boolean eraseInvalidSets(
-    int rekTiefe,
-    Set<Set<UnifyPair>> aParDef,
-    List<Set<UnifyPair>> nextSetAsList
-  ) {
-    // Nothing
-    return false;
-  }
-
-}

src/main/java/de/dhbwstuttgart/typeinference/unify/cartesianproduct/UnknownVarianceCase.java

@@ -1,241 +0,0 @@
-package de.dhbwstuttgart.typeinference.unify.cartesianproduct;
-
-import de.dhbwstuttgart.exceptions.UnifyCancelException;
-import de.dhbwstuttgart.typeinference.constraints.Constraint;
-import de.dhbwstuttgart.typeinference.unify.TypeUnify2Task;
-import de.dhbwstuttgart.typeinference.unify.TypeUnifyTask;
-import de.dhbwstuttgart.typeinference.unify.UnifyContext;
-import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
-import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
-import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
-import de.dhbwstuttgart.util.Tuple;
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Optional;
-import java.util.Set;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.stream.Collectors;
-
-public class UnknownVarianceCase extends VarianceCase {
-
-  protected final int variance = 0;
-
-  protected final AtomicBoolean shouldBreak = new AtomicBoolean(false);
-
-  protected UnknownVarianceCase(boolean isOderConstraint, TypeUnifyTask typeUnifyTask, UnifyContext context) {
-    super(isOderConstraint, typeUnifyTask, context);
-  }
-
-  @Override
-  public void selectNextData(
-    TypeUnifyTask typeUnifyTask,
-    List<Set<UnifyPair>> nextSetAsList,
-    Optional<UnifyPair> optOrigPair
-
-  ) {
-    //wenn a <. theta dann ist ein maximales Element sehr wahrscheinlich
-    //wenn theta <. a dann ist ein minimales Element sehr wahrscheinlich
-    if (!this.isOderConstraint && optOrigPair != null && optOrigPair.isPresent()) {
-      if (optOrigPair.get().getBasePair().getLhsType() instanceof PlaceholderType) {
-        a = typeUnifyTask.oup.max(nextSetAsList.iterator());
-      } else {
-        a = typeUnifyTask.oup.min(nextSetAsList.iterator());
-      }
-      nextSetAsList.remove(a);
-    } else if (this.isOderConstraint) {
-      a = typeUnifyTask.oup.max(nextSetAsList.iterator());
-      nextSetAsList.remove(a);
-      nextSetasListOderConstraints.add(((Constraint<UnifyPair>) a).getExtendConstraint());
-    } else {
-      a = nextSetAsList.removeFirst();
-    }
-
-    Set<UnifyPair> finalA = a;
-    if (!this.isOderConstraint && optOrigPair != null && optOrigPair.isPresent()) {
-      if (optOrigPair.get().getBasePair().getLhsType() instanceof PlaceholderType) {
-        nextSetasListRest = typeUnifyTask.oup.maxElements(
-          nextSetAsList.stream().filter(a_next -> typeUnifyTask.oup.compare(finalA, a_next) != 1).toList()
-        );
-      } else {
-        nextSetasListRest = typeUnifyTask.oup.minElements(
-          nextSetAsList.stream().filter(a_next -> typeUnifyTask.oup.compare(finalA, a_next) != -1).toList()
-        );
-      }
-    } else if (this.isOderConstraint) {
-      nextSetasListRest = typeUnifyTask.oup.maxElements(
-        nextSetAsList.stream().filter(a_next -> typeUnifyTask.oup.compare(finalA, a_next) != 1).toList()
-      );
-    } else {
-      nextSetasListRest = (nextSetAsList.size() > 5) ? nextSetAsList.subList(0, 5) : nextSetAsList;
-    }
-
-    nextSetAsList.removeAll(nextSetasListRest);
-    // */
-  }
-
-  @Override
-  public CompletableFuture<ComputationResults> computeParallel(
-    Set<Set<UnifyPair>> elems,
-    Set<UnifyPair> eq,
-    List<Set<Constraint<UnifyPair>>> oderConstraints,
-    IFiniteClosure fc,
-    int rekTiefe,
-    Set<UnifyPair> methodSignatureConstraint,
-    List<Set<UnifyPair>> nextSetAsList,
-    Set<UnifyPair> sameEqSet,
-    Set<Set<UnifyPair>> result,
-    Set<Set<UnifyPair>> aParDef
-  ) {
-    Set<UnifyPair> newEqOrig = new HashSet<>(eq);
-    Set<Set<UnifyPair>> newElemsOrig = new HashSet<>(elems);
-    List<Set<Constraint<UnifyPair>>> newOderConstraintsOrig = new ArrayList<>(oderConstraints);
-    newElemsOrig.add(a);
-    Set<UnifyPair> newMethodSignatureConstraintOrig = new HashSet<>(methodSignatureConstraint);
-    if (isOderConstraint) {
-      methodSignatureConstraint.addAll(((Constraint<UnifyPair>) a).getmethodSignatureConstraint());
-    }
-    TypeUnify2Task forkOrig = new TypeUnify2Task(newElemsOrig, newEqOrig, newOderConstraintsOrig, a, fc, context, rekTiefe, newMethodSignatureConstraintOrig);
-    typeUnifyTask.addChildTask(forkOrig);
-    CompletableFuture<Set<Set<UnifyPair>>> forkOrigFuture = CompletableFuture.supplyAsync(forkOrig::compute, context.executor()).thenCompose(f -> f);
-    CompletableFuture<ComputationResults> resultValues = forkOrigFuture.thenApply(
-      (currentThreadResult) -> {
-        forkOrig.context.logger().debug("final Orig 0");
-        forkOrig.closeLogFile();
-        return new ComputationResults(currentThreadResult);
-      });
-
-    int i = 0;
-    Set<Set<UnifyPair>>[] additionalResults = new HashSet[nextSetasListRest.size()];
-    Constraint<UnifyPair>[] extendConstraints = new Constraint[nextSetasListRest.size()];
-    while (!nextSetasListRest.isEmpty()) {
-      final int finalI = i++;
-
-      Set<UnifyPair> nSaL = nextSetasListRest.removeFirst();
-      context.logger().debug(() -> "0 RM" + nSaL.toString());
-
-      if (this.isOderConstraint) {
-        Constraint<UnifyPair> extendConstraint = ((Constraint<UnifyPair>) nSaL).getExtendConstraint();
-        extendConstraints[finalI] = extendConstraint;
-      }
-      else if (!sameEqSet.isEmpty() && !typeUnifyTask.checkNoContradiction(nSaL, sameEqSet, result)) {
-        TypeUnifyTask.noShortendElements++;
-        continue;
-      }
-
-      Set<UnifyPair> newEq = new HashSet<>(eq);
-      Set<Set<UnifyPair>> newElems = new HashSet<>(elems);
-      List<Set<Constraint<UnifyPair>>> newOderConstraints = new ArrayList<>(oderConstraints);
-      newElems.add(nSaL);
-      Set<UnifyPair> newMethodSignatureConstraint = new HashSet<>(methodSignatureConstraint);
-      if (isOderConstraint) {
-        methodSignatureConstraint.addAll(((Constraint<UnifyPair>) nSaL).getmethodSignatureConstraint());
-      }
-
-      TypeUnify2Task fork = new TypeUnify2Task(newElems, newEq, newOderConstraints, nSaL, fc, context, rekTiefe, newMethodSignatureConstraint);
-      typeUnifyTask.addChildTask(fork);
-      // schedule compute() on another thread
-      CompletableFuture<Set<Set<UnifyPair>>> forkFuture = CompletableFuture.supplyAsync(fork::compute, context.executor()).thenCompose(f -> f);
-      resultValues = resultValues.thenCombine(forkFuture, (compResult, forkResult) -> {
-        additionalResults[finalI] = forkResult;
-        context.logger().error("finalI: " + finalI);
-        return compResult;
-      });
-    }
-
-
-    int finalI1 = i;
-    return resultValues.thenCompose(compResult -> {
-      var oldResult = compResult.mainResult;
-
-      for (int e = 0; e < finalI1; e++) {
-        Set<Set<UnifyPair>> currentResult = additionalResults[e];
-
-        boolean oldResultInvalid = typeUnifyTask.isUndefinedPairSetSet(oldResult);
-        boolean currentResultInvalid = typeUnifyTask.isUndefinedPairSetSet(currentResult);
-
-        if (!oldResult.isEmpty() && !oldResultInvalid) {
-          boolean shouldBreak = this.eraseInvalidSets(rekTiefe, new HashSet<>(), nextSetAsList);
-          if (shouldBreak) {
-            return CompletableFuture.completedFuture(compResult);
-          }
-        }
-
-        if (this.isOderConstraint) {
-          nextSetasListOderConstraints.add(extendConstraints[e]);
-        }
-
-        if (!currentResultInvalid && oldResultInvalid) {
-          //wenn korrektes Ergebnis gefunden alle Fehlerfaelle loeschen
-          oldResult = currentResult;
-        } else if (oldResultInvalid == currentResultInvalid || oldResult.isEmpty()) {
-          //alle Fehlerfaelle und alle korrekten Ergebnis jeweils adden
-          Set<Set<UnifyPair>> finalOldResult = oldResult;
-          context.logger().debug(() -> "RES var1 ADD:" + finalOldResult.toString() + " " + currentResult.toString());
-          oldResult.addAll(currentResult);
-        }
-      }
-
-      compResult.mainResult = oldResult;
-      return CompletableFuture.completedFuture(compResult);
-    });
-  }
-
-  @Override
-  public void applyComputedResults(
-    Set<Set<UnifyPair>> result,
-    Set<Set<UnifyPair>> currentThreadResult,
-    Set<UnifyPair> compResult,
-    Set<UnifyPair> compRes
-  ) {
-    context.logger().debug("RES var=0 ADD:" + result.toString() + " " + currentThreadResult.toString());
-    result.addAll(currentThreadResult);
-  }
-
-  @Override
-  public boolean eraseInvalidSets(
-    int rekTiefe,
-    Set<Set<UnifyPair>> aParDef,
-    List<Set<UnifyPair>> nextSetAsList
-  ) {
-    if (!this.isOderConstraint) {
-      return true;
-    } else {
-      nextSetAsList.removeAll(nextSetasListOderConstraints);
-      nextSetasListOderConstraints = new ArrayList<>();
-      context.logger().debug("Removed: " + nextSetasListOderConstraints);
-      List<Set<UnifyPair>> smallerSetasList = typeUnifyTask.oup.smallerThan(a, nextSetAsList);
-      List<Set<UnifyPair>> notInherited = smallerSetasList.stream()
-        .filter(x -> !((Constraint<UnifyPair>) x).isInherited())
-        .collect(Collectors.toCollection(ArrayList::new));
-      List<Set<UnifyPair>> notErased = new ArrayList<>();
-      notInherited.forEach(x -> notErased.addAll(typeUnifyTask.oup.smallerEqThan(x, smallerSetasList)));
-      List<Set<UnifyPair>> erased = new ArrayList<>(smallerSetasList);
-      erased.removeAll(notErased);
-      nextSetAsList.removeAll(erased);
-
-      context.logger().debug("Removed: " + erased);
-      context.logger().debug("Not Removed: " + nextSetAsList);
-
-      for (Set<UnifyPair> aPar : aParDef) {
-        smallerSetasList.clear();
-        smallerSetasList.addAll(typeUnifyTask.oup.smallerThan(aPar, nextSetAsList));
-        notInherited = smallerSetasList.stream()
-          .filter(x -> !((Constraint<UnifyPair>) x).isInherited())
-          .collect(Collectors.toCollection(ArrayList::new));
-        notErased.clear();
-        notInherited.forEach(x -> notErased.addAll(typeUnifyTask.oup.smallerEqThan(x, smallerSetasList)));
-        erased = new ArrayList<>(smallerSetasList);
-        erased.removeAll(notErased);
-        nextSetAsList.removeAll(erased);
-        context.logger().debug("Removed: " + erased);
-        context.logger().debug("Not Removed: " + nextSetAsList);
-      }
-
-    }
-
-    return false;
-  }
-
-}

src/main/java/de/dhbwstuttgart/typeinference/unify/cartesianproduct/VarianceCase.java

@@ -1,132 +0,0 @@
-package de.dhbwstuttgart.typeinference.unify.cartesianproduct;
-
-import de.dhbwstuttgart.typeinference.constraints.Constraint;
-import de.dhbwstuttgart.typeinference.unify.TypeUnifyTask;
-import de.dhbwstuttgart.typeinference.unify.UnifyContext;
-import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
-import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
-import de.dhbwstuttgart.util.Tuple;
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Optional;
-import java.util.Set;
-import java.util.concurrent.CompletableFuture;
-
-public abstract class VarianceCase {
-
-  public static VarianceCase createFromVariance(int variance, boolean isOderConstraint, TypeUnifyTask typeUnifyTask, UnifyContext context) {
-    return switch (variance) {
-      case 0    -> new UnknownVarianceCase(isOderConstraint, typeUnifyTask, context);
-      case 1    -> new ContravarianceCase(isOderConstraint, typeUnifyTask, context);
-      case -1   -> new CovarianceCase(isOderConstraint, typeUnifyTask, context);
-      case 2    -> new InvarianceOrConstraintCase(isOderConstraint, typeUnifyTask, context);
-      default   -> throw new RuntimeException("Invalid variance: " + variance);
-    };
-  }
-
-  protected final boolean isOderConstraint;
-  protected final TypeUnifyTask typeUnifyTask;
-  protected final UnifyContext context;
-
-  /**
-   * Aktueller Fall
-   */
-  public Set<UnifyPair> a;
-
-  /**
-   * Liste der Faelle für die parallele Verarbeitung
-   * Enthaelt Elemente, die nicht in Relation zu aktuellem Fall in der
-   * Variablen a stehen. Diese muesse auf alle Faelle bearbeitet werden,
-   * Deshalb wird ihre Berechnung parallel angestossen.
-   */
-  public List<Set<UnifyPair>> nextSetasListRest = new ArrayList<>();
-
-  /**
-   * Liste der Faelle, bei dem Receiver jeweils "? extends" enthaelt bzw. nicht enthaelt
-   * In der Regel ist dies genau ein Element
-   * Dieses Element wird später aus nextSetasList geloescht, wenn das jeweils andere Element zum Erfolg
-   * gefuehrt hat.
-   */
-  public List<Set<UnifyPair>> nextSetasListOderConstraints = new ArrayList<>();
-
-
-  protected VarianceCase(boolean isOderConstraint, TypeUnifyTask typeUnifyTask, UnifyContext context) {
-    this.isOderConstraint = isOderConstraint;
-    this.typeUnifyTask = typeUnifyTask;
-    this.context = context;
-  }
-
-  /**
-   *  Selects values for the next iteration in the run method:
-   *  - a : The element to ???
-   *  - nextSetAsList: The list of cases that have no relation to the selected a and will have to be worked on
-   *  - nextSetasListOderConstraints: The list of cases of which the receiver contains "? extends", typically one element
-   */
-  public abstract void selectNextData(
-    TypeUnifyTask typeUnifyTask,
-    List<Set<UnifyPair>> nextSetAsList,
-    Optional<UnifyPair> optOrigPair
-  );
-
-  /**
-   *
-   */
-  public abstract CompletableFuture<ComputationResults> computeParallel(
-    Set<Set<UnifyPair>> elems,
-    Set<UnifyPair> eq,
-    List<Set<Constraint<UnifyPair>>> oderConstraints,
-    IFiniteClosure fc,
-    int rekTiefe,
-    Set<UnifyPair> methodSignatureConstraint,
-    List<Set<UnifyPair>> nextSetAsList,
-    Set<UnifyPair> sameEqSet,
-    Set<Set<UnifyPair>> result,
-    Set<Set<UnifyPair>> aParDef
-  );
-
-  /**
-   *
-   */
-  public abstract void applyComputedResults(
-    Set<Set<UnifyPair>> result,
-    Set<Set<UnifyPair>> currentThreadResult,
-    Set<UnifyPair> compResult,
-    Set<UnifyPair> compRes
-  );
-
-  /**
-   *
-   * @return If the current iteration should be broken out of
-   */
-  public abstract boolean eraseInvalidSets(
-    int rekTiefe,
-    Set<Set<UnifyPair>> aParDef,
-    List<Set<UnifyPair>> nextSetAsList
-  );
-
-  /**
-   * Wrapper class for the parallel computation results
-   */
-  public static class ComputationResults {
-    public Set<Set<UnifyPair>> mainResult;
-    public Set<Set<Set<UnifyPair>>> forkResults;
-
-    public ComputationResults() {
-      this(new HashSet<>(), new HashSet<>());
-    }
-
-    public ComputationResults(Set<Set<UnifyPair>> mainResult) {
-      this(mainResult, new HashSet<>());
-    }
-
-    public ComputationResults(Set<Set<UnifyPair>> mainResult, Set<Set<Set<UnifyPair>>> forkResults) {
-      this.mainResult = mainResult;
-      this.forkResults = forkResults;
-    }
-
-    void addForkResult(Set<Set<UnifyPair>> forkResult) {
-      forkResults.add(forkResult);
-    }
-  }
-}

src/main/java/de/dhbwstuttgart/typeinference/unify/distributeVariance.java

@@ -12,12 +12,15 @@ import de.dhbwstuttgart.typeinference.unify.model.UnifyType;
 
 public class distributeVariance extends visitUnifyTypeVisitor<Integer> {
 	
-	public static int inverseVariance(int variance) {
+	public static int inverseVariance(int variance) { 
-		return switch (variance) {
+		Integer ret = 0;
-			case 1 -> -1;
+		if (variance == 1) {
-			case -1 -> 1;
+		   ret = -1;
-			default -> 0;
+		}
-		};
+		if (variance == -1) {
+			ret = 1;
+		}
+		return ret;
 	}
 
 
@@ -39,7 +42,7 @@ public class distributeVariance extends visitUnifyTypeVisitor<Integer> {
 		List<UnifyType> param = new ArrayList<>(funnty.getTypeParams().get().length);
 		param.addAll(Arrays.asList(funnty.getTypeParams().get()));
 		UnifyType resultType = param.remove(param.size()-1);
-		int htInverse = inverseVariance(ht);
+		Integer htInverse = inverseVariance(ht);
 		param = param.stream()
 				     .map(x -> x.accept(this, htInverse))
 				     .collect(Collectors.toCollection(ArrayList::new));

src/main/java/de/dhbwstuttgart/typeinference/unify/interfaces/IFiniteClosure.java

@@ -1,7 +1,6 @@
 package de.dhbwstuttgart.typeinference.unify.interfaces;
 
-import de.dhbwstuttgart.server.packet.dataContainers.ISerializableData;
+import java.util.List;
-import de.dhbwstuttgart.typeinference.unify.UnifyContext;
 import java.util.Optional;
 import java.util.Set;
 
@@ -19,8 +18,9 @@ import org.antlr.v4.runtime.Token;
  * 
  * @author Florian Steurer
  */
-public interface IFiniteClosure extends ISerializableData {
+public interface IFiniteClosure {
 	
+	public void setLogTrue();
 	/**
 	 * Returns all types of the finite closure that are subtypes of the argument.
 	 * @return The set of subtypes of the argument.
@@ -74,5 +74,5 @@ public interface IFiniteClosure extends ISerializableData {
 	public Set<UnifyType> getChildren(UnifyType t);
 	public Set<UnifyType> getAllTypesByName(String typeName);
 
-	public int compare(UnifyType rhsType, UnifyType rhsType2, PairOperator pairop, UnifyContext context);
+	public int compare(UnifyType rhsType, UnifyType rhsType2, PairOperator pairop);
 }

src/main/java/de/dhbwstuttgart/typeinference/unify/model/ExtendsType.java

@@ -1,9 +1,8 @@
 package de.dhbwstuttgart.typeinference.unify.model;
 
-import de.dhbwstuttgart.server.packet.dataContainers.ISerializableData;
+import java.util.ArrayList;
-import de.dhbwstuttgart.server.packet.dataContainers.KeyStorage;
+import java.util.Collection;
-import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialMap;
+import java.util.HashMap;
-import de.dhbwstuttgart.typeinference.unify.UnifyContext;
 import java.util.Set;
 
 import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
@@ -12,7 +11,7 @@ import de.dhbwstuttgart.typeinference.unify.interfaces.UnifyTypeVisitor;
 /**
  * An extends wildcard type "? extends T". 
  */
-public final class ExtendsType extends WildcardType implements ISerializableData  {
+public final class ExtendsType extends WildcardType {
 	
 	public <T> UnifyType accept(UnifyTypeVisitor<T> visitor, T ht) {
 		return visitor.visit(this, ht);
@@ -24,6 +23,9 @@ public final class ExtendsType extends WildcardType implements ISerializableData
 	 */
 	public ExtendsType(UnifyType extendedType) {
 		super("? extends " + extendedType.getName(), extendedType);
+		if (extendedType instanceof ExtendsType) {
+			System.out.print("");
+		}
 	}
 
 	/**
@@ -90,21 +92,5 @@ public final class ExtendsType extends WildcardType implements ISerializableData
 		return "? extends " + wildcardedType;
 	}
 
-	@Override
-	public SerialMap toSerial(KeyStorage keyStorage) {
-		SerialMap serialized = new SerialMap();
-		serialized.put("wildcardedType", this.wildcardedType.toSerial(keyStorage));
-
-		// create the wrapper and put this as the object
-		var serializedWrapper = super.toSerial(keyStorage).assertType(SerialMap.class);
-		serializedWrapper.put("object", serialized);
-		return serializedWrapper;
-	}
-
-	public static ExtendsType fromSerial(SerialMap data, UnifyContext context) {
-		return new ExtendsType(
-			UnifyType.fromSerial(data.getMap("wildcardedType"), context)
-		);
-	}
 	
 }

src/main/java/de/dhbwstuttgart/typeinference/unify/model/FunInterfaceType.java

@@ -1,17 +1,14 @@
 package de.dhbwstuttgart.typeinference.unify.model;
 
-import de.dhbwstuttgart.server.packet.dataContainers.ISerializableData;
+import de.dhbwstuttgart.parser.scope.JavaClassName;
-import de.dhbwstuttgart.server.packet.dataContainers.KeyStorage;
+import de.dhbwstuttgart.syntaxtree.factory.UnifyTypeFactory;
-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.unify.UnifyContext;
+import java.lang.reflect.Modifier;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
-public class FunInterfaceType extends ReferenceType implements ISerializableData {
+public class FunInterfaceType extends ReferenceType  {
     final List<UnifyType> intfArgTypes;
     final UnifyType intfReturnType;
     final List<String> generics;
@@ -49,29 +46,4 @@ public class FunInterfaceType extends ReferenceType implements ISerializableData
 
         return args;
     }
-
-    @Override
-    public SerialMap toSerial(KeyStorage keyStorage) {
-        var serializedWrapper = super.toSerial(keyStorage);
-        SerialMap serialized = serializedWrapper.getMap("object");
-
-        serialized.put("intfArgTypes", SerialList.fromMapped(intfArgTypes, u -> u.toSerial(keyStorage)));
-        serialized.put("intfReturnType", intfReturnType.toSerial(keyStorage));
-        serialized.put("generics", SerialList.fromMapped(generics, SerialValue::new));
-
-        return serializedWrapper;
-    }
-
-    public static FunInterfaceType fromSerial(SerialMap data, UnifyContext context) {
-        var name = data.getValue("name").getOf(String.class);
-        var params = data.getList("params").assertListOfMaps().stream().map(
-          paramData -> UnifyType.fromSerial(paramData, context)).toList();
-        var intfArgTypes = data.getList("intfArgTypes").assertListOfMaps().stream().map(
-          argTypeData -> UnifyType.fromSerial(argTypeData, context)).toList();
-        var intfReturnType = UnifyType.fromSerial(data.getMap("intfReturnType"), context);
-        var generics = data.getList("generics").assertListOfValues().stream().map(
-          generic -> generic.getOf(String.class)).toList();
-
-        return new FunInterfaceType(name, new TypeParams(params), intfArgTypes, intfReturnType, generics);
-    }
 }

src/main/java/de/dhbwstuttgart/typeinference/unify/model/FunNType.java

@@ -1,13 +1,8 @@
 package de.dhbwstuttgart.typeinference.unify.model;
 
-import de.dhbwstuttgart.server.packet.dataContainers.ISerializableData;
-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.typeinference.unify.UnifyContext;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.List;
+import java.util.HashMap;
 import java.util.Set;
 
 import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
@@ -17,7 +12,7 @@ import de.dhbwstuttgart.typeinference.unify.interfaces.UnifyTypeVisitor;
  * A real function type in java.
  * @author Florian Steurer
  */
-public class FunNType extends UnifyType implements ISerializableData {
+public class FunNType extends UnifyType {
 
 	public <T> UnifyType accept(UnifyTypeVisitor<T> visitor, T ht) {
 		return visitor.visit(this, ht);
@@ -81,7 +76,7 @@ public class FunNType extends UnifyType implements ISerializableData {
 	}
 
 	@Override
-	public boolean wrongWildcard() {
+	public Boolean wrongWildcard() {
 		return (new ArrayList<UnifyType>(Arrays.asList(getTypeParams()
 				.get())).stream().filter(x -> (x instanceof WildcardType)).findFirst().isPresent());
 	}
@@ -104,22 +99,5 @@ public class FunNType extends UnifyType implements ISerializableData {
 
 		return other.getTypeParams().equals(typeParams);
 	}
-
+	
-	@Override
-	public SerialMap toSerial(KeyStorage keyStorage) {
-		SerialMap serialized = new SerialMap();
-		serialized.put("params", SerialList.fromMapped(this.typeParams.get(), param -> param.toSerial(keyStorage)));
-
-		// create the wrapper and put this as the object
-		var serializedWrapper = super.toSerial(keyStorage);
-		serializedWrapper.put("object", serialized);
-		return serializedWrapper;
-	}
-
-	public static FunNType fromSerial(SerialMap data, UnifyContext context) {
-		List<UnifyType> params = data.getList("params").assertListOfMaps().stream().map(
-			paramData -> UnifyType.fromSerial(paramData, context)).toList();
-		return new FunNType(new TypeParams(params));
-	}
-
 }

src/main/java/de/dhbwstuttgart/typeinference/unify/model/Node.java

@@ -53,7 +53,7 @@ class Node<T> {
 			addDescendant(descendant);
 		}
 	}
-	
+
 	/**
 	 * Adds a directed edge from the predecessor to this node (predecessor -> this)
 	 */
@@ -73,7 +73,7 @@ class Node<T> {
 			addPredecessor(predecessor);
 		}
 	}
-	
+
 	/**
 	 * The content of this node.
 	 */