FileDocCategorySizeDatePackage
Coercions.javaAPI DocGlassfish v2 API29544Sat May 05 19:17:26 BST 2007org.apache.taglibs.standard.lang.jstl

Coercions

public class Coercions extends Object

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 Float, Double, or String containing ".", "e", or "E"
coerce both A and B to Double
apply operator
otherwise
coerce both A and B to Long
apply operator
if operator results in exception (such as divide by 0), error

Binary operator - A {/,div} B
if A and B are null
return 0
otherwise
coerce both A and B to Double
apply operator
if operator results in exception (such as divide by 0), error

Binary operator - A {%,mod} B
if A and B are null
return 0
if A or B is Float, Double, or String containing ".", "e" or "E"
coerce both to Double
apply operator
otherwise
coerce both A and B to Long
apply operator
if operator results in exception (such as divide by 0), error

Unary minus operator - -A
if A is null
return 0
if A is String
if A contains ".", "e", or "E"
coerce to Double, apply operator
otherwise
coerce to a Long and apply operator
if A is Byte,Short,Integer,Long,Float,Double
retain type, apply operator
if operator results in exception, error
otherwise
error

Applying "empty" operator - empty A
if A is null
return true
if A is zero-length String
return true
if A is zero-length array
return true
if A is List and ((List) A).isEmpty()
return true
if A is Map and ((Map) A).isEmpty()
return true
otherwise
return false

Applying logical operators
Binary operator - A {and,or} B
coerce both A and B to Boolean, apply operator
NOTE - operator stops as soon as expression can be determined, i.e.,
A and B and C and D - if B is false, then only A and B is evaluated
Unary not operator - not A
coerce A to Boolean, apply operator

Applying relational operator
A {<,>,<=,>=,lt,gt,lte,gte} B
if A==B
if operator is >= or <=
return true
otherwise
return false
if A or B is null
return false
if A or B is Float or Double
coerce both A and B to Double
apply operator
if A or B is Byte,Short,Character,Integer,Long
coerce both A and B to Long
apply operator
if A or B is String
coerce both A and B to String, compare lexically
if A is Comparable
if A.compareTo (B) throws exception
error
otherwise
use result of A.compareTo(B)
if B is Comparable
if B.compareTo (A) throws exception
error
otherwise
use result of B.compareTo(A)
otherwise
error

Applying equality operator
A {==,!=} B
if A==B
apply operator
if A or B is null
return false for ==, true for !=
if A or B is Float or Double
coerce both A and B to Double
apply operator
if A or B is Byte,Short,Character,Integer,Long
coerce both A and B to Long
apply operator
if A or B is Boolean
coerce both A and B to Boolean
apply operator
if A or B is String
coerce both A and B to String, compare lexically
otherwise
if an error occurs while calling A.equals(B)
error
apply operator to result of A.equals(B)

coercions

coerce A to String
A is String
return A
A is null
return ""
A.toString throws exception
error
otherwise
return A.toString

coerce A to primitive Number type N
A is null or ""
return 0
A is Character
convert to short, apply following rules
A is Boolean
error
A is Number type N
return A
A is Number with less precision than N
coerce quietly
A is Number with greater precision than N
coerce quietly
A is String
new N.valueOf(A) throws exception
error
return N.valueOf(A)
otherwise
error

coerce A to Character should be
A is null or ""
return (char) 0
A is Character
return A
A is Boolean
error
A is Number with less precision than short
coerce quietly - return (char) A
A is Number with greater precision than short
coerce quietly - return (char) A
A is String
return A.charAt (0)
otherwise
error

coerce A to Boolean
A is null or ""
return false
A is Boolean
return A
A is String
Boolean.valueOf(A) throws exception
error
return Boolean.valueOf(A)
otherwise
error

coerce A to any other type T
A is null
return null
A is assignable to T
coerce quietly
A is String
T has no PropertyEditor
if A is "", return null
otherwise error
T's PropertyEditor throws exception
if A is "", return null
otherwise error
otherwise
apply T's PropertyEditor
otherwise
error
author
Nathan Abramson - Art Technology Group
version
$Change: 181177 $$DateTime: 2001/06/26 08:45:09 $$Author: tcfujii $

