/ - Diff - Application: gvSIG desktop - gvSIG

+    {
         "name": "LENGTH",
         "group": "String",
         "template": "LENGTH({{string}})",
         "args": [
             "string - string to return the length for"
         ],
         "description": ["Returns the number of characters in a string. This method returns a long. For BLOB, CLOB, BYTES and JAVA_OBJECT, the precision is used.",
         "Example: LENGTH(NAME)"],
         "returnType": "Integer"
+    }

+    {
         "name": "POW",
         "group": "Numeric",
         "template": "POW({{number}}, exp)",
         "args": [
             "number - value",
             "exp - exponent value"
         ],
         "description": "Returns the exponent value to a number",
         "returnType": "Double"
+    }

+    {
         "name": "ST_Z",
         "group": "OGC",
         "template": "ST_Z({{point}})",
         "args": [
             "point - Geometry point from which you have to calculate "
         ],
         "description": "Return the Z coordinate of the point.",
         "returnType": "Double"
+    }

+    {
         "name": "ST_Envelope",
         "group": "OGC",
         "template": "ST_Envelope({{geometry}})",
         "args": [
             "geometry - Geometry from which you have to calculate "
         ],
         "description": "Returns the float8 minimum bounding box for the supplied geometry, as a geometry. The polygon is defined by the corner points of the bounding box ((MINX, MINY), (MINX, MAXY), (MAXX, MAXY), (MAXX, MINY), (MINX, MINY)). (PostGIS will add a ZMIN/ZMAX coordinate as well).",
         "returnType": "Geometry"
+    }

+    {
         "name": "ST_Intersects",
         "group": "OGC",
         "template": "ST_Intersects({{geometryA}}, geometryB)",
         "args": [
             "geometryA - Geometry from which you have to calculate the intersection",
             "geometryB - Geometry againt you have to calculate the intersection"
         ],
         "description": ["If a geometry or geography shares any portion of space then they intersect.",
           " For geography -- tolerance is 0.00001 meters (so any points that are close are considered to intersect)",
           "Overlaps, Touches, Within all imply spatial intersection.",
           "If any of the aforementioned returns true, then the geometries also spatially intersect.",
           "Disjoint implies false for spatial intersection."],
         "returnType": "Boolean"
+    }

+    {
         "name": "ST_Distance",
         "group": "OGC",
         "template": "ST_Distance({{geometryA}}, geometryB)",
         "args": [
             "geometryA - Geometry from which you have to calculate the distance",
             "geometryB - Geometry againt you have to calculate the distance"
         ],
         "description": "For geometry type returns the minimum 2D Cartesian distance between two geometries in projected units (spatial ref units). For geography type defaults to return the minimum geodesic distance between two geographies in meters. If use_spheroid is false, a faster sphere calculation is used instead of a spheroid.",
         "returnType": "Double"
+    }

+    {
         "name": "ST_Intersection",
         "group": "OGC",
         "template": "ST_Intersection({{geometryA}}, geometryB)",
         "args": [
             "geometryA - Geometry from which you have to calculate the intersection",
             "geometryB - Geometry againt you have to calculate the intersection"
         ],
         "description": ["Returns a geometry that represents the point set intersection of the Geometries.",
           "In other words - that portion of geometry A and geometry B that is shared between the two geometries.",
           "If the geometries do not share any space (are disjoint), then an empty geometry collection is returned.",
           "ST_Intersection in conjunction with ST_Intersects is very useful for clipping geometries such as in",
           "bounding box, buffer, region queries where you only want to return that portion of a geometry",
           " that sits in a country or region of interest."],
         "returnType": "Geometry"
+    }

+    {
         "name": "ST_StartPoint",
         "group": "OGC",
         "template": "ST_StartPoint({{geometry}})",
         "args": [
             "geometry - Geometry from which you have to calculate "
         ],
         "description": "Returns the first point.",
         "returnType": "Geometry"
+    }

+    {
         "name": "ST_GeometryN",
         "group": "OGC",
         "template": "ST_GeometryN({{geometry}}, n)",
         "args": [
             "geometry - Geometry from which you have to calculate ",
             "n - integer value"
         ],
         "description": "Return the 1-based Nth geometry if the geometry is a GEOMETRYCOLLECTION, (MULTI)POINT, (MULTI)LINESTRING, MULTICURVE or (MULTI)POLYGON, POLYHEDRALSURFACE Otherwise, return NULL",
         "returnType": "Geometry"
+    }

+    {
         "name": "LENGTH",
         "group": "String",
         "template": "LENGTH({{string}})",
         "args": [
             "string - string to return the length for"
         ],
         "description": ["Returns the number of characters in a string.",
           "This method returns a long. For BLOB, CLOB, BYTES and JAVA_OBJECT, the precision is used.",
         "Example: LENGTH(NAME)"
       ],
         "returnType": "Integer"
+    }

