Application: gvSIG desktop

gvSIG. Desktop Geographic Information System.

Copyright (C) 2007-2020 gvSIG Association.

This program is free software; you can redistribute it and/or

modify it under the terms of the GNU General Public License

as published by the Free Software Foundation; either version 3

of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

 You should have received a copy of the GNU General Public License 

along with this program. If not, see <https://www.gnu.org/licenses/>. 

For any additional information, do not hesitate to contact us

at info AT gvsig.com, or visit our website www.gvsig.com.

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>

  <parent>

    <groupId>org.gvsig</groupId>

    <artifactId>org.gvsig.expressionevaluator.geometry</artifactId>

    <version>2.0.369</version>

  </parent>

  <groupId>org.gvsig</groupId>

  <artifactId>org.gvsig.expressionevaluator.geometry.lib</artifactId>

  <packaging>pom</packaging>

  <modules>

    <module>org.gvsig.expressionevaluator.geometry.lib.api</module>

    <module>org.gvsig.expressionevaluator.geometry.lib.impl</module>

  </modules>

</project>

package org.gvsig.expressionevaluator;

/**

 *

 * @author jjdelcerro

 */

public interface GeometryExpressionBuilder 

    extends ExpressionBuilder, GeometryExpressionBuilderHelper {

}

package org.gvsig.expressionevaluator;

import org.cresques.cts.IProjection;

import org.gvsig.expressionevaluator.ExpressionBuilder.Constant;

import org.gvsig.expressionevaluator.ExpressionBuilder.Parameter;

import org.gvsig.expressionevaluator.ExpressionBuilder.Value;

import org.gvsig.expressionevaluator.ExpressionBuilder.Function;

import org.gvsig.fmap.geom.Geometry;

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

public interface GeometryExpressionBuilderHelper  {

    public static final String FUNCTION_ST_SRID = "ST_SRID";

    public static final String FUNCTION_ST_ASTEXT = "ST_AsText";

    public static final String FUNCTION_ST_ASBINARY = "ST_AsBinary";

    public static final String FUNCTION_ST_ASEWKB = "ST_AsEWKB";

    public static final String FUNCTION_ST_ENVELOPE = "ST_Envelope";

    public static final String FUNCTION_ST_GEOMFROMTEXT = "ST_GeomFromText";

    public static final String FUNCTION_ST_GEOMFROMWKB = "ST_GeomFromWKB";

    public static final String FUNCTION_ST_GEOMFROMEWKB = "ST_GeomFromEWKB";

    public static final String FUNCTION_ST_SIMPLIFY = "ST_Simplify";

    public static final String FUNCTION_ST_EQUALS = "ST_Equals";

    public static final String FUNCTION_ST_INTERSECTS = "ST_Intersects";

    public static final String FUNCTION_ST_CONTAINS = "ST_Contains";

    public static final String FUNCTION_ST_DISJOINT = "ST_Disjoint";

    public static final String FUNCTION_ST_CROSSES = "ST_Crosses";

    public static final String FUNCTION_ST_ISCLOSED = "ST_IsClosed";

    public static final String FUNCTION_ST_OVERLAPS = "ST_Overlaps";

    public static final String FUNCTION_ST_TOUCHES = "ST_Touches";

    public static final String FUNCTION_ST_WITHIN = "ST_Within";

    public static final String FUNCTION_ST_SETSRID = "ST_SetSRID";

    public static final String FUNCTION_ST_POINT = "ST_Point";

    public static final String FUNCTION_ST_MAKEPOINT = "ST_MakePoint";

    public static final String FUNCTION_ST_UNIONAGGREGATE = "ST_UnionAggregate";

    public static final String FUNCTION_ST_EXTENTAGGREGATE = "ST_ExtentAggregate";

    public static final String FUNCTION_ST_FORCE2D = "ST_Force2D";

    public static final int PARAMETER_TYPE_GEOMETRY = 2;

    public enum GeometrySupportType {

        WKT,

        WKB,

        EWKB,

        NATIVE

    }

    public interface GeometryParameter extends Parameter {

        @Override

        public GeometryParameter as_constant();

        @Override

        public GeometryParameter as_variable(); 

        public GeometryParameter as_geometry_variable();

        @Override

        public GeometryParameter value(Object value);

        @Override

        public GeometryParameter name(String value);

        public GeometryParameter srs(IProjection srs);

        public GeometryParameter srs(Value srs);

        public Value srs();

        public Geometry geometry();

        public boolean is_geometry_variable();

    }

