Application: gvSIG desktop

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

import java.math.BigDecimal;

import org.gvsig.expressionevaluator.Code;

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

import org.gvsig.expressionevaluator.Function;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.Optimizer;

public class DivOperator 

        extends AbstractBinaryOperator 

        implements Optimizer.FunctionOptimizer

    {

    public DivOperator() {

        super(Function.GROUP_NUMERIC, OPERATOR_DIV, 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_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_BIGDECIMAL) == TYPE_BIGDECIMAL ) {

            try {

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

                return value;

            } catch(ArithmeticException ex) {

                double v1 = getDouble(op1,1) / getDouble(op2,2);

                BigDecimal value = BigDecimal.valueOf(v1);

                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;

        }

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

    }

    @Override

    public Code optimize(Optimizer optimizer, Code.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(), 

                            ((Code.Constant)op1).value(), 

                            ((Code.Constant)op2).value()

                    )

            );

            return newCode;

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

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

            if( value instanceof Number ) {

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

                if( n == 0 ) {

                    Code newCode = optimizer.getCodeBuilder().constant(0);

                    return newCode;

                }

            }

            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 == 1 ) {

                    return op1;

                }

            }

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

            return newCode;

        }

        return caller;

    }

}