/ - Diff - Application: gvSIG desktop - gvSIG

         public TimestampFunction() {
             super("Date", FUNCTION_TIMESTAMP,Range.is(1),
                 "Returns a time stamp from the arguments",
                 FUNCTION_TIMESTAMP+"({{timestamp}})",
                 FUNCTION_TIMESTAMP+" {{timestamp}} ",
                 new String[]{
                     "timestamp - a string with a date/time"
                 },

                 + "    EXTRACT(YEAR FROM TIMESTAMP '2001-02-16 20:38:40');\n"
                 + "    Result: 2001\n"
                 + "",
                 FUNCTION_EXTRACT + "({{field}}, date)",
                 "EXTRACT( {{time_field}} FROM time_expression)",
                 new String[]{
                   "field - ",
                   "date - a string with a date"

         public DateFunction() {
             super("Date", FUNCTION_DATE,Range.is(1),
                 "Returns a date from the arguments",
                 FUNCTION_DATE+"({{date}})",
                 FUNCTION_DATE+" {{date}} ",
                 new String[]{
                     "date - a string with a date"
                 },

                         "image",
                         "angle"
                     },
                     "Image",
                     "SimpleImage",
                     false
             );
+        }
-...
+            }
             int angle = this.getInt(args, 1);
             image = image.rotate(angle);
             return image.getBufferedImage();
             return image;
+        }

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/function/image/ImageResizeFunction.java
18	18	"width",
19	19	"height"
20	20	},
21		"Image",
	21	"SimpleImage",
22	22	false
23	23	);
24	24	}
...	...
52	52	"The IMAGERESIZE function has 2 arguments, the image and a scale factor, or 3, the image, width and height"
53	53	);
54	54	}
55		return image.getBufferedImage();
	55	return image;
56	56	}
57	57
58	58	}

     import java.io.ByteArrayInputStream;
     import java.io.File;
     import java.io.IOException;
     import java.io.OutputStream;
     import java.net.URL;
     import java.util.logging.Level;
     import java.util.logging.Logger;
     import javax.imageio.ImageIO;
     import org.apache.commons.codec.DecoderException;
     import org.apache.commons.codec.binary.Base64;
-...
             return theImage;
+        }
         public void save(File output, String formatName) throws IOException {
             ImageIO.write(this.getBufferedImage(), formatName, output);
+        }
         public void save(OutputStream output, String formatName) throws IOException {
             ImageIO.write(this.getBufferedImage(), formatName, output);
+        }
         public int getWidth() {
             return this.image.getWidth();
+        }

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/function/image/ImageHorizontalflipFunction.java
14	14	new String[]{
15	15	"image"
16	16	},
17		"Image",
	17	"SimpleImage",
18	18	false
19	19	);
20	20	}
...	...
32	32	return null;
33	33	}
34	34	image = image.horizontalflip();
35		return image.getBufferedImage();
	35	return image;
36	36	}
37	37
38	38	}

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/function/image/ImageVerticalflipFunction.java
14	14	new String[]{
15	15	"image"
16	16	},
17		"Image",
	17	"SimpleImage",
18	18	false
19	19	);
20	20	}
...	...
32	32	return null;
33	33	}
34	34	image = image.verticalflip();
35		return image.getBufferedImage();
	35	return image;
