You are viewing a plain text version of this content. The canonical link for it is here.
Posted to imperius-commits@incubator.apache.org by jn...@apache.org on 2007/12/22 19:34:03 UTC
svn commit: r606479 [13/30] - in /incubator/imperius/trunk/trunk: ./
modules/ modules/imperius-javaspl/ modules/imperius-javaspl/resources/
modules/imperius-javaspl/resources/samples/
modules/imperius-javaspl/resources/samples/computersystem/ modules/i...
Added: incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/AnyInCollection.java
URL: http://svn.apache.org/viewvc/incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/AnyInCollection.java?rev=606479&view=auto
==============================================================================
--- incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/AnyInCollection.java (added)
+++ incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/AnyInCollection.java Sat Dec 22 11:33:46 2007
@@ -0,0 +1,450 @@
+/*
+ * 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 <pr...@in.ibm.com>
+ *
+ */
+
+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 AnyInCollection 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="AnyInCollection";
+
+
+
+ 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 AnyInCollection(List exprList, boolean evaluateExpression)
+ throws SPLException
+ {
+ super(exprList);
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "AnyInCollection");
+
+
+ //System.out.println("AnyInCollection");
+ if (evaluateExpression)
+ {
+ //System.out.println("evaluateExpression " + evaluateExpression);
+ if (!validate())
+ {
+ logger.severe(Thread.currentThread().getName()+" "+"validation error: wrong data type passed in");
+ 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()+" "+ "AnyInCollection");
+
+ }
+
+ public Object evaluate() throws SPLException
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
+
+ //System.out.println("AnyInCollection: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(Thread.currentThread().getName()+" "+"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());
+ 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()+" "+ "evaluate");
+
+ return new Boolean(res);
+ }
+ }
+ }
+ 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()+" "+ "evaluate");
+
+ return new Boolean(res);
+ }
+ }
+
+ }
+ 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()+" "+ "evaluate");
+
+ return new Boolean(res);
+ }
+ }
+
+ }
+
+ if (operationString.equalsIgnoreCase(EQUAL))
+ {
+ Object Value1 = lhsResult;
+ Object Value2 = value;
+ if (ExpressionUtility.compare(Value2, Value1) == 0)
+ {
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
+
+ return Boolean.TRUE;
+ }
+ }
+ if (operationString.equalsIgnoreCase(NOT_EQUAL))
+ {
+ Object Value1 = lhsResult;
+ Object Value2 = value;
+ if (ExpressionUtility.compare(Value2, Value1) != 0)
+ {
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
+
+ return Boolean.TRUE;
+ }
+ }
+ if (operationString.equalsIgnoreCase(GT))
+ {
+ Object Value1 = lhsResult;
+ Object Value2 = value;
+ if (ExpressionUtility.compare(Value2, Value1) > 0)
+ {
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
+
+ return Boolean.TRUE;
+ }
+ }
+ if (operationString.equalsIgnoreCase(GE))
+ {
+ Object Value1 = lhsResult;
+ Object Value2 = value;
+ if (ExpressionUtility.compare(Value2, Value1) >= 0)
+ {
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
+
+ return Boolean.TRUE;
+ }
+ }
+ if (operationString.equalsIgnoreCase(LT))
+ {
+ Object Value1 = lhsResult;
+ Object Value2 = value;
+ if (ExpressionUtility.compare(Value2, Value1) < 0)
+ {
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
+
+ return Boolean.TRUE;
+ }
+ }
+ if (operationString.equalsIgnoreCase(LE))
+ {
+ Object Value1 = lhsResult;
+ Object Value2 = value;
+ if (ExpressionUtility.compare(Value2, Value1) <= 0)
+ {
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
+
+ return Boolean.TRUE;
+ }
+ }
+
+ //System.out.println("did not match");
+ }
+ //System.out.println("no matches: Lhs not true for AnyInCollection");
+ result = Boolean.FALSE;
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
+
+ return result;
+ }
+ else
+ {
+ logger.severe(
+ "the RHS of AnyInCollection expression is null BasicCollection");
+
+ throw new IllegalParameterTypeException(
+ "the RHS of AnyInCollection expression is null BasicCollection");
+ }
+ }
+ else
+ {
+ logger.severe(
+ "the RHS of AnyInCollection expression should be of BasicCollection type");
+
+ throw new IllegalParameterTypeException(
+ "the RHS of AnyInCollection expression should be of BasicCollection type");
+ }
+
+ }
+
+ public boolean validate() throws SPLException
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "validate");
+
+ //System.out.println("AnyInCollection : 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 (!expression3.getType().getIsArray())
+ {
+ //System.out.println(" expression3.getType().getIsArray() "+expression3.getType().getIsArray());
+ //System.out.println("expression3 "+expression3.getClass()+" "+expression3.toString());
+ logger.severe(Thread.currentThread().getName()+" "+"Last Expression should be a collection");
+
+ throw new SPLException("Last Expression should be a collection");
+ }
+
+ if (expression1.isArray())
+ {
+ logger.severe(Thread.currentThread().getName()+" "+"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(Thread.currentThread().getName()+" "+"Operation string is null");
+
+ throw new SPLException("Operation string is null");
+ }
+ if (this.operationString == null)
+ {
+ logger.severe(Thread.currentThread().getName()+" "+"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 AnyInCollection");
+
+ throw new SPLException(
+ "operationString is not supported by AnyInCollection");
+ }
+
+ }
+
+ public String getReferenceTypeName() throws SPLException {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ public String toString()
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "toString");
+
+ String str = "AnyInCollection("+ this._lhsExp.toString() +"," + this._midExp.toString() + "," + this._rhsExp.toString() + ")";
+
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "toString");
+
+ return str;
+ }
+
+}
Added: incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/ApplyToCollection.java
URL: http://svn.apache.org/viewvc/incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/ApplyToCollection.java?rev=606479&view=auto
==============================================================================
--- incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/ApplyToCollection.java (added)
+++ incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/ApplyToCollection.java Sat Dec 22 11:33:46 2007
@@ -0,0 +1,294 @@
+/*
+ * 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 <pr...@in.ibm.com>
+ *
+ */
+
+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 ApplyToCollection 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="ApplyToCollection";
+
+
+
+ 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 ApplyToCollection(List exprList, boolean evaluateExpression)
+ throws SPLException
+ {
+ super(exprList);
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "ApplyToCollection");
+
+ _dataType.setType(TypeConstants.booleanType);
+ this._dataType.setIsArray(false);
+ //System.out.println("ApplyToCollection");
+ 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);
+ }
+ }
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "ApplyToCollection");
+
+ // this.dataType=TypeConstants.numericType;
+ }
+
+ public Object evaluate() throws SPLException
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
+
+ //System.out.println("ApplyToCollection: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))
+ {
+ //System.out.println("rhsResult is not of type List");
+ throw new SPLException("rhsResult is not of type List");
+ }
+ List resultList = new ArrayList();
+ 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());
+
+ if (_operationString.equalsIgnoreCase(DIV))
+ {
+ Object Value1 = lhsResult;
+ Object Value2 = value;
+ Object res = ExpressionUtility.division(
+ (Number) Value2, (Number) Value1);
+ //System.out.println("result" + res.toString());
+ resultList.add(res);
+ }
+ if (_operationString.equalsIgnoreCase(PLUS))
+ {
+ Object Value1 = lhsResult;
+ Object Value2 = value;
+ Object res = ExpressionUtility.plus((Number) Value1,
+ (Number) Value2);
+ resultList.add(res);
+ }
+ if (_operationString.equalsIgnoreCase(MINUS))
+ {
+ Object Value1 = lhsResult;
+ Object Value2 = value;
+ Object res = ExpressionUtility.minus((Number) Value2,
+ (Number) Value1);
+ resultList.add(res);
+ }
+ if (_operationString.equalsIgnoreCase(STAR))
+ {
+ Object Value1 = lhsResult;
+ Object Value2 = value;
+ Object res = ExpressionUtility.multiplication(
+ (Number) Value2, (Number) Value1);
+ resultList.add(res);
+ }
+
+ }
+
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
+
+ return resultList;
+ }
+ else
+ {
+ logger.severe(
+ "the RHS of ApplyToCollection expression is null BasicCollection");
+
+ throw new IllegalParameterTypeException(
+ "the RHS of ApplyToCollection expression is null BasicCollection");
+ }
+ }
+ else
+ {
+ logger.severe(
+ "the RHS of ApplyToCollection expression should be of BasicCollection type");
+
+
+ throw new IllegalParameterTypeException(
+ "the RHS of ApplyToCollection expression should be of BasicCollection type");
+ }
+
+ }
+
+ public boolean validate() throws SPLException
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "validate");
+
+ //System.out.println("ApplyToCollection : 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 (!expression3.isArray())
+ {
+ logger.severe(Thread.currentThread().getName()+" "+"Last Expression should be a collection");
+
+ throw new SPLException("Last Expression should be a collection");
+ }
+
+ if (expression1.isArray())
+ {
+ logger.severe(Thread.currentThread().getName()+" "+"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(Thread.currentThread().getName()+" "+"Operation string is null");
+
+ throw new SPLException("Operation string is null");
+ }
+ if (this._operationString == null)
+ {
+ logger.severe(Thread.currentThread().getName()+" "+"Operation type is "
+ + this._operationString);
+
+ throw new SPLException("Operation type is "
+ + this._operationString);
+ }
+
+ if (_operationString.equalsIgnoreCase(DIV)
+ || _operationString.equalsIgnoreCase(PLUS)
+ || _operationString.equalsIgnoreCase(MINUS)
+ || _operationString.equalsIgnoreCase(STAR))
+ {
+
+ if (TypeResolver.isNumeric(leftType))
+ {
+ if (TypeResolver.isNumeric(rightType))
+ {
+ this._dataType = TypeResolver
+ .binaryNumericPromotionResolver(leftType, rightType);
+ _dataType.setIsArray(true);
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validate");
+
+ return true;
+ }
+ else
+ {
+ logger.severe(
+ "RHS is not numeric, and hence not applicable to ApplyToCollection");
+
+
+ throw new SPLException(
+ "RHS is not numeric, and hence not applicable to ApplyToCollection");
+ }
+ }
+ else
+ {
+ logger.severe(
+ "LHS is not numeric, and hence not applicable to ApplyToCollection");
+
+
+ throw new SPLException(
+ "LHS is not numeric, and hence not applicable to ApplyToCollection");
+ }
+ }
+ else
+ {
+ logger.severe(
+ "operationString is not supported by ApplyToCollection");
+ throw new SPLException(
+ "operationString is not supported by ApplyToCollection");
+ }
+ }
+
+ public String getReferenceTypeName() throws SPLException {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ public String toString()
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "toString");
+
+ String str = "ApplyToCollection("+ this._lhsExp.toString() + "," + this._midExp.toString() + "," + this._rhsExp.toString() + ")";
+
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "toString");
+
+ return str;
+ }
+
+}
Added: incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/AssignmentExpression.java
URL: http://svn.apache.org/viewvc/incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/AssignmentExpression.java?rev=606479&view=auto
==============================================================================
--- incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/AssignmentExpression.java (added)
+++ incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/AssignmentExpression.java Sat Dec 22 11:33:46 2007
@@ -0,0 +1,129 @@
+/*
+ * 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
+ *
+ */
+
+package org.apache.imperius.spl.parser.expressions.impl;
+
+import java.util.List;
+import java.util.logging.Logger;
+
+import org.apache.imperius.spl.external.Expression;
+import org.apache.imperius.spl.parser.exceptions.SPLException;
+import org.apache.imperius.spl.parser.exceptions.TypesNotAssignableException;
+import org.apache.imperius.spl.parser.expressions.DoubleArgumentExpression;
+import org.apache.imperius.spl.parser.util.TypeInfo;
+import org.apache.imperius.spl.parser.util.TypeResolver;
+import org.apache.imperius.util.SPLLogger;
+
+
+
+public class AssignmentExpression extends DoubleArgumentExpression
+{
+
+ private static Logger logger = SPLLogger.getSPLLogger().getLogger();
+ private static final String sourceClass="AssignmentExpression";
+
+
+
+ public AssignmentExpression(List exprList, boolean evaluateExpression)
+ throws SPLException
+ {
+
+ super(exprList);
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "AssignmentExpression");
+
+ validate();
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "AssignmentExpression");
+
+
+ }
+
+ public Object evaluate() throws SPLException
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
+
+
+ Object rhsResult = _rhsExp.evaluate();
+ // code to insert rhs into the symbol table
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
+
+ return rhsResult;
+ }
+
+ // @Override
+ public TypeInfo getType()
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "getType");
+
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "getType");
+
+
+ return _dataType;
+ }
+
+ // @Override
+ public boolean validate() throws SPLException
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "validate");
+
+ TypeInfo lType = _lhsExp.getType();
+ TypeInfo rType = _rhsExp.getType();
+ if (!TypeResolver.isTypeAssignableForEquality(lType, rType))
+ {
+ logger.severe(Thread.currentThread().getName()+" "+"Types not compatible");
+ throw new TypesNotAssignableException("Types not compatible");
+ }
+ _dataType.copy(rType);
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validate");
+
+ return true;
+ }
+
+ public Expression getLHSExpression() throws SPLException
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "getLHSExpression");
+
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "getLHSExpression");
+
+ return this._lhsExp;
+ }
+
+ public Expression getRHSExpression() throws SPLException
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "getRHSExpression");
+
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "getRHSExpression");
+
+ return this._rhsExp;
+ }
+
+ 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;
+ }
+
+}
Added: incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/AvrgInCollection.java
URL: http://svn.apache.org/viewvc/incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/AvrgInCollection.java?rev=606479&view=auto
==============================================================================
--- incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/AvrgInCollection.java (added)
+++ incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/AvrgInCollection.java Sat Dec 22 11:33:46 2007
@@ -0,0 +1,201 @@
+/*
+ * 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 <pr...@in.ibm.com>
+ *
+ */
+package org.apache.imperius.spl.parser.expressions.impl;
+
+import java.util.Iterator;
+import java.util.List;
+import java.util.ArrayList;
+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.SPLException;
+import org.apache.imperius.spl.parser.expressions.SingleArgumentExpression;
+import org.apache.imperius.spl.parser.util.ExpressionUtility;
+import org.apache.imperius.util.SPLLogger;
+
+
+public class AvrgInCollection extends SingleArgumentExpression implements
+ Expression
+{
+
+ public String className = AvrgInCollection.class.toString();
+
+ private static Logger logger = SPLLogger.getSPLLogger().getLogger();
+ private static final String sourceClass="AvrgInCollection";
+
+
+
+ public AvrgInCollection(List exprList, boolean evaluateExpression)
+ throws SPLException
+ {
+ super(exprList);
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "AvrgInCollection");
+
+ //System.out.println("AvrgInCollection");
+ if (evaluateExpression)
+ {
+ //System.out.println("evaluateExpression " + evaluateExpression);
+ if (!validate())
+ {
+ logger.severe(Thread.currentThread().getName()+" "
+ +"validation error: wrong data type passed in "
+ + this._dataType);
+
+ throw new SPLException(
+ "validation error: wrong data type passed in "
+ + this._dataType);
+ }
+ }
+
+ this._dataType.copy(this._exp.getType());
+ _dataType.setIsArray(false);
+
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "AvrgInCollection");
+
+ }
+
+ public Object evaluate() throws SPLException
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
+
+ //System.out.println("AvrgInCollection:evaluate");
+ //System.out.println("this.exp class " + this.exp.getClass() + " type "+ this.exp.getType());
+ Object avrgInCollection = null;
+ Object expResult = this._exp.evaluate();
+ if (!(expResult instanceof java.util.List))
+ {
+ logger.severe(Thread.currentThread().getName()+" "+"result of expression is not of type List");
+ throw new SPLException(
+ "result of expression is not of type List");
+ }
+ ArrayList resultArray = (ArrayList) expResult;
+ Integer size = new Integer(resultArray.size());
+ //System.out.println("resultArray size " + resultArray.size() + " to string " + resultArray.toString());
+ if ((resultArray != null) && (!resultArray.isEmpty()))
+ {
+ Iterator resultIt = resultArray.iterator();
+ while (resultIt.hasNext())
+ {
+ Object resultObject = resultIt.next();
+ //System.out.println("resultObject,class " + resultObject + " " + resultObject.getClass());
+ if (avrgInCollection == null)
+ {
+ avrgInCollection = resultObject;
+ }
+ else
+ {
+ //System.out.println("Adding resultObject to sum "+ resultObject + " " + avrgInCollection);
+ avrgInCollection = ExpressionUtility.plus(
+ (Number) avrgInCollection, (Number) resultObject);
+ }
+ //System.out.println("current sum is " + avrgInCollection);
+ }
+ //System.out.println("sum ,Array size " + avrgInCollection + " " + size);
+ avrgInCollection = ExpressionUtility.division(
+ (Number) avrgInCollection, (Number) size);
+ //System.out.println("AvrgInCollection=" + avrgInCollection);
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
+
+ return avrgInCollection;
+ }
+ else
+ {
+ logger.severe(Thread.currentThread().getName()+" "+"result Array is empty");
+ throw new SPLException("result Array is empty");
+ }
+
+ }
+
+ public boolean validate() throws SPLException
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "validate");
+
+ //System.out.println("AvrgInCollection : validate ");
+ //System.out.println("this.exp.getClass() " + this.exp.getClass()+ " type " + this.exp.getType());
+
+ if (!this._exp.isArray())
+ {
+ //System.out.println("expression is not a valid BasicCollectExpression");
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validate");
+
+ return false;
+ }
+
+ else
+ {
+ //System.out.println("expression is a valid BasicCollectExpression");
+ switch (this._exp.getType().getType())
+ {
+ case TypeConstants.byteType:
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validate");
+
+ return true;
+ case TypeConstants.doubleType:
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validate");
+
+ return true;
+ case TypeConstants.floatType:
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validate");
+
+ return true;
+ case TypeConstants.intType:
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validate");
+
+ return true;
+ case TypeConstants.longType:
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validate");
+
+ return true;
+ case TypeConstants.numericType:
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validate");
+
+ return true;
+ case TypeConstants.shortType:
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validate");
+
+ return true;
+ default:
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validate");
+
+ return false;
+ }
+
+ }
+
+ }
+
+ public String getReferenceTypeName() throws SPLException {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ public String toString()
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "toString");
+
+ String str = "AverageInCollection("+ this._exp.toString() + ")";
+
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "toString");
+
+ return str;
+ }
+
+}
Added: incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/BooleanConstant.java
URL: http://svn.apache.org/viewvc/incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/BooleanConstant.java?rev=606479&view=auto
==============================================================================
--- incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/BooleanConstant.java (added)
+++ incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/BooleanConstant.java Sat Dec 22 11:33:46 2007
@@ -0,0 +1,99 @@
+/*
+ * 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 <pr...@in.ibm.com>
+ *
+ */
+package org.apache.imperius.spl.parser.expressions.impl;
+
+import java.util.logging.Logger;
+
+import org.apache.imperius.spl.external.TypeConstants;
+import org.apache.imperius.spl.parser.exceptions.SPLException;
+import org.apache.imperius.spl.parser.expressions.BooleanExpression;
+import org.apache.imperius.spl.parser.expressions.ConstantExpression;
+import org.apache.imperius.spl.parser.util.TypeInfo;
+import org.apache.imperius.util.SPLLogger;
+
+
+public class BooleanConstant extends ConstantExpression implements
+ BooleanExpression
+{
+ private boolean _boolVal = false;
+
+ private TypeInfo _dataType=new TypeInfo();
+
+ private static Logger logger = SPLLogger.getSPLLogger().getLogger();
+ private static final String sourceClass="BooleanConstant";
+
+
+
+ public boolean isArray()
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "isArray");
+
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "isArray");
+
+
+ return _dataType.getIsArray();
+ }
+
+ public BooleanConstant(boolean val)
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "BooleanConstant");
+
+ this._boolVal = val;
+ _dataType.setType(TypeConstants.booleanType);
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "BooleanConstant");
+
+ }
+
+ public Object evaluate()
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
+
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
+
+ return new Boolean(_boolVal);
+ }
+
+ public TypeInfo getType()
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "getType");
+
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "getType");
+
+ return _dataType;
+ }
+
+ public String toString()
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "toString");
+
+ String str=Boolean.toString(this._boolVal);
+
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "toString");
+
+ return str;
+ }
+
+ public String getReferenceTypeName() throws SPLException
+ {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+}
Added: incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/ByteConstant.java
URL: http://svn.apache.org/viewvc/incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/ByteConstant.java?rev=606479&view=auto
==============================================================================
--- incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/ByteConstant.java (added)
+++ incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/ByteConstant.java Sat Dec 22 11:33:46 2007
@@ -0,0 +1,100 @@
+/*
+ * 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 <pr...@in.ibm.com>
+ *
+ */
+package org.apache.imperius.spl.parser.expressions.impl;
+
+import java.util.logging.Logger;
+
+import org.apache.imperius.spl.external.TypeConstants;
+import org.apache.imperius.spl.parser.exceptions.SPLException;
+import org.apache.imperius.spl.parser.expressions.ConstantExpression;
+import org.apache.imperius.spl.parser.expressions.NumericExpression;
+import org.apache.imperius.spl.parser.util.TypeInfo;
+import org.apache.imperius.util.SPLLogger;
+
+
+public class ByteConstant extends ConstantExpression implements
+ NumericExpression
+{
+
+ private byte _byteValue;
+
+ private TypeInfo _dataType=new TypeInfo() ;
+
+ private static Logger logger = SPLLogger.getSPLLogger().getLogger();
+ private static final String sourceClass="ByteConstant";
+
+
+
+ public boolean isArray()
+ {
+
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "isArray");
+
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "isArray");
+
+ return _dataType.getIsArray();
+ }
+
+ public ByteConstant(byte val)
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "ByteConstant");
+
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "ByteConstant");
+ _dataType.setType(TypeConstants.byteType);
+
+ this._byteValue = val;
+ }
+
+ public Object evaluate() throws SPLException
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
+
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
+
+ return new Byte(_byteValue);
+ }
+
+ public TypeInfo getType()
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "getType");
+
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "getType");
+
+ return _dataType;
+ }
+
+
+ public String toString()
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "toString");
+
+ String str=Byte.toString(this._byteValue);
+
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "toString");
+
+ return str;
+ }
+
+ public String getReferenceTypeName() throws SPLException {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+}
Added: incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/Ceiling.java
URL: http://svn.apache.org/viewvc/incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/Ceiling.java?rev=606479&view=auto
==============================================================================
--- incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/Ceiling.java (added)
+++ incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/Ceiling.java Sat Dec 22 11:33:46 2007
@@ -0,0 +1,133 @@
+/*
+ * 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 <pr...@in.ibm.com>
+ *
+ */
+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.SPLException;
+import org.apache.imperius.spl.parser.expressions.NumericExpression;
+import org.apache.imperius.spl.parser.expressions.SingleArgumentExpression;
+import org.apache.imperius.spl.parser.util.TypeInfo;
+import org.apache.imperius.spl.parser.util.TypeResolver;
+import org.apache.imperius.util.SPLLogger;
+
+
+public class Ceiling extends SingleArgumentExpression implements
+ NumericExpression
+{
+
+ public static final String className = Ceiling.class.getName();
+
+ private static Logger logger = SPLLogger.getSPLLogger().getLogger();
+ private static final String sourceClass="Ceiling";
+
+
+
+ public Ceiling(List exprList, boolean validateExpression)
+ throws SPLException
+ {
+ super(exprList);
+
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "Ceiling");
+
+ if (validateExpression)
+ {
+ if (!validate())
+ {
+ logger.severe(Thread.currentThread().getName()+" "+"validation error: " + className
+ + " has wrong data type passed in.");
+ throw new SPLException("validation error: " + className
+ + " has wrong data type passed in.");
+ }
+ }
+
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "Ceiling");
+
+ }
+
+ public Object evaluate() throws SPLException
+ {
+
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
+
+
+ try
+ {
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
+
+ return ceiling((Number) _exp.evaluate());
+ }
+ catch (Exception e)
+ {
+ logger.severe(Thread.currentThread().getName()+" "+"evaluation error: " + e.toString());
+
+ throw new SPLException("evaluation error: " + e.toString());
+ }
+ }
+
+ public static Number ceiling(Number o)
+ {
+
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "ceiling");
+
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "ceiling");
+
+ return new Double(Math.ceil(o.doubleValue()));
+ }
+
+ public boolean validate() throws SPLException
+ {
+
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "validate");
+
+ TypeInfo eType = _exp.getType();
+
+ _dataType.setType(TypeConstants.intType);
+ if (TypeResolver.isNumeric(eType))
+ {
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validate");
+
+ return true;
+ }
+
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validate");
+
+ return false;
+ }
+
+ public String getReferenceTypeName() throws SPLException {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ public String toString()
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "toString");
+
+ String str = "Ceiling("+ this._exp.toString() + ")";
+
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "toString");
+
+ return str;
+ }
+
+}
Added: incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/CharConstant.java
URL: http://svn.apache.org/viewvc/incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/CharConstant.java?rev=606479&view=auto
==============================================================================
--- incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/CharConstant.java (added)
+++ incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/CharConstant.java Sat Dec 22 11:33:46 2007
@@ -0,0 +1,120 @@
+/*
+ * 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 <pr...@in.ibm.com>
+ *
+ */
+package org.apache.imperius.spl.parser.expressions.impl;
+
+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.SPLException;
+import org.apache.imperius.spl.parser.util.*;
+import org.apache.imperius.util.SPLLogger;
+
+
+
+public class CharConstant implements Expression
+{
+
+ private char _charValue;
+
+ private TypeInfo _dataType =new TypeInfo();
+
+ private static Logger logger = SPLLogger.getSPLLogger().getLogger();
+ private static final String sourceClass="CharConstant";
+
+
+
+ public boolean isArray()
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "isArray");
+
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "isArray");
+
+
+ return _dataType.getIsArray();
+ }
+
+ public CharConstant(char c)
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "CharConstant");
+
+ this._charValue = c;
+ _dataType.setType(TypeConstants.charType);
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "CharConstant");
+
+ }
+
+ // @Override
+ /*
+ * public Object evaluate() { //
+ * Character(charValue); }
+ *
+ * @Override public int getType() {
+ * return TypeConstants.charType; } public boolean validate() throws
+ * CIMSPLException {
+ */
+
+ public Object evaluate() throws SPLException
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
+
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
+
+
+ return new Character(_charValue);
+ }
+
+ public TypeInfo getType()
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "getType");
+
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "getType");
+
+
+ return _dataType;
+ }
+
+ public boolean validate() throws SPLException
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "validate");
+
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validate");
+
+
+ return Character.isLetter(_charValue);
+ }
+
+ public String toString()
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "toString");
+
+ String str=Character.toString(this._charValue);
+
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "toString");
+
+ return str;
+ }
+
+ public String getReferenceTypeName() throws SPLException {
+
+ return null;
+ }
+
+}
Added: incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/CollectionSize.java
URL: http://svn.apache.org/viewvc/incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/CollectionSize.java?rev=606479&view=auto
==============================================================================
--- incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/CollectionSize.java (added)
+++ incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/CollectionSize.java Sat Dec 22 11:33:46 2007
@@ -0,0 +1,152 @@
+/*
+ * 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 <pr...@in.ibm.com>
+ *
+ */
+package org.apache.imperius.spl.parser.expressions.impl;
+
+import java.util.ArrayList;
+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.SPLException;
+import org.apache.imperius.spl.parser.expressions.SingleArgumentExpression;
+import org.apache.imperius.util.SPLLogger;
+
+
+public class CollectionSize extends SingleArgumentExpression implements
+ Expression
+{
+
+ public String className = CollectionSize.class.toString();
+
+ private static Logger logger = SPLLogger.getSPLLogger().getLogger();
+ private static final String sourceClass="CollectionSize";
+
+
+
+ public CollectionSize(List exprList, boolean evaluateExpression)
+ throws SPLException
+ {
+ super(exprList);
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "CollectionSize");
+
+ //System.out.println("CollectionSize");
+ 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);
+ }
+ }
+
+ this._dataType.setType(TypeConstants.intType);
+
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "CollectionSize");
+
+ }
+
+ public Object evaluate() throws SPLException
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
+
+ //System.out.println("CollectionSize:evaluate");
+ //System.out.println("this.exp class " + this.exp.getClass() + " type "+ this.exp.getType());
+
+ Object expResult = this._exp.evaluate();
+ if (!(expResult instanceof java.util.List))
+ {
+ logger.severe(Thread.currentThread().getName()+" "+"result of expression is not of type List");
+ throw new SPLException(
+ "result of expression is not of type List");
+ }
+ ArrayList resultArray = (ArrayList) expResult;
+ //System.out.println("resultArray size " + resultArray.size()+ " to string " + resultArray.toString());
+ // //System.out.println("resultArray is of type "+expression.getType());
+ if ((resultArray != null) && (!resultArray.isEmpty()))
+ {
+ Integer size = new Integer(resultArray.size());
+ //System.out.println("Size of collection is " + size);
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
+
+ return size;
+
+ }
+ else
+ {
+ logger.severe(Thread.currentThread().getName()+" "+"result Array is empty");
+ throw new SPLException("result Array is empty");
+ }
+
+ }
+
+ /*
+ * public int getType() {
+ *
+ * return this.dataType; }
+ */
+
+ public boolean validate() throws SPLException
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "validate");
+
+ //System.out.println("CollectionSize : validate ");
+ //System.out.println("this.exp.getClass() " + this.exp.getClass()+ " type " + this.exp.getType());
+
+ if (!this._exp.isArray())
+ {
+ //System.out.println("expression is not a valid BasicCollectExpression");
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validate");
+
+ return false;
+ }
+ else
+ {
+ //System.out.println("expression is a valid BasicCollectExpression");
+
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validate");
+
+ return true;
+ }
+
+ }
+
+ public String getReferenceTypeName() throws SPLException {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ public String toString()
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "toString");
+
+ String str = "CollectionSize("+ this._exp.toString() + ")";
+
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "toString");
+
+ return str;
+ }
+
+}
Added: incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/Concatenate.java
URL: http://svn.apache.org/viewvc/incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/Concatenate.java?rev=606479&view=auto
==============================================================================
--- incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/Concatenate.java (added)
+++ incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/Concatenate.java Sat Dec 22 11:33:46 2007
@@ -0,0 +1,118 @@
+/*
+ * 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 <pr...@in.ibm.com>
+ *
+ */
+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.SPLException;
+import org.apache.imperius.spl.parser.expressions.DoubleArgumentExpression;
+import org.apache.imperius.spl.parser.expressions.StringExpression;
+import org.apache.imperius.spl.parser.util.TypeInfo;
+import org.apache.imperius.spl.parser.util.TypeResolver;
+import org.apache.imperius.util.SPLLogger;
+
+
+public class Concatenate extends DoubleArgumentExpression implements
+ StringExpression
+{
+
+ public static final String className = Concatenate.class.getName();
+
+ private static Logger logger = SPLLogger.getSPLLogger().getLogger();
+ private static final String sourceClass="Concatenate";
+
+
+
+ public Concatenate(List exprList, boolean validateExpression)
+ throws SPLException
+ {
+ super(exprList);
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "Concatenate");
+
+ if (validateExpression)
+ {
+ if (!validate())
+ {
+ logger.severe(Thread.currentThread().getName()+" "+"validation error: " + className
+ + " has wrong data type passed in.");
+
+ throw new SPLException("validation error: " + className
+ + " has wrong data type passed in.");
+ }
+ }
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "Concatenate");
+
+ }
+
+ public Object evaluate() throws SPLException
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
+
+ try
+ {
+ String s0 = (String) _lhsExp.evaluate();
+ String s1 = (String) _rhsExp.evaluate();
+
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
+
+ return new String(s0 + s1);
+ }
+ catch (Exception e)
+ {
+ logger.severe(Thread.currentThread().getName()+" "+"evaluation error: " + toString());
+
+ throw new SPLException("evaluation error: " + toString());
+ }
+ }
+
+ public boolean validate() throws SPLException
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "validate");
+
+ TypeInfo lType = _lhsExp.getType();
+ TypeInfo rType = _rhsExp.getType();
+
+ if (TypeResolver.isString(lType) && TypeResolver.isString(rType))
+ {
+ _dataType.setType(TypeConstants.stringType);
+ 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 = "Concatenate("+ this._lhsExp.toString() + "," + this._rhsExp.toString() + ")";
+
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "toString");
+
+ return str;
+ }
+
+}
Added: incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/ConstantExpression.java
URL: http://svn.apache.org/viewvc/incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/ConstantExpression.java?rev=606479&view=auto
==============================================================================
--- incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/ConstantExpression.java (added)
+++ incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/ConstantExpression.java Sat Dec 22 11:33:46 2007
@@ -0,0 +1,43 @@
+/*
+ * 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 <pr...@in.ibm.com>
+ *
+ */
+package org.apache.imperius.spl.parser.expressions.impl;
+
+import org.apache.imperius.spl.external.Expression;
+import org.apache.imperius.spl.parser.exceptions.SPLException;
+import org.apache.imperius.spl.parser.util.TypeInfo;
+
+
+public abstract class ConstantExpression implements Expression
+{
+
+ public abstract Object evaluate() throws SPLException;
+
+ public abstract TypeInfo getType();
+
+ public boolean validate()
+ {
+ return true;
+ }
+ public String getReferenceTypeName() throws SPLException
+ {
+ throw new SPLException("Expression not of reference type");
+ }
+
+}
Added: incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/Contains.java
URL: http://svn.apache.org/viewvc/incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/Contains.java?rev=606479&view=auto
==============================================================================
--- incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/Contains.java (added)
+++ incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/Contains.java Sat Dec 22 11:33:46 2007
@@ -0,0 +1,136 @@
+/*
+ * 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 <pr...@in.ibm.com>
+ *
+ */
+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.SPLException;
+import org.apache.imperius.spl.parser.expressions.BooleanExpression;
+import org.apache.imperius.spl.parser.expressions.DoubleArgumentExpression;
+import org.apache.imperius.spl.parser.util.TypeInfo;
+import org.apache.imperius.spl.parser.util.TypeResolver;
+import org.apache.imperius.util.SPLLogger;
+
+
+public class Contains extends DoubleArgumentExpression implements
+ BooleanExpression
+{
+
+ public static final String className = Contains.class.getName();
+
+ private static Logger logger = SPLLogger.getSPLLogger().getLogger();
+ private static final String sourceClass="Contains";
+
+
+
+ public Contains(List exprList, boolean validateExpression)
+ throws SPLException
+ {
+ super(exprList);
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "Contains");
+
+ if (validateExpression)
+ {
+ if (!validate())
+ {
+ logger.severe(Thread.currentThread().getName()+" "+"validation error: " + className
+ + " has wrong data type passed in.");
+
+ throw new SPLException("validation error: " + className
+ + " has wrong data type passed in.");
+ }
+ }
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "Contains");
+
+ }
+
+ public Object evaluate() throws SPLException
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
+
+ try
+ {
+ String s0 = (String) _lhsExp.evaluate();
+ String s1 = (String) _rhsExp.evaluate();
+
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
+
+ return new Boolean(contains(s0, s1));
+ }
+ catch (Exception e)
+ {
+ logger.severe(Thread.currentThread().getName()+" "+"evaluation error: " + e.toString());
+
+ throw new SPLException("evaluation error: " + e.toString());
+ }
+ }
+
+ public static boolean contains(String o1, String o2)
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "contains");
+
+ if (o1.indexOf(o2) < 0)
+ {
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "contains");
+
+ return false;
+ }
+ else
+ {
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "contains");
+
+ return true;
+ }
+ }
+
+ public boolean validate() throws SPLException
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "validate");
+
+ TypeInfo lType = _lhsExp.getType();
+ TypeInfo rType = _rhsExp.getType();
+
+ if (TypeResolver.isString(lType) && TypeResolver.isString(rType))
+ {
+ _dataType.setType(TypeConstants.booleanType);
+ 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 = "Contains("+ this._lhsExp.toString() + "," + this._rhsExp.toString() + ")";
+
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "toString");
+
+ return str;
+ }
+
+}
Added: incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/ContainsOnlyDigits.java
URL: http://svn.apache.org/viewvc/incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/ContainsOnlyDigits.java?rev=606479&view=auto
==============================================================================
--- incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/ContainsOnlyDigits.java (added)
+++ incubator/imperius/trunk/trunk/modules/imperius-splcore/src/org/apache/imperius/spl/parser/expressions/impl/ContainsOnlyDigits.java Sat Dec 22 11:33:46 2007
@@ -0,0 +1,132 @@
+/*
+ * 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 <pr...@in.ibm.com>
+ *
+ */
+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.SPLException;
+import org.apache.imperius.spl.parser.expressions.BooleanExpression;
+import org.apache.imperius.spl.parser.expressions.SingleArgumentExpression;
+import org.apache.imperius.spl.parser.util.TypeInfo;
+import org.apache.imperius.spl.parser.util.TypeResolver;
+import org.apache.imperius.util.SPLLogger;
+
+
+public class ContainsOnlyDigits extends SingleArgumentExpression implements
+ BooleanExpression
+{
+
+ public static final String className = ContainsOnlyDigits.class.getName();
+
+ private static Logger logger = SPLLogger.getSPLLogger().getLogger();
+ private static final String sourceClass="ContainsOnlyDigits";
+
+
+
+ public ContainsOnlyDigits(List exprList, boolean validateExpression)
+ throws SPLException
+ {
+ super(exprList);
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "ContainsOnlyDigits");
+
+ if (validateExpression)
+ {
+ if (!validate())
+ {
+ logger.severe(Thread.currentThread().getName()+" "+"validation error: " + className
+ + " has wrong data type passed in.");
+
+ throw new SPLException("validation error: " + className
+ + " has wrong data type passed in.");
+ }
+ }
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "ContainsOnlyDigits");
+
+ }
+
+ public Object evaluate() throws SPLException
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
+
+ try
+ {
+ String s0 = (String) _exp.evaluate();
+
+ if (s0.length() == 0)
+ {
+ return Boolean.TRUE;
+ }
+
+ for (int i = 0; i < s0.length(); i++)
+ {
+ if (!Character.isDigit(s0.charAt(i)))
+ {
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
+
+ return Boolean.FALSE;
+ }
+ }
+
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
+
+ return Boolean.TRUE;
+ }
+ catch (Exception e)
+ {
+ logger.severe(Thread.currentThread().getName()+" "+"evaluation error: " + e.toString());
+
+ throw new SPLException("evaluation error: " + e.toString());
+ }
+ }
+
+ public boolean validate() throws SPLException
+ {
+ logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "validate");
+
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validate");
+
+ TypeInfo eType = _exp.getType();
+
+ if (TypeResolver.isString(eType))
+ {
+ _dataType.setType(TypeConstants.booleanType);
+ 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 = "ContainsOnlyDigits( "+ this._exp.toString() + ")";
+
+ logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "toString");
+
+ return str;
+ }
+}