/ - Diff - Application: gvSIG desktop - gvSIG

     import org.gvsig.fmap.dal.SQLBuilder;
     import static org.gvsig.fmap.dal.store.jdbc2.spi.JDBCSQLBuilderBase.PROP_SYMBOLTABLE;
     import static org.gvsig.expressionevaluator.ExpressionBuilder.FUNCTION_$CONSTANT;
     import org.gvsig.expressionevaluator.GeometryExpressionBuilder;
     import org.gvsig.fmap.geom.Geometry;
     /**
+     *
-...
         @Override
         public String format(Value value) {
             return resolve(this.sqlbuilder.expression(), this.formatter, value);
             return resolve(this.sqlbuilder, this.formatter, value);
+        }
         public static boolean isConstant(Value value) {
-...
                    StringUtils.equalsIgnoreCase(((ExpressionBuilder.Function)value).name(),FUNCTION_$CONSTANT);
+        }
         public static String resolve(Value value) {
             ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();
             return resolve(builder, null, value);
+        }
         public static String resolve(ExpressionBuilder builder, Formatter<Value> formatter, Value value) {
         public static String resolve(SQLBuilder sqlbuilder, Formatter<Value> formatter, Value value) {
     		GeometryExpressionBuilder builder = sqlbuilder.expression();
             if( value instanceof ExpressionBuilder.Constant) {
                 Object x = ((ExpressionBuilder.Constant)value).value();
                 return builder.constant(x).toString(formatter);
-...
                     StringUtils.equalsIgnoreCase(((ExpressionBuilder.Function)value).name(),FUNCTION_$CONSTANT) ) {
                 SymbolTable symbolTable = (SymbolTable) value.getProperty(PROP_SYMBOLTABLE);
                 Object x = ExpressionUtils.evaluate(symbolTable, value.toString());
     			if( x instanceof Geometry && builder instanceof GeometryExpressionBuilder) {
     				GeometryExpressionBuilder gbuilder = (GeometryExpressionBuilder) builder;
     				Geometry geom = (Geometry) x;
     				String hexwkb = geom.convertToHexWKBQuietly();
     				Function v = gbuilder.ST_GeomFromWKB(
     					gbuilder.decode(
     						gbuilder.constant(hexwkb),
     						gbuilder.constant("hex")
     					),
     					gbuilder.constant(
     						sqlbuilder.srs_id(geom.getProjection())
+    					)
     				);
     				return v.toString(formatter);
+    			}
                 return builder.constant(x).toString(formatter);
+            }
             throw new RuntimeException("Expected constant value or $$CONSTANT function ("+Objects.toString(value)+").");

     import java.io.FileInputStream;
     import java.util.HashMap;
     import java.util.Iterator;
     import java.util.List;
     import java.util.Map;
     import java.util.Properties;
     import org.apache.commons.io.IOUtils;
-...
     import org.gvsig.fmap.dal.HasDataStore;
     import org.gvsig.fmap.dal.expressionevaluator.FeatureSymbolTable;
     import org.gvsig.fmap.dal.feature.Feature;
     import org.gvsig.fmap.dal.feature.FeatureQuery;
     import org.gvsig.fmap.dal.feature.FeatureSet;
     import org.gvsig.fmap.dal.feature.FeatureStore;
     import org.gvsig.fmap.geom.Geometry;
-...
     import org.gvsig.temporarystorage.TemporaryStorageGroup;
     import org.gvsig.temporarystorage.TemporaryStorageLocator;
     import org.gvsig.temporarystorage.TemporaryStorageManager;
     import org.gvsig.tools.util.UnmodifiableBasicList;
     /**
+     *
-...
                 Geometry value = (Geometry) storage.get(getStr(args, 0));
                 return value;
+            }
+    		}
+        }
         private  class AreaFunction extends AbstractGeometryFunction {
             public AreaFunction() {

+            }
             token.set(Token.STRING_LITERAL, buffer.toString());
+        }
     //    protected void parseStringBlock() {
     //        buffer.clear();
     //        char ch = getch();
     //        while (true) {
     //            if (ch == EOF) {
     //                throw new ExpressionSyntaxException(I18N.End_of_string_was_expected_and_end_of_source_was_found(), this);
     //            }
     //            if (ch == '$') {
     //                ch = getch();
     //                if (ch == EOF) {
     //                    break;
     //                }
     //                if (ch != '$') {
     //                    ungetch();
     //                    break;
     //                }
     //            }
     //            buffer.add(ch);
     //            ch = getch();
     //        }
     //        token.set(Token.STRING_LITERAL, buffer.toString());
     //    }
         protected void parseDMSNumber() {
             int d;
             int m;

             public static final int ASSIGNMENT = 38;
             public static final int ARGUMENT_ASSIGNMENT = 39;
             public static final int COLON = 40;
             public static final int BEGIN_$CONSTANT = 41;
             public static final int END_$CONSTANT = 42;
             @Override
             public Token clone() throws CloneNotSupportedException;

                 token.set(Token.OP_DIV, "/");
                 return token;
             case '%':
     			ch = getch();
                 switch( ch ) {
                 case EOF:
                     throw new ExpressionSyntaxException(I18N.unexpected_end_of_source(), this);
                 case '>':
                     token.set(Token.END_$CONSTANT, "%>");
                     return token;
+                }
                 ungetch();
                 token.set(Token.OP_MOD, "%");
                 return token;
             case '=':
-...
                 case '=':
                     token.set(Token.OP_LE, "<=");
                     return token;
                 case '%':
                     token.set(Token.BEGIN_$CONSTANT, "<%");
                     return token;
+                }
                 ungetch();
                 token.set(Token.OP_LT, "<");
-...
             case '\'':
                 parseString();
                 return token;
             case '@':
                 ungetch();
                 parseDMSNumber();
                 return token;
     //
     //        case '$':
     //            ch = getch();
     //            switch( ch ) {
     //            case EOF:
     //                throw new ExpressionSyntaxException(I18N.unexpected_end_of_source(), this);
     //            case '$':
     //                parseStringBlock();
     //                return token;
     //            }
     //            ungetch();
     //            ungetch();
     //            break;
+            }
             if( Character.isDigit(ch) ) {
                 ungetch();
                 parseNumber();
                 return token;
+            }
+            }
             if( Character.isAlphabetic(ch) || ch =='$' ) {
                 buffer.clear();
                 while( Character.isLetterOrDigit(ch) || ch =='$' || ch == '_' ) {

                 theGrammar.addStatement(this.createTimeStatement(theGrammar));
                 theGrammar.addStatement(this.createTimestampStatement(theGrammar));
                 theGrammar.addStatement(this.createWhileStatement(theGrammar));
                 theGrammar.addStatement(this.create$ConstantStatement(theGrammar));
                 this.grammar = theGrammar;
+            }
-...
             stmt.builder(new BeginStatementBuilder("VALUES", "EXCEPT"));
             return stmt;
+        }
         private Statement create$ConstantStatement(Grammar theGrammar) {
             Statement stmt;
             stmt = theGrammar.createStatement("$Constant");
             stmt.addRule(stmt.require_any_token("<%"));
             stmt.addRule(stmt.require_any_token("="));
             stmt.addRule(stmt.require_expression().capture_as("VALUE"));
             stmt.addRule(stmt.require_any_token("%>"));
     		stmt.code(
     				  ExpressionBuilder.FUNCTION_$CONSTANT,
     				  stmt.args_names("VALUE")
     			  );
             return stmt;
+        }
         private Statement createIfStatement(Grammar theGrammar) {
             Statement stmt;

             link(code);
             assertEquals("PASS()", code.toString());
+        }
         public void test$Constant1() {
             String source = "set x = <%='hola'%>";
             Compiler compiler = createCompiler();
             Code code = compiler.compileExpression(source);
             link(code);
             assertEquals("LET('x', $CONSTANT('hola'))", code.toString());
+        }
+    }

Application: gvSIG desktop

Revision 46091