Filtern von Constraints vor dem Karthesischen Produkt bilden

src/de/dhbwstuttgart/syntaxtree/SourceFile.java

@@ -4,11 +4,14 @@ package de.dhbwstuttgart.syntaxtree;
 
 // ino.module.SourceFile.8722.import 
 import java.io.IOException;
+import java.lang.reflect.Array;
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Enumeration;
 import java.util.HashMap;
 import java.util.Hashtable;
 import java.util.Iterator;
+import java.util.List;
 import java.util.Set;
 import java.util.function.Function;
 
@@ -49,7 +52,9 @@ import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
 import de.dhbwstuttgart.typeinference.exceptions.DebugException;
 import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
 import de.dhbwstuttgart.typeinference.unify.TypeUnify;
+import de.dhbwstuttgart.typeinference.unify.Unifikationsalgorithmus;
 import de.dhbwstuttgart.typeinference.unify.model.FiniteClosure;
+import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 
 
@@ -195,7 +200,122 @@ public class SourceFile
             InterfaceVektor.addElement((Interface) e);
         }
     }
-    
+        
+    /**
+     * PL 2014-10-25
+     * schnitt1 checkt ob die Typeplaceholders aus in den Elemeneten aus vars enthalten sind
+     * Rückgabe ist die Menge der Indizies von vars der Schnittmengen mit var nicht leer sind.
+     * @param var
+     * @param vars
+     * @param indexe
+     * @return
+     */
+    static Menge<Integer> schnitt1 (Menge<PlaceholderType> var, Menge<Menge<PlaceholderType>> vars, Menge<Integer> indexe) {
+        int j = -1;
+        for (Menge<PlaceholderType> varelems : vars) {
+                j++;
+                if (varelems != null) {
+                        if (var.stream().map(x -> varelems.contains(x)).reduce(false, (a,b) -> (a || b))
+                                        && (!indexe.contains(j)))
+                        {
+                                Menge<PlaceholderType> rekvarelements = vars.elementAt(j);
+                                vars.setElementAt(null, j);//Element erledigt muss nicht nochmals bearbeitet werden.
+                                indexe.addElement(j);
+                                indexe = schnitt1(rekvarelements, vars, indexe);
+                        }
+                }
+        }
+        return indexe;
+    }
+
+    /**
+     * Bildet Schnittmengen der Mengen von Typeplaceholders
+     * Rueckgabe ist die Menge der Menge von Indizies die Schnittmengen sind.
+     * @param vars
+     * @return
+     */
+    public static Menge<Menge<Integer>> schnitt (Menge<Menge<PlaceholderType>> vars) {
+        Menge<Menge<Integer>> ret = new Menge<>();
+        int i = -1;
+        for (Menge<PlaceholderType> var : vars) {
+                i++;
+                if (var != null) {//Element wurde noch bearbeitet
+                        Menge<Integer> indexe = new Menge<>();
+                        indexe.add(i);
+                        ret.add(schnitt1(var, vars, indexe));
+                }
+        }
+        return ret;
+    }
+
+    public static Set<Set<UnifyPair>> cartesianProduct(List<UnifyPair> constraints, FiniteClosure finiteClosure){
+    	//IDEE: Man bildet Zusammenhangskomponenten von Paaren, die gemeinsame Variablen haben
+        //      und unifizert nur die Zusammenhangskomponenten in Schritten 1 - 5
+        //Schritt 1: Alle Variablen in den Paaren von Elementen einsammeln
+        Menge<Menge<PlaceholderType>> constraintsclonevars = constraints.stream().map(p -> {Menge<PlaceholderType> TPHs = new Menge<>(); 
+          TPHs.addAll(p.getInvolvedPlaceholderTypes());
+          TPHs.addAll(p.getInvolvedPlaceholderTypes());
+          return TPHs;}
+          ).collect(Menge::new, Menge::add, Menge::addAll);    	
+
+        
+        //Schritt 2: Schnittmengen jedes Elements mit jedem Elememt von vars bilden und dann index zusammenfassen
+        //in indexset sind dann die Mengen von Indizes enthalten, die gemeisam unifiziert wreden müssen
+      	Menge<Menge<Integer>> indexeset = new Menge<>();
+      	if (constraintsclonevars != null && constraintsclonevars.size()>0) { 
+      		indexeset = SourceFile.schnitt(constraintsclonevars);
+      	}
+      	
+      	//Schritt 3: Umwandlung der Indizes in die zugehoerigen Elemente
+      	//           In streamconstraintsclone sind die Mengen von Paar enthalten die unifiziert werden muessen
+      	Stream<Menge<UnifyPair>> streamconstraintsclone = indexeset.stream().<Menge<UnifyPair>>map(x -> x.stream()
+      			                                                           .<UnifyPair>map(i -> constraints.get(i))
+      			                                                               .<Menge<UnifyPair>>collect(Menge::new, Menge::add, Menge::addAll));
+     	//Menge<Menge<Pair>> vecconstraintsclone = streamconstraintsclone.collect(Menge::new, Menge::add, Menge::addAll);
+          //System.out.println();
+      	//Schritt 4: Unifikation  
+      	Menge<Set<Set<UnifyPair>>> vecunifyResult =
+      			//streamconstraintsclone.map(x -> Unify.unify(x, finiteClosure)).collect(Menge::new, Menge::add, Menge::addAll);
+      			//DEBUG-Variante
+      			streamconstraintsclone.map(x -> 
+      			  	{ 	Set<Set<UnifyPair>> z = new TypeUnify().unify(x, finiteClosure);
+      					return z;
+      			  	}
+      					).collect(Menge::new, Menge::add, Menge::addAll);
+      			  	
+      	
+      	//card gibt die Cardinalitaet der unifizierten Mengen an
+      	Menge<Integer> card = vecunifyResult.stream().map(x -> x.size()).collect(Menge::new, Menge::add, Menge::addAll);
+      			;//.reduce(1,(a,b) -> { if ((a > 0) && (b > 0)) return (a * b); else return 1; });
+      			
+          //Schritt 5: Bildung des cartesischen Produkts
+          //sollte wieder entfernt werden: Weiterarbeit mit: 
+      	//[[x_1 -> t_1, x_2 -> t2], [x_1 -> t'_1, x_2 -> t'_2]] x ... x [[x_n -> t_1n], [x_n -> t2n], [x_n -> t3n]] 
+      	Set<Set<UnifyPair>> cardprodret_start = new Menge<>();
+      	cardprodret_start.add(new Menge<UnifyPair>());
+      	
+      	//cart. Produkt mit Linkverschiebung
+      	Set<Set<UnifyPair>> unifyResult = vecunifyResult.stream().reduce(cardprodret_start, (x, y) -> {
+      		Set<Set<UnifyPair>> cardprodret= new Menge<>();
+      		if (y.size() > 0) {
+      			//System.out.println(y);
+      			//Menge<Menge<Pair>> cardprodretold = x;
+					//cardprodret = new Menge<>();
+					for(Set<UnifyPair> xElement : x) {
+						for (Set<UnifyPair> yElement : y){
+							Set<UnifyPair> help = new Menge<>(); 
+							help.addAll(yElement);
+							help.addAll(xElement);
+							cardprodret.add(help);
+						}
+					}
+      		}
+      		else 
+      			return new Menge<>(); //kein unifiziertes Ergebnis, damit wird das Geseamtergebnis []
+      		return cardprodret;
+      	});
+      	return unifyResult;
+    }
     
     /////////////////////////////////////////////////////////////////////////
     // TypeReconstructionAlgorithmus