    public ExpressionBuilder builder();

    public GeometrySupportType geometry_support_type();

    public GeometryExpressionBuilderHelper geometry_support_type(GeometrySupportType geometrySupportType);

    public Object srs_id(IProjection projection);

    public GeometryParameter parameter(Object value);

    public GeometryParameter parameter(String name);

    public GeometryParameter parameter();

    public Constant geometry(Geometry geom, IProjection srs);

    public Constant geometry(Geometry geom);

    public Constant envelope(Envelope envelope, IProjection srs);

    public Constant envelope(Envelope envelope);

    public Constant srs(IProjection srs);

    public Function as_geometry(Value value);

    public Function ST_Area(Value geom);

    public Function ST_AsBinary(Value geom);

    public Function ST_AsEWKB(Value geom);

    public Function ST_AsText(Value geom);

    public Function ST_Buffer(Value geom);

    public Function ST_Buffer(Value geom, Value dist);

    public Function ST_Centroid(Value geom);

    public Function ST_Contains(Value geom1, Value geom2);

    public Function ST_CoveredBy(Value geom1, Value geom2);

    public Function ST_Covers(Value geom1, Value geom2);

    public Function ST_Crosses(Value geom1, Value geom2);

    public Function ST_Diference(Value geom1, Value geom2);

    public Function ST_Dimension(Value geom1);

    public Function ST_Disjoint(Value geom1, Value geom2);

    public Function ST_Distance(Value geom1, Value geom2);

    public Function ST_EndPoint(Value geom1);

    public Function ST_Envelope(Value geom);

    public Function ST_Equals(Value geom1, Value geom2);

    public Function ST_GeomFromText(Value geom, Value crs);

    public Function ST_GeomFromWKB(Value geom, Value crs);

    public Function ST_GeomFromEWKB(Value geom, Value crs);

    public Function ST_Intersection(Value geom1, Value geom2);

    public Function ST_Intersects(Value geom1, Value geom2);

    public Function ST_IsClosed(Value geom);

    public Function ST_IsSimple(Value geom);

    public Function ST_IsValid(Value geom);

    public Function ST_Force2D(Value geom);

    public Function ST_NumGeometries(Value geom);

    public Function ST_NumPoints(Value geom);

    public Function ST_Overlaps(Value geom1, Value geom2);

    public Function ST_Perimeter(Value geom);

    public Function ST_Point(Value x, Value y);

    public Function ST_MakePoint(Value x, Value y);

    public Function ST_MakePoint(Value x, Value y, Value z);

    public Function ST_MakePoint(Value x, Value y, Value z, Value m);

    public Function ST_PointN(Value geom, Value n);

    public Function ST_SRID(Value geom);

    public Function ST_SetSRID(Value geom, Value srid);

    public Function ST_StartPoint(Value geom);

    public Function ST_Simplify(Value geom, Value tolerance);

    public Function ST_Touches(Value geom1, Value geom2);

    public Function ST_Union(Value geom1, Value geom2);

    public Function ST_Within(Value geom1, Value geom2);

    public Function ST_X(Value geom);

    public Function ST_Y(Value geom);

    public Function ST_Z(Value geom);

    public Function ST_UnionAggregate(Value geom);

    public Function ST_ExtentAggregate(Value geom);

}

package org.gvsig.expressionevaluator;

import org.gvsig.tools.locator.AbstractLocator;

import org.gvsig.tools.locator.LocatorException;

public class GeometryExpressionEvaluatorLocator extends AbstractLocator {

    private static final String LOCATOR_NAME = "GeometryExpressionEvaluatorLocator";

    public static final String MANAGER_NAME = "GeometryExpressionEvaluatorManager";

    private static final String MANAGER_DESCRIPTION = "GeometryExpressionEvaluator of gvSIG";

    /**

     * Unique instance.

     */

    private static final GeometryExpressionEvaluatorLocator INSTANCE = new GeometryExpressionEvaluatorLocator();

    /**

     * Return the singleton instance.

     *

     * @return the singleton instance

     */

    public static GeometryExpressionEvaluatorLocator getInstance() {

        return INSTANCE;

    }

    /**

     * Returns the Locator name.

     *

     * @return String containing the locator name.

     */

    @Override

    public String getLocatorName() {

        return LOCATOR_NAME;

    }

    public static GeometryExpressionEvaluatorManager getManager() throws LocatorException {

        return (GeometryExpressionEvaluatorManager) getInstance().get(MANAGER_NAME);

    }

