Application: gvSIG desktop

package org.gvsig.fmap.dal.feature.spi;

import gnu.jel.CompilationException;

import gnu.jel.CompiledExpression;

import gnu.jel.DVMap;

import java.util.ArrayList;

import java.util.Date;

import java.util.List;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import org.cresques.cts.IProjection;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.Find_SRID;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.ST_AsBinary;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.ST_AsEWKB;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.ST_AsText;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.ST_Contains;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.ST_Crosses;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.ST_Disjoint;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.ST_Envelope;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.ST_Equals;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.ST_GeomFromEWKB;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.ST_GeomFromText;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.ST_GeomFromWKB;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.ST_Intersects;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.ST_IsClosed;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.ST_Overlaps;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.ST_SRID;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.ST_Touches;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.ST_Within;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.isNull;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.lcase;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.notIsNull;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.operator_AND;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.operator_EQ;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.operator_GE;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.operator_GT;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.operator_ILIKE;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.operator_LE;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.operator_LIKE;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.operator_LT;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.operator_NE;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.operator_OR;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.operator_not;

import static org.gvsig.fmap.dal.ExpressionBuilder.Config.ucase;

import org.gvsig.fmap.dal.ExpressionEvaluator;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryException;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.operation.GeometryOperationException;

import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException;

import org.gvsig.fmap.geom.primitive.Closeable;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.tools.evaluator.EvaluatorData;

import org.gvsig.tools.evaluator.EvaluatorException;

import org.gvsig.tools.evaluator.EvaluatorFieldsInfo;

public class ExpressionEvaluatorBase extends ExpressionBuilderBase implements ExpressionEvaluator {

    public class JELConfig extends ConfigBase {

        public JELConfig() {

            super();

            this.set(has_spatial_functions,true);

            this.set(constant_true, "true");

            this.set(constant_false, "false");

            this.set(quote_for_identifiers, "");

            this.set(quote_for_strings, "\"");

            this.set(geometry_type_support, GeometrySupportType.WKT);

            this.set(group, "( {0} )");

            this.set(Find_SRID , "Find_SRID(({0}), ({1}), ({2}))");

            this.set(ST_SRID , "ST_SRID({0})");

            this.set(ST_AsText , "ST_AsText({0})");

            this.set(ST_AsBinary, "ST_AsBinary({0})");

            this.set(ST_AsEWKB, "ST_AsWKB({0})");

            this.set(ST_Contains, "ST_Contains(({0}), ({1}))");            

            this.set(ST_Crosses,  "ST_Crosses(({0}), ({1}))");

            this.set(ST_Disjoint ,  "ST_Disjoint(({0}), ({1}))");

            this.set(ST_Equals ,  "ST_Equals(({0}), ({1}))");

            this.set(ST_IsClosed,  "ST_IsClosed({0})");

            this.set(ST_Overlaps,  "ST_Overlaps(({0}), ({1}))");

            this.set(ST_Touches,  "ST_Touches(({0}), ({1}))");

            this.set(ST_Within, "ST_Within(({0}), ({1}))");            

            this.set(ST_Envelope, "ST_Envelope({0})");

            this.set(ST_Intersects, "ST_Intersects(({0}), ({1}))");

            this.set(ST_GeomFromText, "ST_GeomFromText({0}, ({1}))");

            this.set(ST_GeomFromWKB, "ST_GeomFromWKB(({0}), ({1}))");

            this.set(ST_GeomFromEWKB, "ST_GeomFromEWKB(({0}), ({1}))");

            this.set(lcase, "LCASE({0})");

            this.set(ucase, "UCASE({0})");

            this.set(isNull, "( ({0}) == null )");

            this.set(notIsNull, "( ! (({0}) == null) )");

            this.set(operator_not, "( ! ({0}) )");

            this.set(operator_AND, "{0} && {1}");

            this.set(operator_OR, "{0} || {1}");

            this.set(operator_EQ, "( ({0}) == ({1}) )");

            this.set(operator_NE, "( ({0}) != ({1}) )");

            this.set(operator_GT, "( ({0}) > ({1}) )");

            this.set(operator_GE, "( ({0}) >= ({1}) )");

            this.set(operator_LT, "( ({0}) < ({1}) )");

            this.set(operator_LE, "( ({0}) <= ({1}) )");

            this.set(operator_LIKE, "LIKE( ({0}), ({1}) )");

            this.set(operator_ILIKE, "ILIKE( ({0}), ({1}) )");

            this.set(operator_add, "{0} + {1}");

            this.set(operator_subst, "{0} - {1}");

            this.set(operator_mult, "{0} * {1}");

            this.set(operator_div, "{0} / {1}");

            this.set(operator_concat, "{0} + {1}");

        }

    }

