forked from JavaTX/JavaCompilerCore
121 lines
3.2 KiB
Java
Executable File
121 lines
3.2 KiB
Java
Executable File
package typinferenz;
|
|
|
|
import java.util.Iterator;
|
|
import java.util.Vector;
|
|
|
|
import mycompiler.mytype.Pair;
|
|
import mycompiler.mytype.Type;
|
|
import mycompiler.mytype.TypePlaceholder;
|
|
|
|
/**
|
|
* Im Grunde Sammlung von Pair s mit Equal-Operatoren.
|
|
*
|
|
* @author Andreas Stadelmeier, a10023
|
|
*
|
|
*/
|
|
public class ResultSet implements Iterable<Pair> {
|
|
|
|
Vector<Pair> resultPairs;
|
|
|
|
public ResultSet(Vector<Pair> resultSet){
|
|
resultPairs = resultSet;
|
|
}
|
|
|
|
public Vector<Pair> getResultSet(){
|
|
return resultPairs;
|
|
}
|
|
|
|
/**
|
|
* Löst den übergebenen Typ auf. Rückgabetyp ist ein Reftype oder Void
|
|
* @param type
|
|
* @return
|
|
*/
|
|
public Type getTypeEqualTo(Type type) {
|
|
Type res = type;
|
|
Vector<Pair> modifiedResultPairs = (Vector<Pair>) resultPairs.clone();
|
|
int i = findPairWithTypeEqualTo(type, modifiedResultPairs);
|
|
while(i != -1){
|
|
res = modifiedResultPairs.get(i).TA2;
|
|
modifiedResultPairs.remove(i);
|
|
i = findPairWithTypeEqualTo(res, modifiedResultPairs);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
private int findPairWithTypeEqualTo(Type type, Vector<Pair> inResultPairs){
|
|
for(int i = 0; i<inResultPairs.size();i++){
|
|
Pair p = inResultPairs.elementAt(i);
|
|
if((p.OperatorEqual() || p.OperatorSmallerExtends()) && p.TA1.equals(type))return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
public Iterator<Pair> iterator() {
|
|
return this.getResultSet().iterator();
|
|
}
|
|
|
|
/**
|
|
* Durchsucht das ResultSet (die unifizierten Constraints des ResultSets) nach diesem Typ. Der Typ wird nicht aufgelöst.
|
|
* Es spielt keine Rolle in welchem Kontext der Typ im ResultSet auftaucht.
|
|
* @param tA1
|
|
* @return true, falls der gesuchte Typ enthalten ist.
|
|
*/
|
|
public boolean contains(Type tA1) {
|
|
for(Pair p : this){
|
|
if(p.TA1.equals(tA1)||p.TA2.equals(tA1))return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public String toString(){
|
|
return this.getResultSet().toString();
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(Object obj){
|
|
return true;
|
|
}
|
|
|
|
|
|
/**
|
|
* Sammelt alle Constraints, welche mit den übergebenen TPH's in Verbindung stehen.
|
|
* Auch alle Constraints, welche wiederum mit den gesammelten Constraints in Verbindung stehen werden gesammelt.
|
|
* @return
|
|
*/
|
|
public Vector<Pair> getConstraintsFor(Vector<TypePlaceholder> typePlaceholders) {
|
|
Vector<Pair> ret = new Vector<Pair>();
|
|
Vector<TypePlaceholder> tphs = (Vector<TypePlaceholder>) typePlaceholders.clone();
|
|
for(int i = 0;i<tphs.size();i++){
|
|
TypePlaceholder tph = tphs.get(i);
|
|
for(Pair p : this.resultPairs){
|
|
if(p.TA1.equals(tph)){
|
|
ret.add(p);
|
|
if(p.TA2 instanceof TypePlaceholder && !tphs.contains(p.TA2))tphs.add((TypePlaceholder)p.TA2);
|
|
}else if(p.TA2.equals(tph)){
|
|
ret.add(p);
|
|
if(p.TA1 instanceof TypePlaceholder && !tphs.contains(p.TA1))tphs.add((TypePlaceholder)p.TA1);
|
|
}
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* Durchsucht das ResultSet nach Typen, die die übergebenen unresolvedTPHs als generische Variablen einbinden.
|
|
* @param unresolvedTPH
|
|
* @return
|
|
*/
|
|
public Vector<Type> getTypesInvolving(Vector<TypePlaceholder> unresolvedTPH) {
|
|
Vector<Type> ret = new Vector<Type>();
|
|
for(Pair p : this.resultPairs){
|
|
for(TypePlaceholder tph : unresolvedTPH){
|
|
if(p.TA1.involves(tph))ret.add(p.TA1);
|
|
if(p.TA2.involves(tph))ret.add(p.TA2);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
}
|