Modified: tomcat/taglibs/standard/trunk/jstlel/src/main/java/org/apache/taglibs/standard/lang/jstl/RelationalOperator.java URL: http://svn.apache.org/viewvc/tomcat/taglibs/standard/trunk/jstlel/src/main/java/org/apache/taglibs/standard/lang/jstl/RelationalOperator.java?rev=1037284&r1=1037283&r2=1037284&view=diff ============================================================================== --- tomcat/taglibs/standard/trunk/jstlel/src/main/java/org/apache/taglibs/standard/lang/jstl/RelationalOperator.java (original) +++ tomcat/taglibs/standard/trunk/jstlel/src/main/java/org/apache/taglibs/standard/lang/jstl/RelationalOperator.java Sat Nov 20 18:14:00 2010 @@ -13,62 +13,59 @@ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. - */ + */ package org.apache.taglibs.standard.lang.jstl; /** - * * <p>This is the superclass for all relational operators (except == * or !=) - * + * * @author Nathan Abramson - Art Technology Group * @version $Change: 181177 $$DateTime: 2001/06/26 08:45:09 $$Author$ - **/ + */ public abstract class RelationalOperator - extends BinaryOperator -{ - //------------------------------------- - /** - * - * Applies the operator to the given value - **/ - public Object apply (Object pLeft, - Object pRight, - Object pContext, - Logger pLogger) - throws ELException - { - return Coercions.applyRelationalOperator (pLeft, pRight, this, pLogger); - } - - //------------------------------------- - /** - * - * Applies the operator to the given double values - **/ - public abstract boolean apply (double pLeft, - double pRight, - Logger pLogger); - - //------------------------------------- - /** - * - * Applies the operator to the given long values - **/ - public abstract boolean apply (long pLeft, - long pRight, - Logger pLogger); - - //------------------------------------- - /** - * - * Applies the operator to the given String values - **/ - public abstract boolean apply (String pLeft, - String pRight, - Logger pLogger); + extends BinaryOperator { + //------------------------------------- + + /** + * Applies the operator to the given value + */ + public Object apply(Object pLeft, + Object pRight, + Object pContext, + Logger pLogger) + throws ELException { + return Coercions.applyRelationalOperator(pLeft, pRight, this, pLogger); + } + + //------------------------------------- + + /** + * Applies the operator to the given double values + */ + public abstract boolean apply(double pLeft, + double pRight, + Logger pLogger); + + //------------------------------------- + + /** + * Applies the operator to the given long values + */ + public abstract boolean apply(long pLeft, + long pRight, + Logger pLogger); + + //------------------------------------- + + /** + * Applies the operator to the given String values + */ + public abstract boolean apply(String pLeft, + String pRight, + Logger pLogger); - //------------------------------------- + //------------------------------------- }
Modified: tomcat/taglibs/standard/trunk/jstlel/src/main/java/org/apache/taglibs/standard/lang/jstl/StringLiteral.java URL: http://svn.apache.org/viewvc/tomcat/taglibs/standard/trunk/jstlel/src/main/java/org/apache/taglibs/standard/lang/jstl/StringLiteral.java?rev=1037284&r1=1037283&r2=1037284&view=diff ============================================================================== --- tomcat/taglibs/standard/trunk/jstlel/src/main/java/org/apache/taglibs/standard/lang/jstl/StringLiteral.java (original) +++ tomcat/taglibs/standard/trunk/jstlel/src/main/java/org/apache/taglibs/standard/lang/jstl/StringLiteral.java Sat Nov 20 18:14:00 2010 @@ -13,172 +13,156 @@ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. - */ + */ package org.apache.taglibs.standard.lang.jstl; /** - * * <p>An expression representing a String literal value. - * + * * @author Nathan Abramson - Art Technology Group * @version $Change: 181177 $$DateTime: 2001/06/26 08:45:09 $$Author$ - **/ + */ public class StringLiteral - extends Literal -{ - //------------------------------------- - /** - * - * Constructor - **/ - StringLiteral (Object pValue) - { - super (pValue); - } - - //------------------------------------- - /** - * - * Returns a StringLiteral parsed from the given token (enclosed by - * single or double quotes) - **/ - public static StringLiteral fromToken (String pToken) - { - return new StringLiteral (getValueFromToken (pToken)); - } - - //------------------------------------- - /** - * - * Returns a StringLiteral with the given string value - **/ - public static StringLiteral fromLiteralValue (String pValue) - { - return new StringLiteral (pValue); - } - - //------------------------------------- - /** - * - * Parses the given token into the literal value - **/ - public static String getValueFromToken (String pToken) - { - StringBuffer buf = new StringBuffer (); - int len = pToken.length () - 1; - boolean escaping = false; - for (int i = 1; i < len; i++) { - char ch = pToken.charAt (i); - if (escaping) { - buf.append (ch); - escaping = false; - } - else if (ch == '\\') { - escaping = true; - } - else { - buf.append (ch); - } - } - return buf.toString (); - } - - //------------------------------------- - /** - * - * Converts the specified value to a String token, using " as the - * enclosing quotes and escaping any characters that need escaping. - **/ - public static String toStringToken (String pValue) - { - // See if any escaping is needed - if (pValue.indexOf ('\"') < 0 && - pValue.indexOf ('\\') < 0) { - return "\"" + pValue + "\""; - } - - // Escaping is needed - else { - StringBuffer buf = new StringBuffer (); - buf.append ('\"'); - int len = pValue.length (); - for (int i = 0; i < len; i++) { - char ch = pValue.charAt (i); - if (ch == '\\') { - buf.append ('\\'); - buf.append ('\\'); - } - else if (ch == '\"') { - buf.append ('\\'); - buf.append ('\"'); - } - else { - buf.append (ch); - } - } - buf.append ('\"'); - return buf.toString (); - } - } - - //------------------------------------- - /** - * - * Converts the specified value to an identifier token, escaping it - * as a string literal if necessary. - **/ - public static String toIdentifierToken (String pValue) - { - // See if it's a valid java identifier - if (isJavaIdentifier (pValue)) { - return pValue; - } - - // Return as a String literal - else { - return toStringToken (pValue); - } - } - - //------------------------------------- - /** - * - * Returns true if the specified value is a legal java identifier - **/ - static boolean isJavaIdentifier (String pValue) - { - int len = pValue.length (); - if (len == 0) { - return false; - } - else { - if (!Character.isJavaIdentifierStart (pValue.charAt (0))) { - return false; - } - else { - for (int i = 1; i < len; i++) { - if (!Character.isJavaIdentifierPart (pValue.charAt (i))) { - return false; - } - } - return true; - } - } - } - - //------------------------------------- - // Expression methods - //------------------------------------- - /** - * - * Returns the expression in the expression language syntax - **/ - public String getExpressionString () - { - return toStringToken ((String) getValue ()); - } + extends Literal { + //------------------------------------- + + /** + * Constructor + */ + StringLiteral(Object pValue) { + super(pValue); + } + + //------------------------------------- + + /** + * Returns a StringLiteral parsed from the given token (enclosed by + * single or double quotes) + */ + public static StringLiteral fromToken(String pToken) { + return new StringLiteral(getValueFromToken(pToken)); + } + + //------------------------------------- + + /** + * Returns a StringLiteral with the given string value + */ + public static StringLiteral fromLiteralValue(String pValue) { + return new StringLiteral(pValue); + } + + //------------------------------------- + + /** + * Parses the given token into the literal value + */ + public static String getValueFromToken(String pToken) { + StringBuffer buf = new StringBuffer(); + int len = pToken.length() - 1; + boolean escaping = false; + for (int i = 1; i < len; i++) { + char ch = pToken.charAt(i); + if (escaping) { + buf.append(ch); + escaping = false; + } else if (ch == '\\') { + escaping = true; + } else { + buf.append(ch); + } + } + return buf.toString(); + } + + //------------------------------------- + + /** + * Converts the specified value to a String token, using " as the + * enclosing quotes and escaping any characters that need escaping. + */ + public static String toStringToken(String pValue) { + // See if any escaping is needed + if (pValue.indexOf('\"') < 0 && + pValue.indexOf('\\') < 0) { + return "\"" + pValue + "\""; + } + + // Escaping is needed + else { + StringBuffer buf = new StringBuffer(); + buf.append('\"'); + int len = pValue.length(); + for (int i = 0; i < len; i++) { + char ch = pValue.charAt(i); + if (ch == '\\') { + buf.append('\\'); + buf.append('\\'); + } else if (ch == '\"') { + buf.append('\\'); + buf.append('\"'); + } else { + buf.append(ch); + } + } + buf.append('\"'); + return buf.toString(); + } + } + + //------------------------------------- + + /** + * Converts the specified value to an identifier token, escaping it + * as a string literal if necessary. + */ + public static String toIdentifierToken(String pValue) { + // See if it's a valid java identifier + if (isJavaIdentifier(pValue)) { + return pValue; + } + + // Return as a String literal + else { + return toStringToken(pValue); + } + } + + //------------------------------------- + + /** + * Returns true if the specified value is a legal java identifier + */ + static boolean isJavaIdentifier(String pValue) { + int len = pValue.length(); + if (len == 0) { + return false; + } else { + if (!Character.isJavaIdentifierStart(pValue.charAt(0))) { + return false; + } else { + for (int i = 1; i < len; i++) { + if (!Character.isJavaIdentifierPart(pValue.charAt(i))) { + return false; + } + } + return true; + } + } + } + + //------------------------------------- + // Expression methods + //------------------------------------- + + /** + * Returns the expression in the expression language syntax + */ + public String getExpressionString() { + return toStringToken((String) getValue()); + } - //------------------------------------- + //------------------------------------- } Modified: tomcat/taglibs/standard/trunk/jstlel/src/main/java/org/apache/taglibs/standard/lang/jstl/UnaryMinusOperator.java URL: http://svn.apache.org/viewvc/tomcat/taglibs/standard/trunk/jstlel/src/main/java/org/apache/taglibs/standard/lang/jstl/UnaryMinusOperator.java?rev=1037284&r1=1037283&r2=1037284&view=diff ============================================================================== --- tomcat/taglibs/standard/trunk/jstlel/src/main/java/org/apache/taglibs/standard/lang/jstl/UnaryMinusOperator.java (original) +++ tomcat/taglibs/standard/trunk/jstlel/src/main/java/org/apache/taglibs/standard/lang/jstl/UnaryMinusOperator.java Sat Nov 20 18:14:00 2010 @@ -13,124 +13,107 @@ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. - */ + */ package org.apache.taglibs.standard.lang.jstl; /** - * * <p>The implementation of the unary minus operator - * + * * @author Nathan Abramson - Art Technology Group * @version $Change: 181177 $$DateTime: 2001/06/26 08:45:09 $$Author$ - **/ + */ public class UnaryMinusOperator - extends UnaryOperator -{ - //------------------------------------- - // Singleton - //------------------------------------- - - public static final UnaryMinusOperator SINGLETON = - new UnaryMinusOperator (); - - //------------------------------------- - /** - * - * Constructor - **/ - public UnaryMinusOperator () - { - } - - //------------------------------------- - // Expression methods - //------------------------------------- - /** - * - * Returns the symbol representing the operator - **/ - public String getOperatorSymbol () - { - return "-"; - } - - //------------------------------------- - /** - * - * Applies the operator to the given value - **/ - public Object apply (Object pValue, - Object pContext, - Logger pLogger) - throws ELException - { - if (pValue == null) { - /* - if (pLogger.isLoggingWarning ()) { - pLogger.logWarning - (Constants.ARITH_OP_NULL, - getOperatorSymbol ()); - } - */ - return PrimitiveObjects.getInteger (0); - } - - else if (pValue instanceof String) { - if (Coercions.isFloatingPointString (pValue)) { - double dval = - ((Number) - (Coercions.coerceToPrimitiveNumber - (pValue, Double.class, pLogger))). - doubleValue (); - return PrimitiveObjects.getDouble (-dval); - } - else { - long lval = - ((Number) - (Coercions.coerceToPrimitiveNumber - (pValue, Long.class, pLogger))). - longValue (); - return PrimitiveObjects.getLong (-lval); - } - } - - else if (pValue instanceof Byte) { - return PrimitiveObjects.getByte - ((byte) -(((Byte) pValue).byteValue ())); - } - else if (pValue instanceof Short) { - return PrimitiveObjects.getShort - ((short) -(((Short) pValue).shortValue ())); - } - else if (pValue instanceof Integer) { - return PrimitiveObjects.getInteger - ((int) -(((Integer) pValue).intValue ())); - } - else if (pValue instanceof Long) { - return PrimitiveObjects.getLong - ((long) -(((Long) pValue).longValue ())); - } - else if (pValue instanceof Float) { - return PrimitiveObjects.getFloat - ((float) -(((Float) pValue).floatValue ())); - } - else if (pValue instanceof Double) { - return PrimitiveObjects.getDouble - ((double) -(((Double) pValue).doubleValue ())); - } - - else { - if (pLogger.isLoggingError ()) { - pLogger.logError - (Constants.UNARY_OP_BAD_TYPE, - getOperatorSymbol (), - pValue.getClass ().getName ()); - } - return PrimitiveObjects.getInteger (0); + extends UnaryOperator { + //------------------------------------- + // Singleton + //------------------------------------- + + public static final UnaryMinusOperator SINGLETON = + new UnaryMinusOperator(); + + //------------------------------------- + + /** + * Constructor + */ + public UnaryMinusOperator() { + } + + //------------------------------------- + // Expression methods + //------------------------------------- + + /** + * Returns the symbol representing the operator + */ + public String getOperatorSymbol() { + return "-"; + } + + //------------------------------------- + + /** + * Applies the operator to the given value + */ + public Object apply(Object pValue, + Object pContext, + Logger pLogger) + throws ELException { + if (pValue == null) { + /* + if (pLogger.isLoggingWarning ()) { + pLogger.logWarning + (Constants.ARITH_OP_NULL, + getOperatorSymbol ()); + } + */ + return PrimitiveObjects.getInteger(0); + } else if (pValue instanceof String) { + if (Coercions.isFloatingPointString(pValue)) { + double dval = + ((Number) + (Coercions.coerceToPrimitiveNumber + (pValue, Double.class, pLogger))). + doubleValue(); + return PrimitiveObjects.getDouble(-dval); + } else { + long lval = + ((Number) + (Coercions.coerceToPrimitiveNumber + (pValue, Long.class, pLogger))). + longValue(); + return PrimitiveObjects.getLong(-lval); + } + } else if (pValue instanceof Byte) { + return PrimitiveObjects.getByte + ((byte) -(((Byte) pValue).byteValue())); + } else if (pValue instanceof Short) { + return PrimitiveObjects.getShort + ((short) -(((Short) pValue).shortValue())); + } else if (pValue instanceof Integer) { + return PrimitiveObjects.getInteger + ((int) -(((Integer) pValue).intValue())); + } else if (pValue instanceof Long) { + return PrimitiveObjects.getLong + ((long) -(((Long) pValue).longValue())); + } else if (pValue instanceof Float) { + return PrimitiveObjects.getFloat + ((float) -(((Float) pValue).floatValue())); + } else if (pValue instanceof Double) { + return PrimitiveObjects.getDouble + ((double) -(((Double) pValue).doubleValue())); + } else { + if (pLogger.isLoggingError()) { + pLogger.logError + (Constants.UNARY_OP_BAD_TYPE, + getOperatorSymbol(), + pValue.getClass().getName()); + } + return PrimitiveObjects.getInteger(0); + } } - } - //------------------------------------- + //------------------------------------- } Modified: tomcat/taglibs/standard/trunk/jstlel/src/main/java/org/apache/taglibs/standard/lang/jstl/UnaryOperator.java URL: http://svn.apache.org/viewvc/tomcat/taglibs/standard/trunk/jstlel/src/main/java/org/apache/taglibs/standard/lang/jstl/UnaryOperator.java?rev=1037284&r1=1037283&r2=1037284&view=diff ============================================================================== --- tomcat/taglibs/standard/trunk/jstlel/src/main/java/org/apache/taglibs/standard/lang/jstl/UnaryOperator.java (original) +++ tomcat/taglibs/standard/trunk/jstlel/src/main/java/org/apache/taglibs/standard/lang/jstl/UnaryOperator.java Sat Nov 20 18:14:00 2010 @@ -13,47 +13,44 @@ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. - */ + */ package org.apache.taglibs.standard.lang.jstl; /** - * * <p>This is the superclass for all unary operators - * + * * @author Nathan Abramson - Art Technology Group * @version $Change: 181177 $$DateTime: 2001/06/26 08:45:09 $$Author$ - **/ + */ + +public abstract class UnaryOperator { + //------------------------------------- -public abstract class UnaryOperator -{ - //------------------------------------- - /** - * - * Constructor - **/ - public UnaryOperator () - { - } - - //------------------------------------- - // Expression methods - //------------------------------------- - /** - * - * Returns the symbol representing the operator - **/ - public abstract String getOperatorSymbol (); - - //------------------------------------- - /** - * - * Applies the operator to the given value - **/ - public abstract Object apply (Object pValue, - Object pContext, - Logger pLogger) - throws ELException; + /** + * Constructor + */ + public UnaryOperator() { + } + + //------------------------------------- + // Expression methods + //------------------------------------- + + /** + * Returns the symbol representing the operator + */ + public abstract String getOperatorSymbol(); + + //------------------------------------- + + /** + * Applies the operator to the given value + */ + public abstract Object apply(Object pValue, + Object pContext, + Logger pLogger) + throws ELException; - //------------------------------------- + //------------------------------------- } Modified: tomcat/taglibs/standard/trunk/jstlel/src/main/java/org/apache/taglibs/standard/lang/jstl/UnaryOperatorExpression.java URL: http://svn.apache.org/viewvc/tomcat/taglibs/standard/trunk/jstlel/src/main/java/org/apache/taglibs/standard/lang/jstl/UnaryOperatorExpression.java?rev=1037284&r1=1037283&r2=1037284&view=diff ============================================================================== --- tomcat/taglibs/standard/trunk/jstlel/src/main/java/org/apache/taglibs/standard/lang/jstl/UnaryOperatorExpression.java (original) +++ tomcat/taglibs/standard/trunk/jstlel/src/main/java/org/apache/taglibs/standard/lang/jstl/UnaryOperatorExpression.java Sat Nov 20 18:14:00 2010 @@ -13,7 +13,7 @@ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. - */ + */ package org.apache.taglibs.standard.lang.jstl; @@ -21,113 +21,118 @@ import java.util.List; import java.util.Map; /** - * * <p>An expression representing one or more unary operators on a * value - * + * * @author Nathan Abramson - Art Technology Group * @author Shawn Bayern * @version $Change: 181177 $$DateTime: 2001/06/26 08:45:09 $$Author$ - **/ + */ public class UnaryOperatorExpression - extends Expression -{ - //------------------------------------- - // Properties - //------------------------------------- - // property operator - - UnaryOperator mOperator; - public UnaryOperator getOperator () - { return mOperator; } - public void setOperator (UnaryOperator pOperator) - { mOperator = pOperator; } - - //------------------------------------- - // property operators - - List mOperators; - public List getOperators () - { return mOperators; } - public void setOperators (List pOperators) - { mOperators = pOperators; } - - //------------------------------------- - // property expression - - Expression mExpression; - public Expression getExpression () - { return mExpression; } - public void setExpression (Expression pExpression) - { mExpression = pExpression; } - - //------------------------------------- - /** - * - * Constructor - **/ - public UnaryOperatorExpression (UnaryOperator pOperator, - List pOperators, - Expression pExpression) - { - mOperator = pOperator; - mOperators = pOperators; - mExpression = pExpression; - } - - //------------------------------------- - // Expression methods - //------------------------------------- - /** - * - * Returns the expression in the expression language syntax - **/ - public String getExpressionString () - { - StringBuffer buf = new StringBuffer (); - buf.append ("("); - if (mOperator != null) { - buf.append (mOperator.getOperatorSymbol ()); - buf.append (" "); - } - else { - for (int i = 0; i < mOperators.size (); i++) { - UnaryOperator operator = (UnaryOperator) mOperators.get (i); - buf.append (operator.getOperatorSymbol ()); - buf.append (" "); - } - } - buf.append (mExpression.getExpressionString ()); - buf.append (")"); - return buf.toString (); - } - - //------------------------------------- - /** - * - * Evaluates to the literal value - **/ - public Object evaluate (Object pContext, - VariableResolver pResolver, - Map functions, - String defaultPrefix, - Logger pLogger) - throws ELException - { - Object value = mExpression.evaluate (pContext, pResolver, functions, - defaultPrefix, pLogger); - if (mOperator != null) { - value = mOperator.apply (value, pContext, pLogger); - } - else { - for (int i = mOperators.size () - 1; i >= 0; i--) { - UnaryOperator operator = (UnaryOperator) mOperators.get (i); - value = operator.apply (value, pContext, pLogger); - } + extends Expression { + //------------------------------------- + // Properties + //------------------------------------- + // property operator + + UnaryOperator mOperator; + + public UnaryOperator getOperator() { + return mOperator; + } + + public void setOperator(UnaryOperator pOperator) { + mOperator = pOperator; + } + + //------------------------------------- + // property operators + + List mOperators; + + public List getOperators() { + return mOperators; + } + + public void setOperators(List pOperators) { + mOperators = pOperators; + } + + //------------------------------------- + // property expression + + Expression mExpression; + + public Expression getExpression() { + return mExpression; + } + + public void setExpression(Expression pExpression) { + mExpression = pExpression; + } + + //------------------------------------- + + /** + * Constructor + */ + public UnaryOperatorExpression(UnaryOperator pOperator, + List pOperators, + Expression pExpression) { + mOperator = pOperator; + mOperators = pOperators; + mExpression = pExpression; + } + + //------------------------------------- + // Expression methods + //------------------------------------- + + /** + * Returns the expression in the expression language syntax + */ + public String getExpressionString() { + StringBuffer buf = new StringBuffer(); + buf.append("("); + if (mOperator != null) { + buf.append(mOperator.getOperatorSymbol()); + buf.append(" "); + } else { + for (int i = 0; i < mOperators.size(); i++) { + UnaryOperator operator = (UnaryOperator) mOperators.get(i); + buf.append(operator.getOperatorSymbol()); + buf.append(" "); + } + } + buf.append(mExpression.getExpressionString()); + buf.append(")"); + return buf.toString(); + } + + //------------------------------------- + + /** + * Evaluates to the literal value + */ + public Object evaluate(Object pContext, + VariableResolver pResolver, + Map functions, + String defaultPrefix, + Logger pLogger) + throws ELException { + Object value = mExpression.evaluate(pContext, pResolver, functions, + defaultPrefix, pLogger); + if (mOperator != null) { + value = mOperator.apply(value, pContext, pLogger); + } else { + for (int i = mOperators.size() - 1; i >= 0; i--) { + UnaryOperator operator = (UnaryOperator) mOperators.get(i); + value = operator.apply(value, pContext, pLogger); + } + } + return value; } - return value; - } - //------------------------------------- + //------------------------------------- } Modified: tomcat/taglibs/standard/trunk/jstlel/src/main/java/org/apache/taglibs/standard/lang/jstl/ValueSuffix.java URL: http://svn.apache.org/viewvc/tomcat/taglibs/standard/trunk/jstlel/src/main/java/org/apache/taglibs/standard/lang/jstl/ValueSuffix.java?rev=1037284&r1=1037283&r2=1037284&view=diff ============================================================================== --- tomcat/taglibs/standard/trunk/jstlel/src/main/java/org/apache/taglibs/standard/lang/jstl/ValueSuffix.java (original) +++ tomcat/taglibs/standard/trunk/jstlel/src/main/java/org/apache/taglibs/standard/lang/jstl/ValueSuffix.java Sat Nov 20 18:14:00 2010 @@ -13,45 +13,43 @@ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. - */ + */ package org.apache.taglibs.standard.lang.jstl; import java.util.Map; /** - * * <p>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). - * + * * @author Nathan Abramson - Art Technology Group * @author Shawn Bayern * @version $Change: 181177 $$DateTime: 2001/06/26 08:45:09 $$Author$ - **/ + */ + +public abstract class ValueSuffix { + //------------------------------------- -public abstract class ValueSuffix -{ - //------------------------------------- - /** - * - * Returns the expression in the expression language syntax - **/ - public abstract String getExpressionString (); - - //------------------------------------- - /** - * - * Evaluates the expression in the given context, operating on the - * given value. - **/ - public abstract Object evaluate (Object pValue, - Object pContext, - VariableResolver pResolver, - Map functions, - String defaultPrefix, - Logger pLogger) - throws ELException; + /** + * Returns the expression in the expression language syntax + */ + public abstract String getExpressionString(); + + //------------------------------------- + + /** + * Evaluates the expression in the given context, operating on the + * given value. + */ + public abstract Object evaluate(Object pValue, + Object pContext, + VariableResolver pResolver, + Map functions, + String defaultPrefix, + Logger pLogger) + throws ELException; - //------------------------------------- + //------------------------------------- } Modified: tomcat/taglibs/standard/trunk/jstlel/src/main/java/org/apache/taglibs/standard/lang/jstl/VariableResolver.java URL: http://svn.apache.org/viewvc/tomcat/taglibs/standard/trunk/jstlel/src/main/java/org/apache/taglibs/standard/lang/jstl/VariableResolver.java?rev=1037284&r1=1037283&r2=1037284&view=diff ============================================================================== --- tomcat/taglibs/standard/trunk/jstlel/src/main/java/org/apache/taglibs/standard/lang/jstl/VariableResolver.java (original) +++ tomcat/taglibs/standard/trunk/jstlel/src/main/java/org/apache/taglibs/standard/lang/jstl/VariableResolver.java Sat Nov 20 18:14:00 2010 @@ -13,40 +13,38 @@ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. - */ + */ package org.apache.taglibs.standard.lang.jstl; /** - * * <p>This class is used to customize the way the evaluator resolves * variable references. For example, instances of this class can * implement their own variable lookup mechanisms, or introduce the * notion of "implicit variables" which override any other variables. * An instance of this class should be passed to the evaluator's * constructor. - * + * <p/> * <p>Whenever the evaluator is invoked, it is passed a "context" * Object from the application. For example, in a JSP environment, * the "context" is a PageContext. That context object is eventually * passed to this class, so that this class has a context in which to * resolve variables. - * + * * @author Nathan Abramson - Art Technology Group * @version $Change: 181177 $$DateTime: 2001/06/26 08:45:09 $$Author$ - **/ + */ + +public interface VariableResolver { + //------------------------------------- + + /** + * Resolves the specified variable within the given context. + * Returns null if the variable is not found. + */ + public Object resolveVariable(String pName, + Object pContext) + throws ELException; -public interface VariableResolver -{ - //------------------------------------- - /** - * - * Resolves the specified variable within the given context. - * Returns null if the variable is not found. - **/ - public Object resolveVariable (String pName, - Object pContext) - throws ELException; - - //------------------------------------- + //------------------------------------- } --------------------------------------------------------------------- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
