From e6606d08eeb7cdac29be58008165a6dfa3255957 Mon Sep 17 00:00:00 2001 From: JanUlrich Date: Wed, 3 Jun 2015 11:27:39 +0200 Subject: [PATCH] ConstraintPair erbt von Pair --- .../typeinference/ConstraintPair.java | 10 +-- .../typeinference/ConstraintsSet.java | 30 ++++--- .../typeinference/OderConstraint.java | 16 ++-- .../typeinference/OderMenge.java | 63 ++------------- .../typeinference/SingleConstraint.java | 28 ++----- .../typeinference/UndConstraint.java | 31 +++++-- .../dhbwstuttgart/typeinference/UndMenge.java | 81 ++----------------- .../typeinference/unify/Unify.java | 18 ++--- 8 files changed, 77 insertions(+), 200 deletions(-) diff --git a/src/de/dhbwstuttgart/typeinference/ConstraintPair.java b/src/de/dhbwstuttgart/typeinference/ConstraintPair.java index cadbb845..220e5673 100644 --- a/src/de/dhbwstuttgart/typeinference/ConstraintPair.java +++ b/src/de/dhbwstuttgart/typeinference/ConstraintPair.java @@ -1,15 +1,9 @@ package de.dhbwstuttgart.typeinference; -public class ConstraintPair { +public class ConstraintPair extends Pair{ - private Pair p; - public ConstraintPair(ConstraintType t1, ConstraintType t2){ - p = new Pair(t1.getType(), t2.getType()); - } - - public Pair getPair(){ - return p; + super(t1.getType(), t2.getType()); } } diff --git a/src/de/dhbwstuttgart/typeinference/ConstraintsSet.java b/src/de/dhbwstuttgart/typeinference/ConstraintsSet.java index 96beb3be..48d4c4dc 100755 --- a/src/de/dhbwstuttgart/typeinference/ConstraintsSet.java +++ b/src/de/dhbwstuttgart/typeinference/ConstraintsSet.java @@ -6,7 +6,7 @@ import de.dhbwstuttgart.logger.Logger; import de.dhbwstuttgart.logger.*; import de.dhbwstuttgart.typeinference.unify.Unifier; -public class ConstraintsSet implements Iterable{ +public class ConstraintsSet extends UndMenge implements Iterable{ private static final Logger log = Logger.getLogger(ConstraintsSet.class.getName()); private Menge constraintsSet; @@ -21,19 +21,6 @@ public class ConstraintsSet implements Iterable{ public void add(OderConstraint constraint){ constraintsSet.add(constraint); } - - /** - * Liefert alle Constraint-Variationen - * @return - */ - public Vector> getConstraints(){ - Vector> ret = new Vector>(); - for(OderConstraint con : constraintsSet){ - ret.add(con.getUndConstraints()); - } - ret = new KarthesischesProdukt().berechneKarthesischesProdukt(ret); - return ret; - } @Override public String toString(){ @@ -66,12 +53,12 @@ public class ConstraintsSet implements Iterable{ } this.filterWrongConstraints( (pairs)->{ - Vector undConstraintsUndPairs = new Vector<>(); + Menge undConstraintsUndPairs = new Menge<>(); undConstraintsUndPairs.addAll(pairs); undConstraintsUndPairs.addAll(alleUndConstraints); log.debug("Versuche Pairs auszusondern:\n"+pairs, Section.TYPEINFERENCE); log.debug("Unifiziere:\n"+undConstraintsUndPairs, Section.TYPEINFERENCE); - Vector> unifyResult = unifier.apply(undConstraintsUndPairs); + Menge> unifyResult = unifier.apply(undConstraintsUndPairs); return unifyResult; }); } @@ -89,4 +76,15 @@ public class ConstraintsSet implements Iterable{ } return ret; } + + public void add(UndConstraint singleConstraint) { + OderConstraint toAdd = new OderConstraint(); + toAdd.addConstraint(singleConstraint); + constraintsSet.add(toAdd); + } + + @Override + public Menge> getSet() { + return this.constraintsSet; + } } diff --git a/src/de/dhbwstuttgart/typeinference/OderConstraint.java b/src/de/dhbwstuttgart/typeinference/OderConstraint.java index 1c734f79..0c631095 100755 --- a/src/de/dhbwstuttgart/typeinference/OderConstraint.java +++ b/src/de/dhbwstuttgart/typeinference/OderConstraint.java @@ -9,7 +9,7 @@ import de.dhbwstuttgart.syntaxtree.type.Type; import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder; import de.dhbwstuttgart.typeinference.unify.Unifier; -public class OderConstraint{ +public class OderConstraint extends OderMenge{ private Menge oderConstraintPairs; private final static Logger logger = Logger.getLogger(OderConstraint.class.getName()); @@ -35,8 +35,8 @@ public class OderConstraint{ * Liefert alle in diesem OderConstraint enthaltene Constraints. Dabei gehen die Verkn�pfungen (Oder/Und) verloren. * @return */ - public Vector getConstraintPairs(){ - Vector ret = new Vector(); + public Menge getConstraintPairs(){ + Menge ret = new Menge(); for(UndConstraint oC : this.oderConstraintPairs){ ret.addAll(oC.getConstraintPairs()); } @@ -85,9 +85,9 @@ public class OderConstraint{ } void filterWrongConstraints(Unifier unifier) { - Vector filteredConstraints = new Vector<>(); + Menge filteredConstraints = new Menge<>(); for(UndConstraint cons : this.getUndConstraints()){ - Vector> unifierResult = unifier.apply(cons.getConstraintPairs()); + Menge> unifierResult = unifier.apply(cons.getConstraintPairs()); if(!unifierResult.isEmpty()){ filteredConstraints.add(cons); }else{ @@ -103,5 +103,11 @@ public class OderConstraint{ } return null; } + + @Override + public Menge> getSet() { + return this.oderConstraintPairs; + } + } diff --git a/src/de/dhbwstuttgart/typeinference/OderMenge.java b/src/de/dhbwstuttgart/typeinference/OderMenge.java index 5d2a3ef9..ecaaead0 100644 --- a/src/de/dhbwstuttgart/typeinference/OderMenge.java +++ b/src/de/dhbwstuttgart/typeinference/OderMenge.java @@ -18,83 +18,32 @@ import de.dhbwstuttgart.typeinference.unify.Unifier; * Item */ -interface Mapper{ - B applyOrSet(OderMenge i); - B applyAndSet(UndMenge i); - B applySingle(EinzelElement i); -} interface KomplexeMenge{ - void addItems(KomplexeMenge item); - void addItem(A item); + Menge> getSet(); Menge> cartesianProduct(); - KomplexeMenge map(Mapper m); } -public class OderMenge implements KomplexeMenge{ - Menge> set = new Menge<>(); - - @Override - public void addItems(KomplexeMenge item) { - set.add(item); - } - - /* - public Menge getItems(){ - Menge ret = new Menge<>(); - for(KomplexeMenge i : set){ - ret.addAll(i.getItems()); - } - return ret; - } - */ - - @Override - public void addItem(A item) { - set.add(new EinzelElement(item)); - } +public abstract class OderMenge implements KomplexeMenge{ + + public abstract Menge> getSet(); @Override public Menge> cartesianProduct() { Menge> ret = new Menge<>(); - for(KomplexeMenge km : this.set){ + for(KomplexeMenge km : this.getSet()){ ret.addAll(km.cartesianProduct()); } return ret; } - - /* - @Override - public Menge> getOrSets() { - Menge> ret = new Menge<>(); - ret.add(this); - //for(KomplexeMenge i : set){ - // ret.addAll(i.getOrSets()); - //} - return ret; - } - - @Override - public Menge> getAndSets() { - Menge> ret = new Menge<>(); - for(KomplexeMenge i : set){ - ret.addAll(i.getAndSets()); - } - return ret; - } - */ @Override public String toString(){ String ret = "["; - for(KomplexeMenge i : set){ + for(KomplexeMenge i : this.getSet()){ ret += i.toString() + " | "; } return ret + "]"; } - @Override - public KomplexeMenge map(Mapper m) { - return m.applyOrSet(this); - } } diff --git a/src/de/dhbwstuttgart/typeinference/SingleConstraint.java b/src/de/dhbwstuttgart/typeinference/SingleConstraint.java index 2ab2e624..6ac5b4f6 100755 --- a/src/de/dhbwstuttgart/typeinference/SingleConstraint.java +++ b/src/de/dhbwstuttgart/typeinference/SingleConstraint.java @@ -21,6 +21,7 @@ import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException; * */ public class SingleConstraint extends UndConstraint{ + private Pair constraintPair; //entspricht θ condition θ' //private R condition; //entspricht der condition (R) @@ -39,8 +40,8 @@ public class SingleConstraint extends UndConstraint{ } @Override //Methode überschreiben, damit immer nur ein Vector mit nur einem Element zurückgeliefert wird. - public Vector getConstraintPairs(){ - Vector ret = new Vector(); + public Menge getConstraintPairs(){ + Menge ret = new Menge(); ret.add(constraintPair); return ret; } @@ -48,28 +49,9 @@ public class SingleConstraint extends UndConstraint{ public void addConstraint(ConstraintPair toAdd){ if(constraintPair != null)throw new DebugException("Ein Constraint darf nur aus einem ConstraintPair bestehen. Das hinzufügen von "+ toAdd + " ist nicht möglich."); - Type p1 = toAdd.getPair().TA1; - Type p2 = toAdd.getPair().TA2; + Type p1 = toAdd.TA1; + Type p2 = toAdd.TA2; if(p1==null || p2 == null)throw new NullPointerException(); - - - //Hier werden die GTVs zu TPH gewandelt. - //if(p1 instanceof RefType)((RefType)p1).GTV2TPH(); - //if(p2 instanceof RefType)((RefType)p2).GTV2TPH(); - - //if((p1 instanceof GenericTypeVar))p1 = ((GenericTypeVar)p1).getTypePlaceHolder();//throw new DebugException("GenericTypeVar sind in den Constraints nicht erlaubt");// - //if((p2 instanceof GenericTypeVar))p2 = ((GenericTypeVar)p2).getTypePlaceHolder();//throw new DebugException("GenericTypeVar sind in den Constraints nicht erlaubt");// - - // BaseTypes werden in RefTypes umgewandelt. Constraints dürfen nur RefTypes oder TypePlaceholder enthalten, da sonst der Unify-Algorithmus nicht funktioniert. - //if(!(p1 instanceof RefType) && !(p1 instanceof TypePlaceholder) && !(p1 instanceof GenericTypeVar))p1 = new RefType(p1); - //if(!(p2 instanceof RefType) && !(p2 instanceof TypePlaceholder) && !(p2 instanceof GenericTypeVar))p2 = new RefType(p2); - - //if(!(TypePlaceholder.class.isInstance(p1)) || !(RefType.class.isInstance(p1)) || !(TypePlaceholder.class.isInstance(p2)) || !(RefType.class.isInstance(p2))) - //{//Wenn die beiden übergebenen Typen weder RefTypes noch TypePlaceholder sind: - // throw new TypinferenzException("Ein Constraint darf nur aus TypePlaceholdern und Reftypes bestehen"); - //} - //if(!(p1 instanceof RefType) && !(p1 instanceof TypePlaceholder))throw new DebugException("Fehler: "+p2+" kann nicht in TPH oder RefType umgewandelt werden"); - //if(!(p2 instanceof RefType) && !(p2 instanceof TypePlaceholder))throw new DebugException("Fehler: "+p2+" kann nicht in TPH oder RefType umgewandelt werden"); constraintPair = new Pair(p1,p2); } diff --git a/src/de/dhbwstuttgart/typeinference/UndConstraint.java b/src/de/dhbwstuttgart/typeinference/UndConstraint.java index 6dd7ec14..a204b426 100755 --- a/src/de/dhbwstuttgart/typeinference/UndConstraint.java +++ b/src/de/dhbwstuttgart/typeinference/UndConstraint.java @@ -1,8 +1,10 @@ package de.dhbwstuttgart.typeinference; +import java.util.Collection; import java.util.Vector; import de.dhbwstuttgart.syntaxtree.type.Type; +import de.dhbwstuttgart.typeinference.exceptions.DebugException; import de.dhbwstuttgart.typeinference.unify.Unifier; /** @@ -10,14 +12,32 @@ import de.dhbwstuttgart.typeinference.unify.Unifier; * @author janulrich * */ -public class UndConstraint extends OderConstraint { +public class UndConstraint extends UndMenge { - public UndConstraint(ConstraintType p1, ConstraintType p2) { - super(p1, p2); + Menge> set = new Menge<>(); + + @Override + public Menge> getSet() { + return set; } - public UndConstraint() { - super(); + public Menge getConstraintPairs() { + Menge> ret = this.cartesianProduct(); + if(ret.size() != 1){ + //UndConstraints enthalten nur SingleConstraints, wodurch das Karthesische Produkt nur aus einem Element bestehen kann. + throw new DebugException("Fehler in ConstraintPairs-Bildung"); + } + return ret.firstElement(); + } + + public void addConstraint(ConstraintType type, ConstraintType rT) { + Pair p = new ConstraintPair(type, rT); + this.set.add(new EinzelElement(p)); + } + +/* + public UndConstraint(ConstraintType p1, ConstraintType p2) { + super(p1, p2); } @Override @@ -47,4 +67,5 @@ public class UndConstraint extends OderConstraint { UndConstraint filterUndConstraints(){ return this; } +*/ } diff --git a/src/de/dhbwstuttgart/typeinference/UndMenge.java b/src/de/dhbwstuttgart/typeinference/UndMenge.java index fff77db7..98168c1c 100644 --- a/src/de/dhbwstuttgart/typeinference/UndMenge.java +++ b/src/de/dhbwstuttgart/typeinference/UndMenge.java @@ -5,33 +5,15 @@ import java.util.Iterator; import com.rits.cloning.Cloner; -public class UndMenge implements KomplexeMenge{ - Menge> set = new Menge<>(); - - @Override - public void addItems(KomplexeMenge item) { - set.add(item); - } - - public void addItem(A item){ - set.add(new EinzelElement(item)); - } - - /* - public Menge getItems(){ - Menge ret = new Menge<>(); - for(KomplexeMenge i : set){ - ret.addAll(i.getItems()); - } - return ret; - } - */ +public abstract class UndMenge implements KomplexeMenge{ + + public abstract Menge> getSet(); @Override public Menge> cartesianProduct() { Menge> ret = null; Cloner cloner = new Cloner(); - for(KomplexeMenge km : this.set){ + for(KomplexeMenge km : this.getSet()){ if(ret == null){ ret = km.cartesianProduct(); }else{ @@ -49,29 +31,9 @@ public class UndMenge implements KomplexeMenge{ return ret; } - /* - @Override - public Menge> getOrSets() { - Menge> ret = new Menge<>(); - for(KomplexeMenge i : set){ - ret.addAll(i.getOrSets()); - } - return ret; - } - - @Override - public Menge> getAndSets() { - Menge> ret = new Menge<>(); - ret.add(this); - //for(KomplexeMenge i : set){ - // ret.addAll(i.getAndSets()); - //} - return ret; - } - */ public String toString(){ String ret = "["; - for(KomplexeMenge item : set){ + for(KomplexeMenge item : this.getSet()){ ret += item.toString() + " , "; } return ret + "]"; @@ -85,25 +47,12 @@ class EinzelElement implements KomplexeMenge{ public EinzelElement(A element){ item = element; } - - @Override - public void addItems(KomplexeMenge item) { - - } - /* - @Override - public Menge getItems() { - Menge ret = new Menge<>(); - ret.add(item); + public Menge> getSet(){ + Menge> ret = new Menge<>(); + ret.add(this); return ret; } - */ - - @Override - public void addItem(A item) { - - } @Override public Menge> cartesianProduct() { @@ -115,20 +64,6 @@ class EinzelElement implements KomplexeMenge{ return ret; } - /* - @Override - public Menge> getOrSets() { - Menge> ret = new Menge<>(); - return ret; - } - - @Override - public Menge> getAndSets() { - Menge> ret = new Menge<>(); - return ret; - } - */ - @Override public String toString(){ return item.toString(); diff --git a/src/de/dhbwstuttgart/typeinference/unify/Unify.java b/src/de/dhbwstuttgart/typeinference/unify/Unify.java index 5ddca360..6569360f 100755 --- a/src/de/dhbwstuttgart/typeinference/unify/Unify.java +++ b/src/de/dhbwstuttgart/typeinference/unify/Unify.java @@ -630,6 +630,8 @@ public class Unify } } //Schritt 4, Teil 2: Kartesisches Produkt bilden. + + /* //TODO: Vor der Bildung des Karthesischen Produkts unmögliche Kombinationen ausfiltern //cartProduktSets kontrollieren: ConstraintsSet cSet = new ConstraintsSet(); @@ -661,22 +663,12 @@ public class Unify cSet.filterWrongConstraints(filterUnify); } - /* - for (Menge> vecvecpair : cartProduktSets){ - OderConstraint orConstraints = new OderConstraint(); - for(Menge pairs : vecvecpair){ - UndConstraint uCons = new UndConstraint(); - for(Pair p : pairs){ - uCons.addConstraint(new ConstraintPair(p.TA1)); - } - } - } - */ Menge> bigCartProductErg = cSet.cartesianProduct(); if(filter)log.debug("Karthesisches Produkt nach Filterung: "+bigCartProductErg); + */ - /* + ///* //Hier wird aus den in Schritt 4, Teil 1 erzeugten Vektoren das Kartesische Produkt gebildet. Menge helpvp; Menge> bigCartProductErg = new Menge>(); @@ -696,7 +688,7 @@ public class Unify } } } - */ + //*/ //Schritt 5: Einsetzen der Subst Regel //Hier werden die TPHs substituiert, und dann nach geänderten und nicht geänderten Sets sortiert.