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: eq
042: */
043: public class EqExpr 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 EqExpr(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.equals(b);
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.equals(b);
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 (aType == Boolean.class || bType == Boolean.class) {
116: boolean a = toBoolean(aObj, env);
117: boolean b = toBoolean(bObj, env);
118:
119: return a == b;
120: }
121:
122: // XXX: enum
123:
124: if (aObj instanceof String || bObj instanceof String) {
125: String a = toString(aObj, env);
126: String b = toString(bObj, env);
127:
128: return a.equals(b);
129: }
130:
131: return aObj.equals(bObj);
132: }
133:
134: /**
135: * Prints the code to create an LongLiteral.
136: */
137: @Override
138: public void printCreate(WriteStream os) throws IOException {
139: os.print("new com.caucho.el.EqExpr(");
140: _left.printCreate(os);
141: os.print(", ");
142: _right.printCreate(os);
143: os.print(")");
144: }
145:
146: /**
147: * Returns true for equal strings.
148: */
149: public boolean equals(Object o) {
150: if (!(o instanceof EqExpr))
151: return false;
152:
153: EqExpr expr = (EqExpr) o;
154:
155: return (_left.equals(expr._left) && _right.equals(expr._right));
156: }
157:
158: /**
159: * Returns a readable representation of the expr.
160: */
161: public String toString() {
162: return "(" + _left + " eq " + _right + ")";
163: }
164: }
|