/ - Diff - Application: gvSIG desktop - gvSIG

     public class LengthFunction extends AbstractFunction {
         public LengthFunction() {
             super("String", "LEGTH", Range.is(1));
             super("String", "LENGTH", Range.is(1));
+        }
         @Override

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/DefaultExpressionBuilder.java
1424	1424	public Function zero() {
1425	1425	return function("zero");
1426	1426	}
1427
	1427
	1428	@Override
	1429	public Function chr(Value num) {
	1430	return function("chr", num);
	1431	}
1428	1432	}

     import org.gvsig.expressionevaluator.impl.function.numeric.ATanFunction;
     import org.gvsig.expressionevaluator.impl.function.numeric.AbsFunction;
     import org.gvsig.expressionevaluator.impl.function.numeric.BitAndFunction;
     import org.gvsig.expressionevaluator.impl.function.numeric.BitGetFunction;
     import org.gvsig.expressionevaluator.impl.function.numeric.BitOrFunction;
     import org.gvsig.expressionevaluator.impl.function.numeric.BitXorFunction;
     import org.gvsig.expressionevaluator.impl.function.numeric.CeilFunction;
-...
             this.addFunction(new BitAndFunction());
             this.addFunction(new BitOrFunction());
             this.addFunction(new BitXorFunction());
             this.addFunction(new BitGetFunction());
             this.addFunction(new CeilFunction());
             this.addFunction(new CosFunction());
             this.addFunction(new CoshFunction());
-...
             this.addFunction(new TanFunction());
             this.addFunction(new TanhFunction());
             this.addFunction(new ZeroFunction());
             this.addFunction(new LogFunction());
             this.addFunction(new AsciiFunction());
             this.addFunction(new CharFunction());

+    {
         "name": "ATAN",
         "group": "Numeric",
         "template": "ATAN({{a}})",
         "args": [
             "a - an angle, in radians."
         ],
         "description": ["Returns the arc tangent of a number."],
         "returnType": "Double"
+    }

+    {
         "name": "COT",
         "group": "Numeric",
         "template": "COT({{a}})",
         "args": [
             "a - an angle, in radians."
         ],
         "description": [
           "Returns the hyperbolic cosine of a double value. The hyperbolic cosine of x is defined to be (ex + e-x)/2 where e is Euler's number.",
           "Special cases:",
           "- If the argument is NaN, then the result is NaN.",
           "- If the argument is infinite, then the result is positive infinity.",
           "- If the argument is zero, then the result is 1.0.",
           "The computed result must be within 2.5 ulps of the exact result."
           ] ,
         "returnType": "Double"
+    }

+    {
         "name": "RPAD",
         "group": "String",
         "template": "RPAD({{a}})",
         "args": [
             "value whose arc tangent is to be returned"
         ],
         "description": "Right pad the string to the specified length. If the length is shorter than the string, it will be truncated. If the padding string is not set, spaces will be used. Example: RPAD(TEXT, 10, '-')",
         "returnType": "String"
+    }

+    {
         "name": "SQRT",
         "group": "Numeric",
         "template": "SQRT({{number}})",
         "args": [
             "value whose arc tangent is to be returned"
         ],
         "description": "Returns the arc cosine of a value; the returned angle is in the range 0.0 through pi.",
         "returnType": "Double"
+    }

+    {
         "name": "SIN",
         "group": "Numeric",
         "template": "SIN({{a}})",
         "args": [
             "a - an angle, in radians."
         ],
         "description": "Returns the sin value.",
         "returnType": "Double"
+    }

+    {
         "name": "SPACE",
         "group": "String",
         "template": "SPACE({{number}})",
         "args": [
             "number - The number of spaces to be returned"
         ],
         "description": "Returns a string consisting of a number of spaces. Example: SPACE(80)",
         "returnType": "String"
+    }

+    {
         "name": "EXP",
         "group": "Numeric",
         "template": "EXP({{a}})",
         "args": [
             "value whose arc tangent is to be returned"
         ],
         "description": "Returns the arc cosine of a value; the returned angle is in the range 0.0 through pi.",
         "returnType": "Double"
+    }