36	36	}
37	37
38	38	}

     package org.gvsig.expressionevaluator.impl.function.image;
     import java.io.File;
     import java.io.IOException;
     import java.io.OutputStream;
     import java.util.Objects;
     import java.util.logging.Level;
     import java.util.logging.Logger;
     import org.apache.commons.lang3.Range;
     import org.gvsig.expressionevaluator.ExpressionRuntimeException;
     import org.gvsig.expressionevaluator.Interpreter;
     import org.gvsig.expressionevaluator.impl.function.programming.FileFunction;
     import org.gvsig.expressionevaluator.spi.AbstractFunction;
     public class ImageWriteFunction extends AbstractFunction {
         public ImageWriteFunction() {
             super(
                     "Image", "IMAGEWRITE", Range.is(2),
                     "Read an image from a data source and return it as a 'Java BufferedImage' object.",
                     "IMAGEWRITE({{simpleimage}}, target, format)",
                     new String[]{
                         "Image to write",
                         "Value to save the image in",
                         "Format name, PNG, JPEG,...",
                     },
                     "SimpleImage",
                     false
             );
+        }
         @Override
         public boolean allowConstantFolding() {
             return true;
+        }
         @Override
         public Object call(Interpreter interpreter, Object[] args) {
             String formatName = this.getStr(args, 2);
             Object arg0 = this.getObject(args, 0);
             SimpleImage image = ImageReadFunction.createSimpleImage(arg0);
             Object target = this.getObject(args, 1);
             try {
                 if( target instanceof OutputStream ) {
                     image.save((OutputStream) target, formatName);
                 } else {
                   File f = FileFunction.toFile(target);
                   image.save(f, formatName);
+                }
             } catch (IOException ex) {
               throw new ExpressionRuntimeException("Can't write image to '"+Objects.toString(target)+" as format '"+formatName+".", ex);
+            }
             return image;
+        }
+    }

     package org.gvsig.expressionevaluator.impl.function.image;
     import java.awt.Graphics2D;
     import java.awt.Image;
     import java.awt.RenderingHints;
     import java.awt.geom.AffineTransform;
     import java.awt.image.BufferedImage;
     import java.io.ByteArrayInputStream;
     import java.io.File;
     import java.io.IOException;
     import java.net.URL;
     import javax.imageio.ImageIO;
     import org.apache.commons.codec.DecoderException;
     import org.apache.commons.codec.binary.Base64;
     import org.apache.commons.codec.binary.Hex;
     import org.apache.commons.lang3.Range;
     import org.gvsig.expressionevaluator.Interpreter;
     import org.gvsig.expressionevaluator.spi.AbstractFunction;
-...
         public ImageReadFunction() {
             super(
                     "Image", "IMAGEREAD", Range.is(1),
                     "Read an image from a data source and return it as a 'Java BufferedImage' object.\n"
                     "Read an image from a data source and return it as a SimpleImage object.\n"
                     + "The data source of the image can be:\n<ul>"
                     + "<li>A byte array</li>"
                     + "<li>A URL</li>"
-...
                     new String[]{
                         "Value from which to load the image"
                     },
                     "BufferedImage",
                     "SimpleImage",
                     false
             );
+        }
-...
             if( image.isEmpty() ) {
                 return null;
+            }
             return image.getBufferedImage();
             return image;
+        }
         public static SimpleImage createSimpleImage(Object source) {
             if( source instanceof SimpleImage ) {
               return (SimpleImage) source;
+            }
             SimpleImage image = new SimpleImage(source);
             return image;
+        }

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/function/image/ImageTransformFunction.java
19	19	"width - Optional.",
20	20	"height - Optional."
21	21	},
22		"Image",
	22	"SimpleImage",
23	23	false
24	24	);
25	25	}
...	...
53	53	"The IMAGETRANSFORM function has 2 arguments, image and transform, or 4 arguments, image, transform, width and height."
54	54	);
55	55	}
56		return image.getBufferedImage();
	56	return image;
