/ - Diff - Application: gvSIG desktop - gvSIG

     public interface Interpreter {
         public void setSymbolTable(SymbolTable symbolTable);
         public SymbolTable getSymbolTable();
         public Object run(Code code);
         public void link(Code code);
         public Double getAccuracy();
         public void setAccuracy(Double accuracy);
         public void link(Code code);
         public Code getCurrentCode();
+    }

     public interface Function {
         public final String GROUP_NUMERIC = "Numeric";
         public final String GROUP_STRING = "String";
         public final String GROUP_DATETIME = "Datetime";
         public final String GROUP_BOOLEAN = "Boolean";
         public final String GROUP_OGC = "OGC";
         public String group();
         public String name();
-...
         public String description();
         public String template();
         public String[] descriptionArgs();
         public Object call(Object[] args) throws Exception;
         public Object call(Interpreter interpreter, Object[] args) throws Exception;
         public void addAlias(String name);
         public List<String> alias();
         public boolean isOperator();
+    }

     package org.gvsig.expressionevaluator;
     import org.gvsig.tools.locator.AbstractLocator;
     import org.gvsig.tools.locator.LocatorException;
     public class ExpressionEvaluatorLocator extends AbstractLocator {
         private static final String LOCATOR_NAME = "ExpressionEvaluatorLocator";
         public static final String MANAGER_NAME = "ExpressionEvaluatorManager";
         private static final String MANAGER_DESCRIPTION = "ExpressionEvaluator of gvSIG";
         /**
          * Unique instance.
          */
         private static final ExpressionEvaluatorLocator instance = new ExpressionEvaluatorLocator();
         /**
          * Return the singleton instance.
+         *
          * @return the singleton instance
          */
         public static ExpressionEvaluatorLocator getInstance() {
             return instance;
+        }
         /**
          * Returns the Locator name.
+         *
          * @return String containing the locator name.
          */
         @Override
         public String getLocatorName() {
             return LOCATOR_NAME;
+        }
         public static ExpressionEvaluatorManager getManager() throws LocatorException {
             return (ExpressionEvaluatorManager) getInstance().get(MANAGER_NAME);
+        }
         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);
+        }
+    }

trunk/org.gvsig.desktop/org.gvsig.desktop.library/org.gvsig.expressionevaluator/org.gvsig.expressionevaluator.lib/org.gvsig.expressionevaluator.lib.api/src/main/java/org/gvsig/expressionevaluator/ExpressionEvaluatorLibrary.java
20	20
21	21	@Override
22	22	protected void doInitialize() throws LibraryException {
23		// Do nothing
24	23	}
25	24
26	25	@Override

         public static final int CONSTANT = 0;
         public static final int IDENTIFIER = 1;
         public static final int CALLER = 2;
         public interface Constant extends Code {
             public Object value();
-...
             public static final int FUNCTION = 0;
             public static final int BINARY_OPERATOR = 1;
             public static final int UNARY_OPERATOR = 2;
             public String name();
             public Object call(Object[] args) throws Exception;
             public Object call(Interpreter interpreter, Object[] args) throws Exception;
             public Function function();
             public Function function(Function function);
-...
             public Arguments args();
             public int type();
+        }
         int code();

trunk/org.gvsig.desktop/org.gvsig.desktop.library/org.gvsig.expressionevaluator/org.gvsig.expressionevaluator.lib/org.gvsig.expressionevaluator.lib.api/src/main/java/org/gvsig/expressionevaluator/Compiler.java
6	6	public void setLexicalAnalyzer(LexicalAnalyzer lex);
7	7
8	8	public void setCodeBuilder(CodeBuilder codeBuilder);
9
	9
