/ - Diff - Application: gvSIG desktop - gvSIG

     package org.gvsig.expressionevaluator.impl;
     import org.gvsig.expressionevaluator.LexicalAnalyzer;
     public class SQLLexicalAnalyzer extends AbstractLexicalAnalyzer {
         public SQLLexicalAnalyzer(String source) {
-...
+        }
         @Override
         public LexicalAnalyzer clone() throws CloneNotSupportedException {
             // As this implementation does not add state to the abstract class, we
             // just call the super class.
             SQLLexicalAnalyzer other = (SQLLexicalAnalyzer) super.clone();
             return other;
+        }
         @Override
         protected Token getToken() {
             skipblanks();
             char ch = getch();
-...
+                }
                 ungetch();
                 parseNumber();
                 token.literal = "+" + token.literal;
                 token.setLiteral("+" + token.getLiteral());
                 return token;
             case '-':
                 ch = getch();

         private SymbolTable symbolTable = null;
         private Double accuracy;
         private Code currentCode;
         private final Cache cache;
         private Cache cache;
         public DefaultInterpreter() {
             this.symbolTable = SQLSymbolTable.getInstance();
             this.cache = new DefaultCache();
+        }
         @Override
         public Interpreter clone() throws CloneNotSupportedException {
             DefaultInterpreter other = (DefaultInterpreter) super.clone();
             other.cache = new DefaultCache();
             if( this.symbolTable!=null ) {
                 other.symbolTable = this.symbolTable.clone();
+            }
             return other;
+        }
         @Override
         public Cache getCache() {
             return this.cache;
+        }
-...
         @Override
         public SymbolTable getSymbolTable() {
             if( this.symbolTable==null ) {
                 this.symbolTable = SQLSymbolTable.getInstance();
+            }
             return this.symbolTable;
+        }
         @Override
-...
             if( code instanceof Caller ) {
                 Caller caller = (Caller) code;
                 if( caller.function() == null ) {
                     caller.function(this.symbolTable.function(caller.name()));
                     caller.function(this.getSymbolTable().function(caller.name()));
+                }
                 if( caller.args() != null ) {
                     for( Code arg : caller.args() ) {
-...
             case Code.IDENTIFIER:
                 String name = ((Identifier) code).name();
                 if( !symbolTable.exists(name) ) {
                 if( !this.getSymbolTable().exists(name) ) {
                     throw new RuntimeException("Variable '" + name + "' not found.");
+                }
                 value = symbolTable.value(name);
                 value = this.getSymbolTable().value(name);
                 break;
             case Code.CALLER:
                 Caller caller = (Caller) code;
                 Function function = caller.function();
                 if( function == null ) {
                     function = this.symbolTable.function(caller.name());
                     function = this.getSymbolTable().function(caller.name());
                     if( function == null ) {
                         throw new RuntimeException("Function '" + caller.name() + "' not found.");
+                    }

     import java.util.Locale;
     import java.util.Map;
     import java.util.Stack;
     import org.gvsig.tools.lang.Cloneable;
     public abstract class AbstractLexicalAnalyzer implements LexicalAnalyzer {
         protected class Buffer {
         protected class Buffer implements Cloneable {
             StringBuilder builder;
-...
                 this.builder = new StringBuilder();
+            }
             @Override
             public Buffer clone() throws CloneNotSupportedException {
                 Buffer other = (Buffer) super.clone();
                 other.builder = new StringBuilder(builder);
                 return other;
+            }
             public void clear() {
                 builder.delete(0, builder.length());
+            }
-...
         protected static final char EOF = 0;
         private final NumberFormat nf;
         private final ParsePosition nfPos;
         private final Stack<Integer> states;
         private NumberFormat nf;
         private ParsePosition nfPos;
         private Stack<Integer> states;
         private String source;
         private int position;
         protected final Buffer buffer;
         protected final DefaultToken token;
         protected final Map<String, Integer> tokens;
         protected Buffer buffer;
         protected DefaultToken token;
         protected Map<String, Integer> tokens;
         public AbstractLexicalAnalyzer(String source) {
             this.position = 0;
-...
+        }
         @Override
         public LexicalAnalyzer clone() throws CloneNotSupportedException {
             AbstractLexicalAnalyzer other = (AbstractLexicalAnalyzer) super.clone();
             other.nf = NumberFormat.getInstance(Locale.UK);
             other.nfPos = new ParsePosition(0);
             other.buffer = buffer.clone();
             other.token = (DefaultToken) token.clone();
             other.states = new Stack<>();
             other.states.addAll(states);
             other.tokens = new HashMap<>(tokens);
             return other;
+        }
         @Override
         public void setSource(String source) {
             this.source = source;
             this.position = 0;

             addFunction(new STYFunction());
             addFunction(new STZFunction());
+        }
         @Override
         @SuppressWarnings("CloneDoesntCallSuperClone")
         public SymbolTable clone() throws CloneNotSupportedException {
             // SQLSymbolTable is singleton and immutable, so we just return
             // the same instance.
             return this;
+        }
         private void addFunction(Function function) {
             this.functions.put(function.name().toLowerCase(), function);

+        }
         @Override
         public Compiler clone() throws CloneNotSupportedException {
             DefaultCompiler other = (DefaultCompiler) super.clone();
             other.lexer = lexer.clone();
             other.codeBuilder = codeBuilder.clone();
             return other;
+        }
         @Override
         public void setLexicalAnalyzer(LexicalAnalyzer lexer) {
             this.lexer = lexer;
+        }
-...
         public void setCodeBuilder(CodeBuilder codeBuilder) {
             this.codeBuilder = codeBuilder;
+        }
         @Override
         public CodeBuilder getCodeBuilder() {
             return this.codeBuilder;
+        }
         @Override
         public Code compileExpression(String expression) {
             this.lexer.setSource(expression);
             return parseExpression();
-...
                     if( args == null ) {
                         args = codeBuilder.args();
+                    }
                     args.add(arg);
                     ((DefaultCodeBuilder.BaseArguments)args).add(arg);
+                }
                 Token next = lexer.look();
                 switch( next.getType() ) {

     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;
     import org.gvsig.expressionevaluator.integration.DefaultEvaluatorFactory;
     import org.gvsig.expressionevaluator.integration.DefaultExpressionEvaluator;
     public class DefaultExpressionEvaluatorManager implements ExpressionEvaluatorManager {

     public class DefaultSymbolTable implements MutableSymbolTable {
         private SymbolTable symbolTable;
         private final Map<String,Object> vars;
         private final Map<String,Function> functions;
         private SymbolTable delegatedSymbolTable;
         private Map<String,Object> vars;
         private Map<String,Function> functions;
         public DefaultSymbolTable(SymbolTable symbolTable) {
             this.symbolTable = symbolTable;
         public DefaultSymbolTable(SymbolTable delegatedSymbolTable) {
             this.delegatedSymbolTable = delegatedSymbolTable;
             this.vars = new HashMap<>();
             this.functions = new HashMap<>();
+        }
-...
         public DefaultSymbolTable() {
             this(null);
+        }
         @Override
         public MutableSymbolTable clone() throws CloneNotSupportedException {
             DefaultSymbolTable other = (DefaultSymbolTable) super.clone();
             if( this.delegatedSymbolTable!=null ) {
                 other.delegatedSymbolTable = this.delegatedSymbolTable.clone();
+            }
             other.vars = new HashMap<>(vars);
             other.functions = new HashMap<>(functions);
             return other;
+        }
         @Override
         public void addVar(String name, Object value) {
-...
         @Override
         public Function function(String name) {
             Function fn = this.functions.get(name);
             if( fn == null && this.symbolTable != null ) {
                 fn = this.symbolTable.function(name);
             if( fn == null && this.delegatedSymbolTable != null ) {
                 fn = this.delegatedSymbolTable.function(name);
+            }
             return fn;
+        }
-...
         public boolean exists(String name) {
             boolean e = this.vars.containsKey(name);
             if( !e ) {
                 e = this.symbolTable.exists(name);
                 e = this.delegatedSymbolTable.exists(name);
+            }
             return e;
+        }
-...
             if( this.vars.containsKey(name) ) {
                 return this.vars.get(name);
+            }
             return this.symbolTable.value(name);
             return this.delegatedSymbolTable.value(name);
+        }
         @Override
         public void setSymbolTable(SymbolTable symbolTable) {
             this.symbolTable = symbolTable;
             this.delegatedSymbolTable = symbolTable;
+        }
         @Override
         public SymbolTable getSymbolTable() {
             return this.symbolTable;
             return this.delegatedSymbolTable;
+        }
         @Override

     import org.gvsig.expressionevaluator.LexicalAnalyzer.Token;
     public class DefaultToken implements Token {
         private int type;
         String literal;
         private String literal;
         private Object value;
         public DefaultToken() {
+        }
         @Override
         public Token clone() throws CloneNotSupportedException {
             // We will assume that the properties of the class are immutable, so
             // it would suffice to call the super class.
             DefaultToken other = (DefaultToken) super.clone();
             return other;
+        }
         @Override
         public void set(int type, String literal) {
             this.set(type, literal, literal);
+        }
         @Override
         public void set(int type, String literal, Object value) {
             this.literal = literal;
             this.type = type;
             this.value = value;
+        }
         @Override
         public int getType() {
             return type;
+        }
         @Override
         public Object getValue() {
             return value;
+        }
         @Override
         public String getLiteral() {
             return literal;
+        }
         public void setLiteral(String literal) {
             this.literal = literal;
+        }
+    }

                 return this.args.size();
+            }
             @Override
             public void add(Code arg) {
                 this.args.add(arg);
+            }
-...
+        }
         @Override
         public CodeBuilder clone() throws CloneNotSupportedException {
             // This implementation of CodeBuilder does not maintain state, so
             // we only call the super class.
             DefaultCodeBuilder other = (DefaultCodeBuilder) super.clone();
             return other;
+        }
         @Override
         public Constant constant(Object value) {
             return new BaseConstant(value);
+        }
-...
         @Override
         public Caller operator(String name, Code arg1) {
             Arguments args = args();
             args.add(arg1);
             ((BaseArguments)args).add(arg1);
             return function(name, Caller.UNARY_OPERATOR, args);
+        }
         @Override
         public Caller operator(String name, Code arg1, Code arg2) {
             Arguments args = args();
             args.add(arg1);
             args.add(arg2);
             ((BaseArguments)args).add(arg1);
             ((BaseArguments)args).add(arg2);
             return function(name, Caller.BINARY_OPERATOR, args);
+        }

     package org.gvsig.expressionevaluator.integration;
     import java.util.ArrayList;
     import java.util.HashSet;
     import java.util.List;
     import java.util.Set;
     import org.gvsig.expressionevaluator.Code;
     import org.gvsig.expressionevaluator.Interpreter;
     import org.gvsig.expressionevaluator.LexicalAnalyzer;
     import org.gvsig.expressionevaluator.SymbolTable;
     import org.gvsig.expressionevaluator.Compiler;
     import org.gvsig.expressionevaluator.ExpressionEvaluator;
     import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;
     import org.gvsig.expressionevaluator.Function;
     import org.gvsig.expressionevaluator.impl.DefaultCompiler;
     import org.gvsig.expressionevaluator.impl.DefaultInterpreter;
     import org.gvsig.expressionevaluator.impl.SQLLexicalAnalyzer;
     import org.gvsig.expressionevaluator.impl.SQLSymbolTable;
     import org.gvsig.tools.evaluator.AbstractEvaluator;
     import org.gvsig.tools.evaluator.EvaluatorData;
     import org.gvsig.tools.evaluator.EvaluatorException;
     import org.gvsig.tools.evaluator.EvaluatorFieldsInfo;
     import org.gvsig.tools.exception.BaseException;
     import org.gvsig.tools.visitor.VisitCanceledException;
     import org.gvsig.tools.visitor.Visitor;
     import org.gvsig.tools.lang.Cloneable;
     public class DefaultExpressionEvaluator extends AbstractEvaluator implements ExpressionEvaluator, Cloneable {
         private static class DescriptionAdapter implements Description {
             Function function;
             public DescriptionAdapter(Function function) {
                 this.function = function;
+            }
             @Override
             public String getName() {
                 return this.function.name();
+            }
             @Override
             public String getDescription() {
                 return this.function.description();
+            }
             @Override
             public String getTemplate() {
                 return this.function.template();
+            }
             @Override
             public int getDataTypeCategories() {
                 switch(this.function.group()) {
                 case Function.GROUP_STRING:
                     return Description.DATATYPE_CATEGORY_STRING;
                 case Function.GROUP_BOOLEAN:
                     return Description.DATATYPE_CATEGORY_BOOLEAN;
                 case Function.GROUP_DATETIME:
                     return Description.DATATYPE_CATEGORY_DATETIME;
                 case Function.GROUP_NUMERIC:
                     return Description.DATATYPE_CATEGORY_NUMBER;
                 case Function.GROUP_OGC:
                     return Description.DATATYPE_CATEGORY_ALL;
                 default:
                     return Description.DATATYPE_CATEGORY_ALL;
+                }
+            }
+        }
         private EvaluatorDataAdapter evaluatorData;
         private SymbolTable symbolTable;
         private LexicalAnalyzer lexer;
         private Compiler compiler;
         private Interpreter interpreter;
         private Code code;
         private String source;
         private Description[] availableOperators;
         private Description[] availableFunctions;
         private Double accuracy;
         public DefaultExpressionEvaluator() {
             super();
             this.accuracy = ExpressionEvaluatorLocator.getManager().getAccuracy();
+        }
         @Override
         public Code getCode() {
             return this.code;
+        }
         @Override
         public void compile() {
             if( this.symbolTable == null ) {
                 this.symbolTable = SQLSymbolTable.getInstance();
+            }
             if( this.lexer == null ) {
                 this.lexer = new SQLLexicalAnalyzer();
+            }
             if( this.compiler == null ) {
                 this.compiler = new DefaultCompiler();
                 this.compiler.setLexicalAnalyzer(lexer);
+            }
             if( this.interpreter == null ) {
                 this.interpreter = new DefaultInterpreter();
+            }
             this.evaluatorData = new EvaluatorDataAdapter(symbolTable);
             this.interpreter.setAccuracy(this.accuracy);
             this.interpreter.setSymbolTable(this.evaluatorData);
             this.code = this.compiler.compileExpression(source);
+        }
         @Override
         public Object evaluate(EvaluatorData data) throws EvaluatorException {
             if( this.code == null ) {
                 this.compile();
+            }
             this.evaluatorData.setData(data);
             Object v = this.interpreter.run(code);
             return v;
+        }
         @Override
         public String getName() {
             return "Genereric expression";
+        }
         @Override
         public EvaluatorFieldsInfo getFieldsInfo() {
             final Set<String> names = new HashSet<>();
             try {
                 this.code.accept(new Visitor() {
                     @Override
                     public void visit(Object code) throws VisitCanceledException, BaseException {
                         if( code instanceof Code.Identifier ) {
                             Code.Identifier identifier = (Code.Identifier) code;
                             names.add(identifier.name());
+                        }
+                    }
                 });
                 EvaluatorFieldsInfo info = new EvaluatorFieldsInfo();
                 for (String name : names) {
                     info.addFieldValue(name);
+                }
                 return info;
             } catch (BaseException ex) {
                 throw new RuntimeException("Can't calculate fields information.", ex);
+            }
+        }
         @Override
         public Description[] getAvailableOperators() {
             if( availableOperators==null ) {
                 List<Description> l = new ArrayList<>();
                 for( Function function : symbolTable) {
                     if( function.isOperator() ) {
                         l.add(new DescriptionAdapter(function));
+                    }
+                }
                 this.availableOperators = l.toArray(new Description[l.size()]);
+            }
             return availableOperators;
+        }
         @Override
         public Description[] getAvailableFunctions() {
             if( availableFunctions==null ) {
                 List<Description> l = new ArrayList<>();
                 for( Function function : symbolTable) {
                     if( !function.isOperator() ) {
                         l.add(new DescriptionAdapter(function));
+                    }
+                }
                 this.availableFunctions = l.toArray(new Description[l.size()]);
+            }
             return availableFunctions;
+        }
         @Override
         public SymbolTable getSymbolTable() {
             return symbolTable;
+        }
         @Override
         public void setSymbolTable(SymbolTable symbolTable) {
             this.symbolTable = symbolTable;
+        }
         @Override
         public LexicalAnalyzer getLexer() {
             return lexer;
+        }
         @Override
         public void setLexer(LexicalAnalyzer lexer) {
             this.lexer = lexer;
+        }
         @Override
         public Compiler getCompiler() {
             return compiler;
+        }
         @Override
         public void setCompiler(Compiler compiler) {
             this.compiler = compiler;
+        }
         @Override
         public Interpreter getInterpreter() {
             return interpreter;
+        }
         @Override
         public void setInterpreter(Interpreter interpreter) {
             this.interpreter = interpreter;
+        }
         @Override
         public String getSource() {
             return source;
+        }
         @Override
         public void setSource(String source) {
             this.source = source;
             this.code = null;
+        }
         @Override
         public Double getAccuracy() {
             return this.accuracy;
+        }
         @Override
         public void setAccuracy(Double accuracy) {
             this.accuracy = accuracy;
+        }
         @Override
         public ExpressionEvaluator clone() throws CloneNotSupportedException {
             DefaultExpressionEvaluator other = (DefaultExpressionEvaluator) super.clone();
             other.code = this.code;
             other.source = this.source;
             other.accuracy = this.accuracy;
             other.availableFunctions = null;
             other.availableOperators = null;
             if( this.symbolTable!=null ) {
                 other.symbolTable = this.symbolTable.clone();
+            }
             if( this.lexer!=null ) {
                 other.lexer = this.lexer.clone();
+            }
             if( this.evaluatorData!=null ) {
                 // evaluatorData don't support clone.
                 other.evaluatorData = new EvaluatorDataAdapter(other.symbolTable);
+            }
             if( this.compiler!=null ) {
                 other.compiler = this.compiler.clone();
                 other.compiler.setLexicalAnalyzer(other.lexer);
+            }
             if( this.interpreter!=null ) {
                 other.interpreter = this.interpreter.clone();
                 other.interpreter.setAccuracy(this.accuracy);
                 other.interpreter.setSymbolTable(other.symbolTable);
+            }
             return other;
+        }
+    }

     package org.gvsig.expressionevaluator.integration;
     import java.util.Iterator;
     import org.gvsig.expressionevaluator.Function;
     import org.gvsig.expressionevaluator.SymbolTable;
     import org.gvsig.tools.evaluator.EvaluatorData;
     public class EvaluatorDataAdapter implements SymbolTable {
         private EvaluatorData data;
         private final SymbolTable symbolTable;
         EvaluatorDataAdapter(SymbolTable symbolTable) {
             this.symbolTable = symbolTable;
+        }
         public void setData(EvaluatorData data) {
             this.data = data;
+        }
         @Override
         public Function function(String name) {
             return symbolTable.function(name);
+        }
         @Override
         @SuppressWarnings("CloneDoesntCallSuperClone")
         public SymbolTable clone() throws CloneNotSupportedException {
             throw new CloneNotSupportedException("This class can't be cloned.");
+        }
         @Override
         public boolean exists(String name) {
             if( data.hasDataValue(name) ) {
                 return true;
+            }
             if( data.hasContextValue(name) ) {
                 return true;
+            }
             return symbolTable.exists(name);
+        }
         @Override
         public Object value(String name) {
             if( data.hasDataValue(name) ) {
                 return data.getDataValue(name);
+            }
             if( data.hasContextValue(name) ) {
                 return data.getContextValue(name);
+            }
             return symbolTable.value(name);
+        }
         @Override
         public Iterator<String> itervars() {
             return null;
+        }
         @Override
         public Iterator<Function> iterfuncs() {
             return symbolTable.iterfuncs();
+        }
         @Override
         public Iterator<Function> iterator() {
             return symbolTable.iterfuncs();
+        }
+    }

     package org.gvsig.expressionevaluator.integration;
     import org.gvsig.expressionevaluator.ExpressionEvaluator;
     import org.gvsig.fmap.dal.EvaluatorFactory;
     import org.gvsig.tools.evaluator.Evaluator;
     public class DefaultEvaluatorFactory implements EvaluatorFactory {
         @Override
         public Evaluator createEvaluator(String expression) {
             ExpressionEvaluator evaluator = new DefaultExpressionEvaluator();
             evaluator.setSource(expression);
             return evaluator;
+        }
         @Override
         public String getName() {
             return "SQL expression evaluator";
+        }
+    }

     import java.util.Iterator;
     public interface SymbolTable extends Iterable<Function>{
     import org.gvsig.tools.lang.Cloneable;
     public interface SymbolTable extends Iterable<Function>, Cloneable {
         public Function function(String name);
         public boolean exists(String name);
-...
         public Iterator<String> itervars();
         public Iterator<Function> iterfuncs();
         @Override
         public SymbolTable clone() throws CloneNotSupportedException;
+    }

     import org.gvsig.expressionevaluator.Code.Constant;
     import org.gvsig.expressionevaluator.Code.Identifier;
     public interface CodeBuilder {
     import org.gvsig.tools.lang.Cloneable;
     public interface CodeBuilder extends Cloneable {
         @Override
         public CodeBuilder clone() throws CloneNotSupportedException;
         Constant constant(Object value);
         Identifier identifier(String name);

     package org.gvsig.expressionevaluator;
     import org.gvsig.tools.evaluator.EvaluatorWithDescriptions;
     import org.gvsig.tools.lang.Cloneable;
     public interface ExpressionEvaluator extends EvaluatorWithDescriptions {
     public interface ExpressionEvaluator extends EvaluatorWithDescriptions, Cloneable  {
         public void compile();
-...
         public Double getAccuracy();
         public void setAccuracy(Double accuracy);
         @Override
         public ExpressionEvaluator clone() throws CloneNotSupportedException;
+    }

     package org.gvsig.expressionevaluator;
     public interface Interpreter {
     import org.gvsig.tools.lang.Cloneable;
     public interface Interpreter extends Cloneable {
         public interface Cache {
             public Object get(Object context, Object key);
-...
         public Code getCurrentCode();
         public Cache getCache();
         @Override
         public Interpreter clone() throws CloneNotSupportedException;
+    }

     package org.gvsig.expressionevaluator;
     public interface LexicalAnalyzer {
         public interface Token {
     import org.gvsig.tools.lang.Cloneable;
     public interface LexicalAnalyzer extends Cloneable {
         public interface Token extends Cloneable {
             public static final int EOF = -1;
             public static final int IDENTIFIER = 0;
             public static final int STRING_LITERAL = 1;
-...
             public static final int PARENTHESIS_CLOSE = 31;
             public static final int COMA = 32;
             @Override
             public Token clone() throws CloneNotSupportedException;
             public void set(int type, String literal);
             public void set(int type, String literal, Object value);
-...
         public Token next();
         @Override
         public LexicalAnalyzer clone() throws CloneNotSupportedException;
+    }

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/MutableSymbolTable.java
14	14	public void removeVar(String name);
15	15
16	16	public void removeFunction(String name);
	17
	18	@Override
	19	public MutableSymbolTable clone() throws CloneNotSupportedException;
17	20	}

             public interface Arguments extends Iterable<Code>, Visitable {
                 public void add(Code arg);
                 public int count();
                 @Override

     package org.gvsig.expressionevaluator;
     import org.gvsig.tools.lang.Cloneable;
     public interface Compiler {
     public interface Compiler extends Cloneable {
         public void setLexicalAnalyzer(LexicalAnalyzer lex);
         public void setCodeBuilder(CodeBuilder codeBuilder);
         public CodeBuilder getCodeBuilder();
         public Code compileExpression(String expression);
         @Override
         public Compiler clone() throws CloneNotSupportedException;
+    }

Application: gvSIG desktop

Revision 43809