+    {
         "name": "BITAND",
         "group": "Numeric",
         "template": "BITAND({{expr1}}, expr2)",
         "args": [
           "expr1 - the fisrt argument",
           "expr2 - the second argument"
         ],
         "description": ["The BITAND function treats its inputs and its output as vectors of bits; the output is the bitwise AND of the inputs.",
             "The types of expr1 and expr2 are INTEGER or LONG, and the result is of type INTEGER or LONG.",
             "If the types of expr1 or expr2 are not INTEGER or LONG a error is raised."
           ],
         "returnType": "Long"
+    }

+    {
         "name": "ABS",
         "group": "Numeric",
         "template": "ABS({{number}})",
         "args": [
             "number - numeric value"
         ],
         "description": "Returns the absolute value of a number.",
         "returnType": "Double"
+    }

+    {
         "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": "BITXOR",
         "group": "Numeric",
         "template": "BITXOR({{expr1}}, expr2)",
         "args": [
           "expr1 - the fisrt argument",
           "expr2 - the second argument"
         ],
         "description": [
           "The BITXOR function treats its inputs and its output as vectors of bits; the output is the bitwise XOR of the inputs.",
           "The types of expr1 and expr2 are INTEGER or LONG, and the result is of type INTEGER or LONG.",
           "If the types of expr1 or expr2 are not INTEGER or LONG a error is raised."
         ],
             "returnType": "Long"
+    }

+    {
         "name": "PI",
         "group": "Numeric",
         "template": "PI()",
         "args": [
             ""
         ],
         "description": "Returns pi value.",
         "returnType": "Double"
+    }

+    {
         "name": "CEIL",
         "group": "Numeric",
         "template": "CEIL({{number}})",
         "args": [
             "number - numerica value"
         ],
         "description": [
                 "Returns the smallest (closest to negative infinity) double value that is greater than or equal to the argument and is equal to a mathematical integer. Special cases:\n",
                 "- If the argument value is already equal to a mathematical integer, then the result is the same as the argument.",
                 "- If the argument is NaN or an infinity or positive zero or negative zero, then the result is the same as the argument.",
                 "- If the argument value is less than zero but greater than -1.0, then the result is negative zero.",
                 "Note that the value of Math.ceil(x) is exactly the value of -Math.floor(-x)."
               ],
         "returnType": "Double"
+    }

+    {
         "name": "RIGHT",
         "group": "String",
         "template": "RIGHT({{string}}, number_of_chars)",
         "args": [
             "string - The string to extract from",
             "number_of_chars - The number of characters to extract"
         ],
         "description": "Returns the rightmost number of characters. Example: RIGHT(NAME, 3)",
         "returnType": "String"
+    }

+    {
         "name": "DEGREES",
         "group": "Numeric",
         "template": "DEGREES({{a}})",
         "args": [
             "value whose arc tangent is to be returned"
         ],
         "description": "Returns the arc cosine of a value; the returned angle is in the range 0.0 through pi.",
         "returnType": "Double"
+    }

+    {
         "name": "BITGET",
         "group": "Numeric",
         "template": "BITGET({{bits}}, nbit)",
         "args": [
           "bits - a bit set",
           "nbit - bit to check"
         ],
         "description": ["Returns true if and only if the first parameter has a bit set ",
             " in the position specified by the second parameter. ",
             "This method returns a boolean. ",
             "The second parameter is zero-indexed; the least significant ",
             "it has position 0"
           ],
         "returnType": "Boolean"
+    }

+    {
         "name": "ZERO",
         "group": "Numeric",
         "template": "ZERO()",
         "args": [
             ""
         ],
         "description": "Returns the zero value.",
         "returnType": "Double"
+    }

+    {
         "name": "REPEAT",
         "group": "String",
         "template": "REPEAT({{string}}, number)",
         "args": [
             "string - The string to repeat",
             "number - The number of times to repeat the string"
         ],
         "description": "Returns a string repeated some number of times. Example: REPEAT(NAME || ' ', 10)",
         "returnType": "String"
+    }

+    {
         "name": "SUBSTR",
         "group": "String",
         "template": "SUBSTR({{string}}, start, length)",
         "args": [
             "string - The string to extract from",
             "start - The start position.",
             "lenght - The number of characters to extract."
         ],
         "description": "Returns a substring of a string starting at a position. If the start index is negative, then the start index is relative to the end of the string. The length is optional. Also supported is: SUBSTRING(string [FROM start] [FOR length]). Example: SUBSTR('[Hello]', 2, 5); SUBSTR('Hello World', -5);",
         "returnType": "String"
+    }

