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: gt
042: */
043: public class GtExpr 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 GtExpr(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 == null || bObj == null)
078: return false;
079:
080: Class aType = aObj.getClass();
081: Class bType = bObj.getClass();
082:
083: if (aObj instanceof BigDecimal || bObj instanceof BigDecimal) {
084: BigDecimal a = toBigDecimal(aObj, env);
085: BigDecimal b = toBigDecimal(bObj, env);
086:
087: return a.compareTo(b) > 0;
088: }
089:
090: if (aType == Double.class || aType == Float.class
091: || bType == Double.class || bType == Float.class) {
092: double a = toDouble(aObj, env);
093: double b = toDouble(bObj, env);
094:
095: return a > b;
096: }
097:
098: if (aType == BigInteger.class || bType == BigInteger.class) {
099: BigInteger a = toBigInteger(aObj, env);
100: BigInteger b = toBigInteger(bObj, env);
101:
102: return a.compareTo(b) > 0;
103: }
104:
105: if (aObj instanceof Number || bObj instanceof Number) {
106: long a = toLong(aObj, env);
107: long b = toLong(bObj, env);
108:
109: return a > b;
110: }
111:
112: if (aObj instanceof String || bObj instanceof String) {
113: String a = toString(aObj, env);
114: String b = toString(bObj, env);
115:
116: return a.compareTo(b) > 0;
117: }
118:
119: if (aObj instanceof Comparable) {
120: int cmp = ((Comparable) aObj).compareTo(bObj);
121:
122: return cmp > 0;
123: }
124:
125: if (bObj instanceof Comparable) {
126: int cmp = ((Comparable) bObj).compareTo(aObj);
127:
128: return cmp < 0;
129: }
130:
131: ELException e = new ELException(L.l(
132: "can't compare {0} and {1}.", aObj, bObj));
133:
134: error(e, env);
135:
136: return false;
137: }
138:
139: /**
140: * Prints the code to create an LongLiteral.
141: */
142: @Override
143: public void printCreate(WriteStream os) throws IOException {
144: os.print("new com.caucho.el.GtExpr(");
145: _left.printCreate(os);
146: os.print(", ");
147: _right.printCreate(os);
148: os.print(")");
149: }
150:
151: /**
152: * Returns true for equal strings.
153: */
154: public boolean equals(Object o) {
155: if (!(o instanceof GtExpr))
156: return false;
157:
158: GtExpr expr = (GtExpr) o;
159:
160: return (_left.equals(expr._left) && _right.equals(expr._right));
161: }
162:
163: /**
164: * Returns a readable representation of the expr.
165: */
166: public String toString() {
167: return "(" + _left + " gt " + _right + ")";
168: }
169: }
|