Fields Summary
Constructors Summary
Methods Summary
public static java.lang.ObjectapplyArithmeticOperator(java.lang.Object pLeft, java.lang.Object pRight, ArithmeticOperator pOperator, Logger pLogger)
Performs all of the necessary type conversions, then calls on the appropriate operator.

    if (pLeft == null &&
	pRight == null) {
      if (pLogger.isLoggingWarning ()) {
	pLogger.logWarning
	  (Constants.ARITH_OP_NULL,
	   pOperator.getOperatorSymbol ());
      }
      return PrimitiveObjects.getInteger (0);
    }

    else if (isFloatingPointType (pLeft) ||
	     isFloatingPointType (pRight) ||
	     isFloatingPointString (pLeft) ||
	     isFloatingPointString (pRight)) {
      double left =
	coerceToPrimitiveNumber (pLeft, Double.class, pLogger).
	doubleValue ();
      double right =
	coerceToPrimitiveNumber (pRight, Double.class, pLogger).
	doubleValue ();
      return 
	PrimitiveObjects.getDouble (pOperator.apply (left, right, pLogger));
    }

    else {
      long left =
	coerceToPrimitiveNumber (pLeft, Long.class, pLogger).
	longValue ();
      long right =
	coerceToPrimitiveNumber (pRight, Long.class, pLogger).
	longValue ();
      return
	PrimitiveObjects.getLong (pOperator.apply (left, right, pLogger));
    }
public static java.lang.ObjectapplyEqualityOperator(java.lang.Object pLeft, java.lang.Object pRight, EqualityOperator pOperator, Logger pLogger)
Performs all of the necessary type conversions, then calls on the appropriate operator.

    if (pLeft == pRight) {
      return PrimitiveObjects.getBoolean (pOperator.apply (true, pLogger));
    }

    else if (pLeft == null ||
	     pRight == null) {
      return PrimitiveObjects.getBoolean (pOperator.apply (false, pLogger));
    }

    else if (isFloatingPointType (pLeft) ||
	     isFloatingPointType (pRight)) {
      double left =
	coerceToPrimitiveNumber (pLeft, Double.class, pLogger).
	doubleValue ();
      double right =
	coerceToPrimitiveNumber (pRight, Double.class, pLogger).
	doubleValue ();
      return 
	PrimitiveObjects.getBoolean 
	(pOperator.apply (left == right, pLogger));
    }

    else if (isIntegerType (pLeft) ||
	     isIntegerType (pRight)) {
      long left =
	coerceToPrimitiveNumber (pLeft, Long.class, pLogger).
	longValue ();
      long right =
	coerceToPrimitiveNumber (pRight, Long.class, pLogger).
	longValue ();
      return
	PrimitiveObjects.getBoolean 
	(pOperator.apply (left == right, pLogger));
    }

    else if (pLeft instanceof Boolean ||
	     pRight instanceof Boolean) {
      boolean left = coerceToBoolean (pLeft, pLogger).booleanValue ();
      boolean right = coerceToBoolean (pRight, pLogger).booleanValue ();
      return
	PrimitiveObjects.getBoolean 
	(pOperator.apply (left == right, pLogger));
    }

    else if (pLeft instanceof String ||
	     pRight instanceof String) {
      String left = coerceToString (pLeft, pLogger);
      String right = coerceToString (pRight, pLogger);
      return
	PrimitiveObjects.getBoolean 
	(pOperator.apply (left.equals (right), pLogger));
    }

    else {
      try {
      return
	PrimitiveObjects.getBoolean
	(pOperator.apply (pLeft.equals (pRight), pLogger));
      }
      catch (Exception exc) {
	if (pLogger.isLoggingError ()) {
	  pLogger.logError
	    (Constants.ERROR_IN_EQUALS,
	     exc,
	     pLeft.getClass ().getName (),
	     pRight.getClass ().getName (),
	     pOperator.getOperatorSymbol ());
	}
	return Boolean.FALSE;
      }
    }