+    {
         "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": "FLOOR",
         "group": "Numeric",
         "template": "FLOOR({{a}})",
         "args": [
             "value whose arc tangent is to be returned"
         ],
         "description": "Returns the arc cosine of a value; the returned angle is in the range 0.0 through pi.",
         "returnType": "Double"
+    }

+    {
         "name": "LOG10",
         "group": "Numeric",
         "template": "LOG10({{a}})",
         "args": [
             "value whose arc tangent is to be returned"
         ],
         "description": "Returns the arc cosine of a value; the returned angle is in the range 0.0 through pi.",
         "returnType": "Double"
+    }

+    {
         "name": "TAN",
         "group": "Numeric",
         "template": "TAN({{a}})",
         "args": [
             "a - an angle, in radians."
         ],
         "description": "Returns the tan value.",
         "returnType": "Double"
+    }

+    {
         "name": "COS",
         "group": "Numeric",
         "template": "COS({{a}})",
         "args": [
             "a - an angle, in radians."
         ],
         "description": [
           "Returns the trigonometric cosine of an angle. Special cases:",
           "- If the argument is NaN or an infinity, then the result is NaN.",
           "The computed result must be within 1 ulp of the exact result. Results must be semi-monotonic."
           ],
         "returnType": "Double"
+    }

+    {
         "name": "RAND",
         "group": "Numeric",
         "template": "RAND({{number}})",
         "args": [
             "value whose arc tangent is to be returned"
         ],
         "description": "Returns the arc cosine of a value; the returned angle is in the range 0.0 through pi.",
         "returnType": "Double"
+    }

+    {
         "name": "LTRIM",
         "group": "String",
         "template": "LTRIM({{string}})",
         "args": [
             "string - The string to remove leading spaces from"
         ],
         "description": "Removes all leading spaces from a string. Example: LTRIM(NAME) ",
         "returnType": "String"
+    }

+    {
         "name": "ROUND",
         "group": "Numeric",
         "template": "ROUND({{number}})",
         "args": [
             "value whose arc tangent is to be returned"
         ],
         "description": "Returns the arc cosine of a value; the returned angle is in the range 0.0 through pi.",
         "returnType": "Double"
+    }

+    {
         "name": "LOWER",
         "group": "String",
         "template": "LOWER({{string}})",
         "args": [
             "string - The string to convert"
         ],
         "description": "Converts a string to lowercase. Example:LOWER(NAME)",
         "returnType": "String"
+    }

+    {
         "name": "LEFT",
         "group": "String",
         "template": "LEFT({{string}}, len)",
         "args": [
             "string - The string to extract from",
             "len - Number of characters to extract. If the number exceeds the number of characters in string, it returns string"
         ],
         "description": "Returns the leftmost number of characters. Example: LEFT(NAME, 3)",
         "returnType": "String"
+    }

+    {
         "name": "ASIN",
         "group": "Numeric",
         "template": "ASIN({{a}})",
         "args": [
             "a - an angle, in radians."
         ],
         "description": ["The ASIN() function returns the arc sine of a number.",
           "The specified number must be between -1 to 1, otherwise this function returns NULL. "
           ],
         "returnType": "Double"
+    }

+    {
         "name": "TANH",
         "group": "Numeric",
         "template": "TANH({{a}})",
         "args": [
             "a - an angle, in radians."
         ],
         "description": "Returns the arc cosine of a value; the returned angle is in the range 0.0 through pi.",
         "returnType": "Double"
+    }

+    {
         "name": "UPPER",
         "group": "String",
         "template": "UPPER({{string}})",
         "args": [
             "string - The string to convert"
         ],
         "description": "Converts a string to uppercase. Example: UPPER(NAME)",
         "returnType": "String"
+    }

+    {
         "name": "COSH",
         "group": "Numeric",
         "template": "COSH({{a}})",
         "args": [
             "a - The number whose hyperbolic cosine is to be returned."
         ],
         "description": [
           "Returns the hyperbolic cosine of a double value. The hyperbolic cosine of x is defined to be (ex + e-x)/2 where e is Euler's number.",
           "Special cases:",
           "- If the argument is NaN, then the result is NaN.",
           "- If the argument is infinite, then the result is positive infinity.",
           "- If the argument is zero, then the result is 1.0.",
           "The computed result must be within 2.5 ulps of the exact result."
           ] ,
         "returnType": "Double"
+    }