    public static GeometryExpressionEvaluatorManager getGeometryExpressionEvaluatorManager() throws LocatorException {

        return getManager();

    }

    public static void registerManager(Class clazz) {

        getInstance().register(MANAGER_NAME, MANAGER_DESCRIPTION, clazz);

    }

    public static void registerDefaultManager(Class clazz) {

        getInstance().registerDefault(MANAGER_NAME, MANAGER_DESCRIPTION, clazz);

    }

}

package org.gvsig.expressionevaluator;

import org.cresques.ProjectionLibrary;

import org.gvsig.fmap.geom.GeometryLibrary;

import org.gvsig.tools.ToolsLibrary;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataTypesManager;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

public class GeometryExpressionEvaluatorLibrary extends AbstractLibrary {

    @Override

    public void doRegistration() {

        registerAsAPI(GeometryExpressionEvaluatorLibrary.class);

        require(ToolsLibrary.class);

        require(ProjectionLibrary.class);

        require(GeometryLibrary.class);

        require(ExpressionEvaluatorLibrary.class);

    }

    @Override

    protected void doInitialize() throws LibraryException {

    }

    @Override

    protected void doPostInitialize() throws LibraryException {

//        DataTypesManager dataTypesManager = ToolsLocator.getDataTypesManager();

//        dataTypesManager.addtype(DataTypes.EXPRESSION, "Expression", "Expression",

//            Expression.class, null);

    }

}

package org.gvsig.expressionevaluator;

public interface GeometryExpressionEvaluatorManager  {

    public GeometryExpressionBuilder createExpressionBuilder();

}

package org.gvsig.expressionevaluator.spi;

import java.io.File;

import java.io.InputStream;

import java.net.URI;

import java.net.URISyntaxException;

import java.net.URL;

import java.time.LocalDateTime;

import java.time.ZoneId;

import java.time.temporal.TemporalAccessor;

import java.util.ArrayList;

import java.util.Date;

import java.util.List;

import java.util.Locale;

import java.util.Objects;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.BooleanUtils;

import org.apache.commons.lang3.Range;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.math.util.MathUtils;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.Codes;

import org.gvsig.expressionevaluator.Function;

import org.gvsig.expressionevaluator.I18N;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.fmap.geom.Geometry;

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

import org.json.JSONArray;

import org.json.JSONObject;

@SuppressWarnings("UseSpecificCatch")

public abstract class AbstractGeometryFunction 

        extends AbstractFunction

        implements Function 

    {

    protected AbstractGeometryFunction(String group, String name, Range argc, String description, String template, String[] descriptionArgs, String returnType, boolean sqlCompatible) {

        super(group, name, argc, description, template, descriptionArgs, returnType, sqlCompatible);

    }

    protected AbstractGeometryFunction(String group, String name, Range argc, String description, String template, String[] descriptionArgs, String returnType) {

        this(group, name, argc, description, template, descriptionArgs, returnType, false);

    }

    protected AbstractGeometryFunction(String group, String name, Range argc, String description, String template, String[] descriptionArgs) {

        this(group, name, argc, description, template, null, null);

    }

    protected AbstractGeometryFunction(String group, String name, Range argc, String description, String template) {

        this(group, name, argc, description, template, null, null);

    }

    protected AbstractGeometryFunction(String group, String name, Range argc) {

        this(group, name, argc, null, null, null, null);

    }

    protected Geometry getGeom(Object[] args, int n) {

        return this.getGeom(args, n, false);

    }

    protected Geometry getGeom(Object[] args, int n, boolean allowNull) {

        if( args.length < n  ) {

            throw new IllegalArgumentException(I18N.Required_argument_XargnX_and_only_found_XargcX_in_call_to_XIdentifierX(name(), args.length, n));

        }

        Object value = args[n];

        if( value == null ) {

            if( allowNull ) {

                return null;

            }

            throw new IllegalArgumentException(I18N.Illegal_null_value_for_argument_XargnX_of_XIdentifierX_function(name(), n));

        }

        if( !(value instanceof Geometry) ) {

            String type = value.getClass().getCanonicalName();

            throw new IllegalArgumentException(

                    I18N.The_type_of_the_argument_XargnX_for_the_XIdentifierX_function_is_incorrect(name(), n) + " " +

                    I18N.Expected_XexpectedX_and_found_XfoundX("Geometry",type)

            );

        }

        return (Geometry)value;

    }

    protected Point getPoint(Object[] args, int n) {

        if( args.length < n  ) {

            throw new IllegalArgumentException(I18N.Required_argument_XargnX_and_only_found_XargcX_in_call_to_XIdentifierX(name(), args.length, n));

        }

        Object value = args[n];

        if( value == null ) {

            return null;

        }

        if( !(value instanceof Point) ) {

            String type = value.getClass().getCanonicalName();

            throw new IllegalArgumentException(

                    I18N.The_type_of_the_argument_XargnX_for_the_XIdentifierX_function_is_incorrect(name(), n) + " " +

                    I18N.Expected_XexpectedX_and_found_XfoundX("Point",type)

            );

        }

        return (Point)value;

    }

}

