/*
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to You under the Apache License, Version 2.0
    * (the "License"); you may not use this file except in compliance with
    * the License.  You may obtain a copy of the License at
    *
    *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * 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.commons.el;
  
  import java.beans.PropertyEditor;
  import java.beans.PropertyEditorManager;
  import java.math.BigDecimal;
  import java.math.BigInteger;
  
  import javax.servlet.jsp.el.ELException;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  /**
   *
   * <p>This class contains the logic for coercing data types before
   * operators are applied to them.
   *
   * <p>The following is the list of rules applied for various type
   * conversions.
   *
   * <ul><pre>
   * 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 <code>A.add(B)</code>
   *       if operator is -, return <code>A.subtract(B)</code>
   *       if operator is *, return <code>A.multiply(B)</code>
   *     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 apply operator
   *     if A or B is BigInteger, coerce both to BigInteger and then:
   *       if operator is +, return <code>A.add(B)</code>
   *       if operator is -, return <code>A.subtract(B)</code>
   *       if operator is *, return <code>A.multiply(B)</code>
   *     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
   *     if A or B is a BigDecimal or BigInteger, coerce both to BigDecimal and
   *      return <code>A.divide(B, BigDecimal.ROUND_HALF_UP)</code>
   *     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 BigDecimal, Float, Double, or String containing ".", "e" or "E"
   *       coerce both to Double
   *       apply operator
   *     if A or B is BigInteger, coerce both to BigInteger and return
   *      <code>A.remainder(B)</code>
   *     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 BigInteger or BigDecimal, return <code>A.negate()</code>
   *     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
  *   if A is Collection an ((Collection) 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 BigDecimal, coerce both A and B to BigDecimal and use the
  *      return value of <code>A.compareTo(B)</code>
  *     if A or B is Float or Double
  *       coerce both A and B to Double
  *       apply operator
  *     if A or B is BigInteger, coerce both A and B to BigInteger and use the
  *      return value of <code>A.compareTo(B)</code>
  *     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 BigDecimal, coerce both A and B to BigDecimal and then:
  *       if operator is == or eq, return <code>A.equals(B)</code>
  *       if operator is != or ne, return <code>!A.equals(B)</code>
  *     if A or B is Float or Double
  *       coerce both A and B to Double
  *       apply operator
  *     if A or B is BigInteger, coerce both A and B to BigInteger and then:
  *       if operator is == or eq, return <code>A.equals(B)</code>
  *       if operator is != or ne, return <code>!A.equals(B)</code>
  *     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 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, coerce quietly to type N using the following algorithm
  *         If N is BigInteger
  *             If A is BigDecimal, return <code>A.toBigInteger()</code>
  *             Otherwise, return <code>BigInteger.valueOf(A.longValue())</code>
  *        if N is BigDecimal
  *             If A is a BigInteger, return <code>new BigDecimal(A)</code>
  *             Otherwise, return <code>new BigDecimal(A.doubleValue())</code>
  *        If N is Byte, return <code>new Byte(A.byteValue())</code>
  *        If N is Short, return <code>new Short(A.shortValue())</code>
  *        If N is Integer, return <code>new Integer(A.integerValue())</code>
  *        If N is Long, return <code>new Long(A.longValue())</code>
  *        If N is Float, return <code>new Float(A.floatValue())</code>
  *        If N is Double, return <code>new Double(A.doubleValue())</code>
  *        otherwise ERROR
  *     A is String
  *       If N is BigDecimal then:
  *            If <code>new BigDecimal(A)</code> throws an exception then ERROR
  *            Otherwise, return <code>new BigDecimal(A)</code>
  *       If N is BigInteger then:
  *            If <code>new BigInteger(A)</code> throws an exception, then ERROR
  *            Otherwise, return <code>new BigInteger(A)</code>
  *       new <code>N.valueOf(A)</code> throws exception
  *         error
  *       return <code>N.valueOf(A)</code>
  *     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
  * </pre></ul>
  *
  * @author Nathan Abramson - Art Technology Group
  * @version $Change: 181177 $$DateTime: 2001/06/26 08:45:09 $$Author: bayard $
  **/
 
 public class Coercions
 {
     //-------------------------------------
     // Constants
     //-------------------------------------
    private static final Number ZERO = new Integer(0);
     private static Log log = LogFactory.getLog(Coercions.class);
     
   //-------------------------------------
   /**
    *
    * Coerces the given value to the specified class.
    **/
   public static Object coerce (Object pValue,
 			       Class pClass)
     throws ELException
   {
     if (pClass == String.class) {
       return coerceToString (pValue);
     }
     else if (isNumberClass (pClass)) {
       return coerceToPrimitiveNumber (pValue, pClass);
     }
     else if (pClass == Character.class ||
 	     pClass == Character.TYPE) {
       return coerceToCharacter (pValue);
     }
     else if (pClass == Boolean.class ||
 	     pClass == Boolean.TYPE) {
       return coerceToBoolean (pValue);
     }
     else {
       return coerceToObject (pValue, pClass);
     }
   }
 
   //-------------------------------------
   /**
    *
    * Returns true if the given class is Byte, Short, Integer, Long,
    * Float, Double, BigInteger, or BigDecimal
    **/
   static boolean isNumberClass (Class pClass)
   {
     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 ||
       pClass == BigInteger.class ||
       pClass == BigDecimal.class;
   }
 
   //-------------------------------------
   /**
    *
    * Coerces the specified value to a String
    **/
   public static String coerceToString (Object pValue)
     throws ELException
   {
     if (pValue == null) {
       return "";
     }
     else if (pValue instanceof String) {
       return (String) pValue;
     }
     else {
       try {
 	return pValue.toString ();
       }
       catch (Exception exc) {          
           if (log.isErrorEnabled()) {
               String message = MessageUtil.getMessageWithArgs(
                   Constants.TOSTRING_EXCEPTION,
                   pValue.getClass().getName());
               log.error(message, exc);
               throw new ELException(exc);
           }
           return "";	
       }
     }
   }
 
   //-------------------------------------
   /**
    *
    * Coerces a value to the given primitive number class
    **/
   public static Number coerceToPrimitiveNumber (Object pValue,
 						Class pClass)
     throws ELException
   {
     if (pValue == null ||
 	"".equals (pValue)) {
       return coerceToPrimitiveNumber (ZERO, pClass);
     }
     else if (pValue instanceof Character) {
       char val = ((Character) pValue).charValue ();
       return coerceToPrimitiveNumber (new Short((short) val), pClass);
     }
     else if (pValue instanceof Boolean) {
         if (log.isErrorEnabled()) {
             String message = MessageUtil.getMessageWithArgs(
                 Constants.BOOLEAN_TO_NUMBER, pValue, pClass.getName());
             log.error(message);
             throw new ELException(message);
         }
         return coerceToPrimitiveNumber(ZERO, 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 (log.isErrorEnabled()) {
               String message = MessageUtil.getMessageWithArgs(
                   Constants.STRING_TO_NUMBER_EXCEPTION,
                   (String) pValue, pClass.getName());
               log.error(message);
               throw new ELException(message);
           }	
 	    return coerceToPrimitiveNumber (ZERO, pClass);
       }
     }
     else {
         if (log.isErrorEnabled()) {
             String message = MessageUtil.getMessageWithArgs(
                 Constants.COERCE_TO_NUMBER,
                 pValue.getClass().getName(),
                 pClass.getName());
             log.error(message);
             throw new ELException(message);
         }      
       return coerceToPrimitiveNumber (0, pClass);
     }
   }
 
   //-------------------------------------
   /**
    *
    * Coerces a value to an Integer, returning null if the coercion
    * isn't possible.
    **/
   public static Integer coerceToInteger (Object pValue)
     throws ELException
   {
     if (pValue == null) {
       return null;
     }
     else if (pValue instanceof Character) {
       return PrimitiveObjects.getInteger 
 	((int) (((Character) pValue).charValue ()));
     }
     else if (pValue instanceof Boolean) {
         if (log.isWarnEnabled()) {
             log.warn(
                 MessageUtil.getMessageWithArgs(
                     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 (log.isWarnEnabled()) {
               log.warn(
                   MessageUtil.getMessageWithArgs(
                       Constants.STRING_TO_NUMBER_EXCEPTION,
                       (String) pValue,
                       Integer.class.getName()));            
           }	
 	return null;
       }
     }
     else {
         if (log.isWarnEnabled()) {
             log.warn(
                 MessageUtil.getMessageWithArgs(
                     Constants.COERCE_TO_NUMBER,
                     pValue.getClass().getName(),
                     Integer.class.getName()));
         }
       return null;
     }
   }
 
   //-------------------------------------
   /**
    *
    * Coerces a long to the given primitive number class
    **/
   static Number coerceToPrimitiveNumber (long pValue,
 					 Class pClass)
     throws ELException
   {
     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 (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);
     }
   }
 
   //-------------------------------------
   /**
    *
    * Coerces a double to the given primitive number class
    **/
   static Number coerceToPrimitiveNumber (double pValue,
 					 Class pClass)
     throws ELException
   {
     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 (pValue);
     }
     else {
       return PrimitiveObjects.getInteger (0);
     }
   }
 
   //-------------------------------------
   /**
    *
    * Coerces a Number to the given primitive number class
    **/
   static Number coerceToPrimitiveNumber (Number pValue, Class pClass)
     throws ELException
   {
     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 if (pClass == BigInteger.class) {
         if (pValue instanceof BigDecimal)
             return ((BigDecimal) pValue).toBigInteger();
         else
             return BigInteger.valueOf(pValue.longValue());
     }
     else if (pClass == BigDecimal.class) {
         if (pValue instanceof BigInteger)
             return new BigDecimal((BigInteger) pValue);
         else
             return new BigDecimal(pValue.doubleValue());
     }
     else {
       return PrimitiveObjects.getInteger (0);
     }
   }
 
   //-------------------------------------
   /**
    *
    * Coerces a String to the given primitive number class
    **/
   static Number coerceToPrimitiveNumber (String pValue, Class pClass)
     throws ELException
   {
     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 if (pClass == BigInteger.class) {
         return new BigInteger(pValue);
     }
     else if (pClass == BigDecimal.class) {
         return new BigDecimal(pValue);
     }
     else {
       return PrimitiveObjects.getInteger (0);
     }
   }
 
   //-------------------------------------
   /**
    *
    * Coerces a value to a Character
    **/
   public static Character coerceToCharacter (Object pValue)
     throws ELException
   {
     if (pValue == null ||
 	"".equals (pValue)) {
       return PrimitiveObjects.getCharacter ((char) 0);
     }
     else if (pValue instanceof Character) {
       return (Character) pValue;
     }
     else if (pValue instanceof Boolean) {
         if (log.isErrorEnabled()) {
             String message = MessageUtil.getMessageWithArgs(
                 Constants.BOOLEAN_TO_CHARACTER, pValue);
             log.error(message);
             throw new ELException(message);
         }     
       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 (log.isErrorEnabled()) {
             String message = MessageUtil.getMessageWithArgs(
                 Constants.COERCE_TO_CHARACTER,
                 pValue.getClass().getName());
             log.error(message);
             throw new ELException(message);
         }     
       return PrimitiveObjects.getCharacter ((char) 0);
     }
   }
 
   //-------------------------------------
   /**
    *
    * Coerces a value to a Boolean
    **/
   public static Boolean coerceToBoolean (Object pValue)
     throws ELException
   {
     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 (log.isErrorEnabled()) {
               String message = MessageUtil.getMessageWithArgs(
                   Constants.STRING_TO_BOOLEAN, (String) pValue);
               log.error(message, exc);
               throw new ELException(message, exc);
           }	
 	return Boolean.FALSE;
       }
     }
     else {
         if (log.isErrorEnabled()) {
             String message = MessageUtil.getMessageWithArgs(
                 Constants.COERCE_TO_BOOLEAN,
                 pValue.getClass().getName());
             log.error(message);
             throw new ELException(message);
         }     
       return Boolean.TRUE;
     }
   }
 
   //-------------------------------------
   /**
    *
    * Coerces a value to the specified Class that is not covered by any
    * of the above cases
    **/
   public static Object coerceToObject (Object pValue, Class pClass)
     throws ELException
   {
     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 (log.isErrorEnabled()) {
             String message = MessageUtil.getMessageWithArgs(
                 Constants.NO_PROPERTY_EDITOR,
                 str, pClass.getName());
             log.error(message);
             throw new ELException(message);
         }	  
 	  return null;
 	}
       }
       try {
 	pe.setAsText (str);
 	return pe.getValue ();
       }
       catch (IllegalArgumentException exc) {
 	if ("".equals (str)) {
 	  return null;
 	}
 	else {
         if (log.isErrorEnabled()) {
             String message = MessageUtil.getMessageWithArgs(
                 Constants.PROPERTY_EDITOR_ERROR,
                 pValue,
                 pClass.getName());
             log.error(message, exc);
             throw new ELException(message, exc);
         }	  
 	  return null;
 	}
       }
     }
     else {
         if (log.isErrorEnabled()) {
             String message = MessageUtil.getMessageWithArgs(
                 Constants.COERCE_TO_OBJECT,
                 pValue.getClass().getName(),
                 pClass.getName());
             log.error(message);
             throw new ELException(message);
         }     
       return null;
     }
   }
 
   //-------------------------------------
   // Applying operators
   //-------------------------------------
   /**
    *
    * Performs all of the necessary type conversions, then calls on the
    * appropriate operator.
    **/
   public static Object applyArithmeticOperator 
     (Object pLeft,
      Object pRight,
      ArithmeticOperator pOperator)
     throws ELException
   {
     if (pLeft == null &&
 	pRight == null) {
         if (log.isWarnEnabled()) {
             log.warn(
                 MessageUtil.getMessageWithArgs(
                     Constants.ARITH_OP_NULL,
                     pOperator.getOperatorSymbol()));
         }    
       return PrimitiveObjects.getInteger (0);
     }
 
     else if (isBigDecimal(pLeft) || isBigDecimal(pRight)) {
         BigDecimal left = (BigDecimal)
             coerceToPrimitiveNumber(pLeft, BigDecimal.class);
         BigDecimal right = (BigDecimal)
             coerceToPrimitiveNumber(pRight, BigDecimal.class);
         return pOperator.apply(left, right);
     }
 
     else if (isFloatingPointType(pLeft) ||
         isFloatingPointType(pRight) ||
         isFloatingPointString(pLeft) ||
         isFloatingPointString(pRight)) {
         if (isBigInteger(pLeft) || isBigInteger(pRight)) {
             BigDecimal left = (BigDecimal)
                 coerceToPrimitiveNumber(pLeft, BigDecimal.class);
             BigDecimal right = (BigDecimal)
                 coerceToPrimitiveNumber(pRight, BigDecimal.class);
             return pOperator.apply(left, right);
         } else {
             double left =
                 coerceToPrimitiveNumber(pLeft, Double.class).
                 doubleValue();
             double right =
                 coerceToPrimitiveNumber(pRight, Double.class).
                 doubleValue();
             return
                 PrimitiveObjects.getDouble(pOperator.apply(left, right));
         }
     }
 
     else if (isBigInteger(pLeft) || isBigInteger(pRight)) {
         BigInteger left = (BigInteger)
             coerceToPrimitiveNumber(pLeft, BigInteger.class);
         BigInteger right = (BigInteger)
             coerceToPrimitiveNumber(pRight, BigInteger.class);
         return pOperator.apply(left, right);
     }
 
     else {
       long left =
 	coerceToPrimitiveNumber (pLeft, Long.class).
 	longValue ();
       long right =
 	coerceToPrimitiveNumber (pRight, Long.class).
 	longValue ();
       return
 	PrimitiveObjects.getLong (pOperator.apply (left, right));
     }
   }
 
   //-------------------------------------
   /**
    *
    * Performs all of the necessary type conversions, then calls on the
    * appropriate operator.
    **/
   public static Object applyRelationalOperator 
     (Object pLeft,
      Object pRight,
      RelationalOperator pOperator)
     throws ELException
   {
     if (isBigDecimal(pLeft) || isBigDecimal(pRight)) {
         BigDecimal left = (BigDecimal)
             coerceToPrimitiveNumber(pLeft, BigDecimal.class);
         BigDecimal right = (BigDecimal)
             coerceToPrimitiveNumber(pRight, BigDecimal.class);
         return PrimitiveObjects.getBoolean(pOperator.apply(left, right));
     }
 
     else if (isFloatingPointType (pLeft) ||
 	isFloatingPointType (pRight)) {
       double left =
 	coerceToPrimitiveNumber (pLeft, Double.class).
 	doubleValue ();
       double right =
 	coerceToPrimitiveNumber (pRight, Double.class).
 	doubleValue ();
       return 
 	PrimitiveObjects.getBoolean (pOperator.apply (left, right));
     }
 
     else if (isBigInteger(pLeft) || isBigInteger(pRight)) {
         BigInteger left = (BigInteger)
             coerceToPrimitiveNumber(pLeft, BigInteger.class);
         BigInteger right = (BigInteger)
             coerceToPrimitiveNumber(pRight, BigInteger.class);
         return PrimitiveObjects.getBoolean(pOperator.apply(left, right));
     }
 
     else if (isIntegerType (pLeft) ||
 	     isIntegerType (pRight)) {
       long left =
 	coerceToPrimitiveNumber (pLeft, Long.class).
 	longValue ();
       long right =
 	coerceToPrimitiveNumber (pRight, Long.class).
 	longValue ();
       return
 	PrimitiveObjects.getBoolean (pOperator.apply (left, right));
     }
 
     else if (pLeft instanceof String ||
 	     pRight instanceof String) {
       String left = coerceToString (pLeft);
       String right = coerceToString (pRight);
       return
 	PrimitiveObjects.getBoolean (pOperator.apply (left, right));
     }
 
     else if (pLeft instanceof Comparable) {
       try {
 	int result = ((Comparable) pLeft).compareTo (pRight);
 	return
 	  PrimitiveObjects.getBoolean 
 	  (pOperator.apply (result, -result));
       }
       catch (Exception exc) {
           if (log.isErrorEnabled()) {
               String message = MessageUtil.getMessageWithArgs(
                   Constants.COMPARABLE_ERROR,
                   pLeft.getClass().getName(),
                   (pRight == null) ? "null" : pRight.getClass().getName(),
                   pOperator.getOperatorSymbol());
               log.error(message, exc);
               throw new ELException(message, exc);
           }	
 	return Boolean.FALSE;
       }
     }
 
     else if (pRight instanceof Comparable) {
       try {
 	int result = ((Comparable) pRight).compareTo (pLeft);
 	return
 	  PrimitiveObjects.getBoolean 
 	  (pOperator.apply (-result, result));
       }
       catch (Exception exc) {
           if (log.isErrorEnabled()) {
               String message = MessageUtil.getMessageWithArgs(
                   Constants.COMPARABLE_ERROR,
                   pRight.getClass().getName(),
                   (pLeft == null) ? "null" : pLeft.getClass().getName(),
                   pOperator.getOperatorSymbol());
               log.error(message, exc);
               throw new ELException(message, exc);
           }		
 	return Boolean.FALSE;
       }
     }
 
     else {
         if (log.isErrorEnabled()) {
             String message = MessageUtil.getMessageWithArgs(
                 Constants.ARITH_OP_BAD_TYPE,
                 pOperator.getOperatorSymbol(),
                 pLeft.getClass().getName(),
                 pRight.getClass().getName());
             log.error(message);
             throw new ELException(message);
         }     
       return Boolean.FALSE;
     }
   }
 
   //-------------------------------------
   /**
    *
    * Performs all of the necessary type conversions, then calls on the
    * appropriate operator.
    **/
   public static Object applyEqualityOperator 
     (Object pLeft,
      Object pRight,
      EqualityOperator pOperator)
     throws ELException
   {
     if (pLeft == pRight) {
       return PrimitiveObjects.getBoolean (pOperator.apply (true));
     }
 
     else if (pLeft == null ||
 	     pRight == null) {
       return PrimitiveObjects.getBoolean (pOperator.apply (false));
     }
 
     else if (isBigDecimal(pLeft) || isBigDecimal(pRight)) {
         BigDecimal left = (BigDecimal)
             coerceToPrimitiveNumber(pLeft, BigDecimal.class);
         BigDecimal right = (BigDecimal)
             coerceToPrimitiveNumber(pRight, BigDecimal.class);
         return PrimitiveObjects.getBoolean(pOperator.apply(left.equals(right)));
     }
 
     else if (isFloatingPointType (pLeft) ||
 	     isFloatingPointType (pRight)) {
       double left =
 	coerceToPrimitiveNumber (pLeft, Double.class).
 	doubleValue ();
       double right =
 	coerceToPrimitiveNumber (pRight, Double.class).
 	doubleValue ();
       return 
 	PrimitiveObjects.getBoolean 
 	(pOperator.apply (left == right));
     }
 
     else if (isBigInteger(pLeft) || isBigInteger(pRight)) {
         BigInteger left = (BigInteger)
             coerceToPrimitiveNumber(pLeft, BigInteger.class);
         BigInteger right = (BigInteger)
             coerceToPrimitiveNumber(pRight, BigInteger.class);
         return PrimitiveObjects.getBoolean(pOperator.apply(left.equals(right)));
     }
 
     else if (isIntegerType (pLeft) ||
 	     isIntegerType (pRight)) {
       long left =
 	coerceToPrimitiveNumber (pLeft, Long.class).
 	longValue ();
       long right =
 	coerceToPrimitiveNumber (pRight, Long.class).
 	longValue ();
       return
 	PrimitiveObjects.getBoolean 
 	(pOperator.apply (left == right));
     }
 
     else if (pLeft instanceof Boolean ||
 	     pRight instanceof Boolean) {
       boolean left = coerceToBoolean (pLeft).booleanValue ();
       boolean right = coerceToBoolean (pRight).booleanValue ();
       return
 	PrimitiveObjects.getBoolean 
 	(pOperator.apply (left == right));
     }
 
     else if (pLeft instanceof String ||
 	     pRight instanceof String) {
       String left = coerceToString (pLeft);
       String right = coerceToString (pRight);
       return
 	PrimitiveObjects.getBoolean 
 	(pOperator.apply (left.equals (right)));
     }
 
     else {
       try {
       return
 	PrimitiveObjects.getBoolean
 	(pOperator.apply (pLeft.equals (pRight)));
       }
       catch (Exception exc) {
           if (log.isErrorEnabled()) {
               String message = MessageUtil.getMessageWithArgs(
                   Constants.ERROR_IN_EQUALS,
                   pLeft.getClass().getName(),
                   pRight.getClass().getName(),
                   pOperator.getOperatorSymbol());
               log.error(message, exc);
               throw new ELException(message, exc);
           }	
 	return Boolean.FALSE;
       }
     }
   }
 
   //-------------------------------------
   /**
    *
    * Returns true if the given Object is of a floating point type
    **/
   public static boolean isFloatingPointType (Object pObject)
   {
     return 
       pObject != null &&
       isFloatingPointType (pObject.getClass ());
   }
 
   //-------------------------------------
   /**
    *
    * Returns true if the given class is of a floating point type
    **/
   public static boolean isFloatingPointType (Class pClass)
   {
     return
       pClass == Float.class ||
       pClass == Float.TYPE ||
       pClass == Double.class ||
       pClass == Double.TYPE;
   }
 
   //-------------------------------------
   /**
    *
    * Returns true if the given string might contain a floating point
    * number - i.e., it contains ".", "e", or "E"
    **/
   public static boolean isFloatingPointString (Object pObject)
   {
     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;
     }
   }
 
   //-------------------------------------
   /**
    *
    * Returns true if the given Object is of an integer type
    **/
   public static boolean isIntegerType (Object pObject)
   {
     return 
       pObject != null &&
       isIntegerType (pObject.getClass ());
   }
 
   //-------------------------------------
   /**
    *
    * Returns true if the given class is of an integer type
    **/
   public static boolean isIntegerType (Class pClass)
   {
     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;
   }
 
   //-------------------------------------
 
   /**
    * Returns true if the given object is BigInteger.
    * @param pObject - Object to evaluate
    * @return - true if the given object is BigInteger
    */
   public static boolean isBigInteger(Object pObject) {
       return
           pObject != null && pObject instanceof BigInteger;
   }
 
   /**
    * Returns true if the given object is BigDecimal.
    * @param pObject - Object to evaluate
    * @return - true if the given object is BigDecimal
    */
   public static boolean isBigDecimal(Object pObject) {
       return
           pObject != null && pObject instanceof BigDecimal;
   }
 }