Application: gvSIG desktop

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

import java.util.Iterator;

import java.util.function.Function;

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.Codes;

import org.gvsig.expressionevaluator.ExpressionBuilder;

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

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

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.ExpressionRuntimeException;

import org.gvsig.expressionevaluator.Formatter;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.Coercion;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dataTypes.DataTypesManager;

public class CastFunction extends AbstractFunction {

    public CastFunction() {

        super(

                GROUP_CONVERSION, 

                FUNCTION_CAST, 

                Range.is(2),

                "",

                "CAST( {{value}} AS type_identifier)",

                null,

                null,

                true

        );

    }

    @Override

    public boolean allowConstantFolding() {

        return true;

    }

    @Override

    public Object call(Interpreter interpreter, Object[] args) throws Exception {

        DataTypesManager manager = ToolsLocator.getDataTypesManager();

        Object valueIn = this.getObject(args, 0);

        String typeName = this.getStr(args, 1);

        int type = manager.getType(typeName);

        if( type == DataTypes.INVALID ) {

            throw new ExpressionRuntimeException("The value of type ("+typeName+") in function CAST is incorrect", getTip());

        }

        Coercion converter = manager.get(type).getCoercion();

        if( converter==null ) {

            throw new IllegalArgumentException("Can't convert to the indicated type ("+typeName+").");

        }

        Object valueOut = converter.coerce(valueIn);

        return valueOut;

    }

    private String getTip() {

        DataTypesManager manager = ToolsLocator.getDataTypesManager();

        StringBuilder builder = new StringBuilder();

        Iterator<DataType> it = manager.iterator();

        while( it.hasNext() ) {

            DataType dataType = it.next();

            builder.append("- ");

            builder.append(dataType.getName());

            builder.append("\n");

        }

        return "The valid type names for the function CAST are:\n"+ builder.toString();

    }

    @Override

    public String toString(Codes args, Formatter<Code> formatter) {

        StringBuilder builder = new StringBuilder();

        Code expression = args.get(0);

        Code typeName = args.get(1);

        if( typeName instanceof Code.Constant && ((Code.Constant)typeName).value() instanceof CharSequence ) {

          builder.append(this.name());

          builder.append("(");

          builder.append(expression.toString(formatter));

          builder.append(" AS ");

          builder.append(((Code.Constant)typeName).value().toString());

          builder.append(")");

          return builder.toString();

        }

        return super.toString(args, formatter);

    }

}