package org.gvsig.expressionevaluator;

/**

 *

 * @author jjdelcerro

 */

public class GeometryExpressionUtils {

    public static GeometryExpressionBuilder createExpressionBuilder() {

        GeometryExpressionEvaluatorManager manager = GeometryExpressionEvaluatorLocator.getManager();

        return manager.createExpressionBuilder();

    }

}

org.gvsig.expressionevaluator.GeometryExpressionEvaluatorLibrary

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>

  <groupId>org.gvsig</groupId>

  <artifactId>org.gvsig.expressionevaluator.geometry.lib.api</artifactId>

  <name>${project.artifactId}</name>

  <parent>

    <groupId>org.gvsig</groupId>

    <artifactId>org.gvsig.expressionevaluator.geometry.lib</artifactId>

    <version>2.0.369</version>

  </parent>

  <build>

    <plugins>

      <plugin>

        <groupId>org.apache.maven.plugins</groupId>

        <artifactId>maven-jar-plugin</artifactId>

        <configuration>

        </configuration>

        <executions>

          <!-- Generates a jar file only with the test classes -->

          <execution>

            <goals>

              <goal>test-jar</goal>

            </goals>

          </execution>

        </executions>

      </plugin>

    </plugins>

  </build>

  <dependencies>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.expressionevaluator.lib.api</artifactId>

      <scope>compile</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.tools.lib</artifactId>

      <scope>compile</scope>

    </dependency>

   <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.fmap.geometry.api</artifactId>

      <scope>compile</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.proj.lib.api</artifactId>

      <scope>compile</scope>

    </dependency>

    <dependency>

        <groupId>org.apache.commons</groupId>

        <artifactId>commons-math</artifactId>

        <scope>compile</scope>

    </dependency>

    <dependency>

        <groupId>org.json</groupId>

        <artifactId>json</artifactId>

        <scope>compile</scope>

    </dependency>

  </dependencies>

</project>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <artifactId>org.gvsig.expressionevaluator.geometry.lib.impl</artifactId>

    <name>${project.artifactId}</name>

    <parent>

        <groupId>org.gvsig</groupId>

        <artifactId>org.gvsig.expressionevaluator.geometry.lib</artifactId>

        <version>2.0.369</version>

    </parent>

    <groupId>org.gvsig</groupId>

    <dependencies>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.expressionevaluator.lib.api</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.expressionevaluator.geometry.lib.api</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.expressionevaluator.lib.impl</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.geometry.api</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.proj.lib.api</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.json</groupId>

            <artifactId>json</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>commons-codec</groupId>

            <artifactId>commons-codec</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.apache.commons</groupId>

            <artifactId>commons-text</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>${org.gvsig.fmap.geometry.impl}</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>${org.gvsig.proj.lib.impl}</artifactId>

            <scope>test</scope>

        </dependency>

        <!--

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.timesupport.lib.impl</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.compat.se</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.tools.swing.impl</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.tools.swing.api</artifactId>

            <scope>test</scope>

        </dependency>

        -->

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.tools.lib</artifactId>

            <scope>compile</scope>

        </dependency>

    </dependencies>

  <build>

    <plugins>

      <!-- Skip test execution ? -->

      <!-- Ignore test execution failure ? -->

      <plugin>

        <groupId>org.apache.maven.plugins</groupId>

        <artifactId>maven-surefire-plugin</artifactId>

        <configuration>

          <skipTests>false</skipTests>

          <testFailureIgnore>false</testFailureIgnore>

        </configuration>

      </plugin>

      <!-- Skip test compilation ? -->

      <plugin>

        <groupId>org.apache.maven.plugins</groupId>

        <artifactId>maven-compiler-plugin</artifactId>

        <executions>

          <execution>

            <id>default-testCompile</id>

            <phase>process-test-sources</phase>

            <goals>

              <goal>testCompile</goal>

            </goals>

            <configuration>

              <skip>false</skip>

            </configuration>

          </execution>

        </executions>

      </plugin>

    </plugins>

  </build>