+    {
         "name": "ST_GeomFromText",
         "group": "OGC",
         "template": "ST_GeomFromText({{WKTtext}})",
         "args": [
             "WKTtext - WKT text representation of the geometry"
         ],
         "description": "Constructs a ST_Geometry object from the OGC Well-Known text representation.",
         "returnType": "Geometry"
+    }

+    {
         "name": "ST_Disjoint",
         "group": "OGC",
         "template": "ST_Disjoint({{geometryA}}, geometryB)",
         "args": [
             "geometryA - Geometry from which you have to calculate the disjoint",
             "geometryB - Geometry againt you have to calculate the disjoint"
         ],
         "description": "Overlaps, Touches, Within all imply geometries are not spatially disjoint. If any of the aforementioned returns true, then the geometries are not spatially disjoint. Disjoint implies false for spatial intersection.",
         "returnType": "Boolean"
+    }

         "name": "INSTR",
         "group": "String",
         "template": "INSTR({{string}}, searchString, startInt)",
         "args": [
               "string - string where to search",
               "searchString - string to search for"
               "startInt - Optional. Start position to be used for search"
         ],
         "description": [
           "Returns the location of a search string in a string.",
           "If a start position is used, the characters before it are ignored.",
           "If position is negative, the rightmost location is returned.",
           "0 is returned if the search string is not found.",
           "Please note this function is case sensitive, even if the parameters are not.\n",
           "Example:\n",
           "Please note this function is case sensitive, even if the parameters are not.",
           "Example:",
           "INSTR(EMAIL,'@')"
         ],
         "args": [
               "string",
               "searchString"
               "startInt - Optional. Start position to be used for search"
         ],
         "returnType": "Integer"
+    }

+    {
         "name": "ST_IsValid",
         "group": "OGC",
         "template": "ST_IsValid({{geometry}})",
         "args": [
             "geometry - Geometry from which you have to calculate "
         ],
         "description": "Test if an ST_Geometry value is well formed.",
         "returnType": "Boolean"
+    }

+    {
         "name": "ST_Perimeter",
         "group": "OGC",
         "template": "ST_Perimeter({{geometry}})",
         "args": [
             "geometry - Geometry from which you have to calculate "
         ],
         "description": "Returns the 2D perimeter of the geometry/geography if it is a ST_Surface, ST_MultiSurface (Polygon, MultiPolygon). 0 is returned for non-areal geometries. For linear geometries use ST_Length. For geometry types, units for perimeter measures are specified by the spatial reference system of the geometry.",
         "returnType": "Double"
+    }

+    {
         "name": "ST_NumPoints",
         "group": "OGC",
         "template": "ST_NumPoints({{geometry}})",
         "args": [
             "geometry - Geometry from which you have to calculate "
         ],
         "description": "Return the number of points.",
         "returnType": "Integer"
+    }

+    {
         "name": "ST_X",
         "group": "OGC",
         "template": "ST_X({{point}})",
         "args": [
             "point - Geometry point from which you have to calculate "
         ],
         "description": "Return the X coordinate of the point.",
         "returnType": "Double"
+    }

+    {
         "name": "ST_Touches",
         "group": "OGC",
         "template": "ST_Touches({{geometryA}}, geometryB)",
         "args": [
             "geometryA - Geometry from which you have to calculate",
             "geometryB - Geometry againt you have to calculate"
         ],
         "description": ["RReturns TRUE if the only points in common between g1 and g2 lie in the union of the boundaries of g1 and g2."],
         "returnType": "Boolean"
+    }

+    {
         "name": "ST_NumGeometries",
         "group": "OGC",
         "template": "ST_NumGeometries({{geometry}})",
         "args": [
             "geometry - Geometry from which you have to calculate "
         ],
         "description": "Returns the number of Geometries. If geometry is a GEOMETRYCOLLECTION (or MULTI*) return the number of geometries, for single geometries will return 1, otherwise return NULL.",
         "returnType": "Integer"
+    }

+    {
         "name": "ST_Dimension",
         "group": "OGC",
         "template": "ST_Dimension({{geometry}})",
         "args": [
             "geometry - Geometry from which you have to calculate "
         ],
         "description": "Returns 0 for POINT, 1 for LINESTRING, 2 for POLYGON, and the largest dimension of the components of a GEOMETRYCOLLECTION. If the dimension is unknown (empty GEOMETRYCOLLECTION) 0 is returned.",
         "returnType": "Integer"
+    }

+    {
         "name": "POWER",
         "group": "Numeric",
         "template": "POW({{number}}, exp)",
         "args": [
             "number - value",
             "exp - exponent value"
         ],
         "description": "Returns the exponent value to a number",
         "returnType": "Double"
+    }

