TypeInsert API anpassen

src/de/dhbwstuttgart/typedeployment/TypeInsert.java

@@ -11,18 +11,12 @@ public class TypeInsert {
     /**
      * point wird hauptsächlich zur Anzeige einer Annotation im Eclipse-plugin benutzt.
      */
-    public final Token point;
+    public final TypeInsertPoint point;
     Set<TypeInsertPoint> inserts;
 
-    public TypeInsert(Token point, String toInsert){
+    public TypeInsert(TypeInsertPoint point, Set<TypeInsertPoint> additionalPoints){
         this.point = point;
-        inserts = new HashSet<>();
+        inserts = additionalPoints;
-        inserts.add(new TypeInsertPoint(point, toInsert));
-    }
-
-    public TypeInsert(Token point, Set<TypeInsertPoint> points){
-        this.point = point;
-        inserts = points;
     }
 
     public String insert(String intoSource){
@@ -34,4 +28,8 @@ public class TypeInsert {
         }
         return ret;
     }
+
+    public String getInsertString(){
+        return point.getInsertString();
+    }
 }

src/de/dhbwstuttgart/typedeployment/TypeInsertFactory.java

@@ -1,5 +1,6 @@
 package de.dhbwstuttgart.typedeployment;
 
+import de.dhbwstuttgart.exceptions.DebugException;
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.syntaxtree.*;
 import de.dhbwstuttgart.syntaxtree.type.*;
@@ -16,6 +17,12 @@ import java.util.*;
  * Für die Instanzierung von Klassen kann man dann beispielsweise nur noch den Diamond-Operator verwenden
  *
  * Es müssen zu einem TPH alle in Beziehung stehenden Constraints gefunden werden
+ *
+ * Anmekung: Es wird nur ein RefType gleichzeitug eingesetzt.
+ * Steht dieser mit anderen Typen in Verbindung, so müssen diese nicht eingesetzt werden
+ * im Result set können nur TPHs mit <. Beziehung stehen
+ * Steht ein Typ A über TPHs mit anderen Typen B in Verbindung, so lassen sich diese auch im nächsten Durchgang
+ * inferieren, wenn A bereits eingesetzt wurde. Es werden dann eben zusätzliche Generics entstehen
  */
 public class TypeInsertFactory {
     public static List<TypeInsert> createTypeInsertPoints(SourceFile forSourcefile, ResultSet withResults){
@@ -25,29 +32,31 @@ public class TypeInsertFactory {
             for(Field field : cl.getFieldDecl()){
                 if(field.getType() instanceof TypePlaceholder){
                     for(Set<Pair> pairs : withResults.results)
-                        ret.add(new TypeInsert(field.getType().getOffset(), createInsertPoints(
+                        ret.add(createInsertPoints(
-                            field.getType(), field.getType().getOffset(), cl, null, pairs)));
+                            field.getType(), field.getType().getOffset(), cl, null, pairs));
                 }
             }
 
             for(Method m : cl.getMethods()){
-                for(Set<Pair> pairs : withResults.results)
+                if(m.getReturnType() instanceof TypePlaceholder)for(Set<Pair> pairs : withResults.results) {
-                    ret.add(new TypeInsert(m.getReturnType().getOffset(), createInsertPoints(
+                    ret.add(createInsertPoints(
-                        m.getReturnType(), m.getReturnType().getOffset(), cl, m, pairs)));
+                            m.getReturnType(), m.getReturnType().getOffset(), cl, m, pairs));
+                }
 
                 for(FormalParameter param : m.getParameterList().getFormalparalist()){
-                    for(Set<Pair> pairs : withResults.results)
+                    if(param.getType() instanceof TypePlaceholder)for(Set<Pair> pairs : withResults.results)
-                        ret.add(new TypeInsert(param.getType().getOffset(), createInsertPoints(
+                        ret.add(createInsertPoints(
-                            param.getType(), param.getType().getOffset(), cl, m, pairs)));
+                            param.getType(), param.getType().getOffset(), cl, m, pairs));
                 }
             }
         }
         return ret;
     }
 
-    private static Set<TypeInsertPoint> createInsertPoints(RefTypeOrTPHOrWildcardOrGeneric type, Token offset, ClassOrInterface cl, Method m,
+    private static TypeInsert createInsertPoints(RefTypeOrTPHOrWildcardOrGeneric type, Token offset, ClassOrInterface cl, Method m,
                                                     Set<Pair> pairs) {
         Set<TypeInsertPoint> ret = new HashSet<>();
+        TypeInsertPoint insertPoint = null;
         Set<TypePlaceholder> additionalInserts = new HashSet<>();
         for (Pair pair : pairs) {
             RefTypeOrTPHOrWildcardOrGeneric relatedType = null;
@@ -61,14 +70,20 @@ public class TypeInsertFactory {
                 if (pair.OperatorEqual()) { //resolved ist vom Typ RefType
                     RefType resolved = ((RefType) relatedType);
                     String insert = createInsertString(resolved, additionalInserts);
-                    ret.add(new TypeInsertPoint(offset, insert));
+                    insertPoint = new TypeInsertPoint(offset, insert);
+                    break;
                 } else { //Ansonsten ist es ein TPH
-                    additionalInserts.add((TypePlaceholder) type);
+                    //additionalInserts.add((TypePlaceholder) relatedType); //Sollte nicht notwendig sein
                     //Dann wurde er nicht aufgelöst und es kann nur der TPH als Generic eingesetzt werden:
-                    ret.add(new TypeInsertPoint(offset, ((TypePlaceholder) type).getName()));
+                    insertPoint = new TypeInsertPoint(offset, ((TypePlaceholder) type).getName());
+                    break;
                 }
             }
         }
+        if(insertPoint == null){ //Dann muss es ein TPH sein, welcher nicht im Result auftaucht
+            insertPoint = new TypeInsertPoint(offset, ((TypePlaceholder) type).getName());
+            additionalInserts.add(((TypePlaceholder) type));
+        }
         //Alle Bounds finden:
         Set<Pair> newGenerics = new HashSet<>();
         boolean added = true;
@@ -96,7 +111,8 @@ public class TypeInsertFactory {
 
         ret.add(createGenericInsert(newGenerics, cl, m));
 
-        return ret;
+        //return ret;
+        return new TypeInsert(insertPoint, ret);
     }
 
     private static String createInsertString(RefType resolved, Set<TypePlaceholder> additionalInserts) {

src/de/dhbwstuttgart/typedeployment/TypeInsertPoint.java

@@ -21,4 +21,8 @@ public class TypeInsertPoint {
                 .mapToInt((typeInsertPoint -> typeInsertPoint.insertString.length())).sum();
         return new StringBuilder(intoSource).insert(point.getStartIndex()+offset, insertString).toString();
     }
+
+    public String getInsertString() {
+        return insertString;
+    }
 }