10	10	public Code compileExpression(String expression);
11	11
12	12	}

     import org.gvsig.fmap.geom.primitive.Point;
     public abstract class AbstractFunction implements Function {
         private final String name;
         private final String group;
         private final Range argc;
         private final String description;
         private final String[] descriptionArgs;
         private List<String> alias;
         private String template;
         protected AbstractFunction(String group, String name, Range argc, String description, String[] descriptionArgs) {
         protected AbstractFunction(String group, String name, Range argc, String description, String template, String[] descriptionArgs) {
             this.name = name;
             this.group = group;
             this.argc = argc;
             this.description = description;
             this.template = template;
             this.descriptionArgs = descriptionArgs;
+        }
         protected AbstractFunction(String group, String name, Range argc, String desription, String template) {
             this(group, name, argc, desription, template, null);
+        }
         protected AbstractFunction(String group, String name, Range argc) {
             this(group, name, argc, null, null);
             this(group, name, argc, null, null, null);
+        }
         @Override
-...
             return this.alias;
+        }
         @Override
         public String template() {
             return this.template;
+        }
         @Override
         public boolean isOperator() {
             return false;
+        }
         protected int getInt(Object args[], int n) {
             if( args.length < n  ) {
                 throw new IllegalArgumentException("Required argument "+n+" and only found " + args.length +" arguments in call to '"+name()+"'.");

     package org.gvsig.expressionevaluator;
     import org.gvsig.fmap.dal.EvaluatorFactory;
     public interface ExpressionEvaluatorManager {
         public Object evaluate(String source);
-...
         public Compiler createCompiler();
         public Interpreter createInterpreter();
         public ExpressionEvaluator createEvaluator(String expression);
+    }
         public ExpressionEvaluator createEvaluator();
         public EvaluatorFactory createEvaluatorFactory();
         public Double getAccuracy();
         public void setAccuracy(Double accuracy);
+        }

     import java.util.Iterator;
     public interface SymbolTable {
     public interface SymbolTable extends Iterable<Function>{
         public Function function(String name);

     package org.gvsig.expressionevaluator;
     import org.gvsig.tools.evaluator.EvaluatorWithDescriptions;
     public interface ExpressionEvaluator extends EvaluatorWithDescriptions {
         public void compile();
         public Code getCode();
         public Compiler getCompiler();
         public void setCompiler(Compiler compiler);
         public Interpreter getInterpreter();
         public void setInterpreter(Interpreter interpreter);
         public LexicalAnalyzer getLexer();
         public void setLexer(LexicalAnalyzer lexer);
         public String getSource();
         public void setSource(String source);
         public SymbolTable getSymbolTable();
         public void setSymbolTable(SymbolTable symbolTable);
         public Double getAccuracy();
         public void setAccuracy(Double accuracy);
+    }

trunk/org.gvsig.desktop/org.gvsig.desktop.library/org.gvsig.expressionevaluator/org.gvsig.expressionevaluator.lib/org.gvsig.expressionevaluator.lib.impl/src/main/java/org/gvsig/expressionevaluator/impl/SQLSymbolTable.java
263	263	public Iterator<Function> iterfuncs() {
264	264	return this.functions.values().iterator();
265	265	}
	266
	267	@Override
	268	public Iterator<Function> iterator() {
	269	return iterfuncs();
	270	}
266	271
267	272	}

         public void setCodeBuilder(CodeBuilder codeBuilder) {
             this.codeBuilder = codeBuilder;
+        }
         @Override
         public Code compileExpression(String expression) {
             this.lexer.setSource(expression);
-...
                     op2 = parse_sum();
                     op1 = codeBuilder.eq(op1, op2);
                     break;
                 case Token.PRED_IS: {
                 case Token.OP_NE:
                     lexer.next();
                     Token next = lexer.look();
                     if( next.getType() == Token.NOTNULL ) {
                         op1 = codeBuilder.is(op1, codeBuilder.constant(null));
                         op1 = codeBuilder.not(op1);
                     } else {
                         op2 = parse_sum();
                         op1 = codeBuilder.is(op1, op2);
                     op2 = parse_sum();
                     op1 = codeBuilder.ne(op1, op2);
                     break;
                 case Token.PRED_IS: {
                         lexer.next();
                         Token next = lexer.look();
                         if( next.getType() == Token.NOTNULL ) {
                             op1 = codeBuilder.is(op1, codeBuilder.constant(null));
                             op1 = codeBuilder.not(op1);
                         } else {
                             op2 = parse_sum();
                             op1 = codeBuilder.is(op1, op2);
+                        }
+                    }
+                }
                 break;
                     break;
                 case Token.ISNULL:
                     lexer.next();
                     op1 = codeBuilder.is(op1, codeBuilder.constant(null));
                     break;
                 case Token.OP_NE:
                     lexer.next();
                     op2 = parse_sum();
                     op1 = codeBuilder.ne(op1, op2);
                     break;
                 case Token.PRED_LIKE:
                     lexer.next();
                     op2 = parse_sum();
-...
             Token token = lexer.look();
             switch( token.getType() ) {
             case Token.PARENTHESIS_OPEN: {
                 lexer.next();
                 Code value = parseExpression();
                 Token next = lexer.next();
                 if( next.getType() != Token.PARENTHESIS_CLOSE ) {
                     throw new RuntimeException();
                     lexer.next();
                     Code value = parseExpression();
                     Token next = lexer.next();
                     if( next.getType() != Token.PARENTHESIS_CLOSE ) {
                         throw new RuntimeException();
+                    }
                     return value;
+                }
                 return value;
+            }
             case Token.IDENTIFIER: {
                 lexer.next();
                 String id = (String) token.getLiteral();
                 Token next = lexer.look();
                 if( next.getType() == Token.PARENTHESIS_OPEN ) {
                     lexer.next();
                     Arguments args = parseArgs();
                     next = lexer.next();
                     if( next.getType() != Token.PARENTHESIS_CLOSE ) {
                         throw new RuntimeException("Expected ')'.");
                     String id = (String) token.getLiteral();
                     Token next = lexer.look();
                     if( next.getType() == Token.PARENTHESIS_OPEN ) {
                         lexer.next();
                         Arguments args = parseArgs();
                         next = lexer.next();
                         if( next.getType() != Token.PARENTHESIS_CLOSE ) {
                             throw new RuntimeException("Expected ')'.");
+                        }
                         return codeBuilder.function(id, args);
                     } else {
                         return codeBuilder.identifier(id);
+                    }
                     return codeBuilder.function(id, args);
                 } else {
                     return codeBuilder.identifier(id);
+                }
+            }
             case Token.STRING_LITERAL:
                 lexer.next();
                 return codeBuilder.constant(token.getValue());

     package org.gvsig.expressionevaluator.impl;
     import org.gvsig.expressionevaluator.Code;
     import org.gvsig.expressionevaluator.CodeBuilder;
     import org.gvsig.expressionevaluator.Compiler;
     import org.gvsig.expressionevaluator.ExpressionEvaluator;
     import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;
     import org.gvsig.expressionevaluator.Interpreter;
     import org.gvsig.expressionevaluator.LexicalAnalyzer;
     import org.gvsig.expressionevaluator.MutableSymbolTable;
     import org.gvsig.expressionevaluator.SymbolTable;
     import org.gvsig.fmap.dal.EvaluatorFactory;
     import org.gvsig.integration.DefaultEvaluatorFactory;
     import org.gvsig.integration.DefaultExpressionEvaluator;
     public class DefaultExpressionEvaluatorManager implements ExpressionEvaluatorManager {
         private Double accuracy;
         public DefaultExpressionEvaluatorManager() {
+        }
         @Override
         public Object evaluate(String source) {
             DefaultInterpreter interpreter = new DefaultInterpreter();
             DefaultCompiler compiler = new DefaultCompiler();
             Code code = compiler.compileExpression(source);
             return interpreter.run(code);
+        }
         @Override
         public Object evaluate(SymbolTable symbolTable, String source) {
             DefaultInterpreter interpreter = new DefaultInterpreter();
             DefaultCompiler compiler = new DefaultCompiler();
             Code code = compiler.compileExpression(source);
             interpreter.setSymbolTable(symbolTable);
             return interpreter.run(code);
+        }
         @Override
         public Object evaluate(SymbolTable symbolTable, Code code) {
             DefaultInterpreter interpreter = new DefaultInterpreter();
             interpreter.setSymbolTable(symbolTable);
             return interpreter.run(code);
+        }
         @Override
         public Code compile(String source) {
             DefaultCompiler compiler = new DefaultCompiler();
             return compiler.compileExpression(source);
+        }
         @Override
         public Code compile(LexicalAnalyzer lex, String source) {
             DefaultCompiler compiler = new DefaultCompiler();
             compiler.setLexicalAnalyzer(lex);
             return compiler.compileExpression(source);
+        }
         @Override
         public MutableSymbolTable createSymbolTable() {
             return new DefaultSymbolTable();
+        }
         @Override
         public LexicalAnalyzer createLexicalAnalyzer() {
             return new SQLLexicalAnalyzer();
+        }
         @Override
         public CodeBuilder createCodeBuilder() {
             return new DefaultCodeBuilder();
+        }
         @Override
         public Compiler createCompiler() {
             return new DefaultCompiler();
+        }
         @Override
         public Interpreter createInterpreter() {
             return new DefaultInterpreter();
+        }
         @Override
         public ExpressionEvaluator createEvaluator(String expression) {
             DefaultExpressionEvaluator e = new DefaultExpressionEvaluator();
             e.setSource(expression);
             return e;
+        }
         @Override
         public ExpressionEvaluator createEvaluator() {
             return new DefaultExpressionEvaluator();
+        }
         @Override
         public EvaluatorFactory createEvaluatorFactory() {
             return new DefaultEvaluatorFactory();
+        }
         @Override
         public Double getAccuracy() {
             return this.accuracy;
+        }
         @Override
         public void setAccuracy(Double accuracy) {
             this.accuracy = accuracy;
+        }
+    }

trunk/org.gvsig.desktop/org.gvsig.desktop.library/org.gvsig.expressionevaluator/org.gvsig.expressionevaluator.lib/org.gvsig.expressionevaluator.lib.impl/src/main/java/org/gvsig/expressionevaluator/impl/DefaultSymbolTable.java
90	90	public Iterator<Function> iterfuncs() {
91	91	return this.functions.values().iterator();
92	92	}
	93
	94	@Override
	95	public Iterator<Function> iterator() {
	96	return iterfuncs();
	97	}
93	98
94	99	}

     package org.gvsig.expressionevaluator.impl.function.operator;
     import org.gvsig.expressionevaluator.Function;
     import org.gvsig.expressionevaluator.Interpreter;
     public class AddOperator extends AbstractBinaryOperator {
         public AddOperator() {
             super("+");
             super(Function.GROUP_NUMERIC, "+");
+        }
         @Override
         public Object call(Object op1, Object op2) {
         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();

     package org.gvsig.expressionevaluator.impl.function.operator;
     import org.apache.commons.lang3.ObjectUtils;
     import org.apache.commons.math.util.MathUtils;
     import org.gvsig.expressionevaluator.Function;
     import org.gvsig.expressionevaluator.Interpreter;
     public class GeOperator extends AbstractBinaryOperator {
         public GeOperator() {
             super(">=");
             super(Function.GROUP_BOOLEAN,">=");
+        }
         @Override
         public Object call(Object op1, Object op2) {
         public Object call(Interpreter interpreter, Object op1, Object op2) {
             Double accuracy = interpreter.getAccuracy();
             if( accuracy!=null ) {
                 if( op1!=null && op2!= null && (
                     op1 instanceof Double || op2 instanceof Double ||
                     op1 instanceof Float || op2 instanceof Float) ) {
                     boolean value = MathUtils.compareTo(((Number)op1).doubleValue(), ((Number)op2).doubleValue(), accuracy) >= 0;
                     return value;
+                }
+            }
             if( op2 instanceof Comparable && op2 instanceof Comparable ) {
                 boolean value = ((Comparable)op1).compareTo((Comparable)op2) >= 0;
                 boolean value = ObjectUtils.compare((Comparable)op1,(Comparable)op2) >= 0;
                 return value;
+            }
             throw new IllegalArgumentException("Types not allowed in '"+name()+"' operand.");

     package org.gvsig.expressionevaluator.impl.function.operator;
     import org.gvsig.expressionevaluator.Function;
     import org.gvsig.expressionevaluator.Interpreter;
     public class MulOperator extends AbstractBinaryOperator {
         public MulOperator() {
             super("*");
             super(Function.GROUP_NUMERIC, "*");
+        }
         @Override
         public Object call(Object op1, Object op2) {
         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();

     package org.gvsig.expressionevaluator.impl.function.operator;
     import org.gvsig.expressionevaluator.Function;
     import org.gvsig.expressionevaluator.Interpreter;
     public interface UnaryOperator extends Function {
         public Object call(Object op);
         public Object call(Interpreter interpreter, Object op);
+    }

     package org.gvsig.expressionevaluator.impl.function.operator;
     import org.gvsig.expressionevaluator.Function;
     import org.gvsig.expressionevaluator.Interpreter;
     public class SubstOperator extends AbstractBinaryOperator {
         public SubstOperator() {
             super("-");
             super(Function.GROUP_NUMERIC,"-");
+        }
         @Override
         public Object call(Object op1, Object op2) {
         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();

     package org.gvsig.expressionevaluator.impl.function.operator;
     import org.apache.commons.lang3.ObjectUtils;
     import org.apache.commons.math.util.MathUtils;
     import org.gvsig.expressionevaluator.Function;
     import org.gvsig.expressionevaluator.Interpreter;
     public class LeOperator extends AbstractBinaryOperator {
         public LeOperator() {
             super("<=");
             super(Function.GROUP_BOOLEAN,"<=");
+        }
         @Override
         public Object call(Object op1, Object op2) {
         public Object call(Interpreter interpreter, Object op1, Object op2) {
             Double accuracy = interpreter.getAccuracy();
             if( accuracy!=null ) {
                 if( op1!=null && op2!= null && (
                     op1 instanceof Double || op2 instanceof Double ||
                     op1 instanceof Float || op2 instanceof Float) ) {
                     boolean value = MathUtils.compareTo(((Number)op1).doubleValue(), ((Number)op2).doubleValue(), accuracy) <= 0;
                     return value;
+                }
+            }
             if( op2 instanceof Comparable && op2 instanceof Comparable ) {
                 boolean value = ((Comparable)op1).compareTo((Comparable)op2) <= 0;
                 boolean value = ObjectUtils.compare((Comparable)op1,(Comparable)op2) <= 0;
                 return value;
+            }
             throw new IllegalArgumentException("Types not allowed in '"+name()+"' operand.");

     package org.gvsig.expressionevaluator.impl.function.operator;
     import org.gvsig.expressionevaluator.Function;
     import org.gvsig.expressionevaluator.Interpreter;
     public class NotOperator extends AbstractUnaryOperator {
         public NotOperator() {
             super("NOT");
             super(Function.GROUP_BOOLEAN,"NOT");
             this.addAlias("!");
+        }
         @Override
         public Object call(Object arg) {
         public Object call(Interpreter interpreter, Object arg) {
             if( ! (arg instanceof Boolean) ) {
                 throw new IllegalArgumentException("NOT operator require a boolean");
+            }

     package org.gvsig.expressionevaluator.impl.function.operator;
     import org.apache.commons.lang3.ObjectUtils;
     import org.apache.commons.math.util.MathUtils;
     import org.gvsig.expressionevaluator.Function;
     import org.gvsig.expressionevaluator.Interpreter;
     public class NeOperator extends AbstractBinaryOperator {
         public NeOperator() {
             super("<>");
             super(Function.GROUP_BOOLEAN,"<>");
             this.addAlias("!=");
+        }
         @Override
         public Object call(Object op1, Object op2) {
         public Object call(Interpreter interpreter, Object op1, Object op2) {
             Double accuracy = interpreter.getAccuracy();
             if( accuracy!=null ) {
                 if( op1!=null && op2!= null && (
                     op1 instanceof Double || op2 instanceof Double ||
                     op1 instanceof Float || op2 instanceof Float) ) {
                     boolean value = MathUtils.compareTo(((Number)op1).doubleValue(), ((Number)op2).doubleValue(), accuracy) != 0;
                     return value;
+                }
+            }
             if( op2 instanceof Comparable && op2 instanceof Comparable ) {
                 boolean value = ((Comparable)op1).compareTo((Comparable)op2) != 0;
                 boolean value = ObjectUtils.compare((Comparable)op1,(Comparable)op2) != 0;
                 return value;
+            }
             throw new IllegalArgumentException("Types not allowed in '"+name()+"' operand.");

     package org.gvsig.expressionevaluator.impl.function.operator;
     import org.gvsig.expressionevaluator.Function;
     import org.gvsig.expressionevaluator.Interpreter;
     public class AndOperator extends AbstractBinaryOperator {
         public AndOperator() {
             super("AND");
             super(Function.GROUP_BOOLEAN, "AND");
             this.addAlias("&&");
+        }
         @Override
         public Object call(Object op1, Object op2) {
         public Object call(Interpreter interpreter, Object op1, Object op2) {
             if( op1 instanceof Boolean && op2 instanceof Boolean ) {
                 boolean value = ((Boolean) op1) && ((Boolean) op2);
                 return value;

     package org.gvsig.expressionevaluator.impl.function.operator;
     import org.apache.commons.lang3.ObjectUtils;
     import org.apache.commons.math.util.MathUtils;
     import org.gvsig.expressionevaluator.Function;
     import org.gvsig.expressionevaluator.Interpreter;
     public class EqOperator extends AbstractBinaryOperator {
         public EqOperator() {
             super("=");
             super(Function.GROUP_BOOLEAN, "=");
+        }
         @Override
         public Object call(Object op1, Object op2) {
         public Object call(Interpreter interpreter, Object op1, Object op2) {
             Double accuracy = interpreter.getAccuracy();
             if( accuracy!=null ) {
                 if( op1!=null && op2!= null && (
                     op1 instanceof Double || op2 instanceof Double ||
                     op1 instanceof Float || op2 instanceof Float) ) {
                     boolean value = MathUtils.compareTo(((Number)op1).doubleValue(), ((Number)op2).doubleValue(), accuracy) == 0;
                     return value;
+                }
+            }
             if( op2 instanceof Comparable && op2 instanceof Comparable ) {
                 boolean value = ((Comparable)op1).compareTo((Comparable)op2) == 0;
                 boolean value = ObjectUtils.compare((Comparable)op1,(Comparable)op2) == 0;
                 return value;
+            }
             throw new IllegalArgumentException("Types not allowed in '"+name()+"' operand.");
             throw new IllegalArgumentException("Types not allowed in '" + name() + "' operand.");
+        }
+    }

     import java.util.Date;
     import org.apache.commons.lang3.Range;
     import org.gvsig.expressionevaluator.Interpreter;
     import org.gvsig.expressionevaluator.spi.AbstractFunction;
     public abstract class AbstractBinaryOperator extends AbstractFunction implements BinaryOperator {
         protected AbstractBinaryOperator(String name, String description) {
             super("Operators", name, Range.is(2), description, null);
         protected AbstractBinaryOperator(String group, String name, String description) {
             super(group, name, Range.is(2), description, null);
+        }
         protected AbstractBinaryOperator(String name) {
             this(name, null);
         protected AbstractBinaryOperator(String group, String name) {
             this(group, name, null);
+        }
         @Override
         public Object call(Object[] args) {
             return call(args[0], args[1]);
         public Object call(Interpreter interpreter, Object[] args) {
             return call(interpreter, args[0], args[1]);
+        }
         @Override
         public boolean isOperator() {
             return true;
+        }
         protected static final int TYPE_INT =     0b0000001;
         protected static final int TYPE_LONG =    0b0000010;

     package org.gvsig.expressionevaluator.impl.function.operator;
     import org.apache.commons.lang3.ObjectUtils;
     import org.apache.commons.math.util.MathUtils;
     import org.gvsig.expressionevaluator.Function;
     import org.gvsig.expressionevaluator.Interpreter;
     public class GtOperator extends AbstractBinaryOperator {
         public GtOperator() {
             super(">");
             super(Function.GROUP_BOOLEAN,">");
+        }
         @Override
         public Object call(Object op1, Object op2) {
         public Object call(Interpreter interpreter, Object op1, Object op2) {
             Double accuracy = interpreter.getAccuracy();
             if( accuracy!=null ) {
                 if( op1!=null && op2!= null && (
                     op1 instanceof Double || op2 instanceof Double ||
                     op1 instanceof Float || op2 instanceof Float) ) {
                     boolean value = MathUtils.compareTo(((Number)op1).doubleValue(), ((Number)op2).doubleValue(), accuracy) > 0;
                     return value;
+                }
+            }
             if( op2 instanceof Comparable && op2 instanceof Comparable ) {
                 boolean value = ((Comparable)op1).compareTo((Comparable)op2) > 0;
                 boolean value = ObjectUtils.compare((Comparable)op1,(Comparable)op2) > 0;
                 return value;
+            }
             throw new IllegalArgumentException("Types not allowed in '"+name()+"' operand.");

     package org.gvsig.expressionevaluator.impl.function.operator;
     import org.apache.commons.lang3.ObjectUtils;
     import org.apache.commons.math.util.MathUtils;
     import org.gvsig.expressionevaluator.Function;
     import org.gvsig.expressionevaluator.Interpreter;
     public class LtOperator extends AbstractBinaryOperator {
         public LtOperator() {
             super("<");
             super(Function.GROUP_BOOLEAN,"<");
+        }
         @Override
         public Object call(Object op1, Object op2) {
         public Object call(Interpreter interpreter, Object op1, Object op2) {
             Double accuracy = interpreter.getAccuracy();
             if( accuracy!=null ) {
                 if( op1!=null && op2!= null && (
                     op1 instanceof Double || op2 instanceof Double ||
                     op1 instanceof Float || op2 instanceof Float) ) {
                     boolean value = MathUtils.compareTo(((Number)op1).doubleValue(), ((Number)op2).doubleValue(), accuracy) < 0;
                     return value;
+                }
+            }
             if( op2 instanceof Comparable && op2 instanceof Comparable ) {
                 boolean value = ((Comparable)op1).compareTo((Comparable)op2) < 0;
                 boolean value = ObjectUtils.compare((Comparable)op1,(Comparable)op2) < 0;
                 return value;
+            }
             throw new IllegalArgumentException("Types not allowed in '"+name()+"' operand.");

     package org.gvsig.expressionevaluator.impl.function.operator;
     import org.gvsig.expressionevaluator.Function;
     import org.gvsig.expressionevaluator.Interpreter;
     public class ModOperator extends AbstractBinaryOperator {
         public ModOperator() {
             super("%");
             super(Function.GROUP_NUMERIC, "%");
+        }
         @Override
         public Object call(Object op1, Object op2) {
         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();

     package org.gvsig.expressionevaluator.impl.function.operator;
     import org.gvsig.expressionevaluator.Function;
     import org.gvsig.expressionevaluator.Interpreter;
     public class OrOperator extends AbstractBinaryOperator {
         public OrOperator() {
             super("OR");
             super(Function.GROUP_BOOLEAN,"OR");
             this.addAlias("||");
+        }
         @Override
         public Object call(Object op1, Object op2) {
         public Object call(Interpreter interpreter, Object op1, Object op2) {
             if( op1 instanceof Boolean && op2 instanceof Boolean ) {
                 boolean value = ((Boolean) op1) || ((Boolean) op2);
                 return value;

     package org.gvsig.expressionevaluator.impl.function.operator;
     import org.apache.commons.lang3.Range;
     import org.gvsig.expressionevaluator.Interpreter;
     import org.gvsig.expressionevaluator.spi.AbstractFunction;
     public abstract class AbstractUnaryOperator extends AbstractFunction implements UnaryOperator {
         protected AbstractUnaryOperator(String name, String description) {
             super("Operators", name, Range.is(1), description, null);
         protected AbstractUnaryOperator(String group, String name, String description) {
             super(group, name, Range.is(1), description, null);
+        }
         protected AbstractUnaryOperator(String name) {
             this(name, null);
         protected AbstractUnaryOperator(String group, String name) {
             this(group, name, null);
+        }
         @Override
         public Object call(Object[] args) {
             return call(args[0]);
         public Object call(Interpreter interpreter, Object[] args) {
             return call(interpreter, args[0]);
+        }
         @Override
         public boolean isOperator() {
             return true;
+        }
+    }

     package org.gvsig.expressionevaluator.impl.function.operator;
     import org.gvsig.expressionevaluator.Function;
     import org.gvsig.expressionevaluator.Interpreter;
     public class DivOperator extends AbstractBinaryOperator {
         public DivOperator() {
             super("/");
             super(Function.GROUP_NUMERIC, "/");
+        }
         @Override
         public Object call(Object op1, Object op2) {
         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();

     package org.gvsig.expressionevaluator.impl.function.operator;
     import org.gvsig.expressionevaluator.Function;
     import org.gvsig.expressionevaluator.Interpreter;
     public interface BinaryOperator extends Function {
         public Object call(Object op1, Object op2);
         public Object call(Interpreter interpreter, Object op1, Object op2);
+    }

     package org.gvsig.expressionevaluator.impl.function.spatial;
     import org.apache.commons.lang3.Range;
     import org.gvsig.expressionevaluator.Interpreter;
     import org.gvsig.expressionevaluator.spi.AbstractFunction;
     public class STOverlapsFunction extends AbstractFunction {
-...
+        }
         @Override
         public Object call(Object[] args)  throws Exception {
         public Object call(Interpreter interpreter, Object[] args) throws Exception {
             boolean r = getGeom(args, 0).overlaps(getGeom(args, 1));
             return r;
+        }

     package org.gvsig.expressionevaluator.impl.function.spatial;
     import org.apache.commons.lang3.Range;
     import org.gvsig.expressionevaluator.Interpreter;
     import org.gvsig.expressionevaluator.spi.AbstractFunction;
     public class STCoversFunction extends AbstractFunction {
-...
+        }
         @Override
         public Object call(Object[] args)  throws Exception {
         public Object call(Interpreter interpreter, Object[] args) throws Exception {
             boolean r = getGeom(args, 0).covers(getGeom(args, 1));
             return r;
+        }

     package org.gvsig.expressionevaluator.impl.function.spatial;
     import org.apache.commons.lang3.Range;
     import org.gvsig.expressionevaluator.Interpreter;
     import org.gvsig.expressionevaluator.spi.AbstractFunction;
     public class STWithinFunction extends AbstractFunction {
-...
+        }
         @Override
         public Object call(Object[] args)  throws Exception {
         public Object call(Interpreter interpreter, Object[] args) throws Exception {
             boolean r = getGeom(args, 0).within(getGeom(args, 1));
             return r;
+        }

     package org.gvsig.expressionevaluator.impl.function.spatial;
     import org.apache.commons.lang3.Range;
     import org.gvsig.expressionevaluator.Interpreter;
     import org.gvsig.expressionevaluator.spi.AbstractFunction;
     public class STYFunction extends AbstractFunction {
-...
+        }
         @Override
         public Object call(Object[] args)  throws Exception {
         public Object call(Interpreter interpreter, Object[] args) throws Exception {
             double r = getPoint(args, 0).getY();
             return r;
+        }

     package org.gvsig.expressionevaluator.impl.function.spatial;
     import org.apache.commons.lang3.Range;
     import org.gvsig.expressionevaluator.Interpreter;
     import org.gvsig.expressionevaluator.spi.AbstractFunction;
     public class STAreaFunction extends AbstractFunction {
-...
+        }
         @Override
         public Object call(Object[] args)  throws Exception {
         public Object call(Interpreter interpreter, Object[] args) throws Exception {
             double r = getGeom(args, 0).area();
             return r;
+        }

     package org.gvsig.expressionevaluator.impl.function.spatial;
     import org.apache.commons.lang3.Range;
     import org.gvsig.expressionevaluator.Interpreter;
     import org.gvsig.expressionevaluator.spi.AbstractFunction;
     public class STAsTextFunction extends AbstractFunction {
-...
+        }
         @Override
         public Object call(Object[] args)  throws Exception {
         public Object call(Interpreter interpreter, Object[] args) throws Exception {
             String r = getGeom(args, 0).convertToWKT();
             return r;
+        }

     package org.gvsig.expressionevaluator.impl.function.spatial;
     import org.apache.commons.lang3.Range;
     import org.gvsig.expressionevaluator.Interpreter;
     import org.gvsig.expressionevaluator.spi.AbstractFunction;
     import org.gvsig.fmap.geom.Geometry;
     import org.gvsig.fmap.geom.aggregate.Aggregate;
-...
+        }
         @Override
         public Object call(Object[] args)  throws Exception {
         public Object call(Interpreter interpreter, Object[] args) throws Exception {
             Geometry geom = getGeom(args, 0);
             if( geom instanceof Aggregate ) {
                 Primitive r = ((Aggregate) geom).getPrimitiveAt(getInt(args, 1));

     package org.gvsig.expressionevaluator.impl.function.spatial;
     import org.apache.commons.lang3.Range;
     import org.gvsig.expressionevaluator.Interpreter;
     import org.gvsig.expressionevaluator.spi.AbstractFunction;
     import org.gvsig.fmap.geom.Geometry;
     import org.gvsig.fmap.geom.primitive.Envelope;
-...
+        }
         @Override
         public Object call(Object[] args)  throws Exception {
         public Object call(Interpreter interpreter, Object[] args) throws Exception {
             Envelope r = getGeom(args, 0).getEnvelope();
             return r;
+        }

     package org.gvsig.expressionevaluator.impl.function.spatial;
     import org.apache.commons.lang3.Range;
     import org.gvsig.expressionevaluator.Interpreter;
     import org.gvsig.expressionevaluator.spi.AbstractFunction;
     public class STContainsFunction extends AbstractFunction {
-...
+        }
         @Override
         public Object call(Object[] args)  throws Exception {
         public Object call(Interpreter interpreter, Object[] args) throws Exception {
             boolean r = getGeom(args, 0).contains(getGeom(args, 1));
             return r;
+        }

     package org.gvsig.expressionevaluator.impl.function.spatial;
     import org.apache.commons.lang3.Range;
     import org.gvsig.expressionevaluator.Interpreter;
     import org.gvsig.expressionevaluator.spi.AbstractFunction;
     public class STCoveredByFunction extends AbstractFunction {
-...
+        }
         @Override
         public Object call(Object[] args)  throws Exception {
         public Object call(Interpreter interpreter, Object[] args) throws Exception {
             boolean r = getGeom(args, 0).coveredBy(getGeom(args, 1));
             return r;
+        }

     package org.gvsig.expressionevaluator.impl.function.spatial;
     import org.apache.commons.lang3.Range;
     import org.gvsig.expressionevaluator.Interpreter;
     import org.gvsig.expressionevaluator.spi.AbstractFunction;
     public class STIntersectsFunction extends AbstractFunction {
-...
+        }
         @Override
         public Object call(Object[] args)  throws Exception {
         public Object call(Interpreter interpreter, Object[] args) throws Exception {
             boolean r = getGeom(args, 0).intersects(getGeom(args, 1));
             return r;
+        }

     package org.gvsig.expressionevaluator.impl.function.spatial;
     import org.apache.commons.lang3.Range;
     import org.gvsig.expressionevaluator.Interpreter;
     import org.gvsig.expressionevaluator.spi.AbstractFunction;
     import org.gvsig.fmap.geom.Geometry;
-...
+        }
         @Override
         public Object call(Object[] args)  throws Exception {
         public Object call(Interpreter interpreter, Object[] args) throws Exception {
             Geometry r = getGeom(args, 0).union(getGeom(args, 1));
             return r;
+        }

     package org.gvsig.expressionevaluator.impl.function.spatial;
     import org.apache.commons.lang3.Range;
     import org.gvsig.expressionevaluator.Interpreter;
     import org.gvsig.expressionevaluator.spi.AbstractFunction;
     public class STDistanceFunction extends AbstractFunction {
-...
+        }
         @Override
         public Object call(Object[] args)  throws Exception {
         public Object call(Interpreter interpreter, Object[] args) throws Exception {
             double r = getGeom(args, 0).distance(getGeom(args, 1));
             return r;
+        }

     package org.gvsig.expressionevaluator.impl.function.spatial;
     import org.apache.commons.lang3.Range;
     import org.gvsig.expressionevaluator.Interpreter;
     import org.gvsig.expressionevaluator.spi.AbstractFunction;
     import org.gvsig.fmap.geom.Geometry;
-...
+        }
         @Override
         public Object call(Object[] args)  throws Exception {
         public Object call(Interpreter interpreter, Object[] args) throws Exception {
             boolean r = getGeom(args, 0).isValid();
             return r;
+        }

     package org.gvsig.expressionevaluator.impl.function.spatial;
     import org.apache.commons.lang3.Range;
     import org.gvsig.expressionevaluator.Interpreter;
     import org.gvsig.expressionevaluator.spi.AbstractFunction;
     import org.gvsig.fmap.geom.Geometry;
     import org.gvsig.fmap.geom.primitive.OrientablePrimitive;
-...
+        }
         @Override
         public Object call(Object[] args)  throws Exception {
         public Object call(Interpreter interpreter, Object[] args) throws Exception {
             Geometry geom = getGeom(args, 0);
             if ( geom instanceof OrientablePrimitive ) {
                 int n = ((OrientablePrimitive) geom).getNumVertices();

     package org.gvsig.expressionevaluator.impl.function.spatial;
     import org.apache.commons.lang3.Range;
     import org.gvsig.expressionevaluator.Interpreter;
     import org.gvsig.expressionevaluator.spi.AbstractFunction;
     import org.gvsig.fmap.geom.Geometry;
-...
+        }
         @Override
         public Object call(Object[] args)  throws Exception {
         public Object call(Interpreter interpreter, Object[] args) throws Exception {
             Geometry r = getGeom(args, 0).intersection(getGeom(args, 1));
             return r;
+        }

     package org.gvsig.expressionevaluator.impl.function.spatial;
     import org.apache.commons.lang3.Range;
     import org.gvsig.expressionevaluator.Interpreter;
     import org.gvsig.expressionevaluator.spi.AbstractFunction;
     import org.gvsig.fmap.geom.primitive.Point;
-...
+        }
         @Override
         public Object call(Object[] args)  throws Exception {
         public Object call(Interpreter interpreter, Object[] args) throws Exception {
             Point r = getGeom(args, 0).centroid();
             return r;
+        }

     package org.gvsig.expressionevaluator.impl.function.spatial;
     import org.apache.commons.lang3.Range;
     import org.gvsig.expressionevaluator.Interpreter;
     import org.gvsig.expressionevaluator.spi.AbstractFunction;
     import org.gvsig.fmap.geom.Geometry;
     import org.gvsig.fmap.geom.primitive.OrientablePrimitive;
-...
+        }
         @Override
         public Object call(Object[] args)  throws Exception {
         public Object call(Interpreter interpreter, Object[] args) throws Exception {
             Geometry geom = getGeom(args, 0);
             if ( geom instanceof OrientablePrimitive ) {
                 Point n = ((OrientablePrimitive) geom).getVertex(getInt(args, 1));

     package org.gvsig.expressionevaluator.impl.function.spatial;
     import org.apache.commons.lang3.Range;
     import org.gvsig.expressionevaluator.Interpreter;
     import org.gvsig.expressionevaluator.spi.AbstractFunction;
     import org.gvsig.fmap.geom.Geometry;
     import org.gvsig.fmap.geom.primitive.OrientablePrimitive;
-...
+        }
         @Override
         public Object call(Object[] args)  throws Exception {
         public Object call(Interpreter interpreter, Object[] args) throws Exception {

Application: gvSIG desktop

Revision 43521