+    {
         "name": "ST_SRID",
         "group": "OGC",
         "template": "ST_SRID({{geometry}})",
         "args": [
             "geometry - Geometry from which you have to calculate "
         ],
         "description": "Returns the spatial reference identifier for the ST_Geometry as defined in spatial_ref_sys table.",
         "returnType": "Integer"
+    }

+    {
         "name": "ST_PointN",
         "group": "OGC",
         "template": "ST_PointN({{geometry}}, n)",
         "args": [
             "geometry - Geometry from which you have to calculate ",
             "n - value to count"
         ],
         "description": "Return the Nth point in a single linestring or circular linestring in the geometry. Negative values are counted backwards from the end of the LineString, so that -1 is the last point. Returns NULL if there is no linestring in the geometry.",
         "returnType": "Geometry"
+    }

+    {
         "name": "ST_Y",
         "group": "OGC",
         "template": "ST_Y({{point}})",
         "args": [
             "point - Geometry point from which you have to calculate "
         ],
         "description": "Return the Y coordinate of the point.",
         "returnType": "Double"
+    }

         "group": "OGC",
         "template": "ST_Buffer({{geometry}}, radius)",
         "args": [
             "geometry - Geometry from which you have to calculate your buffer"
             "geometry - Geometry from which you have to calculate your buffer",
             "radius - radius of the buffer"
         ],
         "description": "Returns a geometry that represents all points whose distance from this Geometry is less than or equal to distance.",
         "returnType": "Geometry"
+    }

+    {
         "name": "ST_GeomFromWKB",
         "group": "OGC",
         "template": "ST_GeomFromWKB({{WKB}}, srid)",
         "args": [
             "WKB - Well known binary representation of the geomtry",
             "srid - Optional. Spatial Reference System ID. If SRID is not specified, it defaults to 0 (Unknown)."
         ],
         "description": "Takes a well-known binary representation of a geometry and a Spatial Reference System ID (SRID) and creates an instance of the appropriate geometry type. This function plays the role of the Geometry Factory in SQL",
         "returnType": "Geometry"
+    }

+    {
         "name": "ST_EndPoint",
         "group": "OGC",
         "template": "ST_EndPoint({{geometry}})",
         "args": [
             "geometry - Geometry from which you have to calculate "
         ],
         "description": "Returns the last point of a LINESTRING geometry as a POINT or NULL if the input parameter is not a LINESTRING.",
         "returnType": "Double"
+    }

+    {
         "name": "ST_IsSimple",
         "group": "OGC",
         "template": "ST_IsSimple({{geometry}})",
         "args": [
             "geometry - Geometry from which you have to calculate "
         ],
         "description": "Returns true if this Geometry has no anomalous geometric points, such as self intersection or self tangency. ",
         "returnType": "Boolean"
+    }

+    {
         "name": "ST_Union",
         "group": "OGC",
         "template": "ST_Union({{geometryA}}, geometryB)",
         "args": [
             "geometryA - Geometry from which you have to calculate",
             "geometryB - Geometry againt you have to calculate"
         ],
         "description": ["Return an union of both geometries."],
         "returnType": "Boolean"
+    }

+    {
         "name": "ST_Overlaps",
         "group": "OGC",
         "template": "ST_Overlaps({{geometryA}}, geometryB)",
         "args": [
             "geometryA - Geometry from which you have to calculate the intersection",
             "geometryB - Geometry againt you have to calculate the intersection"
         ],
         "description": ["Returns TRUE if the Geometries 'spatially overlap'. By that we mean they intersect, but one does not completely contain another."],
         "returnType": "Geometry"
+    }

+    {
         "name": "ST_Within",
         "group": "OGC",
         "template": "ST_Within({{geometryA}}, geometryB)",
         "args": [
             "geometryA - Geometry from which you have to calculate",
             "geometryB - Geometry againt you have to calculate"
         ],
         "description": ["Returns TRUE if geometry A is completely inside geometry B."],
         "returnType": "Boolean"
+    }

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/operator/AbstractUnaryOperator.java
12	12	}
13	13
14	14	protected AbstractUnaryOperator(String group, String name) {
15		super(group, name, Range.is(1), null, name + " {{oper}}} ");
	15	super(group, name, Range.is(1), null, name + " {{oper}} ");
16	16	}
17	17
18	18	@Override

     public class STTouchesFunction extends AbstractFunction {
         public STTouchesFunction() {
             super("OGC", "ST_Touhes", Range.is(2));
             super("OGC", "ST_Touches", Range.is(2));
+        }
         @Override

Application: gvSIG desktop

Revision 44091