Several changes to simplify changing identifiers programatically with the fm builder

Author: SundermannC

src/main/java/de/vill/model/Attribute.java

@@ -20,8 +20,8 @@
 public class Attribute<T> implements VariableReference {
 
     private int line;
-    private final String name;
-    private final T value;
+    private String name;
+    private T value;
     private Feature feature;
 
     /**
@@ -53,6 +53,8 @@ public T getValue() {
         return value;
     }
 
+    public void setValue(T value) { this.value = value; }
+
     /**
      * Returns the name of the attribute.
      *
@@ -62,6 +64,9 @@ public String getName() {
         return name;
     }
 
+    public void setName(String name) { this.name = name; }
+
+
     /**
      * Returns the type of the attribute
      * @return Name of the attribute (never null)

src/main/java/de/vill/model/GlobalAttribute.java

@@ -34,7 +34,7 @@ public static AttributeType fromString(String name) {
         }
     }
 
-    private final String identifier;
+    private String identifier;
     private AttributeType type;
     private final Set<Feature> featuresContainingAttribute;
 
@@ -55,6 +55,8 @@ public GlobalAttribute(String identifier, AttributeType type) {
         featuresContainingAttribute = new HashSet<>();
     }
 
+    public void renameGlobalAttribute(String newIdentifier) { this.identifier = newIdentifier;}
+
     public void addFeature(Feature feature) {
         featuresContainingAttribute.add(feature);
     }

src/main/java/de/vill/model/building/FeatureModelBuilder.java

@@ -3,7 +3,10 @@
 import de.vill.exception.ParseError;
 import de.vill.model.*;
 import de.vill.model.constraint.Constraint;
+import de.vill.model.constraint.ExpressionConstraint;
 import de.vill.model.constraint.LiteralConstraint;
+import de.vill.model.expression.AggregateFunctionExpression;
+import de.vill.model.expression.Expression;
 
 import java.util.List;
 import java.util.Map;
@@ -102,7 +105,7 @@ public void addAttribute(Feature feature, Attribute<?> attribute) {
      */
     public boolean renameFeature(String oldName, String newName) {
         Map<String, Feature> featureMap = fmInConstruction.getFeatureMap();
-        if (featureMap.containsKey(oldName)) {
+        if (!featureMap.containsKey(oldName)) {
             return false;
         }
         Feature featureToUpdate = featureMap.get(oldName);
@@ -116,6 +119,49 @@ public boolean renameFeature(String oldName, String newName) {
         return true;
     }
 
+    public void renameAttribute(Attribute<?> attribute, String newName) {
+        String oldName = attribute.getName();
+        attribute.setName(newName);
+        attribute.getFeature().getAttributes().remove(oldName);
+        attribute.getFeature().getAttributes().put(newName, attribute);
+    }
+
+    public void renameAttributeGlobally(String oldName, String newName) {
+        for (Feature feature : fmInConstruction.getFeatureMap().values()) {
+            if (feature.getAttributes().containsKey(oldName)) {
+                Attribute<?> attribute = feature.getAttributes().get(oldName);
+                renameAttribute(attribute, newName);
+            }
+        }
+        for (Constraint constraint : fmInConstruction.getConstraints()) {
+            crawlConstraintsToRenameGlobalAttribute(constraint, oldName, newName);
+        }
+    }
+    private void crawlConstraintsToRenameGlobalAttribute(Constraint constraint, String attributeName, String replace) {
+        if (constraint instanceof ExpressionConstraint) {
+            for (Expression exp : ((ExpressionConstraint) constraint).getExpressionSubParts()) {
+                crawlExpressionsToRenameGlobalAttribute(exp, attributeName, replace);
+            }
+        } else {
+            for (Constraint child : constraint.getConstraintSubParts()) {
+                crawlConstraintsToRenameGlobalAttribute(child, attributeName, replace);
+            }
+        }
+    }
+
+    private void crawlExpressionsToRenameGlobalAttribute(Expression expression, String attributeName, String replace) {
+        if (expression instanceof AggregateFunctionExpression) {
+            AggregateFunctionExpression aggregateFunctionExpression = (AggregateFunctionExpression) expression;
+            if (aggregateFunctionExpression.getAttribute().getIdentifier().equals(attributeName)) {
+                aggregateFunctionExpression.getAttribute().renameGlobalAttribute(replace);
+            };
+        } else {
+            for (Expression exp : expression.getExpressionSubParts()) {
+                crawlExpressionsToRenameGlobalAttribute(exp, attributeName, replace);
+            }
+        }
+    }
+
     public void addConstraint(Constraint constraint) {
         fmInConstruction.getOwnConstraints().add(0,constraint);
     }