Application: gvSIG desktop

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

import org.gvsig.expressionevaluator.Code;

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

import org.gvsig.expressionevaluator.Function;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.Optimizer;

import org.gvsig.expressionevaluator.Optimizer.FunctionOptimizer;

public class SubstOperator 

        extends AbstractBinaryOperator 

        implements FunctionOptimizer

    {

    public SubstOperator() {

        super(Function.GROUP_NUMERIC, OPERATOR_SUBST, 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);

            return value;

        }

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

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

            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 ( 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;

    }

}