i21023/JavaTXCompilerInJavaTX
2
0
Fork 0
forked from JavaTX/JavaCompilerCore
Code Pull Requests Activity

Unify auf commit 144c31a4cb ändern

Browse Source
This commit is contained in:
JanUlrich 2015-11-13 12:55:34 +01:00
parent 61891177a1
commit b8c0d87056
1 changed files with 101 additions and 269 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

370
src/de/dhbwstuttgart/typeinference/unify/Unify.java
View File

@ -6,25 +6,11 @@ package de.dhbwstuttgart.typeinference.unify;
import java.util.Enumeration; import java.util.Enumeration;
import java.util.Hashtable; import java.util.Hashtable;
import java.util.Iterator; import java.util.Iterator;
import java.util.List;
import java.util.Set;
import de.dhbwstuttgart.typeinference.Menge;
import java.util.function.BiConsumer;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Stream; import java.util.stream.Stream;
import com.google.common.collect.Sets;
import com.google.common.collect.Sets.SetView;
import com.rits.cloning.Cloner;
import de.dhbwstuttgart.logger.Logger; import de.dhbwstuttgart.logger.Logger;
import de.dhbwstuttgart.logger.Section; import de.dhbwstuttgart.logger.Section;
import de.dhbwstuttgart.logger.SectionLogger; import de.dhbwstuttgart.logger.SectionLogger;
import de.dhbwstuttgart.logger.Timestamp;
import de.dhbwstuttgart.logger.Timewatch;
import de.dhbwstuttgart.core.MyCompiler; import de.dhbwstuttgart.core.MyCompiler;
import de.dhbwstuttgart.myexception.CTypeReconstructionException; import de.dhbwstuttgart.myexception.CTypeReconstructionException;
import de.dhbwstuttgart.myexception.MatchException; import de.dhbwstuttgart.myexception.MatchException;
@ -44,19 +30,16 @@ import de.dhbwstuttgart.syntaxtree.type.Type;
import de.dhbwstuttgart.syntaxtree.type.ObjectType; import de.dhbwstuttgart.syntaxtree.type.ObjectType;
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder; import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
import de.dhbwstuttgart.syntaxtree.type.WildcardType; import de.dhbwstuttgart.syntaxtree.type.WildcardType;
import de.dhbwstuttgart.typeinference.ConstraintsSet; import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.typeinference.DeepCloneable;
import de.dhbwstuttgart.typeinference.OderConstraint;
import de.dhbwstuttgart.typeinference.Pair; import de.dhbwstuttgart.typeinference.Pair;
import de.dhbwstuttgart.typeinference.Pair.PairOperator; import de.dhbwstuttgart.typeinference.Pair.PairOperator;
import de.dhbwstuttgart.typeinference.UndConstraint;
// ino.end // ino.end
// ino.class.Unify.28049.description type=javadoc // ino.class.Unify.28049.description type=javadoc
/** /**
* Implementierung des Unifizierungsalgorithmus * Implementierung des Unifizierungsalgorithmus
* @author Martin Pl�micke, Thomas Ott * @author Martin Pl<EFBFBD>micke, Thomas Ott
* @version $Date: 2013/05/22 22:23:50 $ * @version $Date: 2013/05/22 22:23:50 $
*/ */
// ino.end // ino.end
@ -67,7 +50,7 @@ public class Unify
{ {
// ino.attribute.inferencelog.28052.declaration // ino.attribute.inferencelog.28052.declaration
protected static SectionLogger inferencelog = Logger.getSectionLogger(Unify.class.getName(), Section.UNIFY); protected static SectionLogger inferencelog = Logger.getSectionLogger("inference", Section.UNIFY);
// ino.end // ino.end
/** /**
@ -126,21 +109,13 @@ public class Unify
* Entweder alle Elemente in solved Form [A =. type, B =. type2, ...] * Entweder alle Elemente in solved Form [A =. type, B =. type2, ...]
* oder alle Elemente in der Form [A <. B, C <. D, ..., E <? F, G <? H, .... I =. type, J =. type2, ...] * oder alle Elemente in der Form [A <. B, C <. D, ..., E <? F, G <? H, .... I =. type, J =. type2, ...]
* oder [] = fail * oder [] = fail
* Für den Argumenttype FunN<...> in Typ A<FunN<...> ...> werden keine ? extends-, ? super-Typen erzeugt * F<EFBFBD>r den Argumenttype FunN<...> in Typ A<FunN<...> ...> werden keine ? extends-, ? super-Typen erzeugt
*/ */
//public static Menge<Menge<Pair>> unifyWC (Menge<Pair> E, FC_TTO fc_tto)
public static Menge<Menge<Pair>> unify (Menge<Pair> E, FC_TTO fc_tto) public static Menge<Menge<Pair>> unify (Menge<Pair> E, FC_TTO fc_tto)
{ {
return unifyFiltered(E, fc_tto,true);
}
//public static Menge<Menge<Pair>> unifyWC (Menge<Pair> E, FC_TTO fc_tto)
public static Menge<Menge<Pair>> unifyFiltered (Menge<Pair> E, FC_TTO fc_tto, boolean filter)
{
SectionLogger log = Logger.getSectionLogger(Unify.class.getName(), Section.UNIFY);
//Schritt 1: Aufrufen der Regeln durch sub_unify. //Schritt 1: Aufrufen der Regeln durch sub_unify.
Menge<Pair> Eq = sub_unify(E,fc_tto); Menge<Pair> Eq = sub_unify(E,fc_tto);
log.debug("Eq Set nach Schritt 1: "+Eq);
/* Schritt 2: Rausfiltern der Typen die entweder beides Typvariablen sind oder nicht. /* Schritt 2: Rausfiltern der Typen die entweder beides Typvariablen sind oder nicht.
* Sobald ein Paar auftauch, bei denen kein Typ mehr eine Typvariable ist, kann dieses Paar * Sobald ein Paar auftauch, bei denen kein Typ mehr eine Typvariable ist, kann dieses Paar
* nicht mehr unifiziert werden, deshalb abbruch.*/ * nicht mehr unifiziert werden, deshalb abbruch.*/
@ -153,7 +128,7 @@ public class Unify
} }
else if(!(p.TA1 instanceof TypePlaceholder) && !(p.TA2 instanceof TypePlaceholder)) else if(!(p.TA1 instanceof TypePlaceholder) && !(p.TA2 instanceof TypePlaceholder))
{ {
//Diese Paare kÃnnen nicht mehr Unifiziert werden. fail. //Diese Paare k<EFBFBD>nnen nicht mehr Unifiziert werden. fail.
inferencelog.debug("UNIFY FAIL:" + p.TA1 + " <. " + p.TA2 + " muesste mindestens einen TPH enthalten."); inferencelog.debug("UNIFY FAIL:" + p.TA1 + " <. " + p.TA2 + " muesste mindestens einen TPH enthalten.");
return new Menge<Menge<Pair>>(); return new Menge<Menge<Pair>>();
} }
@ -165,8 +140,8 @@ public class Unify
if(!Eq1.contains(p)) if(!Eq1.contains(p))
Eq2.add(p); Eq2.add(p);
} }
/* Schritt 4, Teil 1: Einsammeln der Sets für das Kartesiche Produkt. /* Schritt 4, Teil 1: Einsammeln der Sets f<EFBFBD>r das Kartesiche Produkt.
* Hier werden die Paare verglichen. Je nach Struktur kÃnnen neue Paare erzeugt * Hier werden die Paare verglichen. Je nach Struktur k<EFBFBD>nnen neue Paare erzeugt
* werden, aus denen dann das kartesische Produkt gebildet wird.*/ * werden, aus denen dann das kartesische Produkt gebildet wird.*/
Menge<Menge<Menge<Pair>>> cartProduktSets = new Menge<Menge<Menge<Pair>>>(); Menge<Menge<Menge<Pair>>> cartProduktSets = new Menge<Menge<Menge<Pair>>>();
for(Pair p : Eq2) for(Pair p : Eq2)
@ -178,7 +153,7 @@ public class Unify
p.TA2 = ((SuperWildcardType)p.TA2).get_SuperType(); p.TA2 = ((SuperWildcardType)p.TA2).get_SuperType();
//HIER GIBT ES EIN PROBLEM, WENN get_SuperType ein TPH LIEFERT PL 15-03-12 //HIER GIBT ES EIN PROBLEM, WENN get_SuperType ein TPH LIEFERT PL 15-03-12
//Dann ist THP <. TPH in Eq2 anstatt in Eq1 //Dann ist THP <. TPH in Eq2 anstatt in Eq1
//Muesste mit folgendem if gelÃst sein. PL 15-03-17 //Muesste mit folgendem if gel<EFBFBD>st sein. PL 15-03-17
if (p.TA2 instanceof TypePlaceholder) { if (p.TA2 instanceof TypePlaceholder) {
Eq1.addElement(p); Eq1.addElement(p);
// Eq2.remove(p); // Eq2.remove(p);
@ -229,7 +204,7 @@ public class Unify
unifyErgs.add(unifyErgsElement.firstElement()); unifyErgs.add(unifyErgsElement.firstElement());
} }
} }
// Nach dem Unifizieren wird das Ergebnis überprüft, und evtl. durch die FC entstandene TPHs werden gelÃscht. // Nach dem Unifizieren wird das Ergebnis <EFBFBD>berpr<EFBFBD>ft, und evtl. durch die FC entstandene TPHs werden gel<EFBFBD>scht.
if((p_fc.TA2 instanceof RefType && !unifyErgs.isEmpty()) if((p_fc.TA2 instanceof RefType && !unifyErgs.isEmpty())
|| p_fc.TA2.equals(p_TA2)) //Bedingung fuer Reflexifitaet BRAURHT MAN VERMUTLIRH NIRHT PL 07-08-05 || p_fc.TA2.equals(p_TA2)) //Bedingung fuer Reflexifitaet BRAURHT MAN VERMUTLIRH NIRHT PL 07-08-05
{ {
@ -328,7 +303,7 @@ public class Unify
} }
else if(p.OperatorSmaller() && p.TA2 instanceof GenericTypeVar) else if(p.OperatorSmaller() && p.TA2 instanceof GenericTypeVar)
{ {
//Paar unverändert lassen, wenn eine GenericTypeVar ist //Paar unver<EFBFBD>ndert lassen, wenn eine GenericTypeVar ist
Menge<Menge<Pair>> setofsetofpairs = new Menge<Menge<Pair>>(); Menge<Menge<Pair>> setofsetofpairs = new Menge<Menge<Pair>>();
Menge<Pair> vTmp = new Menge<Pair>(); Menge<Pair> vTmp = new Menge<Pair>();
vTmp.add(p); vTmp.add(p);
@ -370,7 +345,7 @@ public class Unify
unifyErgs.add(unifyErgsElement.firstElement()); unifyErgs.add(unifyErgsElement.firstElement());
} }
} }
//Nach dem Unifizieren wird das Ergebnis überprüft, und evtl. durch die FC entstandene TPHs werden gelÃscht. //Nach dem Unifizieren wird das Ergebnis <EFBFBD>berpr<EFBFBD>ft, und evtl. durch die FC entstandene TPHs werden gel<EFBFBD>scht.
if((p_fc.TA2 instanceof RefType && !unifyErgs.isEmpty()) if((p_fc.TA2 instanceof RefType && !unifyErgs.isEmpty())
|| p_fc.TA2.equals(p_TA2)) //Bedingung fuer Reflexifitaet BRAURHT MAN VERMUTLIRH NIRHT PL 07-08-05 || p_fc.TA2.equals(p_TA2)) //Bedingung fuer Reflexifitaet BRAURHT MAN VERMUTLIRH NIRHT PL 07-08-05
{ {
@ -545,7 +520,7 @@ public class Unify
unifyErgs.add(unifyErgsElement.firstElement()); unifyErgs.add(unifyErgsElement.firstElement());
} }
} }
// Nach dem Unifizieren wird das Ergebnis überprüft, und evtl. durch die FC entstandene TPHs werden gelÃscht. // Nach dem Unifizieren wird das Ergebnis <EFBFBD>berpr<EFBFBD>ft, und evtl. durch die FC entstandene TPHs werden gel<EFBFBD>scht.
if((p_fc.TA2 instanceof RefType && !unifyErgs.isEmpty()) if((p_fc.TA2 instanceof RefType && !unifyErgs.isEmpty())
|| p_fc.TA2.equals(p_TA1)) //Bedingung fuer Reflexifitaet BRAURHT MAN VERMUTLIRH NIRHT PL 07-08-05 || p_fc.TA2.equals(p_TA1)) //Bedingung fuer Reflexifitaet BRAURHT MAN VERMUTLIRH NIRHT PL 07-08-05
{ {
@ -644,91 +619,8 @@ public class Unify
} }
} }
//Schritt 4, Teil 2: Kartesisches Produkt bilden. //Schritt 4, Teil 2: Kartesisches Produkt bilden.
log.debug("Unify Sets nach Schritt 4 vor dem Erstellen des Karthesischen Produkts: "+cartProduktSets); //TODO: Vor der Bildung des Karthesischen Produkts unm<EFBFBD>gliche Kombinationen ausfiltern
/* //Hier wird aus den in Schritt 4, Teil 1 erzeugten Vektoren das Kartesische Produkt gebilden.
//TODO: Vor der Bildung des Karthesischen Produkts unmÃgliche Kombinationen ausfiltern
//cartProduktSets kontrollieren:
ConstraintsSet cSet = new ConstraintsSet();
UndConstraint eq1cons = new UndConstraint();
for(Pair p : Eq1){
eq1cons.addConstraint(p.TA1, p.TA2);
}
cSet.add(eq1cons);
for(Menge<Menge<Pair>> vecvecpair : cartProduktSets){
OderConstraint orConstraints = new OderConstraint();
for(Menge<Pair> pairs : vecvecpair){
UndConstraint uCons = new UndConstraint();
for(Pair p : pairs){
uCons.addConstraint(p.TA1, p.TA2);
}
orConstraints.addConstraint(uCons);
}
cSet.add(orConstraints);
}
Menge<Menge<Pair>> bigCartProductErg3 = cSet.cartesianProduct();
if(filter)log.debug("Karthesisches Produkt nach Filterung: "+bigCartProductErg3);
Sets.cartesianProduct(bigCartProductErg3);
*/
if(filter){
//Cloner cloner = new Cloner();
Menge<Menge<Menge<Pair>>> temp = new Menge<>(); //hier werden gefilterte Constraints gesammelt
Menge<Pair> undMenge = new Menge<Pair>(); //Die Menge von Pairs, welche in jedem Kartesischen Produkt enthalten sind.
//undMenge.addAll(cloner.deepClone(Eq1));
undMenge.addAll(Unify.deepClone(Eq1));
Menge<Menge<Menge<Pair>>> oderConstraints = new Menge<>();//Die zu filternden Constraints
for (Menge<Menge<Pair>> vecvecpair : cartProduktSets){
if(vecvecpair.size() == 1){//gibt es nur eine UndMenge in diesem Set, dann kommt diese in jedem Karthesischen Produkt vor:
//undMenge.addAll(cloner.deepClone(vecvecpair.firstElement()));
undMenge.addAll(Unify.deepClone(vecvecpair.firstElement()));
temp.add(vecvecpair);
}else{//gibt es mehrere Mengen, kann gefiltert werden:
oderConstraints.add(vecvecpair); //die Menge zu den zu filternden OderConstraints anfügen
}
}
//Filtere die OderConstraints:
for(Menge<Menge<Pair>> oderConstraint : oderConstraints){
Menge<Menge<Pair>> filteredOCons = new Menge<>(); //diese Menge sammelt nur Cons
for(Menge<Pair> pairs : oderConstraint){
Menge<Pair> testMenge = new Menge<Pair>();
//testMenge.addAll(cloner.deepClone(undMenge));
//testMenge.addAll(cloner.deepClone(pairs));
testMenge.addAll(Unify.deepClone(undMenge));
testMenge.addAll(Unify.deepClone(pairs));
Menge<Menge<Pair>> test = Unify.unifyFiltered(testMenge, fc_tto, false);
if(test.size()>0){
filteredOCons.add(pairs);
}
else{
log.debug("Ausgesondertes Constraint: "+pairs);
}
}
temp.add(filteredOCons);
}
SetView<Menge<Menge<Pair>>> difference = Sets.difference(cartProduktSets, temp);
log.debug("Ausgelöschte Constraints: "+difference.toString());
cartProduktSets = temp;
/*
Unifier filterUnify = (pairs)->{
String pairsString = pairs.toString();
Menge<Menge<Pair>> retValue = new Menge<>();
retValue = Unify.unifyFiltered(pairs,fc_tto,false);
//Unify.unify(pairs, fc_tto, (i)->{});
log.debug("Filtere Constraints:\n"+pairsString);
log.debug("Ergebnis: "+ retValue);
return retValue;
};
log.debug("Filtere mithilfe von 'filterWrongConstraints': "+cSet);
cSet.filterWrongConstraints(filterUnify);
*/
}
//*/
///* Altes Karthesisches Produkt: Auskommentiert durch Andreas Stadelmeier
//Hier wird aus den in Schritt 4, Teil 1 erzeugten Vektoren das Kartesische Produkt gebildet.
Menge<Pair> helpvp; Menge<Pair> helpvp;
Menge<Menge<Pair>> bigCartProductErg = new Menge<Menge<Pair>>(); Menge<Menge<Pair>> bigCartProductErg = new Menge<Menge<Pair>>();
bigCartProductErg.addElement(copyMengePair(Eq1)); bigCartProductErg.addElement(copyMengePair(Eq1));
@ -747,33 +639,13 @@ public class Unify
} }
} }
} }
/*
if(! bigCartProductErg.equals(bigCartProductErg3)){
for(int i = 0; i<bigCartProductErg3.size();i++){
if(! (bigCartProductErg.get(i).equals(bigCartProductErg3.get(i)))){
System.out.println();
//TODO: Hier testen, wo der Unterschied zwischen den beiden Karthesischen Produkten ist
}
}
}
*/
//*/
//Schritt 5: Einsetzen der Subst Regel //Schritt 5: Einsetzen der Subst Regel
//Hier werden die TPHs substituiert, und dann nach geänderten und nicht geänderten Sets sortiert. //Hier werden die TPHs substituiert, und dann nach ge<EFBFBD>nderten und nicht ge<EFBFBD>nderten Sets sortiert.
Menge<Menge<Pair>> changedSets = new Menge<Menge<Pair>>(); Menge<Menge<Pair>> changedSets = new Menge<Menge<Pair>>();
Menge<Menge<Pair>> notChangedSets = new Menge<Menge<Pair>>(); Menge<Menge<Pair>> notChangedSets = new Menge<Menge<Pair>>();
int counter = 0;
for(Menge<Pair> vecpair : bigCartProductErg) for(Menge<Pair> vecpair : bigCartProductErg)
{ {
//Klone die Menge vecpair, bevor substituiert wird. Viele Paare sind doppelt referenziert und müssen vor dem Substituieren geklont werden
vecpair = vecpair.stream().map(x -> x.clone()).collect(Menge::new, Menge::add, Menge::addAll);
counter++;
if(counter > 1000){
System.out.println(counter + " von "+bigCartProductErg.size());
}
boolean change = false; //eingefuegt PL 13-05-22 boolean change = false; //eingefuegt PL 13-05-22
Pair substPair = null; Pair substPair = null;
do do
@ -823,29 +695,29 @@ public class Unify
} }
} }
//Eq2Set ist das eigentliche Ergebnis, dass zurückgegeben wird. //Eq2Set ist das eigentliche Ergebnis, dass zur<EFBFBD>ckgegeben wird.
Menge<Menge<Pair>> Eq2Set = new Menge<Menge<Pair>>(); Menge<Menge<Pair>> Eq2Set = new Menge<Menge<Pair>>();
//Schritt 6A: Beginnen mit Schritt 1 bei den geänderten. //Schritt 6A: Beginnen mit Schritt 1 bei den ge<EFBFBD>nderten.
for(Menge<Pair> vecpair : changedSets) for(Menge<Pair> vecpair : changedSets)
{ {
Menge<Menge<Pair>> unifyErgs = unify(vecpair,fc_tto); Menge<Menge<Pair>> unifyErgs = unify(vecpair,fc_tto);
//Die Ergebnissvektoren sind schon im Schritt 7 von dem Rekursiven Aufruf geprüft worden. Sie kÃnnen direkt eingefügt werden. //Die Ergebnissvektoren sind schon im Schritt 7 von dem Rekursiven Aufruf gepr<EFBFBD>ft worden. Sie k<EFBFBD>nnen direkt eingef<EFBFBD>gt werden.
Eq2Set.addAll(unifyErgs); Eq2Set.addAll(unifyErgs);
} }
//Schritt 6B Einfügen der nicht geänderten. //Schritt 6B Einf<EFBFBD>gen der nicht ge<EFBFBD>nderten.
//Schritt 7: Aussortieren der falschen Sets //Schritt 7: Aussortieren der falschen Sets
/* /*
* Durch die Rekursion in Schritt 6A sind die Ergebnisse, welche in 6A dazukommen auf jeden Fall korrekt. * Durch die Rekursion in Schritt 6A sind die Ergebnisse, welche in 6A dazukommen auf jeden Fall korrekt.
* Es müssen nur die Ergebnisse aus 6B geprüft werden. * Es m<EFBFBD>ssen nur die Ergebnisse aus 6B gepr<EFBFBD>ft werden.
*/ */
for(Menge<Pair> vecpair : notChangedSets) for(Menge<Pair> vecpair : notChangedSets)
{ {
//Überprüfen ob Menge in SolvedForm ist. //<EFBFBD>berpr<EFBFBD>fen ob Menge in SolvedForm ist.
if(hasSolvedForm(vecpair)) //PL 13-05-22 hasSolvedForm angepasst if(hasSolvedForm(vecpair)) //PL 13-05-22 hasSolvedForm angepasst
{ {
//Überprüfung auf FreshTypeVars in den Typen //<EFBFBD>berpr<EFBFBD>fung auf FreshTypeVars in den Typen
boolean foundFresh = false; boolean foundFresh = false;
for(Pair p : vecpair) for(Pair p : vecpair)
{ {
@ -863,14 +735,14 @@ public class Unify
} }
} }
//Ergebnis zurückgeben. //Ergebnis zur<EFBFBD>ckgeben.
return Eq2Set; return Eq2Set;
} }
/** /**
* PL 2014-10-25 * PL 2014-10-25
* schnitt1 checkt ob die Typeplaceholders aus in den Elemeneten aus vars enthalten sind * 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. * R<EFBFBD>ckgabe ist die Menge der Indizies von vars der Schnittmengen mit var nicht leer sind.
* @param var * @param var
* @param vars * @param vars
* @param indexe * @param indexe
@ -921,10 +793,10 @@ public class Unify
* Beispiel: unifyERgs = [[a = Integer, b = Number ]], test = Menge<a> * Beispiel: unifyERgs = [[a = Integer, b = Number ]], test = Menge<a>
* In diesm fall wird b = Number aus dem Menge entfernt. * In diesm fall wird b = Number aus dem Menge entfernt.
* *
* Durch das Entfernen entstehen evtl. Identische Mengeen, diese werden auch gelÃscht. * Durch das Entfernen entstehen evtl. Identische Mengeen, diese werden auch gel<EFBFBD>scht.
* *
* @param unifyErgs - Ergebnisse des Unify, die geprüft werden sollen. * @param unifyErgs - Ergebnisse des Unify, die gepr<EFBFBD>ft werden sollen.
* @param test - RefType gegen den geprüft werden soll. * @param test - RefType gegen den gepr<EFBFBD>ft werden soll.
*/ */
private static void testUnifyErg(Menge<Menge<Pair>> unifyErgs, RefType test) private static void testUnifyErg(Menge<Menge<Pair>> unifyErgs, RefType test)
{ {
@ -938,7 +810,7 @@ public class Unify
vec--; vec--;
} }
} }
//Gleiche Mengeen lÃschen //Gleiche Mengeen l<EFBFBD>schen
for(int i = 0; i < unifyErgs.size(); i++) for(int i = 0; i < unifyErgs.size(); i++)
{ {
Menge<Pair> p1 = unifyErgs.elementAt(i); Menge<Pair> p1 = unifyErgs.elementAt(i);
@ -967,13 +839,13 @@ public class Unify
} }
/** /**
* Diese Methode generiert einen Menge<Menge<Pair>> wobei immer der übergebene TA1 vorne steht, und jeder Typ aus otherPairTypes hinten. * Diese Methode generiert einen Menge<Menge<Pair>> wobei immer der <EFBFBD>bergebene TA1 vorne steht, und jeder Typ aus otherPairTypes hinten.
* Beispiel: otherPairTypes = [Integer, Number, Menge<Integer>], TA1 = TPH a. * Beispiel: otherPairTypes = [Integer, Number, Menge<Integer>], TA1 = TPH a.
* return: [[TPH a = Integer],[TPH a = Number],[TPH a = Menge<Integer>]] * return: [[TPH a = Integer],[TPH a = Number],[TPH a = Menge<Integer>]]
* *
* @param TA1 - Der Typ der immer vorne steht * @param TA1 - Der Typ der immer vorne steht
* @param otherPairTypes - Die anderen Typen * @param otherPairTypes - Die anderen Typen
* @return - Ein Menge<Menge<Pair>> der alle Paare enthält. * @return - Ein Menge<Menge<Pair>> der alle Paare enth<EFBFBD>lt.
*/ */
private static Menge<Menge<Pair>> generateSetOfSetOfPair(Type TA1, Menge<? extends Type> otherPairTypes) private static Menge<Menge<Pair>> generateSetOfSetOfPair(Type TA1, Menge<? extends Type> otherPairTypes)
{ {
@ -1074,7 +946,7 @@ public class Unify
//Menge wird geclont, Elemente nicht //Menge wird geclont, Elemente nicht
//Menge<RefType> Mub = (Menge<RefType>)ub.clone(); //Menge<RefType> Mub = (Menge<RefType>)ub.clone();
//Elemente die nicht kleinste obere Schranken sind, werden gel�scht //Elemente die nicht kleinste obere Schranken sind, werden gel<EFBFBD>scht
//FUNKTIONIERT NICHT. SIEHE iftest.java PL 08-08-13 //FUNKTIONIERT NICHT. SIEHE iftest.java PL 08-08-13
for (int i = 0; i < ub.size(); i++) { for (int i = 0; i < ub.size(); i++) {
for (int j = 0; j < ub.size(); j++) { for (int j = 0; j < ub.size(); j++) {
@ -1130,7 +1002,7 @@ throws MatchException
// ino.method.match.28064.body // ino.method.match.28064.body
{ {
//PL 05-01-22 //PL 05-01-22
//gibt eine Substitution zur�ck, die den Variablen aus FCtype //gibt eine Substitution zur<EFBFBD>ck, die den Variablen aus FCtype
//die Typterme aus tomatch zu ordnet. Es wird davon ausgegangen, dass //die Typterme aus tomatch zu ordnet. Es wird davon ausgegangen, dass
//FCtype gegen tomatch gematcht werden kann. //FCtype gegen tomatch gematcht werden kann.
if (FCtype.getTypeName().equals(tomatch.getTypeName())) { if (FCtype.getTypeName().equals(tomatch.getTypeName())) {
@ -1174,7 +1046,7 @@ throws MatchException
// ino.method.sub_unify.28067.body // ino.method.sub_unify.28067.body
{ {
//PL 05-01-21 umbenannt in sub_unify //PL 05-01-21 umbenannt in sub_unify
//Luar boolean useSubst hinzugefügt, um bei bedarf zu Steuern ob Subst Regel angewendet wird oder nicht. //Luar boolean useSubst hinzugef<EFBFBD>gt, um bei bedarf zu Steuern ob Subst Regel angewendet wird oder nicht.
// otth: Unifikation - Versuch 1 :-) // otth: Unifikation - Versuch 1 :-)
//Menge FC = fc_tto.getFC(); //Menge FC = fc_tto.getFC();
@ -1199,7 +1071,7 @@ throws MatchException
inferencelog.debug("Ausgewaehltes Paar = " + P.toString() + ""); inferencelog.debug("Ausgewaehltes Paar = " + P.toString() + "");
inferencelog.debug( "--------------------------------------------------"); inferencelog.debug( "--------------------------------------------------");
// Bei allen Erase erfolgt keine Kopie nach H, dadurch wird das Pair gelÃscht. // Bei allen Erase erfolgt keine Kopie nach H, dadurch wird das Pair gel<EFBFBD>scht.
//ERASE3 //ERASE3
if( P.isEqual() && P.OperatorEqual() ) if( P.isEqual() && P.OperatorEqual() )
{ {
@ -1321,13 +1193,13 @@ throws MatchException
} }
catch( SCException Ex ) catch( SCException Ex )
{ {
inferencelog.debug("---- Unifikation nicht m�glich: Permutation fehlgeschlagen!"); inferencelog.debug("---- Unifikation nicht m<EFBFBD>glich: Permutation fehlgeschlagen!");
break; break;
} }
} }
else else
{ {
inferencelog.info("---- Unifikation nicht m�glich: Anzahl der Parameter verschieden!"); inferencelog.info("---- Unifikation nicht m<EFBFBD>glich: Anzahl der Parameter verschieden!");
break; break;
} }
} }
@ -1378,13 +1250,13 @@ throws MatchException
} }
catch( SCException Ex ) catch( SCException Ex )
{ {
inferencelog.debug("---- Unifikation nicht m�glich: Permutation fehlgeschlagen!"); inferencelog.debug("---- Unifikation nicht m<EFBFBD>glich: Permutation fehlgeschlagen!");
break; break;
} }
} }
else else
{ {
inferencelog.info("---- Unifikation nicht m�glich: Anzahl der Parameter verschieden!"); inferencelog.info("---- Unifikation nicht m<EFBFBD>glich: Anzahl der Parameter verschieden!");
break; break;
} }
} }
@ -1455,7 +1327,7 @@ throws MatchException
RefType TA1 = null; RefType TA1 = null;
RefType TA2 = null; RefType TA2 = null;
//Hier werden die RefTypes gefüllt. //Hier werden die RefTypes gef<EFBFBD>llt.
if(P.TA1 instanceof RefType && P.TA2 instanceof RefType) if(P.TA1 instanceof RefType && P.TA2 instanceof RefType)
{ {
TA1 = (RefType)P.TA1; TA1 = (RefType)P.TA1;
@ -1477,7 +1349,7 @@ throws MatchException
} }
catch( SCException Ex ) catch( SCException Ex )
{ {
inferencelog.error("---- Unifikation nicht m�glich: Permutation fehlgeschlagen!"); inferencelog.error("---- Unifikation nicht m<EFBFBD>glich: Permutation fehlgeschlagen!");
break; break;
} }
} }
@ -1510,7 +1382,7 @@ throws MatchException
} }
catch( SCException Ex ) catch( SCException Ex )
{ {
inferencelog.debug("---- Unifikation nicht m�glich: Permutation fehlgeschlagen!"); inferencelog.debug("---- Unifikation nicht m<EFBFBD>glich: Permutation fehlgeschlagen!");
break; break;
} }
} }
@ -1530,7 +1402,7 @@ throws MatchException
} }
catch( SCException Ex ) catch( SCException Ex )
{ {
inferencelog.error("---- Unifikation nicht m�glich: Permutation fehlgeschlagen!"); inferencelog.error("---- Unifikation nicht m<EFBFBD>glich: Permutation fehlgeschlagen!");
break; break;
} }
} }
@ -1643,7 +1515,7 @@ throws MatchException
} }
// Subst --> noch zu pr�fen // Subst --> noch zu pr<EFBFBD>fen
if( P.TA1 instanceof TypePlaceholder && P.OperatorEqual() && useSubst) //&& P.TA2 instanceof RefType ) if( P.TA1 instanceof TypePlaceholder && P.OperatorEqual() && useSubst) //&& P.TA2 instanceof RefType )
//PL 05-02-09 P.TA@ duerfen auch TypePlaceholder sein //PL 05-02-09 P.TA@ duerfen auch TypePlaceholder sein
/* BEISPIEL: /* BEISPIEL:
@ -1797,7 +1669,7 @@ throws MatchException
/** /**
* Implementiert die reduceEq Regel des sub_unify * Implementiert die reduceEq Regel des sub_unify
* Da in reduce2 unnÃtigerweise pi verwendet wird (siehe Kommentar in reduce2), kann reduceEq einfach an reduce2 deligieren. * Da in reduce2 unn<EFBFBD>tigerweise pi verwendet wird (siehe Kommentar in reduce2), kann reduceEq einfach an reduce2 deligieren.
*/ */
private static void reduceEq(Menge<Pair> H, RefType TA1, RefType TA2, Menge TTO) throws SCException private static void reduceEq(Menge<Pair> H, RefType TA1, RefType TA2, Menge TTO) throws SCException
{ {
@ -1819,11 +1691,11 @@ throws MatchException
inferencelog.debug("---- Parameteranzahl gleich"); inferencelog.debug("---- Parameteranzahl gleich");
inferencelog.debug("---- Reduce !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! (" + L1.size() + ") neue(s) Paar(e)"); inferencelog.debug("---- Reduce !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! (" + L1.size() + ") neue(s) Paar(e)");
// hier mu� die PERMUTATION erfolgen // hier mu<EFBFBD> die PERMUTATION erfolgen
inferencelog.debug("---- PAARBILDUNG "); inferencelog.debug("---- PAARBILDUNG ");
for( int k = 0; k < L1.size(); k++ ) for( int k = 0; k < L1.size(); k++ )
{ {
// pi eig. bei reduce2 �berfl�ssig, schadet aber hoff. auch nicht :-) // pi eig. bei reduce2 <EFBFBD>berfl<EFBFBD>ssig, schadet aber hoff. auch nicht :-)
//luar 19-04-2007 durch das pi kann reduce2 auch als reduceEq verwendet werden. Wenn das pi durch k ersetzt wird, muss reduceEq entsprechend ausprogrammiert werden. //luar 19-04-2007 durch das pi kann reduce2 auch als reduceEq verwendet werden. Wenn das pi durch k ersetzt wird, muss reduceEq entsprechend ausprogrammiert werden.
Pair P2 = new Pair( L1.elementAt( pi(k, TA1.getTypeName(), TA2.getTypeName(), TTO ) ), L2.elementAt(k), PairOperator.Equal ); Pair P2 = new Pair( L1.elementAt( pi(k, TA1.getTypeName(), TA2.getTypeName(), TTO ) ), L2.elementAt(k), PairOperator.Equal );
inferencelog.debug("---- Paar1: (" + (L1.elementAt( pi(k, TA1.getTypeName(), TA2.getTypeName(), TTO ) )).getName() + ", " + (L2.elementAt(k)).getName() + P2.OperatorEqual() + ")"); inferencelog.debug("---- Paar1: (" + (L1.elementAt( pi(k, TA1.getTypeName(), TA2.getTypeName(), TTO ) )).getName() + ", " + (L2.elementAt(k)).getName() + P2.OperatorEqual() + ")");
@ -2122,7 +1994,7 @@ throws MatchException
//LIEGT //LIEGT
//erlegigt 06-04-28 //erlegigt 06-04-28
Menge<Pair> res = sub_unify(subunifypair, fc_tto); Menge<Pair> res = sub_unify(subunifypair, fc_tto);
if (hasSolvedForm(res)) { //PL 13-05-22: hasSolvedForm geaendert, es nicht geklärt, ob es funktioniert. if (hasSolvedForm(res)) { //PL 13-05-22: hasSolvedForm geaendert, es nicht gekl<EFBFBD>rt, ob es funktioniert.
inferencelog.debug("HasSolvedForm: "); inferencelog.debug("HasSolvedForm: ");
printMenge("RES_SMALLER", res, 6); printMenge("RES_SMALLER", res, 6);
ht = MengePair2SubstHashtableMengePair(res); ht = MengePair2SubstHashtableMengePair(res);
@ -2237,27 +2109,6 @@ throws MatchException
return ret; return ret;
} }
// ino.end // ino.end
/*
// ino.method.allGreater.29428.definition
public static Menge<RefType> allGreater (BoundedGenericTypeVar ty, Menge<Pair> FC)
// ino.end
// ino.method.allGreater.29428.body
{
CRefTypeSet ret = new CRefTypeSet();
Iterator<ObjectType> typeIt = ty.getBounds().iterator();
while(typeIt.hasNext()) {
CRefTypeSet grBounds = new CRefTypeSet();
RefType act = (RefType)typeIt.next();
grBounds.setMenge(allGreater(act, FC));
grBounds.addElement(act);
ret.unite(grBounds);
}
return ret.getMenge();
}
// ino.end
*/
// ino.method.allGreater.28094.definition // ino.method.allGreater.28094.definition
public static Menge<RefType> allGreater (RefType ty, Menge<Pair> FC) public static Menge<RefType> allGreater (RefType ty, Menge<Pair> FC)
// ino.end // ino.end
@ -2305,7 +2156,7 @@ throws MatchException
{ {
// otth: Funktion, die prueft, ob Paar( R1, R2 ) in FC liegt, // otth: Funktion, die prueft, ob Paar( R1, R2 ) in FC liegt,
// bzw. deren rechten Seiten, ohne die TypePlaceholder-Variablen zu beachten // bzw. deren rechten Seiten, ohne die TypePlaceholder-Variablen zu beachten
// z.B. Menge<A> w�re hier gleich wie Menge<Integer> // z.B. Menge<A> w<EFBFBD>re hier gleich wie Menge<Integer>
// z.B. FC = { ( AA<a, b> <=* CC< DD<b, a> > ) ,...} // z.B. FC = { ( AA<a, b> <=* CC< DD<b, a> > ) ,...}
// R1 = AA<Integer, b> // R1 = AA<Integer, b>
@ -2353,7 +2204,7 @@ throws MatchException
{ {
// otth: Funktion, die prueft, ob Paar( R1, \sigma(R2) ) in FC liegt, // otth: Funktion, die prueft, ob Paar( R1, \sigma(R2) ) in FC liegt,
// bzw. deren rechten Seiten, ohne die TypePlaceholders zu beachten // bzw. deren rechten Seiten, ohne die TypePlaceholders zu beachten
// z.B. Menge<A> w�re hier gleich wie Menge<Integer> // z.B. Menge<A> w<EFBFBD>re hier gleich wie Menge<Integer>
// z.B. FC = { ( AA<a, b> <=* CC< DD<b, a> > ) ,...} // z.B. FC = { ( AA<a, b> <=* CC< DD<b, a> > ) ,...}
// R1 = AA<Integer, b> // R1 = AA<Integer, b>
@ -2391,7 +2242,7 @@ throws MatchException
Menge<Pair> vp = sub_unify(R2vec, fc_tto); Menge<Pair> vp = sub_unify(R2vec, fc_tto);
printMenge("VP", vp, 6); printMenge("VP", vp, 6);
if ( hasSolvedForm(vp) ) //PL 13-05-22: hasSolvedForm geaendert, es nicht geklärt, ob es funktioniert. if ( hasSolvedForm(vp) ) //PL 13-05-22: hasSolvedForm geaendert, es nicht gekl<EFBFBD>rt, ob es funktioniert.
//if( isRXSimilarRY( RFC, R2 ) ) //if( isRXSimilarRY( RFC, R2 ) )
{ {
inferencelog.debug("SIMILAR2"); inferencelog.debug("SIMILAR2");
@ -2476,19 +2327,7 @@ throws MatchException
inferencelog.debug("Nummer: " + nTypnrInPair); inferencelog.debug("Nummer: " + nTypnrInPair);
inferencelog.debug("TV: " + a.getName()); inferencelog.debug("TV: " + a.getName());
inferencelog.debug("Bedingung: " + bMitVorbedingung); inferencelog.debug("Bedingung: " + bMitVorbedingung);
/*
Cloner cloner = new Cloner();
cloner.setDumpClonedClasses(true);
SectionLogger log = Logger.getSectionLogger("Subst-Methode", Section.UNIFY);
Timewatch timer = Timewatch.getTimewatch();
de.dhbwstuttgart.logger.Timestamp timestamp = timer.start("Unify-Subst");
P = cloner.deepClone(P);
a = cloner.deepClone(a);
o = cloner.deepClone(o);
long time = timestamp.stop();
log.debug("Benötigte Zeit für DeepClone: "+time);
*/
// richtiger Typ aus Pair raussuchen // richtiger Typ aus Pair raussuchen
Type T = null; Type T = null;
if( nTypnrInPair == 1 ) if( nTypnrInPair == 1 )
@ -2500,7 +2339,7 @@ throws MatchException
if (o instanceof RefType) {//PL 05-02-09 eingefuegt siehe Methodenkopf if (o instanceof RefType) {//PL 05-02-09 eingefuegt siehe Methodenkopf
if( bMitVorbedingung && isTVinRefType( a, (RefType)o ) ) if( bMitVorbedingung && isTVinRefType( a, (RefType)o ) )
{ {
inferencelog.debug(" Subst nicht m�glich, da TV " + a.getName() + " in RefType " + o.getName()); inferencelog.debug(" Subst nicht m<EFBFBD>glich, da TV " + a.getName() + " in RefType " + o.getName());
return false; return false;
} }
} }
@ -2510,7 +2349,7 @@ throws MatchException
{ {
// Parameterliste durchgehen // Parameterliste durchgehen
Menge vTemp = ((RefType)T).get_ParaList(); Menge vTemp = ((RefType)T).get_ParaList();
boolean ret = true; //EINGEFUEGT PL 14-01-16: Return darf erst am Ende zurückgegeben werden und nicht in den ifs Boolean ret = true; //EINGEFUEGT PL 14-01-16: Return darf erst am Ende zur<EFBFBD>ckgegeben werden und nicht in den ifs
//sonst werden nicht alle Elemente der Forschleife durchlaufen //sonst werden nicht alle Elemente der Forschleife durchlaufen
for( int i = 0; i < vTemp.size(); i++ ) for( int i = 0; i < vTemp.size(); i++ )
{ {
@ -2556,7 +2395,7 @@ throws MatchException
return true; return true;
} }
} }
//Wildcard ergänzt PL 14-12-05 //Wildcard erg<EFBFBD>nzt PL 14-12-05
if ( T instanceof ExtendsWildcardType ) if ( T instanceof ExtendsWildcardType )
{ {
Type Temp = ((ExtendsWildcardType) T).get_ExtendsType(); Type Temp = ((ExtendsWildcardType) T).get_ExtendsType();
@ -2571,7 +2410,7 @@ throws MatchException
} }
} }
} }
//Wildcard ergänzt PL 14-12-05 //Wildcard erg<EFBFBD>nzt PL 14-12-05
if ( T instanceof SuperWildcardType ) if ( T instanceof SuperWildcardType )
{ {
Type Temp = ((SuperWildcardType) T).get_SuperType(); Type Temp = ((SuperWildcardType) T).get_SuperType();
@ -2652,7 +2491,7 @@ throws MatchException
{ {
// otth: Funktion pr�ft, ob Klasse 'Basis' von Klasse 'Mutter' direkt oder indirekt abgeleitet ist // otth: Funktion pr<EFBFBD>ft, ob Klasse 'Basis' von Klasse 'Mutter' direkt oder indirekt abgeleitet ist
// Basisklasse suchen // Basisklasse suchen
Menge tto = fc_tto.getTTO(); Menge tto = fc_tto.getTTO();
@ -2676,9 +2515,9 @@ throws MatchException
} }
/* /*
* Hier wird überprüft ob in der Paraliste ein anderes Element als ein GTV drinne ist. * Hier wird <EFBFBD>berpr<EFBFBD>ft ob in der Paraliste ein anderes Element als ein GTV drinne ist.
* Sollte ein anderes Element gefunden werden ist Reduce nicht mÃglich. * Sollte ein anderes Element gefunden werden ist Reduce nicht m<EFBFBD>glich.
* Beispiel: Matrix <. Menge<Menge<Integer>> ist nur durch adapt mÃglich. * Beispiel: Matrix <. Menge<Menge<Integer>> ist nur durch adapt m<EFBFBD>glich.
*/ */
for(Type t : s) for(Type t : s)
{ {
@ -2812,7 +2651,7 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
if( n >= vD.size() ) if( n >= vD.size() )
throw F; throw F;
// Permuationswert f�r 'n' berechnen // Permuationswert f<EFBFBD>r 'n' berechnen
Type TV = (Type)vD.elementAt(n); Type TV = (Type)vD.elementAt(n);
int nPos = -1; int nPos = -1;
@ -2844,12 +2683,12 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
// ino.method.printMengeUnifier.28121.body // ino.method.printMengeUnifier.28121.body
{ {
//PL 05-01-21 //PL 05-01-21
//Ruft f�r eine Menge von Unifikatoren die Methode //Ruft f<EFBFBD>r eine Menge von Unifikatoren die Methode
//printMenge auf //printMenge auf
for (int i = 0; i < Uni.size(); i++) { for (int i = 0; i < Uni.size(); i++) {
inferencelog.debug((i+1) + ". Unifier"); inferencelog.debug((i+1) + ". Unifier");
printMenge(strMenge, Uni.elementAt(i), nDebug); printMenge(strMenge, Uni.elementAt(i), nDebug);
if( hasSolvedForm( Uni.elementAt(i) ) ) { //PL 13-05-22: hasSolvedForm geaendert, es nicht geklärt, ob es funktioniert. if( hasSolvedForm( Uni.elementAt(i) ) ) { //PL 13-05-22: hasSolvedForm geaendert, es nicht gekl<EFBFBD>rt, ob es funktioniert.
inferencelog.debug((i+1) + ". Unifier ist in 'Solved form'!\n"); inferencelog.debug((i+1) + ". Unifier ist in 'Solved form'!\n");
} }
else { else {
@ -2876,7 +2715,7 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
} }
for( int tt = 0; tt < E.size(); tt++ ) { for( int tt = 0; tt < E.size(); tt++ ) {
//luar 13-03-07 If Else Block gelÃscht, da sinnlos. //luar 13-03-07 If Else Block gel<EFBFBD>scht, da sinnlos.
if( tt > 0 ) if( tt > 0 )
strTemp = strTemp + ",\n" + E.elementAt(tt).toString(); strTemp = strTemp + ",\n" + E.elementAt(tt).toString();
else else
@ -2969,7 +2808,7 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
/** /**
* Implementiert die CaptureConversion. Wendet diese auf jeden Typ im Menge TVec an. * Implementiert die CaptureConversion. Wendet diese auf jeden Typ im Menge TVec an.
* Rückgabe ist ein ErgebnisMenge * R<EFBFBD>ckgabe ist ein ErgebnisMenge
*/ */
private static Menge<ObjectType> CaptureConversion(Menge<ObjectType> TVec, FC_TTO fc_tto) private static Menge<ObjectType> CaptureConversion(Menge<ObjectType> TVec, FC_TTO fc_tto)
{ {
@ -2977,7 +2816,7 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
for(ObjectType t : TVec) for(ObjectType t : TVec)
{ {
ObjectType ccT = (ObjectType)CaptureConversion(t,fc_tto); ObjectType ccT = (ObjectType)CaptureConversion(t,fc_tto);
//CaptureConversion kann nur ObjectTypes zurückliefern, laesst sich aber nicht zurziehen. //CaptureConversion kann nur ObjectTypes zur<EFBFBD>ckliefern, laesst sich aber nicht zurziehen.
if(ccT != null) if(ccT != null)
retVec.add(ccT); retVec.add(ccT);
} }
@ -2987,7 +2826,7 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
/** /**
* Erzeugt die CaptureConversion von einem Typ. * Erzeugt die CaptureConversion von einem Typ.
* *
* @param T - Übergebener Typ, von welchem die CaptureConversion gemacht werden soll. * @param T - <EFBFBD>bergebener Typ, von welchem die CaptureConversion gemacht werden soll.
* @param fc_tto - Hilfsklasse. * @param fc_tto - Hilfsklasse.
* @return - CC(T) * @return - CC(T)
*/ */
@ -3022,7 +2861,7 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
if(t instanceof WildcardType) if(t instanceof WildcardType)
{ {
FreshWildcardType fwcT = ((WildcardType)t).GetFreshWildcardType(); FreshWildcardType fwcT = ((WildcardType)t).GetFreshWildcardType();
//Wenn beim Original Typ an der Stelle eine BoundedGenericTypeVar ist werden die Bounds zu der Wildcard hinzugefügt. //Wenn beim Original Typ an der Stelle eine BoundedGenericTypeVar ist werden die Bounds zu der Wildcard hinzugef<EFBFBD>gt.
if(cl.get_ParaList().elementAt(i) instanceof BoundedGenericTypeVar) if(cl.get_ParaList().elementAt(i) instanceof BoundedGenericTypeVar)
{ {
BoundedGenericTypeVar bgv = (BoundedGenericTypeVar)cl.get_ParaList().elementAt(i); BoundedGenericTypeVar bgv = (BoundedGenericTypeVar)cl.get_ParaList().elementAt(i);
@ -3036,7 +2875,7 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
} }
refT.set_ParaList(ccTypes); refT.set_ParaList(ccTypes);
} }
//Wenn eine CaptureConversion durchgeführt wurde den Typ zurückgeben. //Wenn eine CaptureConversion durchgef<EFBFBD>hrt wurde den Typ zur<EFBFBD>ckgeben.
if(ccDone) if(ccDone)
return refT; return refT;
else else
@ -3053,13 +2892,13 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
//Von hier an Greater implementierung 28-03-07 //Von hier an Greater implementierung 28-03-07
/** /**
* Der Komplette Ablauf von greater und was die einzelnen Teilschritte machen kann anhand von Aktivitätsdiagrammen * Der Komplette Ablauf von greater und was die einzelnen Teilschritte machen kann anhand von Aktivit<EFBFBD>tsdiagrammen
* im Inovator Projekt, oder in der Studienarbeit Arne Lüdtke, 2007 nachgelesen werden. * im Inovator Projekt, oder in der Studienarbeit Arne L<EFBFBD>dtke, 2007 nachgelesen werden.
*/ */
/** /**
* Erzeugt alle Typen die greater sind als T. Gibt diese zurück. * Erzeugt alle Typen die greater sind als T. Gibt diese zur<EFBFBD>ck.
* Für den Argumenttype FunN<...> in Typ A<FunN<...> ...> werden keine ? extends-, ? super-Typen erzeugt * F<EFBFBD>r den Argumenttype FunN<...> in Typ A<FunN<...> ...> werden keine ? extends-, ? super-Typen erzeugt
*/ */
private static Menge<ObjectType> greater(ObjectType T, FC_TTO fc_tto) private static Menge<ObjectType> greater(ObjectType T, FC_TTO fc_tto)
//an die Aenderungen im Skript anpassen 07-11-03 //an die Aenderungen im Skript anpassen 07-11-03
@ -3084,22 +2923,22 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
//greater1 Erzeugen //greater1 Erzeugen
Menge<ObjectType> greater1Erg = greater1(T,fc_tto); Menge<ObjectType> greater1Erg = greater1(T,fc_tto);
//Reflexivität, deshalb T hinzufügen. //Reflexivit<EFBFBD>t, deshalb T hinzuf<EFBFBD>gen.
if(!greater1Erg.contains(T)) if(!greater1Erg.contains(T))
greater1Erg.add(T); greater1Erg.add(T);
//Falls in greater1Erg Typen doppelt vorhanden sind werden diese nicht in retVec übernommen. //Falls in greater1Erg Typen doppelt vorhanden sind werden diese nicht in retVec <EFBFBD>bernommen.
for(ObjectType t : greater1Erg) for(ObjectType t : greater1Erg)
if(!retVec.contains(t)) if(!retVec.contains(t))
retVec.add(t); retVec.add(t);
//Ergebnis von greater1 an greater2 durchreichen, ERgebnisse in retVec einfügen //Ergebnis von greater1 an greater2 durchreichen, ERgebnisse in retVec einf<EFBFBD>gen
Menge<ObjectType> greater2Erg = greater2(greater1Erg,fc_tto); Menge<ObjectType> greater2Erg = greater2(greater1Erg,fc_tto);
for(ObjectType t : greater2Erg) for(ObjectType t : greater2Erg)
if(!retVec.contains(t)) if(!retVec.contains(t))
retVec.add(t); retVec.add(t);
//Ergebnis von greater2 an greater3 durchreichen, ERgebnisse in retVec einfügen //Ergebnis von greater2 an greater3 durchreichen, ERgebnisse in retVec einf<EFBFBD>gen
Menge<ObjectType> greater3Erg = greater3(greater2Erg,fc_tto); Menge<ObjectType> greater3Erg = greater3(greater2Erg,fc_tto);
for(ObjectType t : greater3Erg) for(ObjectType t : greater3Erg)
if(!retVec.contains(t)) if(!retVec.contains(t))
@ -3110,7 +2949,7 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
/** /**
* greater1 Schritt von greater. * greater1 Schritt von greater.
* Für den Argumenttype FunN<...> in Typ A<FunN<...> ...> werden keine ? extends-, ? super-Typen erzeugt * F<EFBFBD>r den Argumenttype FunN<...> in Typ A<FunN<...> ...> werden keine ? extends-, ? super-Typen erzeugt
*/ */
private static Menge<ObjectType> greater1(ObjectType T, FC_TTO fc_tto) private static Menge<ObjectType> greater1(ObjectType T, FC_TTO fc_tto)
{ {
@ -3148,8 +2987,8 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
} }
/** /**
* Überladung der Funktion cartProductType, damit der Programmierer beim ersten Aufruf nicht den 2. Parameter * <EFBFBD>berladung der Funktion cartProductType, damit der Programmierer beim ersten Aufruf nicht den 2. Parameter
* welcher für die rekursion erforderlich ist mit übergeben muss. * welcher f<EFBFBD>r die rekursion erforderlich ist mit <EFBFBD>bergeben muss.
*/ */
private static Menge<Menge<Type>> cartProductType (Menge<Menge<Type>> vec) private static Menge<Menge<Type>> cartProductType (Menge<Menge<Type>> vec)
{ {
@ -3158,7 +2997,7 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
/** /**
* Erzeugt das Kartesische Product von mehreren Mengeen von Typen. * Erzeugt das Kartesische Product von mehreren Mengeen von Typen.
* Für den Startaufruf ist der index = 0. Danach ruft sich cartProductType rekursiv auf. * F<EFBFBD>r den Startaufruf ist der index = 0. Danach ruft sich cartProductType rekursiv auf.
*/ */
private static Menge<Menge<Type>> cartProductType (Menge<Menge<Type>> vec, int index) private static Menge<Menge<Type>> cartProductType (Menge<Menge<Type>> vec, int index)
{ {
@ -3193,8 +3032,8 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
} }
/** /**
* Überladung der Funktion cartProductPair, damit der Programmierer beim ersten Aufruf nicht den 2. Parameter * <EFBFBD>berladung der Funktion cartProductPair, damit der Programmierer beim ersten Aufruf nicht den 2. Parameter
* welcher für die rekursion erforderlich ist mit übergeben muss. * welcher f<EFBFBD>r die rekursion erforderlich ist mit <EFBFBD>bergeben muss.
*/ */
private static Menge<Menge<Pair>> cartProductPair (Menge<Menge<Pair>> vec) private static Menge<Menge<Pair>> cartProductPair (Menge<Menge<Pair>> vec)
{ {
@ -3203,7 +3042,7 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
/** /**
* Erzeugt das Kartesische Product von mehreren Mengeen von Paaren. * Erzeugt das Kartesische Product von mehreren Mengeen von Paaren.
* Für den Startaufruf ist der index = 0. Danach ruft sich cartProductPair rekursiv auf. * F<EFBFBD>r den Startaufruf ist der index = 0. Danach ruft sich cartProductPair rekursiv auf.
*/ */
private static Menge<Menge<Pair>> cartProductPair (Menge<Menge<Pair>> vec, int index) private static Menge<Menge<Pair>> cartProductPair (Menge<Menge<Pair>> vec, int index)
{ {
@ -3263,7 +3102,7 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
/** /**
* greaterArg Schritt von greater * greaterArg Schritt von greater
* Für den Argumenttype FunN<...> werden keine ? extends-, ? super-Typen erzeugt * F<EFBFBD>r den Argumenttype FunN<...> werden keine ? extends-, ? super-Typen erzeugt
*/ */
private static Menge<Type> greaterArg(Type T, FC_TTO fc_tto) private static Menge<Type> greaterArg(Type T, FC_TTO fc_tto)
{ {
@ -3319,7 +3158,7 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
return new Menge<Type>(); return new Menge<Type>();
*/ */
//Diese Abfrage sorgt für grArg(a) = {a} //Luar 07-07-31 //Diese Abfrage sorgt f<EFBFBD>r grArg(a) = {a} //Luar 07-07-31
else if(T instanceof TypePlaceholder) else if(T instanceof TypePlaceholder)
retVec.add(T); retVec.add(T);
//Diese Abfrage verhindert, dass bei FunN Wildcard-Typen generiert werden //PL 13-05-22 //Diese Abfrage verhindert, dass bei FunN Wildcard-Typen generiert werden //PL 13-05-22
@ -3348,7 +3187,7 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
Menge<ObjectType> retVec = new Menge<ObjectType>(); Menge<ObjectType> retVec = new Menge<ObjectType>();
/* /*
* luar 02-05-07: Beschreibung der Funktion: * luar 02-05-07: Beschreibung der Funktion:
* Für Jeden Typ aus greater1 durch die FC laufen, und auf der Linken seite einen Match versuchen. * F<EFBFBD>r Jeden Typ aus greater1 durch die FC laufen, und auf der Linken seite einen Match versuchen.
* Wenn das Funktioniert, dann ist der Typ auf der rechten Seite auch greater. * Wenn das Funktioniert, dann ist der Typ auf der rechten Seite auch greater.
* */ * */
Hashtable<JavaClassName,Type> ht = new Hashtable<JavaClassName,Type>(); Hashtable<JavaClassName,Type> ht = new Hashtable<JavaClassName,Type>();
@ -3373,7 +3212,7 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
RefType TA2neu = ((RefType)p.TA2).clone(); RefType TA2neu = ((RefType)p.TA2).clone();
SubstHashtableGeneric(TA2neu,ht); SubstHashtableGeneric(TA2neu,ht);
//TA2neu ist greater als T. Einfügen in retVec //TA2neu ist greater als T. Einf<EFBFBD>gen in retVec
if(!retVec.contains(TA2neu)) if(!retVec.contains(TA2neu))
retVec.add(TA2neu); retVec.add(TA2neu);
} }
@ -3403,12 +3242,12 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
//Von hier an Smaller implementierung luar 28-03-07 //Von hier an Smaller implementierung luar 28-03-07
/** /**
* Der Komplette Ablauf von smaller und was die einzelnen Teilschritte machen kann anhand von Aktivitätsdiagrammen * Der Komplette Ablauf von smaller und was die einzelnen Teilschritte machen kann anhand von Aktivit<EFBFBD>tsdiagrammen
* im Inovator Projekt, oder in der Studienarbeit Arne Lüdtke, 2007 nachgelesen werden. * im Inovator Projekt, oder in der Studienarbeit Arne L<EFBFBD>dtke, 2007 nachgelesen werden.
*/ */
/** /**
* Erzeugt alle Typen die smaller sind als T. Gibt diese zurück. * Erzeugt alle Typen die smaller sind als T. Gibt diese zur<EFBFBD>ck.
*/ */
private static Menge<ObjectType> smaller(ObjectType T, FC_TTO fc_tto) private static Menge<ObjectType> smaller(ObjectType T, FC_TTO fc_tto)
//an die Aenderungen im Skript anpassen 07-11-03 //an die Aenderungen im Skript anpassen 07-11-03
@ -3444,18 +3283,18 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
if(!smaller12Erg.contains(T)) if(!smaller12Erg.contains(T))
smaller12Erg.add(T); smaller12Erg.add(T);
//Ergebnise in retVec einfügen. Doppelte werden gelÃscht. //Ergebnise in retVec einf<EFBFBD>gen. Doppelte werden gel<EFBFBD>scht.
for(ObjectType t : smaller12Erg) for(ObjectType t : smaller12Erg)
if(!retVec.contains(t)) if(!retVec.contains(t))
retVec.add(t); retVec.add(t);
//Ergebnis von smaller1 und smaller2 an smaller3 weitergeben, Ergebnisse einfügen. //Ergebnis von smaller1 und smaller2 an smaller3 weitergeben, Ergebnisse einf<EFBFBD>gen.
Menge<ObjectType> smaller3Erg = smaller3(smaller12Erg,fc_tto); Menge<ObjectType> smaller3Erg = smaller3(smaller12Erg,fc_tto);
for(ObjectType t : smaller3Erg) for(ObjectType t : smaller3Erg)
if(!retVec.contains(t)) if(!retVec.contains(t))
retVec.add(t); retVec.add(t);
//Ergebnisse von smaller3 an smaller4 weitergeben, Ergebnisse einfügen. //Ergebnisse von smaller3 an smaller4 weitergeben, Ergebnisse einf<EFBFBD>gen.
Menge<ObjectType> smaller4Erg = smaller4(smaller3Erg); Menge<ObjectType> smaller4Erg = smaller4(smaller3Erg);
for(ObjectType t : smaller4Erg) for(ObjectType t : smaller4Erg)
if(!retVec.contains(t)) if(!retVec.contains(t))
@ -3504,7 +3343,7 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
Menge<Type> retVec = new Menge<Type>(); Menge<Type> retVec = new Menge<Type>();
if(T instanceof ExtendsWildcardType) if(T instanceof ExtendsWildcardType)
{ {
//Für eine ExtendsWildcard rekursiv smaller0 aufrufen, und neue Wildcards erzeugen. //F<EFBFBD>r eine ExtendsWildcard rekursiv smaller0 aufrufen, und neue Wildcards erzeugen.
ExtendsWildcardType exT = (ExtendsWildcardType)T; ExtendsWildcardType exT = (ExtendsWildcardType)T;
Menge<ObjectType> smallerTypes = smaller0(exT.get_ExtendsType(),fc_tto); Menge<ObjectType> smallerTypes = smaller0(exT.get_ExtendsType(),fc_tto);
for(ObjectType t : smallerTypes) for(ObjectType t : smallerTypes)
@ -3515,7 +3354,7 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
} }
else if(T instanceof SuperWildcardType) else if(T instanceof SuperWildcardType)
{ {
//Für eine SuperWildcard rekursiv greater0 aufrufen, unr neue Wildcards erzeugen. //F<EFBFBD>r eine SuperWildcard rekursiv greater0 aufrufen, unr neue Wildcards erzeugen.
SuperWildcardType suT = (SuperWildcardType)T; SuperWildcardType suT = (SuperWildcardType)T;
Menge<ObjectType> greaterTypes = greater0(suT.get_SuperType(),fc_tto); Menge<ObjectType> greaterTypes = greater0(suT.get_SuperType(),fc_tto);
for(ObjectType t : greaterTypes) for(ObjectType t : greaterTypes)
@ -3554,7 +3393,7 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
Menge<ObjectType> retVec = new Menge<ObjectType>(); Menge<ObjectType> retVec = new Menge<ObjectType>();
/* /*
* luar 02-05-07: Beschreibung der Funktion: * luar 02-05-07: Beschreibung der Funktion:
* Für Jeden Typ aus Smaller12 durch die FC laufen, und auf der Rechten seite einen Match versuchen. * F<EFBFBD>r Jeden Typ aus Smaller12 durch die FC laufen, und auf der Rechten seite einen Match versuchen.
* Wenn das Funktioniert, dann ist der Typ auf der linken Seite auch smaller. * Wenn das Funktioniert, dann ist der Typ auf der linken Seite auch smaller.
* */ * */
Hashtable<JavaClassName,Type> ht = new Hashtable<JavaClassName,Type>(); Hashtable<JavaClassName,Type> ht = new Hashtable<JavaClassName,Type>();
@ -3577,7 +3416,7 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
//Macht hat funktioniert. In Linker Seite Typen substituieren //Macht hat funktioniert. In Linker Seite Typen substituieren
RefType TA1neu = ((RefType)p.TA1).clone(); RefType TA1neu = ((RefType)p.TA1).clone();
SubstHashtableGeneric(TA1neu,ht); SubstHashtableGeneric(TA1neu,ht);
//TA1neu ist smaller als T. Einfügen in retVec //TA1neu ist smaller als T. Einf<EFBFBD>gen in retVec
if(!retVec.contains(TA1neu)) if(!retVec.contains(TA1neu))
retVec.add(TA1neu); retVec.add(TA1neu);
} }
@ -3627,12 +3466,12 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
} }
/** /**
* Gibt True zurück, wenn T eine FreshWildcard ist, oder im Falle eines RefTypes oder WildcardTypes eine FreshWildcard enthält. * Gibt True zur<EFBFBD>ck, wenn T eine FreshWildcard ist, oder im Falle eines RefTypes oder WildcardTypes eine FreshWildcard enth<EFBFBD>lt.
*/ */
private static boolean DelFreshWildcardTypeVar(Type T) private static boolean DelFreshWildcardTypeVar(Type T)
{ {
//luar 29-05-2007 //luar 29-05-2007
//Überprüft rekursiv ob in dem RefType ein FreshWildcardType enthalten ist. //<EFBFBD>berpr<EFBFBD>ft rekursiv ob in dem RefType ein FreshWildcardType enthalten ist.
if(T instanceof RefType) if(T instanceof RefType)
{ {
RefType refT = (RefType)T; RefType refT = (RefType)T;
@ -3641,7 +3480,7 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
if(DelFreshWildcardTypeVar(t)) if(DelFreshWildcardTypeVar(t))
return true; return true;
} }
//Im Falle einer Wildcard, Typen aus der WC rausnehmen und diesen rekursiv prüfen. //Im Falle einer Wildcard, Typen aus der WC rausnehmen und diesen rekursiv pr<EFBFBD>fen.
if(T instanceof ExtendsWildcardType) if(T instanceof ExtendsWildcardType)
return DelFreshWildcardTypeVar(((ExtendsWildcardType)T).get_ExtendsType()); return DelFreshWildcardTypeVar(((ExtendsWildcardType)T).get_ExtendsType());
@ -3651,12 +3490,5 @@ tempKlasse.get_Superclass_Name() ); System.out.println( "P. S.:
return T instanceof FreshWildcardType; return T instanceof FreshWildcardType;
} }
public static <A extends DeepCloneable> Menge<A> deepClone(Menge<A> m){
Timewatch watch = Timewatch.getTimewatch();
Timestamp timer = watch.start("Unify - deepClone");
Menge<A> ret = m.stream().<A>map((Function<A,A>)(x -> x.deepClone())).<Menge<A>>collect(Menge::new, Menge::add, Menge::addAll);
timer.stop();
return ret;
}
} }
// ino.end // ino.end