@@ -256,13 +376,11 @@ public class SourceFile
         UnifyConstraintsSet unifyConstraints = UnifyTypeFactory.convert(oderConstraints);
         
         //Unmögliche ConstraintsSets aussortieren durch Unifizierung
-        Function<Menge<UnifyPair>,Menge<Menge<UnifyPair>>> unifier = (pairs)->{
+        Unifikationsalgorithmus unifier = (pairs)->new TypeUnify().unify(pairs, finiteClosure);
-        	Menge<Menge<UnifyPair>> retValue = new Menge<>();
-        	Set<Set<UnifyPair>> unifiedPairs = new TypeUnify().unify(pairs, finiteClosure);
-        	return retValue;};
-        //oderConstraints.filterWrongConstraints(unifier);
         	
-        //oderConstraints.unifyUndConstraints(unifier); //rausgeworfen für Tests (08.12.2015)
+        unifyConstraints.filterWrongConstraints(unifier);
+        	
+        unifyConstraints.unifyUndConstraints(unifier); //rausgeworfen für Tests (08.12.2015)
 
     	typinferenzLog.debug("Übriggebliebene Konstraints:\n"+oderConstraints+"\n", Section.TYPEINFERENCE);
     	
@@ -273,7 +391,9 @@ public class SourceFile
 	    ////////////////
         Set<Set<UnifyPair>> xConstraints = unifyConstraints.cartesianProduct();
         	