</project>

package org.gvsig.expresionevaluator.impl;

import junit.framework.TestCase;

import org.cresques.cts.IProjection;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.GeometryExpressionBuilder;

import org.gvsig.expressionevaluator.GeometryExpressionUtils;

import org.gvsig.expressionevaluator.LexicalAnalyzer;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.geom.GeometryUtils;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

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

import org.gvsig.tools.library.impl.DefaultLibrariesInitializer;

public class TestCodeToValue extends TestCase {

    public TestCodeToValue(String testName) {

        super(testName);

    }

    @Override

    protected void setUp() throws Exception {

        super.setUp();

        new DefaultLibrariesInitializer().fullInitialize();

    }

    @Override

    protected void tearDown() throws Exception {

        super.tearDown();

    }

    // TODO add test methods here. The name must begin with 'test'. For example:

    // public void testHello() {}

    protected LexicalAnalyzer createLexicalAnalyzer() {

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        LexicalAnalyzer lexer = manager.createLexicalAnalyzer();

        return lexer;

    }

    protected org.gvsig.expressionevaluator.Compiler createCompiler() {

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        org.gvsig.expressionevaluator.Compiler compiler = manager.createCompiler();

        compiler.setLexicalAnalyzer(createLexicalAnalyzer());

        return compiler;

    }

    public Code compileExpression(String source) {

        org.gvsig.expressionevaluator.Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        return code;

    }

    public void test3() throws CreateGeometryException {

        GeometryExpressionBuilder builder = GeometryExpressionUtils.createExpressionBuilder();

        IProjection proj = CRSFactory.getCRS("EPSG:4326");

        Point point = GeometryUtils.createPoint(10, 20);

        builder.set(        

            builder.ST_Intersects(

              builder.geometry(point,proj),

              builder.variable("the_geom")

            )

        );

        Code code = compileExpression(builder.toString());

        assertEquals(

                "ST_Intersects(ST_GeomFromWKB(DECODE('000000000140240000000000004034000000000000', 'hex'), 4326), \"the_geom\")",

                code.toValue().toString()

        );

    }

    public void test4() throws CreateGeometryException {

        GeometryExpressionBuilder builder = GeometryExpressionUtils.createExpressionBuilder();

        IProjection proj = CRSFactory.getCRS("EPSG:4326");

        Point point = GeometryUtils.createPoint(10, 20);

        builder.set(        

            builder.function("ST_Intersects2",

                builder.geometry(point,proj),

                builder.variable("the_geom")

            )

        );

        Code code = compileExpression(builder.toString());

        assertEquals(

                "ST_Intersects2(ST_GeomFromWKB(DECODE('000000000140240000000000004034000000000000', 'hex'), 4326), \"the_geom\")",

                code.toValue().toString()

        );

    }

}

package org.gvsig.expresionevaluator.impl;

import junit.framework.TestCase;

import org.gvsig.expressionevaluator.LexicalAnalyzer;

import org.gvsig.expressionevaluator.Compiler;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.ExpressionSyntaxException;

import org.gvsig.tools.library.impl.DefaultLibrariesInitializer;

public class TestCompiler extends TestCase {

    public TestCompiler(String testName) {

        super(testName);

    }

    @Override

    protected void setUp() throws Exception {

        super.setUp();

        new DefaultLibrariesInitializer().fullInitialize();

    }

    @Override

    protected void tearDown() throws Exception {

        super.tearDown();

    }

    // TODO add test methods here. The name must begin with 'test'. For example:

    // public void testHello() {}

    protected LexicalAnalyzer createLexicalAnalyzer() {

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        LexicalAnalyzer lexer = manager.createLexicalAnalyzer();

        return lexer;

    }

    protected org.gvsig.expressionevaluator.Compiler createCompiler() {

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        Compiler compiler = manager.createCompiler();

        compiler.setLexicalAnalyzer(createLexicalAnalyzer());

        return compiler;

    }

    public void testIdentifier1() {

        String source = "precio";

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("\"precio\"", code.toString());

    }

    public void testIdentifier2() {

        Compiler compiler = createCompiler();

        compiler.getLexicalAnalyzer().setUseBracketsForIdentifiers(true);

        String source = "[precio]";

        Code code = compiler.compileExpression(source);

        assertEquals("\"precio\"", code.toString());

    }