57	57	}
58	58
59	59	}

                     FUNCTION_TUPLE,
                     Range.between(0, Integer.MAX_VALUE),
                     null,
                     "ARRAY[ {{value1}}, value2, ...]",
                     null,
                     null,
                     "TUPLE",
                     true
             );

                     NAME,
                     Range.between(0, Integer.MAX_VALUE),
                     null,
                     "PRINT({{value1}}, ...)",
                     null,
                     null,
                     "Object",
                     false
             );

                 NAME,
                 Range.is(2),
                 null,
                 "GEIITEM({{object}}, index_or_key)",
                 null,
                 null,
                 "Object",
                 false
             );

                 NAME,
                 Range.is(1),
                 null,
                 NAME+"({{expression}})",
                 null,
                 null,
                 "Object",
                 false
             );

     package org.gvsig.expressionevaluator.impl.function.programming;
     import java.util.ArrayList;
     import java.util.Arrays;
     import java.util.List;
     import org.apache.commons.lang3.Range;
     import org.gvsig.expressionevaluator.Function;
     import org.gvsig.expressionevaluator.Interpreter;
     import org.gvsig.expressionevaluator.spi.AbstractFunction;
     public class PassFunction extends AbstractFunction {
         public PassFunction() {
             super(Function.GROUP_PROGRAMMING,
                     "PASS",
                     Range.between(0, Integer.MAX_VALUE),
                     "Do nothing",
                     "PASS",
                     null,
                     "NULL",
                     false
             );
+        }
         @Override
         public boolean allowConstantFolding() {
             return false;
+        }
         @Override
         public Object call(Interpreter interpreter, Object[] args) throws Exception {
             return null;
+        }
+    }

                     NAME,
                     Range.between(2,3),
                     "The IFF() function tests a specified numeric expression and returns one of two values, based on whether the expression tested was true or false.",
                     NAME+"( {{condition}}, true, false )",
                     "IF {{condition}} THEN\n  PASS\nELSE\n  PASS;\nEND IF\n",
                     null,
                     "Object",
                     true

                     NAME,
                     Range.is(3),
                     "The foreach() function evaluate body for every element of the iterable.",
                     NAME+"( varname, iterable, body )",
                     "FOR n IN {{expression}}\n  BEGIN\n  PASS;\nEND FOR\n",
                     null,
                     "Object",
                     false

                     NAME,
                     Range.is(2),
                     "The while() function evaluate expression while the condition is true.",
                     NAME+"( condition, expression )",
                     "WHILE {{condition}} BEGIN\n  PASS;\nEND WHILE\n",
                     null,
                     "Object",
                     false

                     FUNCTION_GETATTR,
                     Range.is(2),
                     null,
                     "GETATTR({{object}}, attribute_name_as_string)",
                     null,
                     null,
                     null,
                     true
             );
+        }

                     NAME,
                     Range.between(2, Integer.MAX_VALUE),
                     "",
                     "CASE\n  WHEN {{condition}} THEN PASS\n  ELSE PASS\nEND CASE\n",
                     null,
                     null,
                     "Object",
                     false
             );

                     FUNCTION_MAP,
                     Range.between(0, Integer.MAX_VALUE),
                     null,
                     "MAP( {{identifier1}} = value1, {{identifier2}} = value2, ...)",
                     null,
                     null,
                     "MAP",
                     false
             );

                 NAME,
                 Range.is(1),
                 null,
                 "LEN({{expression}})",
                 null,
                 null,
                 "Object",
                 false
             );

                     NAME,
                     Range.between(0, Integer.MAX_VALUE),
                     null,
                     "RETURN {{value}};",
                     null,
                     null,
                     "Object",
                     false
             );

     import java.io.File;
     import java.net.URI;
     import java.net.URL;
     import org.apache.commons.lang3.Range;
     import org.gvsig.expressionevaluator.ExpressionRuntimeException;
     import org.gvsig.expressionevaluator.Function;
-...
                 NAME,
                 Range.is(1),
                 null,
                 NAME+"({{expression}})",
                 null,
                 null,
                 "Object",
                 false
             );
