Application: gvSIG desktop

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

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.Code.Caller;

import org.gvsig.expressionevaluator.Code.Constant;

import org.gvsig.expressionevaluator.Function;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.Optimizer;

import org.gvsig.expressionevaluator.Optimizer.FunctionOptimizer;

public class AddOperator 

        extends AbstractBinaryOperator 

        implements FunctionOptimizer

    {

    public AddOperator() {

        super(Function.GROUP_NUMERIC, "+");

    }

    @Override

    public boolean allowConstantFolding() {

        return true;

    }

    @Override

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

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

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

            double value = ((Number) op1).doubleValue() + ((Number) op2).doubleValue();

            return value;

        }

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

            double value = ((Number) op1).floatValue() + ((Number) op2).floatValue();

            return value;

        }

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

            long value = ((Number) op1).longValue() + ((Number) op2).longValue();

            return value;

        }

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

            int value = ((Number) op1).intValue()+ ((Number) op2).intValue();

            return value;

        }

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

    }

    @Override

    public Code optimize(Optimizer optimizer, Caller caller) {

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

        Code op2 = optimizer.optimize(caller.args().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;

    }

}