+    {
         "name": "RTRIM",
         "group": "String",
         "template": "RTRIM({{string}})",
         "args": [
             "string - The string to remove trailing spaces from"
         ],
         "description": "Removes all trailing spaces from a string. Example: RTRIM(NAME)",
         "returnType": "String"
+    }

+    {
         "name": "SIGN",
         "group": "Numeric",
         "template": "SIGN({{a}})",
         "args": [
             "value whose arc tangent is to be returned"
         ],
         "description": "Returns the arc cosine of a value; the returned angle is in the range 0.0 through pi.",
         "returnType": "Double"
+    }

+    {
         "name": "SINH",
         "group": "Numeric",
         "template": "SINH({{a}})",
         "args": [
             "a - an angle, in radians."
         ],
         "description": "Returns the arc cosine of a value; the returned angle is in the range 0.0 through pi.",
         "returnType": "Double"
+    }

+    {
         "name": "POSITION",
         "group": "String",
         "template": "POSITION({{substring}}, string)",
         "args": [
             "substring - The substring to search for in string",
             "string - The original string that will be searched"
         ],
         "description": "Returns the location of a search string in a string. See also LOCATE. Example: POSITION('.', NAME)",
         "returnType": "String"
+    }

+    {
         "name": "LOCATE",
         "group": "String",
         "template": "LOCATE({{substring}}, string, start)",
         "args": [
             "substring - The substring to search for in string",
             "string - The string that will be searched",
             "start - The starting position for the search. Position 1 is default"
         ],
         "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.
     Example:
     LOCATE('.', NAME)",
         "returnType": "Double"
+    }

+    {
         "name": "REPLACE",
         "group": "String",
         "template": "REPLACE({{string}}, old_string, new_string)",
         "args": [
             "string - The original string",
             "old_string - The string to be replaced",
             "new_string - The new replacement string"
         ],
         "description": "Replaces all occurrences of a search string in a text with another string. If no replacement is specified, the search string is removed from the original string. If any parameter is null, the result is null. Example: REPLACE(NAME, ' ')",
         "returnType": "String"
+    }

+    {
         "name": "TRIM",
         "group": "String",
         "template": "TRIM({{string}})",
         "args": [
             "string - The string to remove spaces or characters from"
         ],
         "description": "Removes all leading spaces, trailing spaces, or spaces at both ends, from a string. Other characters can be removed as well. Example: TRIM(BOTH '_' FROM NAME)",
         "returnType": "String"
+    }

+    {
         "name": "BITOR",
         "group": "Numeric",
         "template": "BITOR({{expr1}}, expr2)",
         "args": [
           "expr1 - the fisrt argument",
           "expr2 - the second argument"
         ],
         "description": [
           "The BITOR function treats its inputs and its output as vectors of bits; the output is the bitwise OR of the inputs.",
           "The types of expr1 and expr2 are INTEGER or LONG, and the result is of type INTEGER or LONG.",
           "If the types of expr1 or expr2 are not INTEGER or LONG a error is raised.",
         ],
             "returnType": "Long"
+    }

+    {
         "name": "LPAD",
         "group": "String",
         "template": "LPAD({{string}}, len, padstr)",
         "args": [
             "string - The original string.",
             "len - The length of the string after it has been left-padded",
             "padstr - The string to left-pad to string"
         ],
         "description": "Left pad the string to the specified length. If the length is shorter than the string, it will be truncated at the end. If the padding string is not set, spaces will be used. Example: LPAD(AMOUNT, 10, '*') ",
         "returnType": "String"
+    }

+    {
         "name": "RADIANS",
         "group": "Numeric",
         "template": "RADIANS({{a}})",
         "args": [
             "value whose arc tangent is to be returned"
         ],
         "description": "Returns the arc cosine of a value; the returned angle is in the range 0.0 through pi.",
         "returnType": "Double"
+    }

+    {
         "name": "LOG",
         "group": "Numeric",
         "template": "LOG({{a}})",
         "args": [
             "value whose arc tangent is to be returned"
         ],
         "description": "Returns the arc cosine of a value; the returned angle is in the range 0.0 through pi.",
         "returnType": "Double"
+    }

Application: gvSIG desktop

Revision 44053