    public static class JELFunctions {

        public static String Find_SRID(Object a, Object b, Object c) {

            return null;

        }

        public static String ST_SRID(Geometry geom) {

            return null;

        }

        public static String ST_AsText(Geometry geom) throws GeometryOperationException, GeometryOperationNotSupportedException {

            return geom.convertToWKT();

        }

        public static byte[] ST_AsBinary(Geometry geom) throws GeometryOperationException, GeometryOperationNotSupportedException {

            return geom.convertToWKB();

        }

        public static byte[] ST_AsEWKB(Geometry geom) throws GeometryOperationException, GeometryOperationNotSupportedException {

            return geom.convertToEWKB();

        }

        public static Envelope ST_Envelope(Geometry geom) throws GeometryOperationException, GeometryOperationNotSupportedException {

            return geom.getEnvelope();

        }            

        public static boolean ST_Contains(Geometry geom1, Geometry geom2) throws GeometryOperationException, GeometryOperationNotSupportedException {

            return geom1.contains(geom2);

        }            

        public static boolean ST_Crosses(Geometry geom1, Geometry geom2) throws GeometryOperationException, GeometryOperationNotSupportedException {

            return geom1.crosses(geom2);

        }            

        public static boolean ST_Disjoint(Geometry geom1, Geometry geom2) throws GeometryOperationException, GeometryOperationNotSupportedException {

            return geom1.disjoint(geom2);

        }            

        public static boolean ST_Overlaps(Geometry geom1, Geometry geom2) throws GeometryOperationException, GeometryOperationNotSupportedException {

            return geom1.overlaps(geom2);

        }            

        public static boolean ST_Touches(Geometry geom1, Geometry geom2) throws GeometryOperationException, GeometryOperationNotSupportedException {

            return geom1.touches(geom2);

        }            

        public static boolean ST_Within(Geometry geom1, Geometry geom2) throws GeometryOperationException, GeometryOperationNotSupportedException {

            return geom1.within(geom2);

        }            

        public static boolean ST_Intersects(Geometry geom1, Geometry geom2) throws GeometryOperationException, GeometryOperationNotSupportedException {

            return geom1.intersects(geom2);

        }            

        public static boolean ST_Equals(Geometry geom1, Geometry geom2) {

            return geom1.equals(geom2);

        }            

        public static boolean ST_IsClosed(Geometry geom1) throws GeometryOperationException, GeometryOperationNotSupportedException {

            if( geom1 instanceof Closeable  ) {

                return ((Closeable)geom1).isClosed();

            }

            return true;

        }            

        public static Geometry ST_GeomFromText(String geom, IProjection srs) throws GeometryException {

            GeometryManager manager = GeometryLocator.getGeometryManager();

            return manager.createFrom(geom,srs);

        }            

        public static Geometry ST_GeomFromWKB(byte[] geom, IProjection srs) throws GeometryException {

            GeometryManager manager = GeometryLocator.getGeometryManager();

            return manager.createFrom(geom,srs);

        }            

        public static Geometry ST_GeomFromEWKB(byte[] geom, IProjection srs) throws GeometryException {

            GeometryManager manager = GeometryLocator.getGeometryManager();

            return manager.createFrom(geom,srs);

        }            

        public static String LCASE(Object x) {

            if( x == null ) {

                return null;

            }

            return x.toString().toLowerCase();

        }            

        public static String UCASE(Object x) {

            if( x == null ) {

                return null;

            }

            return x.toString().toLowerCase();

        }            

        private static final Integer ZERO_OR_MORE_CHARS = 0;

        private static final Integer ONE_CHAR = 1;

