Index: /ModelExtender/src/de/uni_hildesheim/sse/model_extender/convert/ModelExtender.java
===================================================================
--- /ModelExtender/src/de/uni_hildesheim/sse/model_extender/convert/ModelExtender.java (revision 196)
+++ /ModelExtender/src/de/uni_hildesheim/sse/model_extender/convert/ModelExtender.java (revision 197)
@@ -5,4 +5,6 @@
import java.util.List;
import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
import de.uni_hildesheim.sse.model.cst.CSTSemanticException;
@@ -29,4 +31,8 @@
*/
public class ModelExtender {
+
+ // VARIABLE_NAME
+ // VARIABLE_NAME<=2
+ private static final Pattern VARIABLE_PATTERN = Pattern.compile("^([\\w']+)([<>=]{0,2})(.*)$");
private Project model;
@@ -78,57 +84,6 @@
for (AbstractVariable var : newVariables) {
- String name = var.getName();
- String baseName = null;
- Comparator comp = null;
- if (name.contains("<=")) {
- baseName = name.substring(0, name.indexOf("<="));
- final int value = Integer.parseInt(name.substring(name.indexOf("<=") + 2));
- comp = new Comparator() {
- @Override
- public boolean checkExpressions(int other) {
- return other <= value;
- }
- };
- } else if (name.contains(">=")) {
- baseName = name.substring(0, name.indexOf(">="));
- final int value = Integer.parseInt(name.substring(name.indexOf(">=") + 2));
- comp = new Comparator() {
- @Override
- public boolean checkExpressions(int other) {
- return other >= value;
- }
- };
- } else if (name.contains("=")) {
- baseName = name.substring(0, name.indexOf("="));
- final int value = Integer.parseInt(name.substring(name.indexOf("=") + 1));
- comp = new Comparator() {
- @Override
- public boolean checkExpressions(int other) {
- return other == value;
- }
- };
- } else if (name.contains("<")) {
- baseName = name.substring(0, name.indexOf("<"));
- final int value = Integer.parseInt(name.substring(name.indexOf("<") + 1));
- comp = new Comparator() {
- @Override
- public boolean checkExpressions(int other) {
- return other < value;
- }
- };
- } else if (name.contains(">")) {
- baseName = name.substring(0, name.indexOf(">"));
- final int value = Integer.parseInt(name.substring(name.indexOf(">") + 1));
- comp = new Comparator() {
- @Override
- public boolean checkExpressions(int other) {
- return other > value;
- }
- };
- } else {
- System.out.println("Warning: Added completly new variable to model: " + name);
- continue;
- }
- addAdditionalConstraints(var, baseName, comp);
+// System.out.println("Warning: Added completly new variable to model: " + name);
+ addAdditionalConstraints(var);
}
}
@@ -174,70 +129,228 @@
/**
- * Contains a single method to check if both conditions can be true.
- */
- private interface Comparator {
-
- /**
- * Checks if the two values after the operator in the expressions can be
- * true at the same time.
- * E.g.:
- * Assume we have the additional variable A>7
- * If we encounter the variable A=6 it would result in a call of
- * checkExpression(6);
- * A correct implementation of this {@link Comparator} for A>7 would return false,
- * since A>7 && A=6 (== 6>7) is false.
- *
- *
- * @param other The value of the other variable; this is the always the
- * part after the = in the other variable.
- * @return true if both can be true.
- */
- public boolean checkExpressions(int other);
-
- }
-
- /**
* Adds additional needed constraints for new variables that contain <, > or =.
*
- * @param variable The variable.
- * @param baseName The baseName of the variable.
- * @param comp The {@link Comparator} to check if two values can be true at the same time.
- */
- private void addAdditionalConstraints(AbstractVariable variable, String baseName, Comparator comp) {
- List vars = findAllVaraiblesWithBaseName(baseName);
-
- for (AbstractVariable var : vars) {
- String name = var.getName();
- int i = name.length() - 1;
- for (; i >= 0; i--) {
- if (name.charAt(i) < '0' || name.charAt(i) > '9') {
- i++;
- break;
- }
- }
- int value = 0;
- try {
- value = Integer.parseInt(name.substring(i));
- } catch (NumberFormatException e) {
- // probably =n
+ * @param additionalVariable The variable that gets added to the model.
+ */
+ private void addAdditionalConstraints(AbstractVariable additionalVariable) {
+ Matcher additionalVariableMatcher = VARIABLE_PATTERN.matcher(additionalVariable.getName());
+ if (!additionalVariableMatcher.matches()) {
+ System.err.println("Found invalid variable name: " + additionalVariable.getName());
+ return;
+ }
+ List variablesWithSameBasename
+ = findAllVaraiblesWithBaseName(additionalVariableMatcher.group(1));
+
+
+ String op1 = null;
+ int val1 = 0;
+ try {
+ op1 = additionalVariableMatcher.group(2);
+ val1 = Integer.parseInt(additionalVariableMatcher.group(3));
+ } catch (NumberFormatException e) {
+ op1 = null;
+ }
+
+ if (op1 == null) {
+ System.err.println("Warning: adding completly new variable: " + additionalVariable.getName());
+ return;
+ }
+
+ for (AbstractVariable variableWithSameBaseName : variablesWithSameBasename) {
+ Matcher varMatcher = VARIABLE_PATTERN.matcher(variableWithSameBaseName.getName());
+
+ if (!varMatcher.matches()) {
+ System.err.println("Found invalid variable name: " + variableWithSameBaseName.getName());
continue;
}
- Variable additional = varPool.obtainVariable(variable);
- Variable original = varPool.obtainVariable(var);
+ Variable additional = varPool.obtainVariable(additionalVariable);
+ Variable original = varPool.obtainVariable(variableWithSameBaseName);
OCLFeatureCall notAdditional = new OCLFeatureCall(additional, OclKeyWords.NOT);
OCLFeatureCall notOriginal = new OCLFeatureCall(original, OclKeyWords.NOT);
- if (comp.checkExpressions(value)) {
- // add original -> additional == additional || !original
- OCLFeatureCall tree = new OCLFeatureCall(additional, OclKeyWords.OR, notOriginal);
- addConstraint(tree);
- } else {
- // add additional xor original == (!additional || !original) && (additional || original)
- OCLFeatureCall leftSide = new OCLFeatureCall(notAdditional, OclKeyWords.OR, notOriginal);
- OCLFeatureCall rightSide = new OCLFeatureCall(additional, OclKeyWords.OR, original);
- addConstraint(leftSide);
- addConstraint(rightSide);
- }
- }
+ try {
+ String op2 = varMatcher.group(2);
+ int val2 = Integer.parseInt(varMatcher.group(3));
+
+ switch (intersect(op1, val1, op2, val2)) {
+ case NONE:
+ // additional -> !original AND original -> !additional
+ // = additional XOR original
+ // = (!additional OR !original) AND (additional OR original)
+ addConstraint(new OCLFeatureCall(notAdditional, OclKeyWords.OR, notOriginal));
+ addConstraint(new OCLFeatureCall(additional, OclKeyWords.OR, original));
+ break;
+
+ case ONE_IS_SUPERSET_OF_TWO:
+ // additional is superset of original
+ // original -> additional
+ // = additional OR !original
+ addConstraint(new OCLFeatureCall(additional, OclKeyWords.OR, notOriginal));
+ break;
+
+ case TWO_IS_SUPERSET_OF_ONE:
+ // original is superset of additional
+ // additional -> original
+ // = original OR !additional
+ addConstraint(new OCLFeatureCall(original, OclKeyWords.OR, notAdditional));
+ break;
+
+ case INTERSECT:
+ // TODO: no constraints?
+
+ break;
+
+ case EQUAL:
+ // additional = original
+ // = additional -> original AND original -> additional
+ // = original OR !additional AND additional OR !original
+ addConstraint(new OCLFeatureCall(original, OclKeyWords.OR, notAdditional));
+ addConstraint(new OCLFeatureCall(additional, OclKeyWords.OR, notOriginal));
+ break;
+
+ default:
+ // Why does checkstyle want a default here?!
+ }
+
+ } catch (NumberFormatException e) {
+ // ignore, probably '=n' or so
+ }
+ }
+ }
+
+ /**
+ * Possible types of intersections.
+ */
+ private enum IntersectionType {
+ /*
+ * e.g. >2 and <1
+ */
+ NONE,
+ /*
+ * e.g. >2 and >3
+ */
+ ONE_IS_SUPERSET_OF_TWO,
+ /*
+ * e.g. <2 and <3
+ */
+ TWO_IS_SUPERSET_OF_ONE,
+ /*
+ * e.g. >2 and <3
+ */
+ INTERSECT,
+
+ /*
+ * e.g. =2 and =2
+ */
+ EQUAL
+ }
+
+ /**
+ * Checks whether 2 interval definitions (e.g. >2, <= 7) overlap.
+ *
+ * @param op1 The first operator; must be "=", "<", ">", "<=" or ">=".
+ * @param val1 The value for the first operator.
+ * @param op2 The second operator; must be "=", "<", ">", "<=" or ">=".
+ * @param val2 The value for the second operator.
+ * @return The way the two intervals intersect.
+ */
+ private IntersectionType intersect(String op1, int val1, String op2, int val2) {
+ IntersectionType result = null;
+
+ if (op1.equals(">=")) {
+ op1 = ">";
+ val1 -= 1;
+ } else if (op1.equals("<=")) {
+ op1 = "<";
+ val1 += 1;
+ }
+
+ if (op2.equals(">=")) {
+ op2 = ">";
+ val2 -= 1;
+ } else if (op1.equals("<=")) {
+ op2 = "<";
+ val2 += 1;
+ }
+
+ if (op1.equals("=") && op2.equals("=")) {
+ if (val1 == val2) {
+ result = IntersectionType.EQUAL;
+ } else {
+ result = IntersectionType.NONE;
+ }
+
+ /*
+ * op1: '='
+ */
+ } else if (op1.equals("=") && op2.equals(">")) {
+ if (val1 > val2) {
+ result = IntersectionType.TWO_IS_SUPERSET_OF_ONE;
+ } else {
+ result = IntersectionType.NONE;
+ }
+ } else if (op1.equals("=") && op2.equals("<")) {
+ if (val1 < val2) {
+ result = IntersectionType.TWO_IS_SUPERSET_OF_ONE;
+ } else {
+ result = IntersectionType.NONE;
+ }
+
+ /*
+ * op2: '='
+ */
+ } else if (op2.equals("=") && op1.equals(">")) {
+ if (val1 > val2) {
+ result = IntersectionType.ONE_IS_SUPERSET_OF_TWO;
+ } else {
+ result = IntersectionType.NONE;
+ }
+ } else if (op2.equals("=") && op1.equals("<")) {
+ if (val1 < val2) {
+ result = IntersectionType.ONE_IS_SUPERSET_OF_TWO;
+ } else {
+ result = IntersectionType.NONE;
+ }
+
+ /*
+ * < and >
+ */
+ } else if (op1.equals(">") && op2.equals(">")) {
+ if (val1 < val2) {
+ result = IntersectionType.ONE_IS_SUPERSET_OF_TWO;
+ } else if (val1 == val2) {
+ result = IntersectionType.EQUAL;
+ } else {
+ result = IntersectionType.TWO_IS_SUPERSET_OF_ONE;
+ }
+
+ } else if (op1.equals("<") && op2.equals("<")) {
+ if (val1 > val2) {
+ result = IntersectionType.ONE_IS_SUPERSET_OF_TWO;
+ } else if (val1 == val2) {
+ result = IntersectionType.EQUAL;
+ } else {
+ result = IntersectionType.TWO_IS_SUPERSET_OF_ONE;
+ }
+
+ } else if (op1.equals("<") && op2.equals(">")) {
+ if (val1 - 1 >= val2 + 1) {
+ result = IntersectionType.INTERSECT;
+ } else {
+ result = IntersectionType.NONE;
+ }
+
+ } else if (op1.equals(">") && op2.equals("<")) {
+ if (val1 + 1 <= val2 - 1) {
+ result = IntersectionType.INTERSECT;
+ } else {
+ result = IntersectionType.NONE;
+ }
+
+ } else {
+ System.err.println("Unkown operator: " + op1 + " or " + op2);
+ }
+
+ return result;
}