-        
+    	
+        //Sets zu Listen umwandeln:
+        //Set<List<UnifyPair>> allUnifiedConstraints = xConstraints.stream().map((set)-> new ArrayList<>(set)).collect(Menge::new, Menge::add, Menge::addAll);;
 
         typinferenzLog.debug("Finite Closure: "+finiteClosure, Section.TYPEINFERENCE);
         typinferenzLog.debug("Karthesisches Produkt der Constraints: "+xConstraints, Section.TYPEINFERENCE);
@@ -286,74 +406,7 @@ public class SourceFile
     	boolean unifyFail = true;
         for(Set<UnifyPair> constraints : xConstraints){
         	//Alle durch das Karthesische Produkt entstandenen Möglichkeiten durchgehen:
-            //Menge<Menge<Pair>> result = new Menge<Menge<Pair>>();
             
-          //IDEE: Man bildet Zusammenhangskomponenten von Paaren, die gemeinsame Variablen haben
-          //      und unifizert nur die Zusammenhangskomponenten in Schritten 1 - 5
-           /*
-          //Schritt 1: Alle Variablen in den Paaren von Elementen einsammeln
-          Menge<Menge<TypePlaceholder>> constraintsclonevars = constraints.stream().map(p -> {Menge<TypePlaceholder> TPHs = new Menge<>(); 
-            TPHs.addAll(p.TA1.getInvolvedTypePlaceholder());
-            TPHs.addAll(p.TA2.getInvolvedTypePlaceholder());
-            return TPHs;}
-            ).collect(Menge::new, Menge::add, Menge::addAll);    	
-
-          //Schritt 2: Schnittmengen jedes Elements mit jedem Elememt von vars bilden und dann index zusammenfassen
-          //in indexset sind dann die Mengen von Indizes enthalten, die gemeisam unifiziert wreden müssen
-        	Menge<Menge<Integer>> indexeset = new Menge<>();
-        	if (constraintsclonevars != null && constraintsclonevars.size()>0) { 
-        		indexeset = Unify.schnitt(constraintsclonevars);
-        	}
-        	
-        	//Schritt 3: Umwandlung der Indizes in die zugehoerigen Elemente
-        	//           In streamconstraintsclone sind die Mengen von Paar enthalten die unifiziert werden muessen
-        	Stream<Menge<MPair>> streamconstraintsclone = indexeset.stream().map(x -> x.stream()
-        			                                                           .map(i -> constraintsClone.elementAt(i))
-        			                                                               .<Menge<MPair>>collect(Menge::new, Menge::add, Menge::addAll));
-       	//Menge<Menge<Pair>> vecconstraintsclone = streamconstraintsclone.collect(Menge::new, Menge::add, Menge::addAll);
-            //System.out.println();
-        	//Schritt 4: Unifikation  
-        	Set<Set<Set<MPair>>> vecunifyResult =
-        			//streamconstraintsclone.map(x -> Unify.unify(x, finiteClosure)).collect(Menge::new, Menge::add, Menge::addAll);
-        			//DEBUG-Variante
-        			streamconstraintsclone.map(x -> 
-        			  	{ 	Set<Set<MPair>> z = new Unify().unify(x, finiteClosure);
-        					return z;
-        			  	}
-        					).collect(Menge::new, Menge::add, Menge::addAll);
-        			  	
-        	
-        	//card gibt die Cardinalitaet der unifizierten Mengen an
-        	Menge<Integer> card = vecunifyResult.stream().map(x -> x.size()).collect(Menge::new, Menge::add, Menge::addAll);
-        			;//.reduce(1,(a,b) -> { if ((a > 0) && (b > 0)) return (a * b); else return 1; });
-        			
-            //Schritt 5: Bildung des cartesischen Produkts
-            //sollte wieder entfernt werden: Weiterarbeit mit: 
-        	//[[x_1 -> t_1, x_2 -> t2], [x_1 -> t'_1, x_2 -> t'_2]] x ... x [[x_n -> t_1n], [x_n -> t2n], [x_n -> t3n]] 
-        	Set<Set<Pair>> cardprodret_start = new Menge<>();
-        	cardprodret_start.add(new Menge<Pair>());
-        	
-        	//cart. Produkt mit Linkverschiebung
-        	Set<Set<Pair>> unifyResult = vecunifyResult.stream().reduce(cardprodret_start, (x, y) -> {
-        		Set<Set<Pair>> cardprodret= new Menge<>();
-        		if (y.size() > 0) {
-        			//System.out.println(y);
-        			//Menge<Menge<Pair>> cardprodretold = x;
-					//cardprodret = new Menge<>();
-					for(int j = 0; j < x.size(); j++) {
-						for (int k = 0; k < y.size(); k++){
-							Set<Pair> help = new Menge<>(); 
-							help.addAll(y.elementAt(k));
-							help.addAll(x.elementAt(j));
-							cardprodret.add(help);
-						}
-					}
-        		}
-        		else 
-        			return new Menge<>(); //kein unifiziertes Ergebnis, damit wird das Geseamtergebnis []
-        		return cardprodret;
-        	});
-        	*/
         	typinferenzLog.debug("\nUnifiziere Constraints:\n"+constraints, Section.TYPEINFERENCE);
         	typinferenzLog.debug("\nFC:\n"+finiteClosure, Section.TYPEINFERENCE);
         	long start = System.currentTimeMillis();
@@ -361,7 +414,7 @@ public class SourceFile
 			long time = System.currentTimeMillis()-start;
 			typinferenzLog.debug("\nErgebnis der Unifizierung:\n"+unifyResult, Section.TYPEINFERENCE);
 			typinferenzLog.debug("\nAnzahl Lösungen:\n"+unifyResult.size(), Section.TYPEINFERENCE);
-			typinferenzLog.debug("\nZeit für Unifizierung: "+time + "ms", Section.TYPEINFERENCE);
+			//typinferenzLog.debug("\nZeit für Unifizierung: "+time + "ms", Section.TYPEINFERENCE);
 			
 			
             Menge<Menge<Pair>> convertedResult = unifyResult.parallelStream().<Menge<Pair>>map((Set<UnifyPair> resultSet)->{

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

@@ -1,5 +1,7 @@
 package de.dhbwstuttgart.typeinference.unify.model;
 
+import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Set;
 
 import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
@@ -81,4 +83,5 @@ public final class ExtendsType extends WildcardType {
 		return "? extends " + wildcardedType;
 	}
 
+	
 }

src/de/dhbwstuttgart/typeinference/unify/model/PlaceholderType.java

@@ -1,5 +1,7 @@
 package de.dhbwstuttgart.typeinference.unify.model;
 
+import java.util.ArrayList;
+import java.util.Collection;
 import java.util.HashSet;
 import java.util.Random;
 import java.util.Set;
@@ -106,4 +108,12 @@ public final class PlaceholderType extends UnifyType{
 		
 		return ((PlaceholderType) obj).getName().equals(typeName);
 	}
+	
+
+	@Override
+	public Collection<? extends PlaceholderType> getInvolvedPlaceholderTypes() {
+		ArrayList<PlaceholderType> ret = new ArrayList<>();
+		ret.add(this);
+		return ret;
+	}
 }

src/de/dhbwstuttgart/typeinference/unify/model/TypeParams.java

@@ -1,6 +1,8 @@
 package de.dhbwstuttgart.typeinference.unify.model;
 
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.Iterator;
 
 import de.dhbwstuttgart.typeinference.Menge;
@@ -168,5 +170,13 @@ public final class TypeParams implements Iterable<UnifyType>{
 			res += t + ",";
 		return "<" + res.substring(0, res.length()-1) + ">";
 	}
+
+	public Collection<? extends PlaceholderType> getInvolvedPlaceholderTypes() {
+		ArrayList<PlaceholderType> ret = new ArrayList<>();
+		for(UnifyType t : typeParams){
+			ret.addAll(t.getInvolvedPlaceholderTypes());
+		}
+		return ret;
+	}
 }
 

