| /******************************************************************************* |
| * Copyright (c) 2004-2008 Peter Pasztor, Akos Horvath, Gergely Varro, Istvan Rath and Daniel Varro |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Peter Pasztor, Akos Horvath, Gergely Varro, Istvan Rath - initial API and implementation |
| *******************************************************************************/ |
| |
| package org.eclipse.viatra2.gtasm.interpreter.term.rules; |
| |
| |
| import org.eclipse.viatra2.gtasm.interpreter.exception.ViatraTransformationException; |
| import org.eclipse.viatra2.gtasm.interpreter.executionEnvironment.IExecutionEnvironment; |
| import org.eclipse.viatra2.gtasm.interpreter.term.internal.TermInterpreterErrorString; |
| import org.eclipse.viatra2.gtasm.interpreter.term.internal.TermInterpreterException; |
| import org.eclipse.viatra2.gtasmmodel.gtasm.metamodel.asm.enums.MultiplicityKind; |
| import org.eclipse.viatra2.gtasmmodel.gtasm.metamodel.asm.enums.ValueKind; |
| import org.eclipse.viatra2.gtasmmodel.gtasm.metamodel.asm.terms.Term; |
| import org.eclipse.viatra2.gtasmmodel.gtasm.metamodel.asm.terms.builtInFunctions.And; |
| import org.eclipse.viatra2.gtasmmodel.gtasm.metamodel.asm.terms.builtInFunctions.Equals; |
| import org.eclipse.viatra2.gtasmmodel.gtasm.metamodel.asm.terms.builtInFunctions.GreaterThan; |
| import org.eclipse.viatra2.gtasmmodel.gtasm.metamodel.asm.terms.builtInFunctions.GreaterThanOrEqualTo; |
| import org.eclipse.viatra2.gtasmmodel.gtasm.metamodel.asm.terms.builtInFunctions.LessThan; |
| import org.eclipse.viatra2.gtasmmodel.gtasm.metamodel.asm.terms.builtInFunctions.LessThanOrEqualTo; |
| import org.eclipse.viatra2.gtasmmodel.gtasm.metamodel.asm.terms.builtInFunctions.Not; |
| import org.eclipse.viatra2.gtasmmodel.gtasm.metamodel.asm.terms.builtInFunctions.NotEquals; |
| import org.eclipse.viatra2.gtasmmodel.gtasm.metamodel.asm.terms.builtInFunctions.Or; |
| import org.eclipse.viatra2.gtasmmodel.gtasm.metamodel.asm.terms.builtInFunctions.RelationalOperation; |
| import org.eclipse.viatra2.gtasmmodel.gtasm.metamodel.asm.terms.builtInFunctions.XOr; |
| |
| |
| /**All relation operation evaluation are implemented by the class |
| * @author Peter Pasztor, Akos Horvath |
| * |
| */ |
| public class RelationalOperationEvaluator extends TermEvaluator { |
| |
| private static RelationalOperationEvaluator _instance = new RelationalOperationEvaluator(); |
| |
| private RelationalOperationEvaluator() { |
| ; |
| } |
| |
| public static RelationalOperationEvaluator getInstance() { |
| return _instance; |
| } |
| |
| @Override |
| public Object evaluate(IExecutionEnvironment executionEnvironment, |
| Term termToBeEvaluated) throws ViatraTransformationException { |
| RelationalOperation relationalOperation = (RelationalOperation) termToBeEvaluated; |
| |
| // Not is an operation with one parameter! Every other relational |
| // operations have two parameters. |
| |
| if (relationalOperation instanceof Not) // only boolean is accepted |
| { |
| Object op1 = TermEvaluator.getInstance() |
| .evaluate(executionEnvironment, |
| (relationalOperation.getActualParameters() |
| .get(0))); |
| if(op1 instanceof Boolean) |
| return !((Boolean)op1); |
| else |
| { |
| String[] context = {relationalOperation.getName() ,convertToJavaType(op1)}; |
| throw new TermInterpreterException( |
| TermInterpreterErrorString.TERM_NOT_BOOL_COMPATIBLE |
| , context |
| , relationalOperation); |
| } |
| } |
| // TODO: should the term be always evaluated? For example at an And |
| // operation, if the first parameter is false, it's unnecessary to |
| // evaluate the second parameter. |
| |
| if (relationalOperation.getActualParameters().size() != 2) |
| { |
| String[] context = {relationalOperation.getName()}; |
| throw new TermInterpreterException(TermInterpreterErrorString.PARAM_NUM_RELATIONAL |
| ,context |
| ,relationalOperation); |
| } |
| |
| // First we have to evaluate both parameters, and then perform the |
| // operation. |
| |
| Object op1 = TermEvaluator.getInstance().evaluate( |
| executionEnvironment, |
| (relationalOperation.getActualParameters().get(0))); |
| Object op2 = TermEvaluator.getInstance().evaluate( |
| executionEnvironment, |
| (relationalOperation.getActualParameters().get(1))); |
| |
| if (relationalOperation instanceof And) { |
| if (op1 instanceof Boolean) { |
| if (op2 instanceof Boolean) |
| return ((Boolean) op1) && ((Boolean) op2); |
| else |
| {String[] context = {relationalOperation.getName(),convertToJavaType(op1), convertToJavaType(op2)}; |
| throw new TermInterpreterException( |
| TermInterpreterErrorString.PARAM_NOT_SUITABLE_WITH_OPERATION_2, |
| context, |
| termToBeEvaluated); |
| } |
| } else if (op1 instanceof MultiplicityKind) { |
| if (((MultiplicityKind.ONE_TO_ONE_LITERAL.equals(op1)) && (op2 instanceof MultiplicityKind)) |
| || ((MultiplicityKind.ONE_TO_ONE_LITERAL.equals(op2)) && (op1 instanceof MultiplicityKind)) |
| || ((MultiplicityKind.ONE_TO_MANY_LITERAL.equals(op1)) && (MultiplicityKind.MANY_TO_ONE_LITERAL |
| .equals(op2))) |
| || ((MultiplicityKind.ONE_TO_MANY_LITERAL.equals(op2)) && (MultiplicityKind.MANY_TO_ONE_LITERAL |
| .equals(op1)))) |
| return MultiplicityKind.ONE_TO_ONE_LITERAL; |
| |
| else if (((MultiplicityKind.MANY_TO_MANY_LITERAL.equals(op1)) && (MultiplicityKind.ONE_TO_MANY_LITERAL |
| .equals(op2))) |
| || ((MultiplicityKind.MANY_TO_MANY_LITERAL.equals(op2)) && (MultiplicityKind.ONE_TO_MANY_LITERAL |
| .equals(op1))) |
| || ((MultiplicityKind.ONE_TO_MANY_LITERAL.equals(op1)) && (MultiplicityKind.ONE_TO_MANY_LITERAL |
| .equals(op2)))) |
| return MultiplicityKind.ONE_TO_MANY_LITERAL; |
| else if (((MultiplicityKind.MANY_TO_MANY_LITERAL.equals(op1)) && (MultiplicityKind.MANY_TO_ONE_LITERAL |
| .equals(op2))) |
| || ((MultiplicityKind.MANY_TO_MANY_LITERAL.equals(op2)) && (MultiplicityKind.MANY_TO_ONE_LITERAL |
| .equals(op1))) |
| || ((MultiplicityKind.MANY_TO_ONE_LITERAL.equals(op1)) && (MultiplicityKind.MANY_TO_ONE_LITERAL |
| .equals(op2)))) |
| return MultiplicityKind.MANY_TO_ONE_LITERAL; |
| else if (((MultiplicityKind.MANY_TO_MANY_LITERAL.equals(op1)) && (MultiplicityKind.MANY_TO_MANY_LITERAL |
| .equals(op2)))) |
| return MultiplicityKind.MANY_TO_MANY_LITERAL; |
| else |
| {String[] context = {relationalOperation.getName(),convertToJavaType(op1), convertToJavaType(op2)}; |
| throw new TermInterpreterException( |
| TermInterpreterErrorString.PARAM_NOT_SUITABLE_WITH_OPERATION_2, |
| context, |
| termToBeEvaluated); |
| } |
| } else |
| {String[] context = {relationalOperation.getName(),convertToJavaType(op1), convertToJavaType(op2)}; |
| throw new TermInterpreterException( |
| TermInterpreterErrorString.PARAM_NOT_SUITABLE_WITH_OPERATION_1, |
| context, |
| termToBeEvaluated); |
| } |
| } else if (relationalOperation instanceof Or) { |
| if (op1 instanceof Boolean) { |
| if (op2 instanceof Boolean) |
| return ((Boolean) op1) || ((Boolean) op2); |
| else |
| {String[] context = {relationalOperation.getName(),convertToJavaType(op1), convertToJavaType(op2)}; |
| throw new TermInterpreterException( |
| TermInterpreterErrorString.PARAM_NOT_SUITABLE_WITH_OPERATION_2, |
| context, |
| termToBeEvaluated); |
| } |
| } else if (op1 instanceof MultiplicityKind) { |
| if (((MultiplicityKind.MANY_TO_MANY_LITERAL.equals(op1)) && (op2 instanceof MultiplicityKind)) |
| || ((MultiplicityKind.MANY_TO_MANY_LITERAL.equals(op2)) && (op1 instanceof MultiplicityKind)) |
| || ((MultiplicityKind.ONE_TO_MANY_LITERAL.equals(op1)) && (MultiplicityKind.MANY_TO_ONE_LITERAL |
| .equals(op2))) |
| || ((MultiplicityKind.ONE_TO_MANY_LITERAL.equals(op2)) && (MultiplicityKind.MANY_TO_ONE_LITERAL |
| .equals(op1)))) |
| return MultiplicityKind.MANY_TO_MANY_LITERAL; |
| |
| else if (((MultiplicityKind.ONE_TO_ONE_LITERAL.equals(op1)) && (MultiplicityKind.MANY_TO_ONE_LITERAL |
| .equals(op2))) |
| || ((MultiplicityKind.ONE_TO_ONE_LITERAL.equals(op2)) && (MultiplicityKind.MANY_TO_ONE_LITERAL |
| .equals(op1))) |
| || ((MultiplicityKind.MANY_TO_ONE_LITERAL.equals(op1)) && (MultiplicityKind.MANY_TO_ONE_LITERAL |
| .equals(op2)))) |
| return MultiplicityKind.MANY_TO_ONE_LITERAL; |
| else if (((MultiplicityKind.ONE_TO_ONE_LITERAL.equals(op1)) && (MultiplicityKind.ONE_TO_MANY_LITERAL |
| .equals(op2))) |
| || ((MultiplicityKind.ONE_TO_ONE_LITERAL.equals(op2)) && (MultiplicityKind.ONE_TO_MANY_LITERAL |
| .equals(op1))) |
| || ((MultiplicityKind.ONE_TO_MANY_LITERAL.equals(op1)) && (MultiplicityKind.ONE_TO_MANY_LITERAL |
| .equals(op2)))) |
| return MultiplicityKind.ONE_TO_MANY_LITERAL; |
| else if (((MultiplicityKind.ONE_TO_ONE_LITERAL.equals(op1)) && (MultiplicityKind.ONE_TO_ONE_LITERAL |
| .equals(op2)))) |
| return MultiplicityKind.ONE_TO_ONE_LITERAL; |
| else |
| {String[] context = {relationalOperation.getName(),convertToJavaType(op1), convertToJavaType(op2)}; |
| throw new TermInterpreterException( |
| TermInterpreterErrorString.PARAM_NOT_SUITABLE_WITH_OPERATION_2, |
| context, |
| termToBeEvaluated); |
| } |
| } else |
| {String[] context = {relationalOperation.getName(),convertToJavaType(op1), convertToJavaType(op2)}; |
| throw new TermInterpreterException( |
| TermInterpreterErrorString.PARAM_NOT_SUITABLE_WITH_OPERATION_1, |
| context, |
| termToBeEvaluated); |
| } |
| } else if (relationalOperation instanceof XOr) { |
| if (op1 instanceof Boolean) { |
| if (op2 instanceof Boolean) |
| return !((Boolean) op1).equals((op2)); |
| else |
| {String[] context = {relationalOperation.getName(),convertToJavaType(op1), convertToJavaType(op2)}; |
| throw new TermInterpreterException( |
| TermInterpreterErrorString.PARAM_NOT_SUITABLE_WITH_OPERATION_2, |
| context, |
| termToBeEvaluated); |
| } |
| } else |
| {String[] context = {relationalOperation.getName(),convertToJavaType(op1), convertToJavaType(op2)}; |
| throw new TermInterpreterException( |
| TermInterpreterErrorString.PARAM_NOT_SUITABLE_WITH_OPERATION_1, |
| context, |
| termToBeEvaluated); |
| } |
| } else if (relationalOperation instanceof NotEquals) // Valid for any |
| // type. |
| { |
| if (op1 instanceof Integer) { |
| if (op2 instanceof Double) |
| return (((Integer) op1).intValue() != ((Double) op2) |
| .doubleValue()); |
| else |
| return !(op1.equals(op2)); |
| } else if (op1 instanceof Double) { |
| if (op2 instanceof Integer) |
| return (((Double) op1).doubleValue() != ((Integer) op2) |
| .intValue()); |
| else |
| return !(op1.equals(op2)); |
| } else |
| return !(op1.equals(op2)); |
| } else if (relationalOperation instanceof Equals) // Valid for any |
| // type. |
| { |
| if (op1 instanceof Integer) { |
| if (op2 instanceof Double) |
| return (((Integer) op1).intValue() == ((Double) op2) |
| .doubleValue()); |
| else |
| return (op1.equals(op2)); |
| } else if (op1 instanceof Double) { |
| if (op2 instanceof Integer) |
| return (((Double) op1).doubleValue() == ((Integer) op2) |
| .intValue()); |
| else |
| return (op1.equals(op2)); |
| } else |
| return (op1.equals(op2)); |
| |
| } else if (relationalOperation instanceof LessThan) { |
| if (op1 instanceof Integer) { |
| if (op2 instanceof Integer) |
| return ((Integer) op1) < ((Integer) op2); |
| else if (op2 instanceof Double) |
| return (Double.valueOf((((Integer) op1).doubleValue())) < ((Double) op2)); |
| else if (ValueKind.UNDEF_LITERAL.equals(op2)) |
| return Boolean.FALSE; |
| else |
| {String[] context = {relationalOperation.getName(),convertToJavaType(op1), convertToJavaType(op2)}; |
| throw new TermInterpreterException( |
| TermInterpreterErrorString.PARAM_NOT_SUITABLE_WITH_OPERATION_2, |
| context, |
| termToBeEvaluated); |
| } |
| } else if (op1 instanceof Double) { |
| if (op2 instanceof Integer) |
| return ((Double) op1) < (new Double(((Integer) op2))); |
| else if (op2 instanceof Double) |
| return ((Double) op1) < ((Double) op2); |
| else if (ValueKind.UNDEF_LITERAL.equals(op2)) |
| return Boolean.FALSE; |
| else |
| {String[] context = {relationalOperation.getName(),convertToJavaType(op1), convertToJavaType(op2)}; |
| throw new TermInterpreterException( |
| TermInterpreterErrorString.PARAM_NOT_SUITABLE_WITH_OPERATION_2, |
| context, |
| termToBeEvaluated); |
| } |
| } else if (op1 instanceof String) { |
| if (op2 instanceof String) |
| return ((((String) op1).compareTo(((String) op2))) < 0); |
| else if (ValueKind.UNDEF_LITERAL.equals(op2)) |
| return Boolean.FALSE; |
| else |
| {String[] context = {relationalOperation.getName(),convertToJavaType(op1), convertToJavaType(op2)}; |
| throw new TermInterpreterException( |
| TermInterpreterErrorString.PARAM_NOT_SUITABLE_WITH_OPERATION_2, |
| context, |
| termToBeEvaluated); |
| } |
| } else if (op1 instanceof Boolean) { |
| if (op2 instanceof Boolean) |
| return !((Boolean) op1) ? (((Boolean) op2)) : Boolean.FALSE; |
| else if (ValueKind.UNDEF_LITERAL.equals(op2)) |
| return Boolean.FALSE; |
| else |
| {String[] context = {relationalOperation.getName(),convertToJavaType(op1), convertToJavaType(op2)}; |
| throw new TermInterpreterException( |
| TermInterpreterErrorString.PARAM_NOT_SUITABLE_WITH_OPERATION_2, |
| context, |
| termToBeEvaluated); |
| } |
| } else if (op1 instanceof MultiplicityKind) { |
| if (op2 instanceof MultiplicityKind) { |
| if (MultiplicityKind.ONE_TO_ONE_LITERAL.equals(op1) |
| && !MultiplicityKind.ONE_TO_ONE_LITERAL.equals(op2)) |
| return Boolean.TRUE; |
| else if (MultiplicityKind.MANY_TO_ONE_LITERAL.equals(op1) |
| && MultiplicityKind.MANY_TO_MANY_LITERAL |
| .equals(op2)) |
| return Boolean.TRUE; |
| else if (MultiplicityKind.ONE_TO_MANY_LITERAL.equals(op1) |
| && MultiplicityKind.MANY_TO_MANY_LITERAL |
| .equals(op2)) |
| return Boolean.TRUE; |
| else |
| return Boolean.FALSE; |
| } else if (ValueKind.UNDEF_LITERAL.equals(op2)) |
| return Boolean.FALSE; |
| else |
| {String[] context = {relationalOperation.getName(),convertToJavaType(op1), convertToJavaType(op2)}; |
| throw new TermInterpreterException( |
| TermInterpreterErrorString.PARAM_NOT_SUITABLE_WITH_OPERATION_2, |
| context, |
| termToBeEvaluated); |
| } |
| |
| } else if (ValueKind.UNDEF_LITERAL.equals(op1)) |
| return Boolean.FALSE; |
| else |
| {String[] context = {relationalOperation.getName(),convertToJavaType(op1), convertToJavaType(op2)}; |
| throw new TermInterpreterException( |
| TermInterpreterErrorString.PARAM_NOT_SUITABLE_WITH_OPERATION_1, |
| context, |
| termToBeEvaluated); |
| } |
| |
| } else if (relationalOperation instanceof GreaterThan) { |
| if (op1 instanceof Integer) { |
| if (op2 instanceof Integer) |
| return ((Integer) op1) > ((Integer) op2); |
| else if (op2 instanceof Double) |
| return (Double.valueOf((((Integer) op1).doubleValue())) > ((Double) op2)); |
| else if (ValueKind.UNDEF_LITERAL.equals(op2)) |
| return Boolean.FALSE; |
| else |
| {String[] context = {relationalOperation.getName(),convertToJavaType(op1), convertToJavaType(op2)}; |
| throw new TermInterpreterException( |
| TermInterpreterErrorString.PARAM_NOT_SUITABLE_WITH_OPERATION_2, |
| context, |
| termToBeEvaluated); |
| } |
| } else if (op1 instanceof Double) { |
| if (op2 instanceof Integer) |
| return ((Double) op1) > (new Double(((Integer) op2))); |
| else if (op2 instanceof Double) |
| return ((Double) op1) > ((Double) op2); |
| else if (ValueKind.UNDEF_LITERAL.equals(op2)) |
| return Boolean.FALSE; |
| else |
| {String[] context = {relationalOperation.getName(),convertToJavaType(op1), convertToJavaType(op2)}; |
| throw new TermInterpreterException( |
| TermInterpreterErrorString.PARAM_NOT_SUITABLE_WITH_OPERATION_2, |
| context, |
| termToBeEvaluated); |
| } |
| |
| } else if (op1 instanceof String) { |
| if (op2 instanceof String) |
| return ((((String) op1).compareTo(((String) op2))) > 0); |
| else if (ValueKind.UNDEF_LITERAL.equals(op2)) |
| return Boolean.FALSE; |
| else |
| {String[] context = {relationalOperation.getName(),convertToJavaType(op1), convertToJavaType(op2)}; |
| throw new TermInterpreterException( |
| TermInterpreterErrorString.PARAM_NOT_SUITABLE_WITH_OPERATION_2, |
| context, |
| termToBeEvaluated); |
| } |
| } else if (op1 instanceof Boolean) { |
| if (op2 instanceof Boolean) |
| return ((Boolean) op1) ? (!((Boolean) op2)) : Boolean.FALSE; |
| else if (ValueKind.UNDEF_LITERAL.equals(op2)) |
| return Boolean.FALSE; |
| else |
| {String[] context = {relationalOperation.getName(),convertToJavaType(op1), convertToJavaType(op2)}; |
| throw new TermInterpreterException( |
| TermInterpreterErrorString.PARAM_NOT_SUITABLE_WITH_OPERATION_2, |
| context, |
| termToBeEvaluated); |
| } |
| } else if (op1 instanceof MultiplicityKind) { |
| if (op2 instanceof MultiplicityKind) { |
| if (MultiplicityKind.MANY_TO_MANY_LITERAL.equals(op1) |
| && !MultiplicityKind.MANY_TO_MANY_LITERAL |
| .equals(op2)) |
| return Boolean.TRUE; |
| else if (MultiplicityKind.ONE_TO_MANY_LITERAL.equals(op1) |
| && MultiplicityKind.ONE_TO_ONE_LITERAL.equals(op2)) |
| return Boolean.TRUE; |
| else if (MultiplicityKind.MANY_TO_ONE_LITERAL.equals(op1) |
| && MultiplicityKind.ONE_TO_ONE_LITERAL.equals(op2)) |
| return Boolean.TRUE; |
| else |
| return Boolean.FALSE; |
| } else if (ValueKind.UNDEF_LITERAL.equals(op2)) |
| return Boolean.FALSE; |
| else |
| {String[] context = {relationalOperation.getName(),convertToJavaType(op1), convertToJavaType(op2)}; |
| throw new TermInterpreterException( |
| TermInterpreterErrorString.PARAM_NOT_SUITABLE_WITH_OPERATION_2, |
| context, |
| termToBeEvaluated); |
| } |
| } else if (ValueKind.UNDEF_LITERAL.equals(op1)) |
| return Boolean.FALSE; |
| else |
| {String[] context = {relationalOperation.getName(),convertToJavaType(op1), convertToJavaType(op2)}; |
| throw new TermInterpreterException( |
| TermInterpreterErrorString.PARAM_NOT_SUITABLE_WITH_OPERATION_1, |
| context, |
| termToBeEvaluated); |
| } |
| |
| } else if (relationalOperation instanceof LessThanOrEqualTo) { |
| if (op1 instanceof Integer) { |
| if (op2 instanceof Integer) |
| return ((Integer) op1) <= ((Integer) op2); |
| else if (op2 instanceof Double) |
| return (Double.valueOf((((Integer) op1).doubleValue())) <= ((Double) op2)); |
| else if (ValueKind.UNDEF_LITERAL.equals(op2)) |
| return Boolean.FALSE; |
| else |
| {String[] context = {relationalOperation.getName(),convertToJavaType(op1), convertToJavaType(op2)}; |
| throw new TermInterpreterException( |
| TermInterpreterErrorString.PARAM_NOT_SUITABLE_WITH_OPERATION_2, |
| context, |
| termToBeEvaluated); |
| } |
| } else if (op1 instanceof Double) { |
| if (op2 instanceof Integer) |
| return ((Double) op1) <= (new Double(((Integer) op2))); |
| else if (op2 instanceof Double) |
| return ((Double) op1) <= ((Double) op2); |
| else if (ValueKind.UNDEF_LITERAL.equals(op2)) |
| return Boolean.FALSE; |
| else |
| {String[] context = {relationalOperation.getName(),convertToJavaType(op1), convertToJavaType(op2)}; |
| throw new TermInterpreterException( |
| TermInterpreterErrorString.PARAM_NOT_SUITABLE_WITH_OPERATION_2, |
| context, |
| termToBeEvaluated); |
| } |
| |
| } else if (op1 instanceof String) { |
| if (op2 instanceof String) |
| return Boolean.valueOf(((((String) op2) |
| .indexOf(((String) op1))) != -1)); |
| else if (ValueKind.UNDEF_LITERAL.equals(op2)) |
| return Boolean.FALSE; |
| else |
| {String[] context = {relationalOperation.getName(),convertToJavaType(op1), convertToJavaType(op2)}; |
| throw new TermInterpreterException( |
| TermInterpreterErrorString.PARAM_NOT_SUITABLE_WITH_OPERATION_2, |
| context, |
| termToBeEvaluated); |
| } |
| } else if (op1 instanceof Boolean) { |
| if (op2 instanceof Boolean) |
| return ((Boolean) op1) ? (((Boolean) op2)) : Boolean.TRUE; |
| else if (ValueKind.UNDEF_LITERAL.equals(op2)) |
| return Boolean.FALSE; |
| else |
| {String[] context = {relationalOperation.getName(),convertToJavaType(op1), convertToJavaType(op2)}; |
| throw new TermInterpreterException( |
| TermInterpreterErrorString.PARAM_NOT_SUITABLE_WITH_OPERATION_2, |
| context, |
| termToBeEvaluated); |
| } |
| } else if (op1 instanceof MultiplicityKind) { |
| if (op2 instanceof MultiplicityKind) { |
| if (MultiplicityKind.ONE_TO_ONE_LITERAL.equals(op1) |
| && !MultiplicityKind.ONE_TO_ONE_LITERAL.equals(op2)) |
| return Boolean.TRUE; |
| else if (MultiplicityKind.MANY_TO_ONE_LITERAL.equals(op1) |
| && MultiplicityKind.MANY_TO_MANY_LITERAL |
| .equals(op2)) |
| return Boolean.TRUE; |
| else if (MultiplicityKind.ONE_TO_MANY_LITERAL.equals(op1) |
| && MultiplicityKind.MANY_TO_MANY_LITERAL |
| .equals(op2)) |
| return Boolean.TRUE; |
| else if (op1.equals(op2)) |
| return Boolean.TRUE; |
| else |
| return Boolean.FALSE; |
| } else if (ValueKind.UNDEF_LITERAL.equals(op2)) |
| return Boolean.FALSE; |
| else |
| {String[] context = {relationalOperation.getName(),convertToJavaType(op1), convertToJavaType(op2)}; |
| throw new TermInterpreterException( |
| TermInterpreterErrorString.PARAM_NOT_SUITABLE_WITH_OPERATION_2, |
| context, |
| termToBeEvaluated); |
| } |
| |
| } else if (ValueKind.UNDEF_LITERAL.equals(op1)) |
| return Boolean.FALSE; |
| else |
| {String[] context = {relationalOperation.getName(),convertToJavaType(op1), convertToJavaType(op2)}; |
| throw new TermInterpreterException( |
| TermInterpreterErrorString.PARAM_NOT_SUITABLE_WITH_OPERATION_1, |
| context, |
| termToBeEvaluated); |
| } |
| |
| } else if (relationalOperation instanceof GreaterThanOrEqualTo) { |
| if (op1 instanceof Integer) { |
| if (op2 instanceof Integer) |
| return ((Integer) op1) >= ((Integer) op2); |
| else if (op2 instanceof Double) |
| return (Double.valueOf((((Integer) op1).doubleValue())) >= ((Double) op2)); |
| else if (ValueKind.UNDEF_LITERAL.equals(op2)) |
| return Boolean.FALSE; |
| else |
| {String[] context = {relationalOperation.getName(),convertToJavaType(op1), convertToJavaType(op2)}; |
| throw new TermInterpreterException( |
| TermInterpreterErrorString.PARAM_NOT_SUITABLE_WITH_OPERATION_2, |
| context, |
| termToBeEvaluated); |
| } |
| } else if (op1 instanceof Double) { |
| if (op2 instanceof Integer) |
| return ((Double) op1) >= (new Double(((Integer) op2))); |
| else if (op2 instanceof Double) |
| return ((Double) op1) >= ((Double) op2); |
| else if (ValueKind.UNDEF_LITERAL.equals(op2)) |
| return Boolean.FALSE; |
| else |
| {String[] context = {relationalOperation.getName(),convertToJavaType(op1), convertToJavaType(op2)}; |
| throw new TermInterpreterException( |
| TermInterpreterErrorString.PARAM_NOT_SUITABLE_WITH_OPERATION_2, |
| context, |
| termToBeEvaluated); |
| } |
| |
| } else if (op1 instanceof String) { |
| if (op2 instanceof String) |
| return Boolean.valueOf(((((String) op1) |
| .indexOf(((String) op2))) != -1)); |
| else if (ValueKind.UNDEF_LITERAL.equals(op2)) |
| return Boolean.FALSE; |
| else |
| {String[] context = {relationalOperation.getName(),convertToJavaType(op1), convertToJavaType(op2)}; |
| throw new TermInterpreterException( |
| TermInterpreterErrorString.PARAM_NOT_SUITABLE_WITH_OPERATION_2, |
| context, |
| termToBeEvaluated); |
| } |
| } else if (op1 instanceof Boolean) { |
| if (op2 instanceof Boolean) |
| return ((Boolean) op1) ? Boolean.TRUE : (!((Boolean) op2)); |
| else if (ValueKind.UNDEF_LITERAL.equals(op2)) |
| return Boolean.FALSE; |
| else |
| {String[] context = {relationalOperation.getName(),convertToJavaType(op1), convertToJavaType(op2)}; |
| throw new TermInterpreterException( |
| TermInterpreterErrorString.PARAM_NOT_SUITABLE_WITH_OPERATION_2, |
| context, |
| termToBeEvaluated); |
| } |
| } else if (op1 instanceof MultiplicityKind) { |
| if (op2 instanceof MultiplicityKind) { |
| if (MultiplicityKind.MANY_TO_MANY_LITERAL.equals(op1) |
| && !MultiplicityKind.MANY_TO_MANY_LITERAL |
| .equals(op2)) |
| return Boolean.TRUE; |
| else if (MultiplicityKind.ONE_TO_MANY_LITERAL.equals(op1) |
| && MultiplicityKind.ONE_TO_ONE_LITERAL.equals(op2)) |
| return Boolean.TRUE; |
| else if (MultiplicityKind.MANY_TO_ONE_LITERAL.equals(op1) |
| && MultiplicityKind.ONE_TO_ONE_LITERAL.equals(op2)) |
| return Boolean.TRUE; |
| else if (op1.equals(op2)) |
| return Boolean.TRUE; |
| else |
| return Boolean.FALSE; |
| } else if (ValueKind.UNDEF_LITERAL.equals(op2)) |
| return Boolean.FALSE; |
| else |
| {String[] context = {relationalOperation.getName(),convertToJavaType(op1), convertToJavaType(op2)}; |
| throw new TermInterpreterException( |
| TermInterpreterErrorString.PARAM_NOT_SUITABLE_WITH_OPERATION_2, |
| context, |
| termToBeEvaluated); |
| } |
| } else if (ValueKind.UNDEF_LITERAL.equals(op1)) |
| return Boolean.FALSE; |
| else |
| {String[] context = {relationalOperation.getName(),convertToJavaType(op1), convertToJavaType(op2)}; |
| throw new TermInterpreterException( |
| TermInterpreterErrorString.PARAM_NOT_SUITABLE_WITH_OPERATION_1, |
| context, |
| termToBeEvaluated); |
| } |
| |
| } |
| // The control can only get here, if it was a not implemented |
| // RelationalOperation |
| else |
| {String[] context = {relationalOperation.getName()}; |
| throw new TermInterpreterException( |
| TermInterpreterErrorString.UNIMP_RELATIONAL, |
| context, |
| termToBeEvaluated); |
| } |
| } |
| |
| /*protected Boolean object2Boolean(Object obj, RelationalOperation not) |
| throws TermInterpreterException { |
| if (obj instanceof String) { |
| return "true".equals((String) obj) ? (Boolean.TRUE) : ("false" |
| .equals((String) obj) ? Boolean.FALSE : null); |
| } else if (obj instanceof Double) { |
| return (((Double) obj).equals(0.0)) ? Boolean.FALSE : Boolean.TRUE; |
| } else if (obj instanceof Integer) { |
| return (((Integer) obj).equals(0)) ? Boolean.FALSE : Boolean.TRUE; |
| } else if (obj instanceof Boolean) { |
| return (Boolean) obj; |
| } else if (obj.equals(ValueKind.UNDEF_LITERAL)) { |
| return Boolean.FALSE; |
| |
| } else if (obj instanceof IModelElement) { |
| return Boolean.TRUE; |
| } |
| String[] context = {not.getName() ,convertToJavaType(obj)}; |
| throw new TermInterpreterException( |
| TermInterpreterErrorString.TERM_NOT_BOOL_COMPATIBLE |
| , context |
| , not); |
| }*/ |
| } |