        public static boolean LIKE(Object x1, Object x2) {

            if (x1 == null || x2 == null) {

                return false;

            }

            String source = x1.toString();

            String match = x2.toString();

            List<Object> format = new ArrayList<>();

            StringBuilder fill = new StringBuilder();

            final int plen = match.length();

            Character lastSymbol = null;

            for (int i = 0; i < plen; i++) {

                boolean f = false;

                char c = match.charAt(i);

                if (lastSymbol == '\\') {

                    lastSymbol = null;

                    fill.append(c);

                } else {

                    if (c == '%') {

                        if (fill.length() > 0) {

                            format.add(fill.toString());

                            fill.setLength(0);

                        }

                        format.add(ZERO_OR_MORE_CHARS);

                    } else if (c == '_') {

                        if (fill.length() > 0) {

                            format.add(fill.toString());

                            fill.setLength(0);

                        }

                        format.add(ONE_CHAR);

                    } else {

                        fill.append(c);

                    }

                    lastSymbol = c;

                }

                if (fill.length() > 0) {

                    format.add(fill.toString());

                }

            }

            StringBuilder repattern = new StringBuilder("^");

            for (Object o : format) {

                if (o == ZERO_OR_MORE_CHARS) {

                    repattern.append(".*?");

                } else if (o == ONE_CHAR) {

                    repattern.append(".?");

                } else {

                    repattern.append((String) o);

                }

            }

            Pattern pattern = Pattern.compile(repattern.toString());

            Matcher m = pattern.matcher(source);

            return m.find();

        }

        public static boolean ILIKE(Object x1, Object x2) {

            if (x1 == null || x2 == null) {

                return false;

            }

            x1 = x1.toString().toLowerCase();

            x2 = x2.toString().toLowerCase();

            return LIKE(x1, x2);

        }

    }

    protected class VariableProvider extends DVMap {

        private EvaluatorData data;

        public VariableProvider() {

        }

        public void setValues(EvaluatorData data) {

            this.data = data;

        }

        @Override

        public String getTypeName(String name) {

            Object value = this.data.getDataValue(name);

            return value.getClass().getSimpleName();

        }

        public double getDoubleProperty(String name) {

            Object value = this.data.getDataValue(name);

            return (double) value;

        }        

        public float getFloatProperty(String name) {

            Object value = this.data.getDataValue(name);

            return (float) (double) value;

        }        

        public int getIntegerProperty(String name) {

            Object value = this.data.getDataValue(name);

            return (int) (double) value;

        }        

        public long getLongProperty(String name) {

            Object value = this.data.getDataValue(name);

            return (long) (double) value;

        }        

        public String getStringProperty(String name) {

            Object value = this.data.getDataValue(name);

            return (String) value;

        }        

        public Date getDateProperty(String name) {

            Object value = this.data.getDataValue(name);

            return (Date) value;

        }        

    }

    protected VariableProvider jel_variables = null;

    protected Object[] jel_context = null;

    protected CompiledExpression jel_expression = null;

    protected Config jel_config = new JELConfig();

    protected EvaluatorFieldsInfo fieldsInfo = null; // For compatibility 

    public ExpressionEvaluatorBase() {

        super();

    }

    public void compile() {

        jel_variables = new VariableProvider();

        gnu.jel.Library lib = new gnu.jel.Library(

                new Class[]{ Math.class, JELFunctions.class }, 

                new Class[]{ jel_variables.getClass() }, 

                new Class[0],

                jel_variables,

                null

        );

        jel_context = new Object[] { jel_variables };

        Config config = this.config;

        try {

            this.config = jel_config;

            String expr = this.value.toString();

            jel_expression = gnu.jel.Evaluator.compile(expr, lib);

        } catch (CompilationException ex) {

            throw new RuntimeException("Can't compile expression.", ex);

        } finally {

            this.config = config;

        }

    }

    public void clear() {

        this.set(null);

        this.jel_expression = null;

    }

    @Override

    public Object evaluate(EvaluatorData data) throws EvaluatorException {

        try {

            if( jel_variables == null ) {

                this.compile();

            }

            jel_variables.setValues(data);

            return jel_expression.evaluate(jel_context);

        } catch (Throwable th) {

            throw new EvaluatorException(

                    "Can't evaluate expression", 

                    th, 

                    "ExpressionEvaluatorBase_evaluate_error", 

                    0

                );

        }

    }

    @Override

    public String getName() {

        return "Generic expression evaluator";

    }

    @Override

    public String getDescription() {

        return "";

    }

    @Override

    public String getSQL() {

        return this.value.toString();

    }

    @Override

    public EvaluatorFieldsInfo getFieldsInfo() {

        if( this.fieldsInfo==null ) {

            this.fieldsInfo = new EvaluatorFieldsInfo();

            for( Variable var : this.getVariables() ) {

                this.fieldsInfo.addFieldValue(var.getName());

            }

        }

        return this.fieldsInfo;

    }

}