001: package com.calipso.reportgenerator.reportcalculator.arithmetic;
002:
003: import com.calipso.reportgenerator.reportcalculator.arithmetic.ArithmeticExpression;
004:
005: import java.util.Map;
006: import java.util.HashMap;
007: import java.util.Collection;
008: import java.io.Serializable;
009:
010: /**
011: * Genera las operaciones
012: */
013:
014: public class OperationArithmeticExp extends ArithmeticExpression
015: implements Serializable {
016: private ArithmeticExpression m1;
017: private ArithmeticExpression m2;
018: private String operator;
019: private static Map operations;
020:
021: /**
022: * Crea un Map y lo inicializa con todos los resultados
023: * posibles en base a las operaciones soportadas.
024: * @param operator
025: * @return
026: */
027: private Operation fromOperator(String operator) {
028: if (operations == null) {
029: operations = new HashMap();
030: operations.put("+", new Addition());
031: operations.put("-", new Substraction());
032: operations.put("*", new Multiplication());
033: operations.put("/", new Divission());
034: }
035: return (Operation) operations.get(operator);
036: }
037:
038: /**
039: * Retorna el resultado a partir de un Map.
040: * @param context
041: * @return
042: */
043: public float value(Map context) {
044: return fromOperator(operator).calculate(m1.value(context),
045: m2.value(context));
046: }
047:
048: /**
049: * Metodo toString de la clase
050: * @return
051: */
052: public String toString() {
053: String str = m1.toString() + " " + operator + " "
054: + m2.toString();
055: if (operator.equals("+") || operator.equals("-")) {
056: return "(" + str + ")";
057: }
058: return str;
059: }
060:
061: /**
062: * Genera una nueva instancia de <code>OperationArithmeticExp</code>
063: * en base a dos valores y su operador.
064: * @param subExp1
065: * @param operator
066: * @param subExp2
067: * @return
068: */
069: public static ArithmeticExpression newOperationFrom(
070: ArithmeticExpression subExp1, String operator,
071: ArithmeticExpression subExp2) {
072: return new OperationArithmeticExp(subExp1, operator, subExp2);
073: }
074:
075: /**
076: * Inicializa una instancia de <code>OperationArithmeticExp</code>
077: * @param subExp1
078: * @param operator
079: * @param subExp2
080: */
081: public OperationArithmeticExp(ArithmeticExpression subExp1,
082: String operator, ArithmeticExpression subExp2) {
083: this .m1 = subExp1;
084: this .m2 = subExp2;
085: this .operator = operator;
086: }
087:
088: /**
089: * Inner class que calcula para dos valores
090: * todas las operaciones soportadas
091: */
092: private abstract class Operation {
093: public abstract float calculate(float value1, float value2);
094: }
095:
096: /**
097: * Inner class que calcula la suma para dos valores
098: */
099: private class Addition extends Operation {
100: public float calculate(float value1, float value2) {
101: return value1 + value2;
102: }
103: }
104:
105: /**
106: * Inner class que calcula la resta para dos valores
107: */
108: private class Substraction extends Operation {
109: public float calculate(float value1, float value2) {
110: return value1 - value2;
111: }
112: }
113:
114: /**
115: * Inner class que calcula la multiplicacion para dos valores
116: */
117: private class Multiplication extends Operation {
118: public float calculate(float value1, float value2) {
119: return value1 * value2;
120: }
121: }
122:
123: /**
124: * Inner class que calcula la division para dos valores
125: */
126: private class Divission extends Operation {
127: public float calculate(float value1, float value2) {
128: return value1 / value2;
129: }
130: }
131:
132: public void getVariables(Collection variables) {
133: m1.getVariables(variables);
134: m2.getVariables(variables);
135: }
136:
137: }
|