-...
         @Override
         public Object call(Interpreter interpreter, Object[] args) throws Exception {
             Object value;
             Object obj = getObject(args, 0);
             File value = toFile(obj);
             return value;
+        }
         public static File toFile(Object obj) {
             if( obj == null ) {
                 return 0;
                 return null;
+            }
             if( obj instanceof File ) {
                 return obj;
                 return (File) obj;
             } else if( obj instanceof CharSequence ) {
                 value = new File(((CharSequence)obj).toString());
                 return new File(((CharSequence)obj).toString());
             } else if( obj instanceof URI ) {
                 value = new File(((URI)obj));
                 return new File(((URI)obj));
             } else if( obj instanceof URL ) {
                 return new File(((URL)obj).getPath());
             } else {
                 throw new ExpressionRuntimeException("The "+NAME+" function require a File or a String and a received a '"+obj.getClass().getSimpleName()+"'.");
+            }
             return value;
+        }
+    }

                 NAME,
                 Range.is(2),
                 "Assigns the value indicated in the second argument to the variable indicated in the first argument.",
                 NAME+"({{identifier_name}},value)",
                 "SET {{identifier}} = expression",
                 new String[]{
                     "identifier_name - Name of the variable",
                     "value - Value to assign to the variable"

                     NAME,
                     Range.between(1,Integer.MAX_VALUE),
                     "Evaluate each of the arguments sequentially.",
                     NAME+"( {{arguments...}} )",
                     "BEGIN\n  {{sentence}};\nEXCEPT\n  PASS\nEND\n",
                     null,
                     "Object",
                     false

                       "\n" +
                       "What defines a \"getCRS\" function that is implemented in the python module\n" +
                       "located in \"Users / crs\" with the name 'getCRS'.",
                     "CREATE FUNCTION {{name}}(param1, param2) AS\nBEGIN\n  PASS\nEND FUNCTION\n",
                     null,
                     null,
                     "Object",
                     false
             );

     public class CastFunction extends AbstractFunction {
         public CastFunction() {
             super(GROUP_CONVERSION, FUNCTION_CAST, Range.is(2));
             super(
                     GROUP_CONVERSION,
                     FUNCTION_CAST,
                     Range.is(2),
                     "",
                     "CAST( {{value}} AS type_identifier)"
             );
+        }
         @Override

                 theGrammar.addReservedWord("CASE");
                 theGrammar.addReservedWord("WHEN");
                 theGrammar.addReservedWord("FOR");
                 theGrammar.addReservedWord("FOREACH");
                 theGrammar.addReservedWord("CREATE");
                 theGrammar.addReservedWord("FUNCTION");
                 theGrammar.addReservedWord("PROCEDURE");
-...
                 theGrammar.addReservedWord("TO");
                 theGrammar.addReservedWord("FROM");
                 theGrammar.addReservedWord("$$"); // ???? Asi van las funciones
                 theGrammar.addReservedWord("PASS");
                 stmt = theGrammar.createStatement("BLOCK");
                 stmt.addRule(stmt.require_any_token("BEGIN"));
-...
     //            theGrammar.addStatement(stmt);
                 stmt = theGrammar.createStatement("FOREACH");
                 stmt.addRule(stmt.require_any_token("FOR"));
                 stmt.addRule(stmt.require_any_token("FOR","FOREACH"));
                 stmt.addRule(stmt.require_identifier().capture_as("VAR"));
                 stmt.addRule(stmt.require_any_token("IN"));
                 stmt.addRule(stmt.require_expression().capture_as("ITERABLE"));
-...
                 stmt.addRule(
                     stmt.repeat_until_any_tokens("END","ELSE")
                         .addRule(stmt.require_any_token("WHEN"))
                         .addRule(stmt.require_expressions(";").capture_as("CONDITION#"))
                         .addRule(stmt.require_expression().capture_as("CONDITION#"))
                         .addRule(stmt.require_any_token("THEN",":"))
                         .addRule(stmt.require_expressions(";").capture_as("ONTRUE#"))
                 );
-...
                 this.grammar = theGrammar;
                 stmt = theGrammar.createStatement("PASS");
                 stmt.addRule(stmt.require_any_token("PASS"));
                 stmt.addRule(stmt.optional_any_token("(")
                     .addRuleOnTrue(stmt.require_expressions(",").capture_as("ARGS#"))
                     .addRuleOnTrue(stmt.require_any_token(")"))
                 );
                 stmt.code(
                         "PASS",
                         stmt.args_names("ARGS#")
                 );
                 theGrammar.addStatement(stmt);
+            }
             return grammar;

     import org.gvsig.expressionevaluator.impl.function.programming.LetFunction;
     import org.gvsig.expressionevaluator.impl.function.programming.ListFunction;
     import org.gvsig.expressionevaluator.impl.function.programming.MapFunction;
     import org.gvsig.expressionevaluator.impl.function.programming.PassFunction;
     import org.gvsig.expressionevaluator.impl.function.programming.PrintFunction;
     import org.gvsig.expressionevaluator.impl.function.programming.RangeFunction;
     import org.gvsig.expressionevaluator.impl.function.programming.ReturnFunction;