public static java.lang.ObjectapplyRelationalOperator(java.lang.Object pLeft, java.lang.Object pRight, RelationalOperator pOperator, Logger pLogger)
Performs all of the necessary type conversions, then calls on the appropriate operator.

    if (isFloatingPointType (pLeft) ||
	isFloatingPointType (pRight)) {
      double left =
	coerceToPrimitiveNumber (pLeft, Double.class, pLogger).
	doubleValue ();
      double right =
	coerceToPrimitiveNumber (pRight, Double.class, pLogger).
	doubleValue ();
      return 
	PrimitiveObjects.getBoolean (pOperator.apply (left, right, pLogger));
    }

    else if (isIntegerType (pLeft) ||
	     isIntegerType (pRight)) {
      long left =
	coerceToPrimitiveNumber (pLeft, Long.class, pLogger).
	longValue ();
      long right =
	coerceToPrimitiveNumber (pRight, Long.class, pLogger).
	longValue ();
      return
	PrimitiveObjects.getBoolean (pOperator.apply (left, right, pLogger));
    }

    else if (pLeft instanceof String ||
	     pRight instanceof String) {
      String left = coerceToString (pLeft, pLogger);
      String right = coerceToString (pRight, pLogger);
      return
	PrimitiveObjects.getBoolean (pOperator.apply (left, right, pLogger));
    }

    else if (pLeft instanceof Comparable) {
      try {
	int result = ((Comparable) pLeft).compareTo (pRight);
	return
	  PrimitiveObjects.getBoolean 
	  (pOperator.apply (result, -result, pLogger));
      }
      catch (Exception exc) {
	if (pLogger.isLoggingError ()) {
	  pLogger.logError
	    (Constants.COMPARABLE_ERROR,
	     exc,
	     pLeft.getClass ().getName (),
	     (pRight == null) ? "null" : pRight.getClass ().getName (),
	     pOperator.getOperatorSymbol ());
	}
	return Boolean.FALSE;
      }
    }

    else if (pRight instanceof Comparable) {
      try {
	int result = ((Comparable) pRight).compareTo (pLeft);
	return
	  PrimitiveObjects.getBoolean 
	  (pOperator.apply (-result, result, pLogger));
      }
      catch (Exception exc) {
	if (pLogger.isLoggingError ()) {
	  pLogger.logError
	    (Constants.COMPARABLE_ERROR,
	     exc,
	     pRight.getClass ().getName (),
	     (pLeft == null) ? "null" : pLeft.getClass ().getName (),
	     pOperator.getOperatorSymbol ());
	}
	return Boolean.FALSE;
      }
    }

    else {
      if (pLogger.isLoggingError ()) {
	pLogger.logError
	  (Constants.ARITH_OP_BAD_TYPE,
	   pOperator.getOperatorSymbol (),
	   pLeft.getClass ().getName (),
	   pRight.getClass ().getName ());
      }
      return Boolean.FALSE;
    }
public static java.lang.Objectcoerce(java.lang.Object pValue, java.lang.Class pClass, Logger pLogger)
Coerces the given value to the specified class.

    if (pClass == String.class) {
      return coerceToString (pValue, pLogger);
    }
    else if (isPrimitiveNumberClass (pClass)) {
      return coerceToPrimitiveNumber (pValue, pClass, pLogger);
    }
    else if (pClass == Character.class ||
	     pClass == Character.TYPE) {
      return coerceToCharacter (pValue, pLogger);
    }
    else if (pClass == Boolean.class ||
	     pClass == Boolean.TYPE) {
      return coerceToBoolean (pValue, pLogger);
    }
    else {
      return coerceToObject (pValue, pClass, pLogger);
    }
public static java.lang.BooleancoerceToBoolean(java.lang.Object pValue, Logger pLogger)
Coerces a value to a Boolean

    if (pValue == null ||
	"".equals (pValue)) {
      return Boolean.FALSE;
    }
    else if (pValue instanceof Boolean) {
      return (Boolean) pValue;
    }
    else if (pValue instanceof String) {
      String str = (String) pValue;
      try {
	return Boolean.valueOf (str);
      }
      catch (Exception exc) {
	if (pLogger.isLoggingError ()) {
	  pLogger.logError
	    (Constants.STRING_TO_BOOLEAN,
	     exc,
	     (String) pValue);
	}
	return Boolean.FALSE;
      }
    }
    else {
      if (pLogger.isLoggingError ()) {
	pLogger.logError
	  (Constants.COERCE_TO_BOOLEAN,
	   pValue.getClass ().getName ());
      }
      return Boolean.TRUE;
    }
