Merge mit Änderungen am Unify

.classpath

@@ -5,6 +5,5 @@
 	<classpathentry kind="src" path="test"/>
 	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
 	<classpathentry kind="lib" path="lib/junit-4.0.jar"/>
-	<classpathentry kind="lib" path="lib/antlr-4.4-complete.jar"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>

.externalToolBuilders/JavaParserBuilder.launch

@@ -13,7 +13,7 @@
 <booleanAttribute key="org.eclipse.debug.ui.ATTR_LAUNCH_IN_BACKGROUND" value="false"/>
 <stringAttribute key="org.eclipse.jdt.launching.CLASSPATH_PROVIDER" value="org.eclipse.ant.ui.AntClasspathProvider"/>
 <stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="JavaCompilerCore"/>
-<booleanAttribute key="org.eclipse.ui.externaltools.ATTR_BUILDER_ENABLED" value="true"/>
+<booleanAttribute key="org.eclipse.ui.externaltools.ATTR_BUILDER_ENABLED" value="false"/>
 <stringAttribute key="org.eclipse.ui.externaltools.ATTR_LOCATION" value="${workspace_loc:/JavaCompilerCore/tools/AntParserBuilderWindows.xml}"/>
 <stringAttribute key="org.eclipse.ui.externaltools.ATTR_RUN_BUILD_KINDS" value="incremental,clean"/>
 <booleanAttribute key="org.eclipse.ui.externaltools.ATTR_TRIGGERS_CONFIGURED" value="true"/>

src/de/dhbwstuttgart/syntaxtree/SourceFile.java

@@ -9,6 +9,7 @@ import java.util.HashMap;
 import java.util.Hashtable;
 import java.util.Iterator;
 import java.util.Vector;
+import java.util.stream.Stream;
 
 import de.dhbwstuttgart.logger.Logger;
 import de.dhbwstuttgart.logger.Section;
@@ -777,14 +778,96 @@ public class SourceFile
             }
             */
             
