Application: gvSIG desktop

package org.gvsig.expressionevaluator.impl.function.operator;

import java.math.BigDecimal;

import java.util.Objects;

import org.apache.commons.math.exception.OutOfRangeException;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.Code.Constant;

import static org.gvsig.expressionevaluator.ExpressionBuilder.OPERATOR_ADD;

import org.gvsig.expressionevaluator.ExpressionRuntimeException;

import org.gvsig.expressionevaluator.Function;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.Optimizer;

import org.gvsig.expressionevaluator.Optimizer.FunctionOptimizer;

import org.gvsig.expressionevaluator.impl.I18N;

import org.gvsig.expressionevaluator.Code.Callable;

public class AddOperator 

        extends AbstractBinaryOperator 

        implements FunctionOptimizer

    {

    public AddOperator() {

        super(Function.GROUP_NUMERIC, OPERATOR_ADD, true);

    }

    @Override

    public boolean allowConstantFolding() {

        return true;

    }

    @Override

    public Object call(Interpreter interpreter, Object op1, Object op2) {

        if (op1 == null || op2 == null) {

            return null;

        }

        int type = this.getType(op1, op2);

        if( (type & TYPE_BIGDECIMAL) == TYPE_BIGDECIMAL ) {

            BigDecimal value = getBigDecimal(op1,1).add(getBigDecimal(op2,2));

            return value;

        }

        if( (type & TYPE_DOUBLE) == TYPE_DOUBLE ) {

            double value = getDouble(op1,1) + getDouble(op2,2);

            checkDoubleValue(value);

            return value;

        }

        if( (type & TYPE_FLOAT) == TYPE_FLOAT ) {

            double value = getFloat(op1,1) + getFloat(op2,2);

            checkDoubleValue(value);

            return value;

        }

        if( (type & TYPE_LONG) == TYPE_LONG ) {

            long value = getLong(op1,1) + getLong(op2,2);

            return value;

        }

        if( (type & TYPE_INT) == TYPE_INT ) {

            int value = getInt(op1,1) + getInt(op2,2);

            return value;

        }

        if( (type & TYPE_STRING) == TYPE_STRING ) {

            if( interpreter.isSQLCompatible() ) {

                throw new ExpressionRuntimeException(

                        null, 

                        "The '"+name()+"' operator can not be used with string operands", 

                        I18N.Use_the_operator_CONCAT_to_concatenate_strings()

                );

            }

            return Objects.toString(op1, "")+Objects.toString(op2, "");

        }

        throw new IllegalArgumentException("Types not allowed in '"+name()+"' operand.");

    }

    @Override

    public Code optimize(Optimizer optimizer, Callable caller) {

        Code op1 = optimizer.optimize(caller.parameters().get(0));

        Code op2 = optimizer.optimize(caller.parameters().get(1));

        if ( op1.code() == Code.CONSTANT && op2.code() == Code.CONSTANT) {

            Code newCode = optimizer.getCodeBuilder().constant(

                    call(

                            optimizer.getInterpreter(), 

                            ((Constant)op1).value(), 

                            ((Constant)op2).value()

                    )

            );

            return newCode;

        } else if ( op1.code() == Code.CONSTANT ) {

            Object value = ((Constant)op1).value();

            if( value instanceof Number ) {

                double n = ((Number) value).doubleValue();

                if( n == 0 ) {

                   return op2;

                }

            }

            Code newCode = optimizer.getCodeBuilder().operator(caller.name(), op1, op2);

            return newCode;

        } else if ( op2.code() == Code.CONSTANT ) {

            Object value = ((Code.Constant)op2).value();

            if( value instanceof Number ) {

                double n = ((Number) value).doubleValue();

                if( n == 0 ) {

                    return op1;

                }

            }

            Code newCode = optimizer.getCodeBuilder().operator(caller.name(), op1, op2);

            return newCode;

        }

        return caller;

    }

}