/ - Diff - Application: gvSIG desktop - gvSIG

             interpreter.setAccuracy(0.0000001);
             v = interpreter.run(code);
             assertEquals(true, ((Boolean)v).booleanValue());
+        }
+    }
+        }
         public void test2fields() {
             String source = "[1990] = [precio]";
             SymbolTable symbolTable = createSymbolTable();
             Compiler compiler = createCompiler();
             Interpreter interpreter = createInterpreter(symbolTable);
             Code code = compiler.compileExpression(source);
             Object v = interpreter.run(code);
             assertEquals(false, ((Boolean)v).booleanValue());
         }}

             Code code = compiler.compileExpression(source);
             assertEquals("=([1990], 0.168873933773767)", code.toString());
+        }
         public void test2fields() {
             String source = "[1990] = [precio]";
             Compiler compiler = createCompiler();
             Code code = compiler.compileExpression(source);
             assertEquals("=([1990], [precio])", code.toString());
+        }
+    }

     package org.gvsig.expressionevaluator.impl.function.operator;
     import java.util.Objects;
     import java.util.regex.Matcher;
     import java.util.regex.Pattern;
     import org.gvsig.expressionevaluator.Function;
     import org.gvsig.expressionevaluator.Interpreter;
     public class RegExpOperator extends AbstractBinaryOperator {
         public RegExpOperator() {
             super(Function.GROUP_BOOLEAN, "~");
+        }
         @Override
         public Object call(Interpreter interpreter, Object op1, Object op2) {
             String re = Objects.toString(op2, "");
             Pattern exp = (Pattern) interpreter.getCache().get(this.getClass(), re);
             if( exp == null ) {
                 exp = Pattern.compile(re);
                 interpreter.getCache().put(this.getClass(), re, exp);
+            }
             Matcher m = exp.matcher(Objects.toString(op1,""));
             if( m == null ) {
                 return false;
+            }
             return m.matches();
+        }
+    }

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/DefaultCodeBuilder.java
356	356	}
357	357
358	358	@Override
	359	public Code regexp(Code op1, Code op2) {
	360	return operator("~", op1, op2);
	361	}
	362
	363	@Override
359	364	public Code lt(Code op1, Code op2) {
360	365	return operator("<", op1, op2);
361	366	}

             case EOF:
                 token.set(Token.EOF, null, null);
                 return token;
             case '~':
                 token.set(Token.OP_REGEXP, "~");
                 return token;
             case '*':
                 token.set(Token.OP_MULT, "*");
                 return token;

     package org.gvsig.expressionevaluator.impl;
     import java.util.ArrayList;
     import java.util.Comparator;
     import java.util.Date;
     import java.util.HashMap;
     import java.util.List;
     import java.util.Map;
     import org.apache.commons.lang3.tuple.Pair;
     import org.gvsig.expressionevaluator.SymbolTable;
     import org.gvsig.expressionevaluator.Interpreter;
     import org.gvsig.expressionevaluator.Code;
-...
     public class DefaultInterpreter implements Interpreter {
         private class DefaultCache implements Cache {
             private Map<Pair<Object,Object>,Pair<Object,Long>> data;
             public DefaultCache() {
                 this.data = new  HashMap<>();
+            }
             @Override
             public Object get(Object context, Object key) {
                 Pair<Object, Long> v = this.data.get( Pair.of(context, key) );
                 return v.getLeft();
+            }
             @Override
             public void put(Object context, Object key, Object value) {
                 if( this.data.size()>this.getMaxElements() ) {
                     this.reduce();
+                }
                 this.data.put(Pair.of(context, key), Pair.of(value, new Date().getTime()));
+            }
             @Override
             public void remove(Object context, Object key) {
                 this.data.remove(Pair.of(context, key));
+            }
             @Override
             public void removeAll() {
                 this.data = new  HashMap<>();
+            }
             private int getMaxElements() {
                 return 100;
+            }
             private void reduce() {
                 List<Map.Entry<Pair<Object, Object>, Pair<Object, Long>>> entries =
                     new ArrayList<>(this.data.entrySet());
                 entries.sort(new Comparator<Map.Entry<Pair<Object, Object>, Pair<Object, Long>>>() {
                     @Override
                     public int compare(Map.Entry<Pair<Object, Object>, Pair<Object, Long>> o1, Map.Entry<Pair<Object, Object>, Pair<Object, Long>> o2) {
                         return o1.getValue().getRight().compareTo(o2.getValue().getRight());
+                    }
                 });
                 for( int i=0; i<this.getMaxElements()/2; i++ ) {
                     this.data.remove(entries.get(i).getKey());
+                }
+            }
+        }
         private SymbolTable symbolTable = null;
         private Double accuracy;
         private Code currentCode;
         private final Cache cache;
         public DefaultInterpreter() {
             this.symbolTable = SQLSymbolTable.getInstance();
             this.cache = new DefaultCache();
+        }
         @Override
         public Cache getCache() {
             return this.cache;
+        }
         @Override
         public void setSymbolTable(SymbolTable symbolTable) {
             this.symbolTable = symbolTable;
+        }

         private LexicalAnalyzer lexer;
         private CodeBuilder codeBuilder;
         //
         // https://www.postgresql.org/docs/9.1/static/functions.html
         //
         public DefaultCompiler() {
             this.lexer = new SQLLexicalAnalyzer();
-...
                     lexer.next();
                     op1 = codeBuilder.is(op1, codeBuilder.constant(null));
                     break;
                 case Token.OP_REGEXP:
                     lexer.next();
                     op2 = parse_sum();
                     op1 = codeBuilder.regexp(op1, op2);
                     break;
                 case Token.PRED_LIKE:
                     lexer.next();
                     op2 = parse_sum();

         Code ilike(Code op1, Code op2);
         Code regexp(Code op1, Code op2);
         Code lt(Code op1, Code op2);
         Code gt(Code op1, Code op2);

     public interface Interpreter {
         public interface Cache {
             public Object get(Object context, Object key);
             public void put(Object context, Object key, Object value);
             public void remove(Object context, Object key);
             public void removeAll();
+        }
         public void setSymbolTable(SymbolTable symbolTable);
         public SymbolTable getSymbolTable();
-...
         public void setAccuracy(Double accuracy);
         public Code getCurrentCode();
         public Cache getCache();
+    }

             public static final int OP_MULT = 12;
             public static final int OP_DIV = 13;
             public static final int OP_MOD = 14;
     //        public static final int OP_POW = 15;
             public static final int OP_REGEXP = 15;
             public static final int OP_LT = 16;
             public static final int OP_GT = 17;
             public static final int OP_LE = 18;

Application: gvSIG desktop

Revision 43532