-...
         public ProgrammingSymbolTable() {
             super(NAME);
             this.addFunction(new PassFunction());
             this.addFunction(new CaseFunction());
             this.addFunction(new CodeBlockFunction());
             this.addFunction(new CodeBlockWithExceptFunction());

     import org.gvsig.expressionevaluator.impl.function.image.ImageTransformFunction;
     import org.gvsig.expressionevaluator.impl.function.image.ImageVerticalflipFunction;
     import org.gvsig.expressionevaluator.impl.function.image.ImageWidthFunction;
     import org.gvsig.expressionevaluator.impl.function.image.ImageWriteFunction;
     import org.gvsig.expressionevaluator.spi.AbstractSymbolTable;
     /**
-...
             this.addFunction(new ImageHeightFunction());
             this.addFunction(new ImageHorizontalflipFunction());
             this.addFunction(new ImageReadFunction());
             this.addFunction(new ImageWriteFunction());
             this.addFunction(new ImageResizeFunction());
             this.addFunction(new ImageRotateFunction());
             this.addFunction(new ImageTransformFunction());

     import org.gvsig.expressionevaluator.Function;
     import org.gvsig.expressionevaluator.I18N;
     import org.gvsig.expressionevaluator.Interpreter;
     import org.gvsig.tools.ToolsLocator;
     import org.gvsig.tools.i18n.I18nManager;
     //import org.gvsig.fmap.geom.Geometry;
     //import org.gvsig.fmap.geom.primitive.Point;
     import org.json.JSONArray;
-...
             return descriptionArgs;
+        }
         public String getFullDescription() {
             I18nManager i18n = ToolsLocator.getI18nManager();
             StringBuilder html = new StringBuilder();
             html.append("<html>\n");
             // Lo primero llamamos a description() para forzar la recarga de los
             // recursos si fuese necesaria.
             String functionDescription = this.description();
             html.append("<b>").append(i18n.getTranslation("_Function")).append("</b> ").append(this.name()).append("<br>\n<br>\n");
             List<String> aliases = this.aliases();
             if( aliases!=null && !aliases.isEmpty() ) {
                 html.append("<b>").append(i18n.getTranslation("_Aliases")).append(":</b> ").append("<ul>\n");
                 for (String theAlias : aliases) {
                     html.append("<li>").append(theAlias).append("</li>\n");
+                }
                 html.append("</ul>\n");
+            }
             html.append("<b>").append(i18n.getTranslation("_Return")).append("</b> ");
             html.append(StringUtils.isEmpty(this.returnType()) ? "Objec" : this.returnType());
             html.append("<br>\n");
             html.append("<b>").append(i18n.getTranslation("_Template")).append("</b> ");
             html.append(StringUtils.isEmpty(this.template()) ? this.name() + "()" : this.template());
             html.append("<br>\n");
             String[] args = this.descriptionArgs();
             if (args != null) {
                 html.append("<b>").append(i18n.getTranslation("_Arguments")).append(":</b> ").append("<ul>\n");
                 for (String arg : args) {
                     html.append("<li>").append(arg).append("</li>\n");
+                }
                 html.append("</ul>\n");
                 html.append("<br>\n");
+            }
             if( !StringUtils.isBlank(functionDescription) ) {
                 html.append("<b>").append(i18n.getTranslation("_Description")).append("</b><br>\n");
                 html.append(functionDescription.replace("\n", "<br>")).append("<br>\n");
+            }
             html.append("</html>\n");
             return html.toString();
+        }
         @Override
         public void addAlias(String name) {
             if( StringUtils.isBlank(name) ) {

         public String description();
         /**
          * Return a full description of the funcion internationalized in HTML.
          * This full description contains, t name, description, args, template and
          * return type.
+         *
          * @return full description in HTML as a String
          */
         public String getFullDescription();
         public String template();
         public String[] descriptionArgs();

Application: gvSIG desktop

Revision 44924