Index: /ModelTranslator/src/de/uni_hildesheim/sse/trans/convert/DeclarationInConstraintFinderWithDepth.java =================================================================== --- /ModelTranslator/src/de/uni_hildesheim/sse/trans/convert/DeclarationInConstraintFinderWithDepth.java (revision 202) +++ /ModelTranslator/src/de/uni_hildesheim/sse/trans/convert/DeclarationInConstraintFinderWithDepth.java (revision 202) @@ -0,0 +1,195 @@ +package de.uni_hildesheim.sse.trans.convert; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Comparator; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import de.uni_hildesheim.sse.model.cst.CSTSemanticException; +import de.uni_hildesheim.sse.model.cst.Comment; +import de.uni_hildesheim.sse.model.cst.CompoundAccess; +import de.uni_hildesheim.sse.model.cst.CompoundInitializer; +import de.uni_hildesheim.sse.model.cst.ConstantValue; +import de.uni_hildesheim.sse.model.cst.ConstraintSyntaxTree; +import de.uni_hildesheim.sse.model.cst.ContainerInitializer; +import de.uni_hildesheim.sse.model.cst.ContainerOperationCall; +import de.uni_hildesheim.sse.model.cst.IConstraintTreeVisitor; +import de.uni_hildesheim.sse.model.cst.IfThen; +import de.uni_hildesheim.sse.model.cst.Let; +import de.uni_hildesheim.sse.model.cst.OCLFeatureCall; +import de.uni_hildesheim.sse.model.cst.Parenthesis; +import de.uni_hildesheim.sse.model.cst.Self; +import de.uni_hildesheim.sse.model.cst.UnresolvedExpression; +import de.uni_hildesheim.sse.model.cst.Variable; +import de.uni_hildesheim.sse.model.varModel.AbstractVariable; +import de.uni_hildesheim.sse.model.varModel.datatypes.OclKeyWords; + +/** + * Searches variable declartions in a CST sorted by the "depth" in the tree. + * + * @author Adam Krafczyk + */ +public class DeclarationInConstraintFinderWithDepth implements IConstraintTreeVisitor { + + private Map variables; + + private int currentDepth; + + /** + * Sole constructor for this class. + * @param cst A constraint where all nested {@link AbstractVariable}'s should be found. + */ + public DeclarationInConstraintFinderWithDepth(ConstraintSyntaxTree cst) { + variables = new HashMap(); + currentDepth = 0; + cst.accept(this); + } + + /** + * Getter for a sorted {@link List} of {@link AbstractVariable}s. + * + * @return A {@link List} of variable declarations sorted by the depth in the CST. + */ + public List getDeclarationsInOrder() { + Set> entrySet = variables.entrySet(); + @SuppressWarnings("unchecked") + Map.Entry[] entryArray = new Map.Entry[entrySet.size()]; + entryArray = entrySet.toArray(entryArray); + + Arrays.sort(entryArray, new Comparator< Map.Entry>() { + @Override + public int compare(Map.Entry o1, Map.Entry o2) { + int result = 0; + + if (o1.getValue() < o2.getValue()) { + result = -1; + } else if (o1.getValue() > o2.getValue()) { + result = 1; + } + + return result; + } + }); + + ArrayList list = new ArrayList(); + for (Map.Entry entry : entryArray) { + list.add(entry.getKey()); + } + return list; + } + + /** + * Adds the variable with the current depth or updates the depth if its smaller. + * + * @param var The variable to add. + */ + private void addVariable(AbstractVariable var) { + if (!variables.containsKey(var) || (variables.get(var) > currentDepth)) { + variables.put(var, currentDepth); + } + } + + @Override + public void visitConstantValue(ConstantValue value) { + // No function needed + } + + @Override + public void visitVariable(Variable variable) { + addVariable(variable.getVariable()); + } + + @Override + public void visitParenthesis(Parenthesis parenthesis) { + parenthesis.getExpr().accept(this); + } + + @Override + public void visitComment(Comment comment) { + comment.getExpr().accept(this); + } + + @Override + public void visitOclFeatureCall(OCLFeatureCall call) { + if (!call.getOperation().equals(OclKeyWords.NOT)) { // A not doesn't count + currentDepth++; + } + if (null != call.getOperand()) { // user defined function! + call.getOperand().accept(this); + } + for (int i = 0; i < call.getParameterCount(); i++) { + call.getParameter(i).accept(this); + } + if (!call.getOperation().equals(OclKeyWords.NOT)) { + currentDepth--; + } + } + + @Override + public void visitLet(Let let) { + addVariable(let.getVariable()); + currentDepth++; + let.getInExpression().accept(this); + currentDepth--; + } + + @Override + public void visitIfThen(IfThen ifThen) { + currentDepth++; + ifThen.getIfExpr().accept(this); + ifThen.getThenExpr().accept(this); + ifThen.getElseExpr().accept(this); + currentDepth--; + } + + @Override + public void visitContainerOperationCall(ContainerOperationCall call) { + currentDepth++; + call.getContainer().accept(this); + call.getExpression().accept(this); + for (int i = 0; i < call.getDeclaratorsCount(); i++) { + addVariable(call.getDeclarator(i)); + } + currentDepth--; + } + + @Override + public void visitCompoundAccess(CompoundAccess access) { + // access.inferDatatype() must be called before access.getResolvedSlot() can be called + try { + access.inferDatatype(); + } catch (CSTSemanticException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + addVariable(access.getResolvedSlot()); + currentDepth++; + access.getCompoundExpression().accept(this); + currentDepth--; + } + + @Override + public void visitUnresolvedExpression(UnresolvedExpression expression) { + // TODO Auto-generated method stub + } + + @Override + public void visitCompoundInitializer(CompoundInitializer initializer) { + // TODO Auto-generated method stub + } + + @Override + public void visitContainerInitializer(ContainerInitializer initializer) { + // TODO Auto-generated method stub + } + + @Override + public void visitSelf(Self self) { + // no variable declaration + } + + +} Index: /ModelTranslator/src/de/uni_hildesheim/sse/trans/convert/MaxTermConverter.java =================================================================== --- /ModelTranslator/src/de/uni_hildesheim/sse/trans/convert/MaxTermConverter.java (revision 201) +++ /ModelTranslator/src/de/uni_hildesheim/sse/trans/convert/MaxTermConverter.java (revision 202) @@ -14,4 +14,5 @@ import de.uni_hildesheim.sse.model.cst.CSTSemanticException; import de.uni_hildesheim.sse.model.cst.ConstraintSyntaxTree; +import de.uni_hildesheim.sse.model.cst.DebugConstraintTreeVisitor; import de.uni_hildesheim.sse.model.cst.OCLFeatureCall; import de.uni_hildesheim.sse.model.cst.Parenthesis; @@ -94,6 +95,5 @@ if (getSyntaxTreeLength(originalConstraint) >= MIN_SIMPLYIFY_LENGTH) { - LOGGER.info("Constraint (" + StringProvider.toIvmlString(originalConstraint) + ") is longer than " - + MIN_SIMPLYIFY_LENGTH + ", trying to simplify"); + LOGGER.info("Constraint is longer than " + MIN_SIMPLYIFY_LENGTH + ", trying to simplify"); // pull in NOT's as far as possible @@ -132,12 +132,21 @@ // Get an array of all variables in the constraint - DeclrationInConstraintFinder finder = new DeclrationInConstraintFinder(originalConstraint); - Set declarations = finder.getDeclarations(); - AbstractVariable[] declarationArray = declarations.toArray(new AbstractVariable[] {}); - Arrays.sort(declarationArray, new Comparator() { - public int compare(AbstractVariable o1, AbstractVariable o2) { - return o1.getName().compareTo(o2.getName()); - } - }); +// DeclrationInConstraintFinder finder = new DeclrationInConstraintFinder(originalConstraint); +// Set declarations = finder.getDeclarations(); +// AbstractVariable[] declarationArray = declarations.toArray(new AbstractVariable[] {}); +// Arrays.sort(declarationArray, new Comparator() { +// public int compare(AbstractVariable o1, AbstractVariable o2) { +// return o1.getName().compareTo(o2.getName()); +// } +// }); + DeclarationInConstraintFinderWithDepth finder = + new DeclarationInConstraintFinderWithDepth(originalConstraint); + AbstractVariable[] declarationArray = finder.getDeclarationsInOrder().toArray(new AbstractVariable[] {}); + + originalConstraint.accept(new DebugConstraintTreeVisitor()); + + for (AbstractVariable var : declarationArray) { + System.out.println(var.getName()); + } // Create a project which only contains our single Constraint Index: /ModelTranslator/test/de/uni_hildesheim/sse/trans/AllTests.java =================================================================== --- /ModelTranslator/test/de/uni_hildesheim/sse/trans/AllTests.java (revision 201) +++ /ModelTranslator/test/de/uni_hildesheim/sse/trans/AllTests.java (revision 202) @@ -9,6 +9,7 @@ import org.junit.runners.Suite.SuiteClasses; +import de.uni_hildesheim.sse.trans.convert.CSTExpanderTest; import de.uni_hildesheim.sse.trans.convert.CSTNegaterTest; -import de.uni_hildesheim.sse.trans.convert.CSTExpanderTest; +import de.uni_hildesheim.sse.trans.convert.DeclarationInConstraintFinderWithDepthTest; import de.uni_hildesheim.sse.trans.convert.DisjunctionCheckerTest; import de.uni_hildesheim.sse.trans.convert.LiteralFinderTest; @@ -39,5 +40,6 @@ RsfToDimacsTranslationTest.class, CSTNegaterTest.class, - CSTExpanderTest.class + CSTExpanderTest.class, + DeclarationInConstraintFinderWithDepthTest.class }) public class AllTests { Index: /ModelTranslator/test/de/uni_hildesheim/sse/trans/convert/DeclarationInConstraintFinderWithDepthTest.java =================================================================== --- /ModelTranslator/test/de/uni_hildesheim/sse/trans/convert/DeclarationInConstraintFinderWithDepthTest.java (revision 202) +++ /ModelTranslator/test/de/uni_hildesheim/sse/trans/convert/DeclarationInConstraintFinderWithDepthTest.java (revision 202) @@ -0,0 +1,44 @@ +package de.uni_hildesheim.sse.trans.convert; + +import static org.junit.Assert.assertEquals; + +import org.junit.Test; + +import de.uni_hildesheim.sse.model.cst.OCLFeatureCall; +import de.uni_hildesheim.sse.model.cst.Variable; +import de.uni_hildesheim.sse.model.varModel.DecisionVariableDeclaration; +import de.uni_hildesheim.sse.model.varModel.datatypes.BooleanType; +import de.uni_hildesheim.sse.model.varModel.datatypes.OclKeyWords; + +/** + * Tests the {@link DeclarationInConstraintFinderWithDepth} class. + * + * @author Adam Krafczyk + */ +public class DeclarationInConstraintFinderWithDepthTest { + + /** + * Tests if the number of found {@link AbstractVariable}s is correct. + */ + @Test + public void test() { + // Create Constraint with 3 variables + DecisionVariableDeclaration a = new DecisionVariableDeclaration("a", BooleanType.TYPE, null); + DecisionVariableDeclaration b = new DecisionVariableDeclaration("b", BooleanType.TYPE, null); + DecisionVariableDeclaration c = new DecisionVariableDeclaration("c", BooleanType.TYPE, null); + + Variable varA = new Variable(a); + Variable varB = new Variable(b); + Variable varC = new Variable(c); + + OCLFeatureCall call = new OCLFeatureCall(varA, OclKeyWords.AND, varB); + call = new OCLFeatureCall(call, OclKeyWords.OR, varC); + + DeclarationInConstraintFinderWithDepth finder = new DeclarationInConstraintFinderWithDepth(call); + + assertEquals(3, finder.getDeclarationsInOrder().size()); + + assertEquals(c, finder.getDeclarationsInOrder().get(0)); + } + +}