    public void testIdentifier3() {

        Compiler compiler = createCompiler();

        String source = "\"precio\"";

        Code code = compiler.compileExpression(source);

        assertEquals("\"precio\"", code.toString());

    }

    public void testTrue() {

        String source = "true";

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("TRUE", code.toString());

    }

    public void testFalse() {

        String source = "false";

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("FALSE", code.toString());

    }

    public void testNull() {

        String source = "null";

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("NULL", code.toString());

    }

    public void testIsNull() {

        String source = "10 is null";

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("(10 IS NULL)", code.toString());

    }

    public void testIsNotNull() {

        String source = "10 is not null";

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("NOT((10 IS NULL))", code.toString());

    }

    public void testNotTrue() {

        String source = "not true";

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("NOT(TRUE)", code.toString());

    }

    public void testInteger() {

        String source = "23";

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("23", code.toString());

    }

    public void operator(String operatorName) {

        String source = "precio " + operatorName + " 23";

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("(\"precio\" "+ operatorName + " 23)", code.toString());

    }

        public void testOperatorMod() {

        String source = "precio % 23";

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("MOD(\"precio\", 23)", code.toString());

    }

    public void testOperators() {

        operator("=");

        operator("<>");

        operator(">");

        operator(">=");

        operator("<");

        operator("<=");

        operator("LIKE");

        operator("ILIKE");

        operator("||");

        operator("+");

        operator("-");

        operator("*");

        operator("OR");

        operator("AND");

        operator("IS");

        operator("~");

    }

    public void testAddMul() {

        String source = "precio + 10 * 2 + 20 + 30";

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("(((\"precio\" + (10 * 2)) + 20) + 30)", code.toString());

    }

    public void testAddMulPar() {

        String source = "(precio + 10) * 2 + 20 + 30";

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("((((\"precio\" + 10) * 2) + 20) + 30)", code.toString());

    }

    public void testAbs() {

        String source = "precio + abs(10)";

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("(\"precio\" + abs(10))", code.toString());

    }

    public void testAbs2() {

        String source = "precio + abs(-10)";

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("(\"precio\" + abs(-10))", code.toString());

    }

    public void testPI() {

        String source = "precio + PI()";

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("(\"precio\" + PI())", code.toString());

    }

    public void testCeil() {

        String source = "precio + CEIL(PI())";

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("(\"precio\" + CEIL(PI()))", code.toString());

    }

    public void testGetitem1() {

        String source = "LIST('uno','dos','tres')[1]" ;

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("GETITEM(LIST('uno', 'dos', 'tres'), 1)", code.toString());

    }

    public void testConcat() {

        String source = "CONCAT(precio,' euros')";

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("CONCAT(\"precio\", ' euros')", code.toString());

    }

    public void test1() {

        String source = "NOMBRE03 = 'Torre d''En Besora (la)'";

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("(\"NOMBRE03\" = 'Torre d''En Besora (la)')", code.toString());

    }

    public void test2() {

        Compiler compiler = createCompiler();

        compiler.getLexicalAnalyzer().setUseBracketsForIdentifiers(true);

        String source = "[1990] = 0.168873933773767";

        Code code = compiler.compileExpression(source);

        assertEquals("(\"1990\" = 0.168873933773767)", code.toString());

    }

    public void test2fields() {

        Compiler compiler = createCompiler();

        compiler.getLexicalAnalyzer().setUseBracketsForIdentifiers(true);

        String source = "[1990] = [precio]";

        Code code = compiler.compileExpression(source);

        assertEquals("(\"1990\" = \"precio\")", code.toString());

    }

    public void testInvokeFunction1() {

        String source = "ST_Area(GEOMETRY)";

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("ST_Area(\"GEOMETRY\")", code.toString());

    }

    public void testInvokeMethod1() {

        String source = "'hola'.length()";

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("'hola'.length()", code.toString());

    }

    public void testInvokeMethod1b() {

        String source = "'hola'->length()";

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("'hola'.length()", code.toString());

    }

    public void testInvokeMethod2() {

        String source = "'hola'.indexOf('l')    ";

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("'hola'.indexOf('l')", code.toString());

    }