public static java.lang.CharactercoerceToCharacter(java.lang.Object pValue, Logger pLogger)
Coerces a value to a Character

    if (pValue == null ||
	"".equals (pValue)) {
      return PrimitiveObjects.getCharacter ((char) 0);
    }
    else if (pValue instanceof Character) {
      return (Character) pValue;
    }
    else if (pValue instanceof Boolean) {
      if (pLogger.isLoggingError ()) {
	pLogger.logError (Constants.BOOLEAN_TO_CHARACTER, pValue);
      }
      return PrimitiveObjects.getCharacter ((char) 0);
    }
    else if (pValue instanceof Number) {
      return PrimitiveObjects.getCharacter 
	((char) ((Number) pValue).shortValue ());
    }
    else if (pValue instanceof String) {
      String str = (String) pValue;
      return PrimitiveObjects.getCharacter (str.charAt (0));
    }
    else {
      if (pLogger.isLoggingError ()) {
	pLogger.logError
	  (Constants.COERCE_TO_CHARACTER,
	   pValue.getClass ().getName ());
      }
      return PrimitiveObjects.getCharacter ((char) 0);
    }
public static java.lang.IntegercoerceToInteger(java.lang.Object pValue, Logger pLogger)
Coerces a value to an Integer, returning null if the coercion isn't possible.

    if (pValue == null) {
      return null;
    }
    else if (pValue instanceof Character) {
      return PrimitiveObjects.getInteger 
	((int) (((Character) pValue).charValue ()));
    }
    else if (pValue instanceof Boolean) {
      if (pLogger.isLoggingWarning ()) {
	pLogger.logWarning (Constants.BOOLEAN_TO_NUMBER,
			    pValue,
			    Integer.class.getName ());
      }
      return PrimitiveObjects.getInteger
	(((Boolean) pValue).booleanValue () ? 1 : 0);
    }
    else if (pValue instanceof Integer) {
      return (Integer) pValue;
    }
    else if (pValue instanceof Number) {
      return PrimitiveObjects.getInteger (((Number) pValue).intValue ());
    }
    else if (pValue instanceof String) {
      try {
	return Integer.valueOf ((String) pValue);
      }
      catch (Exception exc) {
	if (pLogger.isLoggingWarning ()) {
	  pLogger.logWarning
	    (Constants.STRING_TO_NUMBER_EXCEPTION,
	     (String) pValue,
	     Integer.class.getName ());
	}
	return null;
      }
    }
    else {
      if (pLogger.isLoggingWarning ()) {
	pLogger.logWarning
	  (Constants.COERCE_TO_NUMBER,
	   pValue.getClass ().getName (),
	   Integer.class.getName ());
      }
      return null;
    }
public static java.lang.ObjectcoerceToObject(java.lang.Object pValue, java.lang.Class pClass, Logger pLogger)
Coerces a value to the specified Class that is not covered by any of the above cases

    if (pValue == null) {
      return null;
    }
    else if (pClass.isAssignableFrom (pValue.getClass ())) {
      return pValue;
    }
    else if (pValue instanceof String) {
      String str = (String) pValue;
      PropertyEditor pe = PropertyEditorManager.findEditor (pClass);
      if (pe == null) {
	if ("".equals (str)) {
	  return null;
	}
	else {
	  if (pLogger.isLoggingError ()) {
	    pLogger.logError
	      (Constants.NO_PROPERTY_EDITOR,
	       str,
	       pClass.getName ());
	  }
	  return null;
	}
      }
      try {
	pe.setAsText (str);
	return pe.getValue ();
      }
      catch (IllegalArgumentException exc) {
	if ("".equals (str)) {
	  return null;
	}
	else {
	  if (pLogger.isLoggingError ()) {
	    pLogger.logError
	      (Constants.PROPERTY_EDITOR_ERROR,
	       exc,
	       pValue,
	       pClass.getName ());
	  }
	  return null;
	}
      }
    }
    else {
      if (pLogger.isLoggingError ()) {
	pLogger.logError
	  (Constants.COERCE_TO_OBJECT,
	   pValue.getClass ().getName (),
	   pClass.getName ());
      }
      return null;
    }