src/de/dhbwstuttgart/typeinference/unify/model/UnifyPair.java

@@ -1,5 +1,9 @@
 package de.dhbwstuttgart.typeinference.unify.model;
 
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
 /**
  * A pair which contains two types and an operator, e.q. (Integer <. a).
  * @author Florian Steurer
@@ -83,6 +87,13 @@ public class UnifyPair {
 	public String toString() {
 		return "(" + lhs + " " + pairOp + " " + rhs + ")";
 	}
+
+	public List<? extends PlaceholderType> getInvolvedPlaceholderTypes() {
+		ArrayList<PlaceholderType> ret = new ArrayList<>();
+		ret.addAll(lhs.getInvolvedPlaceholderTypes());
+		ret.addAll(rhs.getInvolvedPlaceholderTypes());
+		return ret;
+	}
 }
 
 

src/de/dhbwstuttgart/typeinference/unify/model/UnifyType.java

@@ -1,5 +1,8 @@
 package de.dhbwstuttgart.typeinference.unify.model;
 
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
 import java.util.Set;
 
 import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
@@ -87,4 +90,10 @@ public abstract class UnifyType {
 		
 		return typeName + params;
 	}
+
+	public Collection<? extends PlaceholderType> getInvolvedPlaceholderTypes() {
+		ArrayList<PlaceholderType> ret = new ArrayList<>();
+		ret.addAll(typeParams.getInvolvedPlaceholderTypes());
+		return ret;
+	}
 }

src/de/dhbwstuttgart/typeinference/unify/model/WildcardType.java

@@ -1,5 +1,8 @@
 package de.dhbwstuttgart.typeinference.unify.model;
 
+import java.util.ArrayList;
+import java.util.Collection;
+
 /**
  * A wildcard type that is either a ExtendsType or a SuperType.
  * @author Florian Steurer
@@ -53,4 +56,12 @@ public abstract class WildcardType extends UnifyType {
 		WildcardType other = (WildcardType) obj;
 		return other.getWildcardedType().equals(wildcardedType);
 	}
+	
+
+	@Override
+	public Collection<? extends PlaceholderType> getInvolvedPlaceholderTypes() {
+		ArrayList<PlaceholderType> ret = new ArrayList<>();
+		ret.addAll(wildcardedType.getInvolvedPlaceholderTypes());
+		return ret;
+	}
 }