001: /*
002: * Copyright (c) 1998-2008 Caucho Technology -- all rights reserved
003: *
004: * This file is part of Resin(R) Open Source
005: *
006: * Each copy or derived work must preserve the copyright notice and this
007: * notice unmodified.
008: *
009: * Resin Open Source is free software; you can redistribute it and/or modify
010: * it under the terms of the GNU General Public License as published by
011: * the Free Software Foundation; either version 2 of the License, or
012: * (at your option) any later version.
013: *
014: * Resin Open Source is distributed in the hope that it will be useful,
015: * but WITHOUT ANY WARRANTY; without even the implied warranty of
016: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, or any warranty
017: * of NON-INFRINGEMENT. See the GNU General Public License for more
018: * details.
019: *
020: * You should have received a copy of the GNU General Public License
021: * along with Resin Open Source; if not, write to the
022: *
023: * Free Software Foundation, Inc.
024: * 59 Temple Place, Suite 330
025: * Boston, MA 02111-1307 USA
026: *
027: * @author Scott Ferguson
028: */
029:
030: package com.caucho.el;
031:
032: import com.caucho.vfs.WriteStream;
033:
034: import javax.el.ELContext;
035: import javax.el.ELException;
036: import java.io.IOException;
037: import java.math.BigDecimal;
038: import java.math.BigInteger;
039:
040: /**
041: * Represents the numeric comparison operation: le
042: */
043: public class LeExpr extends AbstractBooleanExpr {
044: private final Expr _left;
045: private final Expr _right;
046:
047: /**
048: * Creates a comparison expression
049: *
050: * @param op the lexical code for the operation
051: * @param left the left subexpression
052: * @param right the right subexpression
053: */
054: public LeExpr(Expr left, Expr right) {
055: _left = left;
056: _right = right;
057: }
058:
059: /**
060: * Returns true if this is a constant expression.
061: */
062: @Override
063: public boolean isConstant() {
064: return _left.isConstant() && _right.isConstant();
065: }
066:
067: /**
068: * Evaluate the expression as a boolean.
069: *
070: * @param env the variable environment
071: */
072: @Override
073: public boolean evalBoolean(ELContext env) throws ELException {
074: Object aObj = _left.getValue(env);
075: Object bObj = _right.getValue(env);
076:
077: if (aObj == bObj)
078: return true;
079:
080: if (aObj == null || bObj == null)
081: return false;
082:
083: Class aType = aObj.getClass();
084: Class bType = bObj.getClass();
085:
086: if (aObj instanceof BigDecimal || bObj instanceof BigDecimal) {
087: BigDecimal a = toBigDecimal(aObj, env);
088: BigDecimal b = toBigDecimal(bObj, env);
089:
090: return a.compareTo(b) <= 0;
091: }
092:
093: if (aType == Double.class || aType == Float.class
094: || bType == Double.class || bType == Float.class) {
095: double a = toDouble(aObj, env);
096: double b = toDouble(bObj, env);
097:
098: return a <= b;
099: }
100:
101: if (aType == BigInteger.class || bType == BigInteger.class) {
102: BigInteger a = toBigInteger(aObj, env);
103: BigInteger b = toBigInteger(bObj, env);
104:
105: return a.compareTo(b) <= 0;
106: }
107:
108: if (aObj instanceof Number || bObj instanceof Number) {
109: long a = toLong(aObj, env);
110: long b = toLong(bObj, env);
111:
112: return a <= b;
113: }
114:
115: if (aObj instanceof String || bObj instanceof String) {
116: String a = toString(aObj, env);
117: String b = toString(bObj, env);
118:
119: return a.compareTo(b) <= 0;
120: }
121:
122: if (aObj instanceof Comparable) {
123: int cmp = ((Comparable) aObj).compareTo(bObj);
124:
125: return cmp <= 0;
126: }
127:
128: if (bObj instanceof Comparable) {
129: int cmp = ((Comparable) bObj).compareTo(aObj);
130:
131: return cmp >= 0;
132: }
133:
134: ELException e = new ELException(L.l(
135: "can't compare {0} and {1}.", aObj, bObj));
136:
137: error(e, env);
138:
139: return false;
140: }
141:
142: /**
143: * Prints the code to create an LongLiteral.
144: */
145: @Override
146: public void printCreate(WriteStream os) throws IOException {
147: os.print("new com.caucho.el.LeExpr(");
148: _left.printCreate(os);
149: os.print(", ");
150: _right.printCreate(os);
151: os.print(")");
152: }
153:
154: /**
155: * Returns true for equal strings.
156: */
157: public boolean equals(Object o) {
158: if (!(o instanceof LeExpr))
159: return false;
160:
161: LeExpr expr = (LeExpr) o;
162:
163: return (_left.equals(expr._left) && _right.equals(expr._right));
164: }
165:
166: /**
167: * Returns a readable representation of the expr.
168: */
169: public String toString() {
170: return "(" + _left + " le " + _right + ")";
171: }
172: }
|