public static java.lang.NumbercoerceToPrimitiveNumber(java.lang.Object pValue, java.lang.Class pClass, Logger pLogger)
Coerces a value to the given primitive number class

    if (pValue == null ||
	"".equals (pValue)) {
      return coerceToPrimitiveNumber (0, pClass);
    }
    else if (pValue instanceof Character) {
      char val = ((Character) pValue).charValue ();
      return coerceToPrimitiveNumber ((short) val, pClass);
    }
    else if (pValue instanceof Boolean) {
      if (pLogger.isLoggingError ()) {
	pLogger.logError (Constants.BOOLEAN_TO_NUMBER,
			  pValue,
			  pClass.getName ());
      }
      return coerceToPrimitiveNumber (0, pClass);
    }
    else if (pValue.getClass () == pClass) {
      return (Number) pValue;
    }
    else if (pValue instanceof Number) {
      return coerceToPrimitiveNumber ((Number) pValue, pClass);
    }
    else if (pValue instanceof String) {
      try {
	return coerceToPrimitiveNumber ((String) pValue, pClass);
      }
      catch (Exception exc) {
	if (pLogger.isLoggingError ()) {
	  pLogger.logError
	    (Constants.STRING_TO_NUMBER_EXCEPTION,
	     (String) pValue,
	     pClass.getName ());
	}
	return coerceToPrimitiveNumber (0, pClass);
      }
    }
    else {
      if (pLogger.isLoggingError ()) {
	pLogger.logError
	  (Constants.COERCE_TO_NUMBER,
	   pValue.getClass ().getName (),
	   pClass.getName ());
      }
      return coerceToPrimitiveNumber (0, pClass);
    }
static java.lang.NumbercoerceToPrimitiveNumber(long pValue, java.lang.Class pClass)
Coerces a long to the given primitive number class

    if (pClass == Byte.class || pClass == Byte.TYPE) {
      return PrimitiveObjects.getByte ((byte) pValue);
    }
    else if (pClass == Short.class || pClass == Short.TYPE) {
      return PrimitiveObjects.getShort ((short) pValue);
    }
    else if (pClass == Integer.class || pClass == Integer.TYPE) {
      return PrimitiveObjects.getInteger ((int) pValue);
    }
    else if (pClass == Long.class || pClass == Long.TYPE) {
      return PrimitiveObjects.getLong ((long) pValue);
    }
    else if (pClass == Float.class || pClass == Float.TYPE) {
      return PrimitiveObjects.getFloat ((float) pValue);
    }
    else if (pClass == Double.class || pClass == Double.TYPE) {
      return PrimitiveObjects.getDouble ((double) pValue);
    }
    else {
      return PrimitiveObjects.getInteger (0);
    }
static java.lang.NumbercoerceToPrimitiveNumber(double pValue, java.lang.Class pClass)
Coerces a double to the given primitive number class

    if (pClass == Byte.class || pClass == Byte.TYPE) {
      return PrimitiveObjects.getByte ((byte) pValue);
    }
    else if (pClass == Short.class || pClass == Short.TYPE) {
      return PrimitiveObjects.getShort ((short) pValue);
    }
    else if (pClass == Integer.class || pClass == Integer.TYPE) {
      return PrimitiveObjects.getInteger ((int) pValue);
    }
    else if (pClass == Long.class || pClass == Long.TYPE) {
      return PrimitiveObjects.getLong ((long) pValue);
    }
    else if (pClass == Float.class || pClass == Float.TYPE) {
      return PrimitiveObjects.getFloat ((float) pValue);
    }
    else if (pClass == Double.class || pClass == Double.TYPE) {
      return PrimitiveObjects.getDouble ((double) pValue);
    }
    else {
      return PrimitiveObjects.getInteger (0);
    }
