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

modified:   src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java
	modified:   src/main/java/de/dhbwstuttgart/typeinference/unify/UnifyResultListenerImpl.java
Asynchrone Variante soweit ok

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

@@ -275,7 +275,138 @@ public class JavaTXCompiler {
 	*/
     
     public UnifyResultModel typeInferenceAsync() throws ClassNotFoundException {
-    	return new UnifyResultModel();
+    	List<ClassOrInterface> allClasses = new ArrayList<>();//environment.getAllAvailableClasses();
+        //Alle Importierten Klassen in allen geparsten Sourcefiles kommen ins FC
+        for(SourceFile sf : this.sourceFiles.values()) {
+            allClasses.addAll(getAvailableClasses(sf));
+            allClasses.addAll(sf.getClasses());
+        }
+
+        final ConstraintSet<Pair> cons = getConstraints();
+        Set<Set<UnifyPair>> results = new HashSet<>();
+        UnifyResultModel urm = new UnifyResultModel();
+        try {
+			FileWriter logFile = new FileWriter(new File(System.getProperty("user.dir")+"/src/test/java/logFiles/"+"log_"+sourceFiles.keySet().iterator().next().getName()));
+			
+			IFiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses,logFile);
+			System.out.println(finiteClosure);
+			ConstraintSet<UnifyPair> unifyCons = UnifyTypeFactory.convert(cons);
+			
+			Function<UnifyPair, UnifyPair> distributeInnerVars = 
+					x -> { 
+						UnifyType lhs, rhs;
+						if (((lhs = x.getLhsType()) instanceof PlaceholderType) 
+						   && ((rhs = x.getRhsType()) instanceof PlaceholderType)
+						   && (((PlaceholderType)lhs).isInnerType()
+						      ||  ((PlaceholderType)rhs).isInnerType()))
+						{
+							((PlaceholderType)lhs).setInnerType(true);
+							((PlaceholderType)rhs).setInnerType(true);
+						}
+						return x;
+					
+					};
+		    logFile.write(unifyCons.toString());
+			unifyCons = unifyCons.map(distributeInnerVars);	
+			logFile.write(unifyCons.toString());
+			TypeUnify unify = new TypeUnify();
+			//Set<Set<UnifyPair>> results = new HashSet<>(); Nach vorne gezogen
+			logFile.write("FC:\\" + finiteClosure.toString()+"\n");
+			for(SourceFile sf : this.sourceFiles.values()) {
+				logFile.write(ASTTypePrinter.print(sf));
+			}
+			logFile.flush();
+				
+			Set<String> methodParaTypeVarNames = allClasses.stream().map(x -> x.getMethods().stream().map(y -> y.getParameterList().getFormalparalist()
+					.stream().filter(z -> z.getType() instanceof TypePlaceholder)
+					.map(z -> ((TypePlaceholder)z.getType()).getName()).collect(Collectors.toCollection(HashSet::new)))
+					.reduce(new HashSet<String>(), (a,b) -> { a.addAll(b); return a;}, (a,b) -> { a.addAll(b); return a;} )  )
+					.reduce(new HashSet<String>(), (a,b) -> { a.addAll(b); return a;} );
+			
+			Set<String> constructorParaTypeVarNames = allClasses.stream().map(x -> x.getConstructors().stream().map(y -> y.getParameterList().getFormalparalist()
+					.stream().filter(z -> z.getType() instanceof TypePlaceholder)
+					.map(z -> ((TypePlaceholder)z.getType()).getName()).collect(Collectors.toCollection(HashSet::new)))
+					.reduce(new HashSet<String>(), (a,b) -> { a.addAll(b); return a;}, (a,b) -> { a.addAll(b); return a;} )  )
+					.reduce(new HashSet<String>(), (a,b) -> { a.addAll(b); return a;} );
+			
+			Set<String> paraTypeVarNames = methodParaTypeVarNames;
+			paraTypeVarNames.addAll(constructorParaTypeVarNames);
+
+				
+			Set<String> returnTypeVarNames = allClasses.stream().map(x -> x.getMethods().stream().filter(y -> y.getReturnType() instanceof TypePlaceholder)
+						.map(z -> ((TypePlaceholder)z.getReturnType()).getName()).collect(Collectors.toCollection(HashSet::new))).reduce((a,b) -> { a.addAll(b); return a;} ).get();
+				
+			Set<String> fieldTypeVarNames = allClasses.stream().map(x -> x.getFieldDecl().stream().filter(y -> y.getReturnType() instanceof TypePlaceholder)
+						.map(z -> ((TypePlaceholder)z.getReturnType()).getName()).collect(Collectors.toCollection(HashSet::new))).reduce((a,b) -> { a.addAll(b); return a;} ).get();
+
+			returnTypeVarNames.addAll(fieldTypeVarNames);
+				
+			unifyCons = unifyCons.map(x -> { 
+				//Hier muss ueberlegt werden, ob
+				//1. alle Argument- und Retuntyp-Variablen in allen UnifyPairs 
+				//   mit disableWildcardtable() werden.
+				//2. alle Typvariablen mit Argument- oder Retuntyp-Variablen 
+				//in Beziehung auch auf disableWildcardtable() gesetzt werden muessen
+				//PL 2018-04-23
+				if ((x.getLhsType() instanceof PlaceholderType)) {
+					if (paraTypeVarNames.contains(x.getLhsType().getName())) { 
+						((PlaceholderType)x.getLhsType()).setVariance((byte)1);
+						((PlaceholderType)x.getLhsType()).disableWildcardtable();
+					}
+					if (returnTypeVarNames.contains(x.getLhsType().getName())) {
+						((PlaceholderType)x.getLhsType()).setVariance((byte)-1);
+						((PlaceholderType)x.getLhsType()).disableWildcardtable();
+					}
+				}
+				if ((x.getRhsType() instanceof PlaceholderType)) {
+					if (paraTypeVarNames.contains(x.getRhsType().getName())) {
+						((PlaceholderType)x.getRhsType()).setVariance((byte)1);
+						((PlaceholderType)x.getRhsType()).disableWildcardtable();
+					}
+					if (returnTypeVarNames.contains(x.getRhsType().getName())) {
+						((PlaceholderType)x.getRhsType()).setVariance((byte)-1);
+						((PlaceholderType)x.getRhsType()).disableWildcardtable();
+					}	
+				}
+				return x;//HIER DIE JEWEILS RECHT BZW. LINKE SEITE AUF GLEICHE VARIANZ SETZEN WIE DIE JEWEILS ANDERE SEITE 
+			});
+			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<Set<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, cons, urm);
+        }
+    	catch (IOException e) { 
+        	System.err.println("kein LogFile");
+        }
+        return urm;	
     }
     
     

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

