* The first time the Introspector sees a class it creates a class method map * for the class in question. Basically the class method map is a Hastable where * Method objects are keyed by a concatenation of the method name and the names @@ -324,4 +324,4 @@ public class IntrospectorBase { return classMap; } } -} \ No newline at end of file +} diff -up commons-jexl-2.1.1-src/src/main/java/org/apache/commons/jexl2/internal/introspection/MethodKey.java.javadoc commons-jexl-2.1.1-src/src/main/java/org/apache/commons/jexl2/internal/introspection/MethodKey.java --- commons-jexl-2.1.1-src/src/main/java/org/apache/commons/jexl2/internal/introspection/MethodKey.java.javadoc 2011-12-19 06:15:01.000000000 -0700 +++ commons-jexl-2.1.1-src/src/main/java/org/apache/commons/jexl2/internal/introspection/MethodKey.java 2015-04-15 19:05:24.055352589 -0600 @@ -40,7 +40,7 @@ import java.util.Arrays; *
* A key can be constructed either from arguments (array of objects) or from parameters * (array of class). - * Roughly 3x faster than string key to access the map & uses less memory. + * Roughly 3x faster than string key to access the map & uses less memory. */ public final class MethodKey { /** The hash code. */ diff -up commons-jexl-2.1.1-src/src/main/java/org/apache/commons/jexl2/internal/Introspector.java.javadoc commons-jexl-2.1.1-src/src/main/java/org/apache/commons/jexl2/internal/Introspector.java --- commons-jexl-2.1.1-src/src/main/java/org/apache/commons/jexl2/internal/Introspector.java.javadoc 2011-12-19 06:15:01.000000000 -0700 +++ commons-jexl-2.1.1-src/src/main/java/org/apache/commons/jexl2/internal/Introspector.java 2015-04-15 19:05:24.055352589 -0600 @@ -28,11 +28,11 @@ import org.apache.commons.logging.Log; /** * Default introspection services. - *Finding methods as well as property getters & setters.
+ *Finding methods as well as property getters & setters.
* @since 1.0 */ public class Introspector { - /** The logger to use for all warnings & errors. */ + /** The logger to use for all warnings & errors. */ protected final Log rlog; /** The soft reference to the introspector currently in use. */ private volatile SoftReference* A whitelist explicitly allows methods/properties for a class; + *
** A blacklist explicitly forbids methods/properties for a class; + *
** Permissions are composed of three lists, read, write, execute, each being "white" or "black": + *
** All arithmetic operators (+, - , *, /, %) follow the same rules regarding their arguments. + *
** Creates and evaluates Expression and Script objects. - * Determines the behavior of Expressions & Scripts during their evaluation with respect to: + * Determines the behavior of Expressions & Scripts during their evaluation with respect to: + *
*The setSilent and setLenient methods allow to fine-tune an engine instance behavior
* according to various error control needs. The lenient/strict flag tells the engine when and if null as operand is
* considered an error, the silent/verbose flag tells the engine what to do with the error
@@ -68,7 +68,7 @@ import org.apache.commons.jexl2.parser.A
*
0 & null should be indicators of "default" values so that even in an case of error, + *
0 & null should be indicators of "default" values so that even in an case of error, * something meaningfull can still be inferred; may be convenient for configurations. *
*The finest error control grain is obtained; it is the closest to Java code - - * still augmented by "script" capabilities regarding automated conversions & type matching. + * still augmented by "script" capabilities regarding automated conversions & type matching. *
*
- * Supports the following:
- * File Extensions: ".jexl", ".jexl2"
+ * Supports the following:
+ * Language short names: "JEXL", "Jexl", "jexl", "JEXL2", "Jexl2", "jexl2"
+ * File Extensions: ".jexl", ".jexl2"
* "jexl2" etc. were added for engineVersion="2.0".
*
diff -up commons-jexl-2.1.1-src/src/main/java/org/apache/commons/jexl2/scripting/JexlScriptEngine.java.javadoc commons-jexl-2.1.1-src/src/main/java/org/apache/commons/jexl2/scripting/JexlScriptEngine.java --- commons-jexl-2.1.1-src/src/main/java/org/apache/commons/jexl2/scripting/JexlScriptEngine.java.javadoc 2011-12-19 06:15:00.000000000 -0700 +++ commons-jexl-2.1.1-src/src/main/java/org/apache/commons/jexl2/scripting/JexlScriptEngine.java 2015-04-15 19:33:18.303497441 -0600 @@ -95,6 +95,7 @@ public class JexlScriptEngine extends Ab * Those properties are allways bound to the default engine scope context. *
* The following properties are defined: + *
** An expression can mix immediate, deferred and nested sub-expressions as well as string constants; + *
*"...${jexl-expr}...""...#{jexl-expr}...""...#{...${jexl-expr0}...}...""...${jexl-expr0}... #{jexl-expr1}..."- * Deferred & immediate expression carry different intentions: + * Deferred & immediate expression carry different intentions: + *
*
* For instance: "Hello ${name}, now is #{time}" is a composite "deferred" expression since one
* of its subexpressions is deferred. Furthermore, this (composite) expression intent is
@@ -62,14 +62,14 @@ import org.apache.commons.jexl2.parser.S
*
* The API reflects this feature in 2 methods, prepare and evaluate. The prepare method * will evaluate the immediate subexpression and return an expression that contains only - * the deferred subexpressions (& constants), a prepared expression. Such a prepared expression + * the deferred subexpressions (& constants), a prepared expression. Such a prepared expression * is suitable for a later phase evaluation that may occur with a different JexlContext. * Note that it is valid to call evaluate without prepare in which case the same JexlContext * is used for the 2 evaluation phases. *
** In the most common use-case where deferred expressions are to be kept around as properties of objects, - * one should parse & prepare an expression before storing it and evaluate it each time + * one should parse & prepare an expression before storing it and evaluate it each time * the property storing it is accessed. *
*@@ -339,7 +339,7 @@ public final class UnifiedJEXL { *
* In effect, this binds the result of the immediate sub-expressions evaluation in the * context, allowing to differ evaluation of the remaining (deferred) expression within another context. - * This only has an effect to nested & composite expressions that contain differed & immediate sub-expressions. + * This only has an effect to nested & composite expressions that contain differed & immediate sub-expressions. *
** If the underlying JEXL engine is silent, errors will be logged through its logger as warning. @@ -409,7 +409,7 @@ public final class UnifiedJEXL { * Prepares a sub-expression for interpretation. * @param interpreter a JEXL interpreter * @return a prepared expression - * @throws JexlException (only for nested & composite) + * @throws JexlException (only for nested & composite) */ protected Expression prepare(Interpreter interpreter) { return this; @@ -419,7 +419,7 @@ public final class UnifiedJEXL { * Intreprets a sub-expression. * @param interpreter a JEXL interpreter * @return the result of interpretation - * @throws JexlException (only for nested & composite) + * @throws JexlException (only for nested & composite) */ protected abstract Object evaluate(Interpreter interpreter); } @@ -734,7 +734,7 @@ public final class UnifiedJEXL { } /** Creates a a {@link UnifiedJEXL.Expression} from an expression string. - * Uses & fills up the expression cache if any. + * Uses & fills up the expression cache if any. *
* If the underlying JEXL engine is silent, errors will be logged through its logger as warnings. *
@@ -1010,20 +1010,23 @@ public final class UnifiedJEXL { * evaluation and their output gathered through a writer. * It is thus possible to use looping or conditional construct "around" expressions generating output. * - * For instance: - *+ *For instance: + *
+ *+ ** $$ for(var x : [1, 3, 5, 42, 169]) { * $$ if (x == 42) { * Life, the universe, and everything - * $$ } else if (x > 42) { + * $$ } else if (x > 42) { * The value $(x} is over fourty-two * $$ } else { * The value ${x} is under fourty-two * $$ } * $$ } ** Will evaluate as: - *
+ * + ** The value 1 is under fourty-two * The value 3 is under fourty-two * The value 5 is under fourty-two @@ -1033,10 +1036,10 @@ public final class UnifiedJEXL { ** During evaluation, the template context exposes its writer as '$jexl' which is safe to use in this case. * This allows writing directly through the writer without adding new-lines as in: - *
+ * + *- * ** $$ for(var cell : cells) { $jexl.print(cell); $jexl.print(';') } ** A template is expanded as one JEXL script and a list of UnifiedJEXL expressions; each UnifiedJEXL expression * being replace in the script by a call to jexl:print(expr) (the expr is in fact the expr number in the template). @@ -1461,4 +1464,4 @@ public final class UnifiedJEXL { public Template createTemplate(String source) { return new Template("$$", new StringReader(source), (String[]) null); } -} \ No newline at end of file +}