Application: gvSIG desktop

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

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.Function;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.Optimizer;

public class DivOperator 

        extends AbstractBinaryOperator 

        implements Optimizer.FunctionOptimizer

    {

    public static final String NAME = "/";

    public DivOperator() {

        super(Function.GROUP_NUMERIC, NAME);

    }

    @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, Code.Caller 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;

    }

}