    public void testSyntaxError1() {

        Compiler compiler = createCompiler();

        String source;

        source = "3 + (2*)";

        try {

            compiler.compileExpression(source);

            assertTrue("A syntax exception should have been thrown compiling '"+source+"'.", false);

        } catch(ExpressionSyntaxException ex) {

            // Ok

        }

        source = "3 + 2*";

        try {

            compiler.compileExpression(source);

            assertTrue("A syntax exception should have been thrown compiling '"+source+"'.", false);

        } catch(ExpressionSyntaxException ex) {

            // Ok

        }

        source = "3 + (2*2))";

        try {

            compiler.compileExpression(source);

            assertTrue("A syntax exception should have been thrown compiling '"+source+"'.", false);

        } catch(ExpressionSyntaxException ex) {

            // Ok

        }

        source = "3 and or 2";

        try {

            compiler.compileExpression(source);

            assertTrue("A syntax exception should have been thrown compiling '"+source+"'.", false);

        } catch(ExpressionSyntaxException ex) {

            // Ok

        }

        source = "3*/2";

        try {

            compiler.compileExpression(source);

            assertTrue("A syntax exception should have been thrown compiling '"+source+"'.", false);

        } catch(ExpressionSyntaxException ex) {

            // Ok

        }

    }

    public void testInvokeFunction2paramters1() {

        String source = "LEFT('NOMBRE', 2)";

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("LEFT('NOMBRE', 2)", code.toString());

    }

    public void testInvokeFunction2paramters2() {

        String source = "LEFT('NOMBRE',2)";

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("LEFT('NOMBRE', 2)", code.toString());

    }

    public void testInvokeFunction3paramters1() {

        String source = "MID('NOMBRE', 2, 2)";

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("MID('NOMBRE', 2, 2)", code.toString());

    }

    public void testInvokeFunction3paramters2() {

        String source = "MID('NOMBRE', 2,2)";

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("MID('NOMBRE', 2, 2)", code.toString());

    }

    public void testDecimal1() {

        String source = "23.1";

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("23.1", code.toString());

    }

    public void testDecimal2() {

        String source = "23,1";

        Compiler compiler = createCompiler();

        try {

            Code code = compiler.compileExpression(source);

            fail("I expected 23,1 to be erroneous.");

        } catch(ExpressionSyntaxException ex) {

            // This is OK.

        }

    }

    public void testDecimal3() {

        String source = "1.23E4";

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("12300", code.toString());

    }

    public void testDecimal4() {

        String source = "1.23E-2";

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("0.0123", code.toString());

    }

    public void testDecimal5() {

        String source = "1.23E-4";

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("0.000123", code.toString());

    }

    public void testDecimal6() {

        String source = "-23.1";

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("-23.1", code.toString());

    }

    public void testDecimal7() {

        String source = "-1.23E-2";

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("-0.0123", code.toString());

    }

    public void testDecimal8() {

        String source = "-1.23E-4";

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source);

        assertEquals("-0.000123", code.toString());

    }

}

package org.gvsig.expresionevaluator.impl;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.List;

import junit.framework.TestCase;

import org.apache.commons.lang3.ArrayUtils;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.tuple.Pair;

import org.cresques.cts.IProjection;

import org.gvsig.expressionevaluator.Formatter;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionBuilder.Constant;

import org.gvsig.expressionevaluator.ExpressionBuilder.Function;

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

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

import org.gvsig.expressionevaluator.ExpressionBuilder.Parameter;

import org.gvsig.expressionevaluator.ExpressionBuilder.Value;

import org.gvsig.expressionevaluator.ExpressionBuilder.Variable;

import org.gvsig.expressionevaluator.GeometryExpressionBuilder;

import org.gvsig.expressionevaluator.GeometryExpressionBuilderHelper.GeometrySupportType;

import org.gvsig.expressionevaluator.GeometryExpressionUtils;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.GeometryUtils;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

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

import org.gvsig.tools.library.impl.DefaultLibrariesInitializer;

public class TestExpressionBuilderFormatter extends TestCase {

    private static class MyFormatter implements Formatter<Value> {

        private class Formatter_constant_bytearray implements Formatter<Value> {

            @Override

            public boolean canApply(Value value) {

                if( value instanceof Constant ) {

                    return ((Constant)value).value() instanceof byte[];

                }

                return false;

            }

            @Override

            public String format(Value constant) {

                return builder.bytearray_x((byte[]) ((Constant)constant).value());

            }

        }

        private class Formatter_constant_geometry implements Formatter<Value> {

            @Override

            public boolean canApply(Value value) {

                if( value instanceof Constant ) {

                    return ((Constant)value).value() instanceof Geometry;

                }

                return false;

            }

            @Override

