Home >> All >> org >> apache >> commons >> [ el Javadoc ]

•	org.apache.commons.el.parser.* (7)

• org.apache.commons.el: Javadoc index of package org.apache.commons.el.


Package Samples:

• org.apache.commons.el.parser

Classes:

• Coercions: This class contains the logic for coercing data types before operators are applied to them. The following is the list of rules applied for various type conversions. Applying arithmetic operator Binary operator - A {+,-,*} B if A and B are null return 0 if A or B is BigDecimal, coerce both to BigDecimal and then: if operator is +, return A.add(B) if operator is -, return A.subtract(B) if operator is *, return A.multiply(B) if A or B is Float, Double, or String containing ".", "e", or "E" if A or B is BigInteger, coerce both A and B to BigDecimal and apply operator coerce both A and B to Double and ...
• ExpressionEvaluatorImpl: This is the main class for evaluating expression Strings. An expression String is a String that may contain expressions of the form ${...}. Multiple expressions may appear in the same expression String. In such a case, the expression String's value is computed by concatenating the String values of those evaluated expressions and any intervening non-expression text, then converting the resulting String to the expected type using the PropertyEditor mechanism. In the special case where the expression String is a single expression, the value of the expression String is determined by evaluating the ...
• ArraySuffix: Represents an operator that obtains a Map entry, an indexed value, a property value, or an indexed property value of an object. The following are the rules for evaluating this operator: Evaluating a[b] (assuming a.b == a["b"]) a is null return null b is null return null a is Map !a.containsKey (b) return null a.get(b) == null return null otherwise return a.get(b) a is List or array coerce b to int (using coercion rules) coercion couldn't be performed error a.get(b) or Array.get(a, b) throws ArrayIndexOutOfBoundsException or IndexOutOfBoundsException return null a.get(b) or Array.get(a, b) throws ...
• BeanInfoIndexedProperty: This contains the information for one indexed property in a BeanInfo - IndexedPropertyDescriptor, read method, and write method. This class is necessary because the read/write methods in the IndexedPropertyDescriptor may not be accessible if the bean given to the introspector is not a public class. In this case, a publicly accessible version of the method must be found by searching for a public superclass/interface that declares the method (this searching is done by the BeanInfoManager).
• BeanInfoProperty: This contains the information for one property in a BeanInfo - PropertyDescriptor, read method, and write method. This class is necessary because the read/write methods in the PropertyDescriptor may not be accessible if the bean given to the introspector is not a public class. In this case, a publicly accessible version of the method must be found by searching for a public superclass/interface that declares the method (this searching is done by the BeanInfoManager).
• Logger: The evaluator may pass an instance of this class to operators and expressions during evaluation. They should use this to log any warning or error messages that might come up. This allows all of our logging policies to be concentrated in one class. Errors are conditions that are severe enough to abort operation. Warnings are conditions through which the operation may continue, but which should be reported to the developer.
• EnumeratedMap: This is a Map implementation driven by a data source that only provides an enumeration of keys and a getValue(key) method. This class must be subclassed to implement those methods. Some of the methods may incur a performance penalty that involves enumerating the entire data source. In these cases, the Map will try to save the results of that enumeration, but only if the underlying data source is immutable.
• ConditionalExpression: Represents a conditional expression. I've decided not to produce an abstract base "TernaryOperatorExpression" class since (a) future ternary operators are unlikely and (b) it's not clear that there would be a meaningful way to abstract them. (For instance, would they all be right- associative? Would they all have two fixed operator symbols?)
• BeanInfoManager: Manages the BeanInfo for one class - contains the BeanInfo, and also a mapping from property name to BeanInfoProperty. There are also static methods for accessing the BeanInfoManager for a class - those mappings are cached permanently so that once the BeanInfoManager is calculated, it doesn't have to be calculated again.
• ParseException: This exception is thrown when parse errors are encountered. You can explicitly create objects of this exception type by calling the method generateParseException in the generated parser. You can modify this class to customize your error reporting mechanisms so long as you retain the public fields.
• ComplexValue: Represents a dynamic value, which consists of a prefix and an optional set of ValueSuffix elements. A prefix is something like an identifier, and a suffix is something like a "property of" or "indexed element of" operator.
• ImplicitObjects: This class is used to generate the implicit Map and List objects that wrap various elements of the PageContext. It also returns the correct implicit object for a given implicit object name.
• PrimitiveObjects: This converts primitive values to their Object counterparts. For bytes and chars, values from 0 to 255 are cached. For shorts, ints, and longs, values -1000 to 1000 are cached.
• ValueSuffix: Represents an element that can appear as a suffix in a complex value, such as a property or index operator, or a method call (should they ever need to be supported).
• VariableResolverImpl: This is the JSTL-specific implementation of VariableResolver. It looks up variable references in the PageContext, and also recognizes references to implicit objects.
• PropertySuffix: Represents an operator that obtains the value of another value's property. This is a specialization of ArraySuffix - a.b is equivalent to a["b"]
• SimpleCharStream: An implementation of interface CharStream, where the stream is assumed to contain only ASCII characters (without unicode processing).
• FloatingPointLiteral: An expression representing a floating point literal value. The value is stored internally as a double.
• Constants: This contains all of the non-public constants, including messsage strings read from the resource file.
• IntegerLiteral: An expression representing an integer literal value. The value is stored internally as a long.
• ExpressionString: Represents an expression String consisting of a mixture of Strings and Expressions.
• RelationalOperator: This is the superclass for all relational operators (except == or !=)
• NamedValue: Represents a name that can be used as the first element of a value.
• UnaryOperatorExpression: An expression representing one or more unary operators on a value

Home | Contact Us | Privacy Policy | Terms of Service