From imperius-commits-return-123-apmail-incubator-imperius-commits-archive=incubator.apache.org@incubator.apache.org Sat Jan 12 18:09:49 2008 Return-Path: Delivered-To: apmail-incubator-imperius-commits-archive@locus.apache.org Received: (qmail 55408 invoked from network); 12 Jan 2008 18:09:49 -0000 Received: from hermes.apache.org (HELO mail.apache.org) (140.211.11.2) by minotaur.apache.org with SMTP; 12 Jan 2008 18:09:49 -0000 Received: (qmail 73583 invoked by uid 500); 12 Jan 2008 18:09:39 -0000 Delivered-To: apmail-incubator-imperius-commits-archive@incubator.apache.org Received: (qmail 73570 invoked by uid 500); 12 Jan 2008 18:09:39 -0000 Mailing-List: contact imperius-commits-help@incubator.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: imperius-dev@incubator.apache.org Delivered-To: mailing list imperius-commits@incubator.apache.org Delivered-To: moderator for imperius-commits@incubator.apache.org Received: (qmail 29186 invoked by uid 99); 11 Jan 2008 18:59:21 -0000 X-ASF-Spam-Status: No, hits=-100.0 required=10.0 tests=ALL_TRUSTED X-Spam-Check-By: apache.org Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: svn commit: r611261 [12/43] - in /incubator/imperius/trunk: ./ imperius-javaspl/ imperius-javaspl/src/main/java/org/apache/imperius/javaspl/ imperius-splcore/ imperius-splcore/src/main/antlr/org/apache/imperius/spl/parser/compiler/ imperius-splcore/src... Date: Fri, 11 Jan 2008 18:57:14 -0000 To: imperius-commits@incubator.apache.org From: kevan@apache.org X-Mailer: svnmailer-1.0.8 Message-Id: <20080111185841.ABE941A9864@eris.apache.org> X-Virus-Checked: Checked by ClamAV on apache.org Modified: incubator/imperius/trunk/imperius-splcore/src/main/java/org/apache/imperius/spl/parser/expressions/impl/Addition.java URL: http://svn.apache.org/viewvc/incubator/imperius/trunk/imperius-splcore/src/main/java/org/apache/imperius/spl/parser/expressions/impl/Addition.java?rev=611261&r1=611260&r2=611261&view=diff ============================================================================== --- incubator/imperius/trunk/imperius-splcore/src/main/java/org/apache/imperius/spl/parser/expressions/impl/Addition.java (original) +++ incubator/imperius/trunk/imperius-splcore/src/main/java/org/apache/imperius/spl/parser/expressions/impl/Addition.java Fri Jan 11 10:56:30 2008 @@ -1,180 +1,180 @@ -/* - * Licensed 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. - */ -// - -/** - * - * @author Xiping Change Log: 3/9/07: Neeraj Joshi: Changed signature to take a - * list of expressions and boolean This will help in reflection 3/9/07: - * Neeraj Joshi: Updated the method for determining return type to use - * binary numeric promotion - * - */ - -package org.apache.imperius.spl.parser.expressions.impl; - -import java.util.List; -import java.util.logging.Logger; - -import org.apache.imperius.spl.external.TypeConstants; -import org.apache.imperius.spl.parser.exceptions.IllegalExpressionTypeException; -import org.apache.imperius.spl.parser.exceptions.SPLException; -import org.apache.imperius.spl.parser.expressions.DoubleArgumentExpression; -import org.apache.imperius.spl.parser.expressions.NumericExpression; -import org.apache.imperius.spl.parser.util.TypeInfo; -import org.apache.imperius.spl.parser.util.TypeResolver; -import org.apache.imperius.util.SPLLogger; - - - -public class Addition extends DoubleArgumentExpression implements - NumericExpression -{ - - public static final String className = Addition.class.getName(); - - private static Logger logger = SPLLogger.getSPLLogger().getLogger(); - private static final String sourceClass="Addition"; - - - - public Addition(List exprList, boolean evaluateExpression) - throws SPLException - { - super(exprList); - logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "Addition"); - - - if (evaluateExpression) - { - - if (!validate()) - { - - logger.severe(Thread.currentThread().getName()+" "+"validation error: wrong data type passed into " - + className + "."); - - throw new SPLException( - "validation error: wrong data type passed into " - + className + "."); - } - } - - logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "Addition"); - - } - - public Object evaluate() throws SPLException - { - logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "evaluate"); - - try - { - Number lhs = (Number) _lhsExp.evaluate(); - Number rhs = (Number) _rhsExp.evaluate(); - logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "evaluate"); - - return plus(lhs, rhs); - } - catch (Exception e) - { - logger.severe(Thread.currentThread().getName()+" "+"evaluation error: " + e.toString()); - - throw new SPLException("evaluation error: " + e.toString()); - } - - } - - private static Number plus(Number o1, Number o2) - throws IllegalExpressionTypeException - { - logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "plus"); - - Number[] o = new Number[2]; - o[0] = o1; - o[1] = o2; - - int resolvedType = TypeResolver.resolveType(o); - - if (resolvedType == TypeConstants.doubleType) - { - logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "plus"); - - return new Double(o1.doubleValue() + o2.doubleValue()); - } - else if (resolvedType == TypeConstants.floatType) - { - logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "plus"); - - return new Float(o1.floatValue() + o2.floatValue()); - } - else if (resolvedType == TypeConstants.longType) - { - logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "plus"); - - return new Long(o1.longValue() + o2.longValue()); - } - else if (resolvedType == TypeConstants.shortType) - { - logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "plus"); - - return new Long(o1.shortValue() + o2.shortValue()); - } - else if (resolvedType == TypeConstants.byteType) - { - logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "plus"); - - return new Long(o1.byteValue() + o2.byteValue()); - } - else - { - logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "plus"); - - return new Integer(o1.intValue() + o2.intValue()); - } - } - - public boolean validate() throws SPLException - { - logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "validate"); - - TypeInfo lType = _lhsExp.getType(); - TypeInfo rType = _rhsExp.getType(); - - // dataType = TypeConstants.numericType; - if (TypeResolver.isNumeric(lType) && TypeResolver.isNumeric(rType) && - !lType.getIsArray() && !rType.getIsArray()) - { - _dataType = TypeResolver.binaryNumericPromotionResolver(lType, rType); - logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validate"); - - return true; - } - - logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validate"); - - return false; - } - - public String toString() - { - logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "toString"); - - String str = this._lhsExp.toString() + " + " + this._rhsExp.toString(); - - logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "toString"); - - return str; - } -} +/* + * Licensed 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. + */ +// + +/** + * + * @author Xiping Change Log: 3/9/07: Neeraj Joshi: Changed signature to take a + * list of expressions and boolean This will help in reflection 3/9/07: + * Neeraj Joshi: Updated the method for determining return type to use + * binary numeric promotion + * + */ + +package org.apache.imperius.spl.parser.expressions.impl; + +import java.util.List; +import java.util.logging.Logger; + +import org.apache.imperius.spl.external.TypeConstants; +import org.apache.imperius.spl.parser.exceptions.IllegalExpressionTypeException; +import org.apache.imperius.spl.parser.exceptions.SPLException; +import org.apache.imperius.spl.parser.expressions.DoubleArgumentExpression; +import org.apache.imperius.spl.parser.expressions.NumericExpression; +import org.apache.imperius.spl.parser.util.TypeInfo; +import org.apache.imperius.spl.parser.util.TypeResolver; +import org.apache.imperius.util.SPLLogger; + + + +public class Addition extends DoubleArgumentExpression implements + NumericExpression +{ + + public static final String className = Addition.class.getName(); + + private static Logger logger = SPLLogger.getSPLLogger().getLogger(); + private static final String sourceClass="Addition"; + + + + public Addition(List exprList, boolean evaluateExpression) + throws SPLException + { + super(exprList); + logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "Addition"); + + + if (evaluateExpression) + { + + if (!validate()) + { + + logger.severe(Thread.currentThread().getName()+" "+"validation error: wrong data type passed into " + + className + "."); + + throw new SPLException( + "validation error: wrong data type passed into " + + className + "."); + } + } + + logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "Addition"); + + } + + public Object evaluate() throws SPLException + { + logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "evaluate"); + + try + { + Number lhs = (Number) _lhsExp.evaluate(); + Number rhs = (Number) _rhsExp.evaluate(); + logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "evaluate"); + + return plus(lhs, rhs); + } + catch (Exception e) + { + logger.severe(Thread.currentThread().getName()+" "+"evaluation error: " + e.toString()); + + throw new SPLException("evaluation error: " + e.toString()); + } + + } + + private static Number plus(Number o1, Number o2) + throws IllegalExpressionTypeException + { + logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "plus"); + + Number[] o = new Number[2]; + o[0] = o1; + o[1] = o2; + + int resolvedType = TypeResolver.resolveType(o); + + if (resolvedType == TypeConstants.doubleType) + { + logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "plus"); + + return new Double(o1.doubleValue() + o2.doubleValue()); + } + else if (resolvedType == TypeConstants.floatType) + { + logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "plus"); + + return new Float(o1.floatValue() + o2.floatValue()); + } + else if (resolvedType == TypeConstants.longType) + { + logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "plus"); + + return new Long(o1.longValue() + o2.longValue()); + } + else if (resolvedType == TypeConstants.shortType) + { + logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "plus"); + + return new Long(o1.shortValue() + o2.shortValue()); + } + else if (resolvedType == TypeConstants.byteType) + { + logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "plus"); + + return new Long(o1.byteValue() + o2.byteValue()); + } + else + { + logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "plus"); + + return new Integer(o1.intValue() + o2.intValue()); + } + } + + public boolean validate() throws SPLException + { + logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "validate"); + + TypeInfo lType = _lhsExp.getType(); + TypeInfo rType = _rhsExp.getType(); + + // dataType = TypeConstants.numericType; + if (TypeResolver.isNumeric(lType) && TypeResolver.isNumeric(rType) && + !lType.getIsArray() && !rType.getIsArray()) + { + _dataType = TypeResolver.binaryNumericPromotionResolver(lType, rType); + logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validate"); + + return true; + } + + logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validate"); + + return false; + } + + public String toString() + { + logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "toString"); + + String str = this._lhsExp.toString() + " + " + this._rhsExp.toString(); + + logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "toString"); + + return str; + } +} Propchange: incubator/imperius/trunk/imperius-splcore/src/main/java/org/apache/imperius/spl/parser/expressions/impl/Addition.java ------------------------------------------------------------------------------ svn:eol-style = native Modified: incubator/imperius/trunk/imperius-splcore/src/main/java/org/apache/imperius/spl/parser/expressions/impl/AllInCollection.java URL: http://svn.apache.org/viewvc/incubator/imperius/trunk/imperius-splcore/src/main/java/org/apache/imperius/spl/parser/expressions/impl/AllInCollection.java?rev=611261&r1=611260&r2=611261&view=diff ============================================================================== --- incubator/imperius/trunk/imperius-splcore/src/main/java/org/apache/imperius/spl/parser/expressions/impl/AllInCollection.java (original) +++ incubator/imperius/trunk/imperius-splcore/src/main/java/org/apache/imperius/spl/parser/expressions/impl/AllInCollection.java Fri Jan 11 10:56:30 2008 @@ -1,474 +1,474 @@ -/* - * Licensed 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. - */ -// - -/** - * @author Prashant Baliga - * - */ - -package org.apache.imperius.spl.parser.expressions.impl; - -import java.util.ArrayList; -import java.util.Iterator; -import java.util.List; -import java.util.logging.Logger; - -import org.apache.imperius.spl.external.Expression; -import org.apache.imperius.spl.external.TypeConstants; -import org.apache.imperius.spl.parser.exceptions.IllegalParameterTypeException; -import org.apache.imperius.spl.parser.exceptions.SPLException; -import org.apache.imperius.spl.parser.expressions.TripleArgumentExpression; -import org.apache.imperius.spl.parser.util.ExpressionUtility; -import org.apache.imperius.spl.parser.util.TypeInfo; -import org.apache.imperius.spl.parser.util.TypeResolver; -import org.apache.imperius.util.SPLLogger; - - -public class AllInCollection extends TripleArgumentExpression implements - Expression -{ - - public String className = InCollection.class.toString(); - - public List expressionList = null; - - public String operationString = null; - - private static Logger logger = SPLLogger.getSPLLogger().getLogger(); - private static final String sourceClass="AllInCollection"; - - - - public static final String LOR = "OR"; - - public static final String LAND = "AND"; - - public static final String BXOR = "XOR"; - - public static final String NOT_EQUAL = "NOT_EQUAL"; - - public static final String EQUAL = "EQUAL"; - - public static final String LT = "LESS"; - - public static final String GT = "GREATER"; - - public static final String LE = "LESS_OR_EQUAL"; - - public static final String GE = "GREATER_OR_EQUAL"; - - public static final String PLUS = "PLUS"; - - public static final String MINUS = "MINUS"; - - public static final String STAR = "MULTIPLY"; - - public static final String DIV = "DIVIDE"; - - public AllInCollection(List exprList, boolean evaluateExpression) - throws SPLException - { - super(exprList); - - logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "AllInCollection"); - - //System.out.println("AllInCollection"); - if (evaluateExpression) - { - //System.out.println("evaluateExpression " + evaluateExpression); - if (!validate()) - { - - logger.severe( - "validation error: wrong data type passed in " - + this._dataType); - - throw new SPLException( - "validation error: wrong data type passed in " - + this._dataType); - } - } - _dataType.setType(TypeConstants.booleanType); - this._dataType.setIsArray(false); - logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "AllInCollection"); - - } - - public Object evaluate() throws SPLException - { - logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "evaluate"); - //System.out.println("AllInCollection:evaluate"); - Expression lhsExpression = (Expression) this._lhsExp; - Expression rhsExpression = (Expression) this._rhsExp; - - if (rhsExpression.isArray()) - { - //System.out.println("rhs is of type Basic Collection"); - Object rhsResult = rhsExpression.evaluate(); - //System.out.println("rhsResult , class " + rhsResult + " "+ rhsResult.getClass()); - if (!(rhsResult instanceof java.util.List)) - { - - logger.severe( - "rhsResult is not of type List"); - - throw new SPLException("rhsResult is not of type List"); - } - Boolean result = Boolean.FALSE; - ArrayList rhsResultArray = (ArrayList) rhsResult; - //System.out.println("resultArray size " + rhsResultArray.size()+ " to string " + rhsResultArray.toString()); - //System.out.println("LHS expression is of type "+ lhsExpression.getType()); - if ((rhsResultArray != null) && (!rhsResultArray.isEmpty())) - { - Object lhsResult = (Object) lhsExpression.evaluate(); - //System.out.println("lhsResult " + lhsResult.toString()); - Iterator rhsResultIt = rhsResultArray.iterator(); - while (rhsResultIt.hasNext()) - { - Object value = (Object) rhsResultIt.next(); - //System.out.println("rhsResult element " + value.toString()); - //System.out.println("operationString " + operationString); - if (operationString.equalsIgnoreCase(LAND)) - { - if ((!(value instanceof Boolean)) - || (!(lhsResult instanceof Boolean))) - { - logger.severe( - "LHS or RHS result is not of type Boolean"); - - throw new SPLException( - "LHS or RHS result is not of type Boolean"); - } - else - { - Boolean Value1 = (Boolean) lhsResult; - Boolean Value2 = (Boolean) value; - boolean res = Value1.booleanValue() - && Value2.booleanValue(); - if (!res) - { - logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "AllInCollection"); - - return new Boolean(!res); - } - } - } - else if (operationString.equalsIgnoreCase(LOR)) - { - if ((!(value instanceof Boolean)) - || (!(lhsResult instanceof Boolean))) - { - logger.severe( - "LHS or RHS result is not of type Boolean"); - - throw new SPLException( - "LHS or RHS result is not of type Boolean"); - } - else - { - Boolean Value1 = (Boolean) lhsResult; - Boolean Value2 = (Boolean) value; - boolean res = Value1.booleanValue() - || Value2.booleanValue(); - if (!res) - { - logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "AllInCollection"); - - return new Boolean(!res); - } - } - - } - else if (operationString.equalsIgnoreCase(BXOR)) - { - if ((!(value instanceof Boolean)) - || (!(lhsResult instanceof Boolean))) - { - logger.severe( - "LHS or RHS result is not of type Boolean"); - - throw new SPLException( - "LHS or RHS result is not of type Boolean"); - } - else - { - Boolean Value1 = (Boolean) lhsResult; - Boolean Value2 = (Boolean) value; - boolean res = (Value1.booleanValue() && !Value2 - .booleanValue()) - || (!Value1.booleanValue() && Value2 - .booleanValue()); - if (!res) - { - logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "AllInCollection"); - - return new Boolean(!res); - } - } - - } - - else if (operationString.equalsIgnoreCase(EQUAL)) - { - Object Value1 = lhsResult; - Object Value2 = value; - if (!(ExpressionUtility.compare(Value2, Value1) == 0)) - { - logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "AllInCollection"); - - return Boolean.FALSE; - } - } - else if (operationString.equalsIgnoreCase(NOT_EQUAL)) - { - Object Value1 = lhsResult; - Object Value2 = value; - if (!(ExpressionUtility.compare(Value2, Value1) != 0)) - { - logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "AllInCollection"); - - return Boolean.FALSE; - } - } - else if (operationString.equalsIgnoreCase(GT)) - { - Object Value1 = lhsResult; - Object Value2 = value; - // //System.out.println("Value1 GT Value2 "+Value1+" - // "+Value2); - if (!(ExpressionUtility.compare(Value2, Value1) > 0)) - { - logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "AllInCollection"); - - return Boolean.FALSE; - } - - } - else if (operationString.equalsIgnoreCase(GE)) - { - Object Value1 = lhsResult; - Object Value2 = value; - if (!(ExpressionUtility.compare(Value2, Value1) >= 0)) - { - logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "AllInCollection"); - - return Boolean.FALSE; - } - } - else if (operationString.equalsIgnoreCase(LT)) - { - Object Value1 = lhsResult; - Object Value2 = value; - // //System.out.println("Value1 LT Value2 "+Value1+" - // "+Value2); - if (!(ExpressionUtility.compare(Value2, Value1) < 0)) - { - logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "AllInCollection"); - - return Boolean.FALSE; - } - - } - else if (operationString.equalsIgnoreCase(LE)) - { - Object Value1 = lhsResult; - Object Value2 = value; - if (!(ExpressionUtility.compare(Value2, Value1) <= 0)) - { - logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "AllInCollection"); - - return Boolean.FALSE; - } - } - else - { - - logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "AllInCollection"); - - //System.out.println("did not match"); - return Boolean.FALSE; - } - - } - //System.out.println("result=true"); - logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "AllInCollection"); - - result = Boolean.TRUE; - - return result; - } - else - { - logger.severe( - "the RHS of AllInCollection expression is null BasicCollection"); - - throw new IllegalParameterTypeException( - "the RHS of AllInCollection expression is null BasicCollection"); - } - } - else - { - logger.severe( - "the RHS of AllInCollection expression should be of BasicCollection type"); - - throw new IllegalParameterTypeException( - "the RHS of AllInCollection expression should be of BasicCollection type"); - } - - } - - public boolean validate() throws SPLException - { - logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "validate"); - - //System.out.println("AllInCollection : validate "); - Expression expression1 = (Expression) this._lhsExp; - Expression expression2 = (Expression) this._midExp; - Expression expression3 = (Expression) this._rhsExp; - TypeInfo leftType = expression1.getType(); - TypeInfo middleType = expression2.getType(); - TypeInfo rightType = expression3.getType(); - - if (!rightType.getIsArray()) - { - logger.severe( - "Last Expression should be a collection"); - - throw new SPLException("Last Expression should be a collection"); - } - - if (leftType.getIsArray()) - { - logger.severe( - "First Expression cannot be a collection"); - - throw new SPLException("First Expression cannot be a collection"); - } - - if (!TypeResolver.isString(middleType)) - { - logger.severe( - "Middle Expression should be a string describing the Operation"); - throw new SPLException( - "Middle Expression should be a string describing the Operation"); - } - this.operationString = (String) expression2.evaluate(); - if (this.operationString == null) - { - logger.severe( - "Operation string is null"); - - throw new SPLException("Operation string is null"); - } - if (this.operationString == null) - { - logger.severe( - "Operation type is " - + this.operationString); - - throw new SPLException("Operation type is " - + this.operationString); - } - - if (operationString.equalsIgnoreCase(LAND) - || operationString.equalsIgnoreCase(LOR) - || operationString.equalsIgnoreCase(BXOR)) - { - if (TypeResolver.isBoolean(leftType)) - { - if (TypeResolver.isBoolean(rightType)) - { - logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validate"); - - return true; - - } - else - { - logger.severe( - "LHS is of type Boolean but RHS is not of type Boolean"); - - throw new SPLException( - "LHS is of type Boolean but RHS is not of type Boolean"); - } - } - else - { - logger.severe( - "Operation is of type Boolean but LHS is not of type boolean"); - - throw new SPLException( - "Operation is of type Boolean but LHS is not of type boolean"); - } - } - else if (operationString.equalsIgnoreCase(EQUAL) - || operationString.equalsIgnoreCase(NOT_EQUAL) - || operationString.equalsIgnoreCase(GT) - || operationString.equalsIgnoreCase(GE) - || operationString.equalsIgnoreCase(LT) - || operationString.equalsIgnoreCase(LE)) - { - - if (TypeResolver.isTypeAssignableForEquality(leftType, rightType)) - { - logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validate"); - - return true; - } - else if (TypeResolver.isTypeAssignableForRelation(leftType, - rightType)) - { - logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validate"); - - return true; - } - else - { - logger.severe( - "types are not assignable for Relation or Equality"); - - throw new SPLException( - "types are not assignable for Relation or Equality"); - } - } - else - { - - logger.severe( - "operationString is not supported by AllInCollection"); - - throw new SPLException( - "operationString is not supported by AllInCollection"); - } - - } - - public String getReferenceTypeName() throws SPLException { - // TODO Auto-generated method stub - return null; - } - - public String toString() - { - logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "toString"); - - String str = "AllInCollection("+ this._lhsExp.toString() + "," + this._midExp.toString() + "," + this._rhsExp.toString() + ")"; - - logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "toString"); - - return str; - } - -} +/* + * Licensed 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. + */ +// + +/** + * @author Prashant Baliga + * + */ + +package org.apache.imperius.spl.parser.expressions.impl; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; +import java.util.logging.Logger; + +import org.apache.imperius.spl.external.Expression; +import org.apache.imperius.spl.external.TypeConstants; +import org.apache.imperius.spl.parser.exceptions.IllegalParameterTypeException; +import org.apache.imperius.spl.parser.exceptions.SPLException; +import org.apache.imperius.spl.parser.expressions.TripleArgumentExpression; +import org.apache.imperius.spl.parser.util.ExpressionUtility; +import org.apache.imperius.spl.parser.util.TypeInfo; +import org.apache.imperius.spl.parser.util.TypeResolver; +import org.apache.imperius.util.SPLLogger; + + +public class AllInCollection extends TripleArgumentExpression implements + Expression +{ + + public String className = InCollection.class.toString(); + + public List expressionList = null; + + public String operationString = null; + + private static Logger logger = SPLLogger.getSPLLogger().getLogger(); + private static final String sourceClass="AllInCollection"; + + + + public static final String LOR = "OR"; + + public static final String LAND = "AND"; + + public static final String BXOR = "XOR"; + + public static final String NOT_EQUAL = "NOT_EQUAL"; + + public static final String EQUAL = "EQUAL"; + + public static final String LT = "LESS"; + + public static final String GT = "GREATER"; + + public static final String LE = "LESS_OR_EQUAL"; + + public static final String GE = "GREATER_OR_EQUAL"; + + public static final String PLUS = "PLUS"; + + public static final String MINUS = "MINUS"; + + public static final String STAR = "MULTIPLY"; + + public static final String DIV = "DIVIDE"; + + public AllInCollection(List exprList, boolean evaluateExpression) + throws SPLException + { + super(exprList); + + logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "AllInCollection"); + + //System.out.println("AllInCollection"); + if (evaluateExpression) + { + //System.out.println("evaluateExpression " + evaluateExpression); + if (!validate()) + { + + logger.severe( + "validation error: wrong data type passed in " + + this._dataType); + + throw new SPLException( + "validation error: wrong data type passed in " + + this._dataType); + } + } + _dataType.setType(TypeConstants.booleanType); + this._dataType.setIsArray(false); + logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "AllInCollection"); + + } + + public Object evaluate() throws SPLException + { + logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "evaluate"); + //System.out.println("AllInCollection:evaluate"); + Expression lhsExpression = (Expression) this._lhsExp; + Expression rhsExpression = (Expression) this._rhsExp; + + if (rhsExpression.isArray()) + { + //System.out.println("rhs is of type Basic Collection"); + Object rhsResult = rhsExpression.evaluate(); + //System.out.println("rhsResult , class " + rhsResult + " "+ rhsResult.getClass()); + if (!(rhsResult instanceof java.util.List)) + { + + logger.severe( + "rhsResult is not of type List"); + + throw new SPLException("rhsResult is not of type List"); + } + Boolean result = Boolean.FALSE; + ArrayList rhsResultArray = (ArrayList) rhsResult; + //System.out.println("resultArray size " + rhsResultArray.size()+ " to string " + rhsResultArray.toString()); + //System.out.println("LHS expression is of type "+ lhsExpression.getType()); + if ((rhsResultArray != null) && (!rhsResultArray.isEmpty())) + { + Object lhsResult = (Object) lhsExpression.evaluate(); + //System.out.println("lhsResult " + lhsResult.toString()); + Iterator rhsResultIt = rhsResultArray.iterator(); + while (rhsResultIt.hasNext()) + { + Object value = (Object) rhsResultIt.next(); + //System.out.println("rhsResult element " + value.toString()); + //System.out.println("operationString " + operationString); + if (operationString.equalsIgnoreCase(LAND)) + { + if ((!(value instanceof Boolean)) + || (!(lhsResult instanceof Boolean))) + { + logger.severe( + "LHS or RHS result is not of type Boolean"); + + throw new SPLException( + "LHS or RHS result is not of type Boolean"); + } + else + { + Boolean Value1 = (Boolean) lhsResult; + Boolean Value2 = (Boolean) value; + boolean res = Value1.booleanValue() + && Value2.booleanValue(); + if (!res) + { + logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "AllInCollection"); + + return new Boolean(!res); + } + } + } + else if (operationString.equalsIgnoreCase(LOR)) + { + if ((!(value instanceof Boolean)) + || (!(lhsResult instanceof Boolean))) + { + logger.severe( + "LHS or RHS result is not of type Boolean"); + + throw new SPLException( + "LHS or RHS result is not of type Boolean"); + } + else + { + Boolean Value1 = (Boolean) lhsResult; + Boolean Value2 = (Boolean) value; + boolean res = Value1.booleanValue() + || Value2.booleanValue(); + if (!res) + { + logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "AllInCollection"); + + return new Boolean(!res); + } + } + + } + else if (operationString.equalsIgnoreCase(BXOR)) + { + if ((!(value instanceof Boolean)) + || (!(lhsResult instanceof Boolean))) + { + logger.severe( + "LHS or RHS result is not of type Boolean"); + + throw new SPLException( + "LHS or RHS result is not of type Boolean"); + } + else + { + Boolean Value1 = (Boolean) lhsResult; + Boolean Value2 = (Boolean) value; + boolean res = (Value1.booleanValue() && !Value2 + .booleanValue()) + || (!Value1.booleanValue() && Value2 + .booleanValue()); + if (!res) + { + logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "AllInCollection"); + + return new Boolean(!res); + } + } + + } + + else if (operationString.equalsIgnoreCase(EQUAL)) + { + Object Value1 = lhsResult; + Object Value2 = value; + if (!(ExpressionUtility.compare(Value2, Value1) == 0)) + { + logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "AllInCollection"); + + return Boolean.FALSE; + } + } + else if (operationString.equalsIgnoreCase(NOT_EQUAL)) + { + Object Value1 = lhsResult; + Object Value2 = value; + if (!(ExpressionUtility.compare(Value2, Value1) != 0)) + { + logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "AllInCollection"); + + return Boolean.FALSE; + } + } + else if (operationString.equalsIgnoreCase(GT)) + { + Object Value1 = lhsResult; + Object Value2 = value; + // //System.out.println("Value1 GT Value2 "+Value1+" + // "+Value2); + if (!(ExpressionUtility.compare(Value2, Value1) > 0)) + { + logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "AllInCollection"); + + return Boolean.FALSE; + } + + } + else if (operationString.equalsIgnoreCase(GE)) + { + Object Value1 = lhsResult; + Object Value2 = value; + if (!(ExpressionUtility.compare(Value2, Value1) >= 0)) + { + logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "AllInCollection"); + + return Boolean.FALSE; + } + } + else if (operationString.equalsIgnoreCase(LT)) + { + Object Value1 = lhsResult; + Object Value2 = value; + // //System.out.println("Value1 LT Value2 "+Value1+" + // "+Value2); + if (!(ExpressionUtility.compare(Value2, Value1) < 0)) + { + logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "AllInCollection"); + + return Boolean.FALSE; + } + + } + else if (operationString.equalsIgnoreCase(LE)) + { + Object Value1 = lhsResult; + Object Value2 = value; + if (!(ExpressionUtility.compare(Value2, Value1) <= 0)) + { + logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "AllInCollection"); + + return Boolean.FALSE; + } + } + else + { + + logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "AllInCollection"); + + //System.out.println("did not match"); + return Boolean.FALSE; + } + + } + //System.out.println("result=true"); + logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "AllInCollection"); + + result = Boolean.TRUE; + + return result; + } + else + { + logger.severe( + "the RHS of AllInCollection expression is null BasicCollection"); + + throw new IllegalParameterTypeException( + "the RHS of AllInCollection expression is null BasicCollection"); + } + } + else + { + logger.severe( + "the RHS of AllInCollection expression should be of BasicCollection type"); + + throw new IllegalParameterTypeException( + "the RHS of AllInCollection expression should be of BasicCollection type"); + } + + } + + public boolean validate() throws SPLException + { + logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "validate"); + + //System.out.println("AllInCollection : validate "); + Expression expression1 = (Expression) this._lhsExp; + Expression expression2 = (Expression) this._midExp; + Expression expression3 = (Expression) this._rhsExp; + TypeInfo leftType = expression1.getType(); + TypeInfo middleType = expression2.getType(); + TypeInfo rightType = expression3.getType(); + + if (!rightType.getIsArray()) + { + logger.severe( + "Last Expression should be a collection"); + + throw new SPLException("Last Expression should be a collection"); + } + + if (leftType.getIsArray()) + { + logger.severe( + "First Expression cannot be a collection"); + + throw new SPLException("First Expression cannot be a collection"); + } + + if (!TypeResolver.isString(middleType)) + { + logger.severe( + "Middle Expression should be a string describing the Operation"); + throw new SPLException( + "Middle Expression should be a string describing the Operation"); + } + this.operationString = (String) expression2.evaluate(); + if (this.operationString == null) + { + logger.severe( + "Operation string is null"); + + throw new SPLException("Operation string is null"); + } + if (this.operationString == null) + { + logger.severe( + "Operation type is " + + this.operationString); + + throw new SPLException("Operation type is " + + this.operationString); + } + + if (operationString.equalsIgnoreCase(LAND) + || operationString.equalsIgnoreCase(LOR) + || operationString.equalsIgnoreCase(BXOR)) + { + if (TypeResolver.isBoolean(leftType)) + { + if (TypeResolver.isBoolean(rightType)) + { + logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validate"); + + return true; + + } + else + { + logger.severe( + "LHS is of type Boolean but RHS is not of type Boolean"); + + throw new SPLException( + "LHS is of type Boolean but RHS is not of type Boolean"); + } + } + else + { + logger.severe( + "Operation is of type Boolean but LHS is not of type boolean"); + + throw new SPLException( + "Operation is of type Boolean but LHS is not of type boolean"); + } + } + else if (operationString.equalsIgnoreCase(EQUAL) + || operationString.equalsIgnoreCase(NOT_EQUAL) + || operationString.equalsIgnoreCase(GT) + || operationString.equalsIgnoreCase(GE) + || operationString.equalsIgnoreCase(LT) + || operationString.equalsIgnoreCase(LE)) + { + + if (TypeResolver.isTypeAssignableForEquality(leftType, rightType)) + { + logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validate"); + + return true; + } + else if (TypeResolver.isTypeAssignableForRelation(leftType, + rightType)) + { + logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validate"); + + return true; + } + else + { + logger.severe( + "types are not assignable for Relation or Equality"); + + throw new SPLException( + "types are not assignable for Relation or Equality"); + } + } + else + { + + logger.severe( + "operationString is not supported by AllInCollection"); + + throw new SPLException( + "operationString is not supported by AllInCollection"); + } + + } + + public String getReferenceTypeName() throws SPLException { + // TODO Auto-generated method stub + return null; + } + + public String toString() + { + logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "toString"); + + String str = "AllInCollection("+ this._lhsExp.toString() + "," + this._midExp.toString() + "," + this._rhsExp.toString() + ")"; + + logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "toString"); + + return str; + } + +} Propchange: incubator/imperius/trunk/imperius-splcore/src/main/java/org/apache/imperius/spl/parser/expressions/impl/AllInCollection.java ------------------------------------------------------------------------------ svn:eol-style = native