            public String format(Value constant) {

                Geometry geometry = (Geometry) ((Constant)constant).value();

                switch (builder.geometry_support_type()) {

                    case EWKB:

                        return MessageFormat.format(

                                "ST_GeomFromEWKB(({0}), ({1}))",

                                builder.bytearray_x(GeometryUtils.toEWKB(geometry)),

                                String.valueOf(builder.srs_id(geometry.getProjection()))

                        );

                    case WKB:

                        return MessageFormat.format(

                                "ST_GeomFromWKB(({0}), ({1}))",

                                builder.bytearray_x(GeometryUtils.toWKB(geometry)),

                                String.valueOf(builder.srs_id(geometry.getProjection()))

                        );

                    case WKT:

                    default:

                        return MessageFormat.format(

                                "ST_GeomFromText({0}, ({1}))",

                                builder.string(GeometryUtils.toWKT(geometry)),

                                String.valueOf(builder.srs_id(geometry.getProjection()))

                        );

                }

            }

        }

        private class Formatter_ST_intersects implements Formatter<Value> {

            @Override

            public boolean canApply(Value value) {

                if( value instanceof Function ) {

                    return StringUtils.equalsIgnoreCase("ST_intersects",((Function)value).name());

                }

                return false;

            }

            @Override

            public String format(Value function) {

                List<Value> parameters = ((Function)function).parameters();

                String p1 = parameters.get(0).toString(formatter());

                String p2 = parameters.get(1).toString(formatter());

                String r = MessageFormat.format(

                        "( (({0}) && ({1})) AND ST_Intersects(({0}),({1}) ))", 

                        p1,

                        p2

                );

                return r;

            }

        }

        private class Formatter_ST_GeomFromEWKB implements Formatter<Value> {

            @Override

            public boolean canApply(Value value) {

                if( value instanceof Function ) {

                    return StringUtils.equalsIgnoreCase("ST_GeomFromEWKB",((Function)value).name());

                }

                return false;

            }

            @Override

            public String format(Value function) {

                List<Value> parameters = ((Function)function).parameters();

                String p1 = parameters.get(0).toString(formatter());

                String p2 = parameters.get(1).toString(formatter());

                String r = MessageFormat.format(

                        "GeomFromWKB({0}, {1})", 

                        p1,

                        p2

                );

                return r;

            }

        }

        private class Formatter_IFNULL implements Formatter<Value> {

            @Override

            public boolean canApply(Value value) {

                if( value instanceof Function ) {

                    return StringUtils.equalsIgnoreCase("IFNULL",((Function)value).name());

                }

                return false;

            }

            @Override

            public String format(Value function) {

                List<Value> parameters = ((Function)function).parameters();

                String p1 = parameters.get(0).toString(formatter());

                String p2 = parameters.get(1).toString(formatter());

                String p3 = parameters.get(2).toString(formatter());

                String r = MessageFormat.format(

                        "NVL2({0}, {1}, {2})", 

                        p1,

                        p3,

                        p2

                );

                return r;

            }

        }

        private class Formatter_ST_AsEWKB implements Formatter<Value> {

            @Override

            public boolean canApply(Value value) {

                if( value instanceof Function ) {

                    return StringUtils.equalsIgnoreCase("ST_AsEWKB",((Function)value).name());

                }

                return false;

            }

            @Override

            public String format(Value function) {

                List<Value> parameters = ((Function)function).parameters();

                String p1 = parameters.get(0).toString(formatter());

                String r = MessageFormat.format(

                        "AsWKB(({0}))", 

                        p1

                );

                return r;

            }

        }

        private class Formatter_NOT_IS_NULL implements Formatter<Value> {

            @Override

            public boolean canApply(Value value) {

                if( value instanceof Function ) {

                    return StringUtils.equalsIgnoreCase("NOT_IS_NULL",((Function)value).name());

                }

                return false;

            }

            @Override

            public String format(Value function) {

                List<Value> parameters = ((Function)function).parameters();

                String p1 = parameters.get(0).toString(formatter());

                String r = MessageFormat.format(

                        "( ({0}) IS NOT NULL )", 

                        p1

                );

                return r;

            }

        }

        private final Formatter<Value>[] formatters;

        private final GeometryExpressionBuilder builder;

        public MyFormatter(GeometryExpressionBuilder builder) {

            this.builder = builder;

            this.formatters = new Formatter[] {

                new Formatter_IFNULL(),

                new Formatter_NOT_IS_NULL(),

                new Formatter_ST_AsEWKB(),

                new Formatter_ST_GeomFromEWKB(),

                new Formatter_constant_bytearray(),

                new Formatter_constant_geometry(),

                new Formatter_ST_intersects()

            };

        }