static java.lang.NumbercoerceToPrimitiveNumber(java.lang.Number pValue, java.lang.Class pClass)
Coerces a Number to the given primitive number class

    if (pClass == Byte.class || pClass == Byte.TYPE) {
      return PrimitiveObjects.getByte (pValue.byteValue ());
    }
    else if (pClass == Short.class || pClass == Short.TYPE) {
      return PrimitiveObjects.getShort (pValue.shortValue ());
    }
    else if (pClass == Integer.class || pClass == Integer.TYPE) {
      return PrimitiveObjects.getInteger (pValue.intValue ());
    }
    else if (pClass == Long.class || pClass == Long.TYPE) {
      return PrimitiveObjects.getLong (pValue.longValue ());
    }
    else if (pClass == Float.class || pClass == Float.TYPE) {
      return PrimitiveObjects.getFloat (pValue.floatValue ());
    }
    else if (pClass == Double.class || pClass == Double.TYPE) {
      return PrimitiveObjects.getDouble (pValue.doubleValue ());
    }
    else {
      return PrimitiveObjects.getInteger (0);
    }
static java.lang.NumbercoerceToPrimitiveNumber(java.lang.String pValue, java.lang.Class pClass)
Coerces a String to the given primitive number class

    if (pClass == Byte.class || pClass == Byte.TYPE) {
      return Byte.valueOf (pValue);
    }
    else if (pClass == Short.class || pClass == Short.TYPE) {
      return Short.valueOf (pValue);
    }
    else if (pClass == Integer.class || pClass == Integer.TYPE) {
      return Integer.valueOf (pValue);
    }
    else if (pClass == Long.class || pClass == Long.TYPE) {
      return Long.valueOf (pValue);
    }
    else if (pClass == Float.class || pClass == Float.TYPE) {
      return Float.valueOf (pValue);
    }
    else if (pClass == Double.class || pClass == Double.TYPE) {
      return Double.valueOf (pValue);
    }
    else {
      return PrimitiveObjects.getInteger (0);
    }
public static java.lang.StringcoerceToString(java.lang.Object pValue, Logger pLogger)
Coerces the specified value to a String

    if (pValue == null) {
      return "";
    }
    else if (pValue instanceof String) {
      return (String) pValue;
    }
    else {
      try {
	return pValue.toString ();
      }
      catch (Exception exc) {
	if (pLogger.isLoggingError ()) {
	  pLogger.logError (Constants.TOSTRING_EXCEPTION,
			    exc,
			    pValue.getClass ().getName ());
	}
	return "";
      }
    }
public static booleanisFloatingPointString(java.lang.Object pObject)
Returns true if the given string might contain a floating point number - i.e., it contains ".", "e", or "E"

    if (pObject instanceof String) {
      String str = (String) pObject;
      int len = str.length ();
      for (int i = 0; i < len; i++) {
	char ch = str.charAt (i);
	if (ch == '." ||
	    ch == 'e" ||
	    ch == 'E") {
	  return true;
	}
      }
      return false;
    }
    else {
      return false;
    }
public static booleanisFloatingPointType(java.lang.Object pObject)
Returns true if the given Object is of a floating point type

    return 
      pObject != null &&
      isFloatingPointType (pObject.getClass ());
public static booleanisFloatingPointType(java.lang.Class pClass)
Returns true if the given class is of a floating point type

    return
      pClass == Float.class ||
      pClass == Float.TYPE ||
      pClass == Double.class ||
      pClass == Double.TYPE;
public static booleanisIntegerType(java.lang.Object pObject)
Returns true if the given Object is of an integer type

    return 
      pObject != null &&
      isIntegerType (pObject.getClass ());
public static booleanisIntegerType(java.lang.Class pClass)
Returns true if the given class is of an integer type

    return
      pClass == Byte.class ||
      pClass == Byte.TYPE ||
      pClass == Short.class ||
      pClass == Short.TYPE ||
      pClass == Character.class ||
      pClass == Character.TYPE ||
      pClass == Integer.class ||
      pClass == Integer.TYPE ||
      pClass == Long.class ||
      pClass == Long.TYPE;
static booleanisPrimitiveNumberClass(java.lang.Class pClass)
Returns true if the given class is Byte, Short, Integer, Long, Float, Double

    return
      pClass == Byte.class ||
      pClass == Byte.TYPE ||
      pClass == Short.class ||
      pClass == Short.TYPE ||
      pClass == Integer.class ||
      pClass == Integer.TYPE ||
      pClass == Long.class ||
      pClass == Long.TYPE ||
      pClass == Float.class ||
      pClass == Float.TYPE ||
      pClass == Double.class ||
      pClass == Double.TYPE;