@@ -1878,13 +1878,13 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 				allGen = false;
 				break;
 			}
-		if (thetaPrime.getName().equals("java.util.Vector") //Fuer Bug 127
+		//if (thetaPrime.getName().equals("java.util.Vector") //Fuer Bug 127
-				&& thetaPrime instanceof ReferenceType 
+		//		&& thetaPrime instanceof ReferenceType 
-				&& ((ReferenceType)thetaPrime).getTypeParams().iterator().next().getName().equals("java.util.Vector"))
+		//		&& ((ReferenceType)thetaPrime).getTypeParams().iterator().next() instanceof PlaceholderType) //.getName().equals("java.util.Vector"))
 		//		&& ((ReferenceType)((ReferenceType)thetaPrime).getTypeParams().iterator().next()).getTypeParams().iterator().next().getName().equals("java.lang.Integer")) {
-				{
+		//		{
-				System.out.println("");
+		//		System.out.println("");
-		}
+		//}
 		Set<UnifyType> cs = fc.getAllTypesByName(thetaPrime.getName());//cs= [java.util.Vector<NP>, java.util.Vector<java.util.Vector<java.lang.Integer>>, ????java.util.Vector<gen_hv>???]
 		
 		
@@ -1979,7 +1979,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 						if(allGen) {
 							UnifyPair up = new UnifyPair(a, theta, PairOperator.EQUALSDOT, pair.getSubstitution(), pair);
 							Iterator<UnifyType> upit = up.getRhsType().getTypeParams().iterator();
-							//TODO PL 2019-01-24: upit.next() ist nicht unbedingt ein PlaceholderType -> Visitor
+							//TODO PL 2019-01-24: upit.next() ist nicht unbedingt ein PlaceholderType -> Visitor erledigt
 							while (upit.hasNext()) upit.next().accept(new distributeVariance(), a.getVariance());//((PlaceholderType)upit.next()).setVariance(a.getVariance());
 							resultPrime.add(up);
 						}
@@ -1987,7 +1987,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 							UnifyPair up = new UnifyPair(a, theta.setTypeParams(new TypeParams(freshTphs.toArray(new UnifyType[0]))), PairOperator.EQUALSDOT, pair.getSubstitution(), pair);
 							Iterator<UnifyType> upit = up.getRhsType().getTypeParams().iterator();
 							distributeVariance dv = new distributeVariance();
-							//TODO PL 2019-01-24: upit.next() ist nicht unbedingt ein PlaceholderType -> Visitor
+							//TODO PL 2019-01-24: upit.next() ist nicht unbedingt ein PlaceholderType -> Visitor erledigt
 							while (upit.hasNext()) upit.next().accept(new distributeVariance(), a.getVariance()); //((PlaceholderType)upit.next()).setVariance(a.getVariance());
 							resultPrime.add(up);
 						}

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

@@ -10,7 +10,7 @@ public class UnifyResultListenerImpl implements UnifyResultListener {
 
 	List<ResultSet> results = new ArrayList<>();
 	
-	public void onNewTypeResultFound(UnifyResultEvent evt) {
+	public synchronized void onNewTypeResultFound(UnifyResultEvent evt) {
 		results.addAll(evt.getNewTypeResult());
 	}