-            Vector<Vector<Pair>> unifyResult = Unify.unify(constraintsClone, 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
+          Vector<Vector<TypePlaceholder>> constraintsclonevars = constraintsClone.stream().map(p -> {Vector<TypePlaceholder> TPHs = new Vector<>(); 
+            TPHs.addAll(p.TA1.getInvolvedTypePlaceholder());
+            TPHs.addAll(p.TA2.getInvolvedTypePlaceholder());
+            return TPHs;}
+            ).collect(Vector::new, Vector::add, Vector::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
+        	Vector<Vector<Integer>> indexeset = new Vector<>();
+        	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<Vector<Pair>> streamconstraintsclone = indexeset.stream().map(x -> x.stream()
+        			                                                           .map(i -> constraintsClone.elementAt(i))
+        			                                                               .collect(Vector::new, Vector::add, Vector::addAll));
+//        	Vector<Vector<Pair>> vecconstraintsclone = streamconstraintsclone.collect(Vector::new, Vector::add, Vector::addAll);
+            
+        	//Schritt 4: Unifikation  
+        	Vector<Vector<Vector<Pair>>> vecunifyResult =
+        			streamconstraintsclone.map(x -> Unify.unify(x, finiteClosure)).collect(Vector::new, Vector::add, Vector::addAll);
+        	
+        	//card gibt die Cardinalitaet der unifizierten Mengen an
+        	Vector<Integer> card = vecunifyResult.stream().map(x -> x.size()).collect(Vector::new, Vector::add, Vector::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]] 
+        	Vector<Vector<Pair>> cardprodret_start = new Vector<>();
+        	cardprodret_start.add(new Vector<Pair>());
+        	
+        	//cart. Produkt mit kopieren
+        	//Vector<Vector<Pair>> unifyResult = vecunifyResult.stream().reduce(cardprodret_start, (x, y) -> {
+        		//Vector<Vector<Pair>> cardprodret= new Vector<>();
+        		//if (y.size() > 0) {
+        			////System.out.println(y);
+        			//Vector<Vector<Pair>> cardprodretold = x;
+					//cardprodret = new Vector<>();
+					//for(int j = 0; j < cardprodretold.size(); j++) {
+						//for (int k = 0; k < y.size(); k++){
+							//Vector<Pair> help;
+							//if (y.size() == 1) help = cardprodretold.elementAt(j); //bei einem hinzuzufuegenden Element muss nicht kopiert werden
+							//else help = Unify.copyVectorPair(cardprodretold.elementAt(j));
+							//help.addAll(y.elementAt(k));
+							//cardprodret.add(help);
+						//}
+					//}
+        		//}
+        		//else 
+        			//return new Vector<>(); //kein unifiziertes Ergebnis, damit wird das Geseamtergebnis []
+        		//return cardprodret;
+        	//});
+        	
+        	//cart. Produkt mit Linkverschiebung
+        	Vector<Vector<Pair>> unifyResult = vecunifyResult.stream().reduce(cardprodret_start, (x, y) -> {
+        		Vector<Vector<Pair>> cardprodret= new Vector<>();
+        		if (y.size() > 0) {
+        			//System.out.println(y);
+        			//Vector<Vector<Pair>> cardprodretold = x;
+					//cardprodret = new Vector<>();
+					for(int j = 0; j < x.size(); j++) {
+						for (int k = 0; k < y.size(); k++){
+							Vector<Pair> help = new Vector<>(); 
+							help.addAll(y.elementAt(k));
+							help.addAll(x.elementAt(j));
+							cardprodret.add(help);
+						}
+					}
+        		}
+        		else 
+        			return new Vector<>(); //kein unifiziertes Ergebnis, damit wird das Geseamtergebnis []
+        		return cardprodret;
+        	});
+        	
+        	//Vector<Vector<Pair>> unifyResult = Unify.unify(constraintsClone, finiteClosure);
         	//Dann den Ergebnissen anfügen
             result.addAll(unifyResult);
         
 	        // Debugoutput:Vector<Vector<Pair>>
-	        typinferenzLog.debug("Unifiziertes Ergebnis: "+result, Section.TYPEINFERENCE);
 	        
-	        /*
+            typinferenzLog.debug("Unifiziertes Ergebnis: "+result, Section.TYPEINFERENCE);
+	        
+            /*
 	        // Prüfe ob eindeutige Lösung:
 	        if(result.size()>1 && !Unify.hasSolvedForm(result.elementAt(0))){
 	        	

src/de/dhbwstuttgart/typeinference/unify/Unify.java

@@ -847,6 +847,54 @@ public class Unify
     	return Eq2Set;
     }
     
+    /**
+     * 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 Vector<Integer> schnitt1 (Vector<TypePlaceholder> var, Vector<Vector<TypePlaceholder>> vars, Vector<Integer> indexe) {
+        int j = -1;
+        for (Vector<TypePlaceholder> varelems : vars) {
+                j++;
+                if (varelems != null) {
+                        if (var.stream().map(x -> varelems.contains(x)).reduce(false, (a,b) -> (a || b))
+                                        && (!indexe.contains(j)))
+                        {
+                                Vector<TypePlaceholder> 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 Vector<Vector<Integer>> schnitt (Vector<Vector<TypePlaceholder>> vars) {
+        Vector<Vector<Integer>> ret = new Vector<>();
+        int i = -1;
+        for (Vector<TypePlaceholder> var : vars) {
+                i++;
+                if (var != null) {//Element wurde noch bearbeitet
+                        Vector<Integer> indexe = new Vector<>();
+                        indexe.add(i);
+                        ret.add(schnitt1(var, vars, indexe));
+                }
+        }
+        return ret;
+    }  
+
+    
     /**
      * Diese Methode wird verwendet, um Zuordnungen z.B. TPH a = Integer
      * aus der Ergebnismenge zu entfernen, wenn im Typ in den die eingesetzt werden sollen kein TPH a vorhanden ist.