incubator-imperius-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ke...@apache.org
Subject svn commit: r611261 [9/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 GMT
Modified: incubator/imperius/trunk/imperius-splcore/src/main/java/org/apache/imperius/spl/parser/expression/primary/CollectOperation.java
URL: http://svn.apache.org/viewvc/incubator/imperius/trunk/imperius-splcore/src/main/java/org/apache/imperius/spl/parser/expression/primary/CollectOperation.java?rev=611261&r1=611260&r2=611261&view=diff
==============================================================================
--- incubator/imperius/trunk/imperius-splcore/src/main/java/org/apache/imperius/spl/parser/expression/primary/CollectOperation.java (original)
+++ incubator/imperius/trunk/imperius-splcore/src/main/java/org/apache/imperius/spl/parser/expression/primary/CollectOperation.java Fri Jan 11 10:56:30 2008
@@ -1,882 +1,882 @@
-/*
- * 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 <prabalig@in.ibm.com>
- *
- */
-
-
-
-package org.apache.imperius.spl.parser.expression.primary;
-
-import java.security.InvalidParameterException;
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-import org.apache.imperius.spl.external.DataCollector;
-import org.apache.imperius.spl.external.Expression;
-import org.apache.imperius.spl.external.TypeConstants;
-import org.apache.imperius.spl.parser.compiler.symboltable.SPLSymbolTable;
-import org.apache.imperius.spl.parser.compiler.symboltable.Symbol;
-import org.apache.imperius.spl.parser.exceptions.IllegalExpressionTypeException;
-import org.apache.imperius.spl.parser.exceptions.MissingParameterException;
-import org.apache.imperius.spl.parser.exceptions.NonExistentSymbolException;
-import org.apache.imperius.spl.parser.exceptions.SPLException;
-import org.apache.imperius.spl.parser.expressions.*;
-import org.apache.imperius.spl.parser.util.*;
-import org.apache.imperius.util.SPLLogger;
-//import org.pegasus.jmpi.CIMObjectPath;
-
-//import com.ibm.ac.cimspl.CIMSPLTypeConstants;
-
-public class CollectOperation implements ReferenceExpression {
-
-	private static final int COLLECT_FLAVOUR1 = 0;
-	private static final int COLLECT_FLAVOUR2 = 1;
-	private static final int INVALID_TYPE = 2;
-	private static Logger logger = SPLLogger.getSPLLogger().getLogger();
-	private static final String sourceClass="CollectOperation";
-
-
-	private int collectType;
-	private ArrayList paramList;
-	private SPLSymbolTable symTab;
-	private String returnClassName;
-	private PostCollectExpression postCollectOperation;
-	private TypeInfo _dataType=new TypeInfo();
-//	private boolean isArray;
-	private boolean noPostCollectOperation;
-	private Expression referenceExpression;
-	private String associationName;
-	private String sourceRole;
-	private String targetRole;
-	private String targetClassName;
-	private String targetClassPropertyName;
-	private Expression expressionForTarget;
-
-
-
-//	#(c:COLLECT_OP #(COLLECT_CALL paramList = exprList[collectSymbolTable]) (postExpr = methodPropArrForCollect[symTab,collectSymbolTable])?  )	
-	public CollectOperation(ArrayList pList, Expression postCollect, SPLSymbolTable sTab) throws SPLException
-	{
-		logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "CollectOperation");
-		//System.out.println("creating collect expression");
-
-
-
-
-
-		this.paramList = pList;
-		// if no of params is 6 then flavour1 collect(refExp, associationname, srcRole, targetRole, targetClass, targetExp)
-		if(pList.size()  == 6) 
-		{	
-			collectType = COLLECT_FLAVOUR1;
-			//System.out.println("COLLECT_FLAVOUR1");
-
-		}	
-		else if(pList.size()  == 7) 
-		{
-//			if no of params is 7 then flavour2 collect(refExp, associationname, srcRole, targetRole, targetClass, <target class param>, targetExp)
-			collectType = COLLECT_FLAVOUR2;
-			//System.out.println("COLLECT_FLAVOUR2");
-
-		}	
-		else
-		{
-			logger.severe(Thread.currentThread().getName()+" "+"No of parameters for collect has to be 6 or 7");
-			throw new InvalidParameterException("No of parameters for collect has to be 6 or 7");
-		}
-
-		if(postCollect != null) //  expression following collect e.g. collect(....)[1].param
-		{	
-			postCollectOperation = (PostCollectExpression)postCollect;
-			noPostCollectOperation = false;
-			//System.out.println(" PostCollectOperation exists");
-
-		}
-		else // no expression following collect e.g. collect(...) implies return is an array of targetclass instances (flavour 1) or param values (flavour 2) 
-		{
-			_dataType.setIsArray(true);
-			noPostCollectOperation = true;
-			//System.out.println("no PostCollectOperation");
-
-		}
-
-		this.symTab = sTab;
-
-
-		// validate the expression
-		if (!validate())
-		{
-			logger.severe(Thread.currentThread().getName()+" "+"validation error:");
-			throw new SPLException("validation error:");
-		}
-
-
-		logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "CollectOperation");
-
-
-	}
-
-	public boolean validate() throws SPLException 
-	{
-		logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "validate");
-
-		boolean result = false;
-		if(collectType != INVALID_TYPE)
-		{
-			if(collectType == COLLECT_FLAVOUR1)
-			{
-				//System.out.println(" validateCollectFlavour1");
-
-				result = validateCollectFlavour1();
-			}
-			else
-			{
-				//System.out.println(" validateCollectFlavour2");
-
-				result = validateCollectFlavour2();
-			}
-		}
-		else
-		{
-			logger.severe(Thread.currentThread().getName()+" "+"Missing parameters");
-			throw new MissingParameterException("Missing parameters");
-		}
-		logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validate");
-		return result;
-
-
-	}
-	// The first 4 parameters are common to both Collect flavours
-	private boolean validateCommonParameters() throws SPLException
-	{
-		logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "validateCommonParameters");
-		//System.out.println("validateCommonParameters ");
-
-		String sourceClassValidate = null;
-		if(symTab.getParentSymbolTable() != null) // the symbol table which is the parent of the collect symbol table
-			sourceClassValidate = (String)symTab.getParentSymbolTable().getAnchorData().getAnchorClassList().get(0);
-
-		//System.out.println("sourceClassValidate "+sourceClassValidate);
-		Expression refExp = (Expression)paramList.get(0);
-		if(refExp.getType().getType() != TypeConstants.referenceType) // param 0 is the source class
-		{
-			logger.severe(Thread.currentThread().getName()+" "+"First param to collect needs to be a reference expression");
-			throw new IllegalExpressionTypeException("First param to collect needs to be a reference expression");
-		}
-		if(refExp instanceof ReferenceExpression)
-		{
-			sourceClassValidate = ((ReferenceExpression)refExp).getReferenceTypeName();
-			referenceExpression = refExp;
-			ReferenceExpression ref=(ReferenceExpression)refExp;
-			//System.out.println(" class of refExp is "+ref.getReferenceTypeName());
-
-			//refExp.
-		}
-		else{
-			referenceExpression = refExp;
-		}
-
-		Expression assocExp = (Expression)paramList.get(1); // param 1 is the assoc Name
-		if(assocExp.getType().getType() != TypeConstants.stringType)
-		{
-			logger.severe(Thread.currentThread().getName()+" "+"2nd param to collect needs to be a string expression");
-
-			throw new IllegalExpressionTypeException("2nd param to collect needs to be a string expression");
-		}
-		associationName = (String)assocExp.evaluate();
-
-		Expression roleExp = (Expression)paramList.get(2); // param 2 is role 1
-		if(roleExp.getType().getType() != TypeConstants.stringType)
-		{
-			logger.severe(Thread.currentThread().getName()+" "+"3rd param to collect needs to be a string expression");
-
-			throw new IllegalExpressionTypeException("3rd param to collect needs to be a string expression");
-		}
-
-		sourceRole = (String)roleExp.evaluate();
-
-		roleExp = (Expression)paramList.get(3); // param 3 is role 2
-		if(roleExp.getType().getType() != TypeConstants.stringType)
-		{
-
-			logger.severe(Thread.currentThread().getName()+" "+"4th param to collect needs to be a string expression");
-
-			throw new IllegalExpressionTypeException("4th param to collect needs to be a string expression");
-		}
-		targetRole = (String)roleExp.evaluate();
-
-		Expression targetClassExp = (Expression)paramList.get(4); // param 4 is the target class name
-		if(targetClassExp.getType().getType() != TypeConstants.stringType)
-		{
-
-			logger.severe(Thread.currentThread().getName()+" "+"5th param to collect needs to be a string expression");
-
-			throw new IllegalExpressionTypeException("5th param to collect needs to be a string expression");
-		}
-		targetClassName = (String)targetClassExp.evaluate();
-
-		List instanceInfoList=new ArrayList();
-		String qual=symTab.getDefaultQualifier();
-
-		symTab.addAnchor(this.targetClassName, qual, instanceInfoList);
-
-		if(refExp instanceof ReferenceExpression)
-		{
-			validateAssociation(sourceClassValidate,associationName,sourceRole,targetRole,targetClassName);
-
-		}
-		// validate that such an association actually exists
-
-		// set the anchor for the collect symbol table to the targetclass name. This will populate static symbol info. for the targetclass
-		//symTab.addCollectAnchor(targetClassName, qual, new ArrayList(), true);
-		// NRJ
-
-//		if(symTab.getAnchorClassList().size() !=1)
-//		{
-//		//System.out.println("symTab.getAnchorClassList().size() "+symTab.getAnchorClassList().size());
-//		throw new SPLException(" symTab.getAnchorClassList().size() !=1 ");
-//		}
-//		else
-//		{
-//		symTab.addAnchor(this.targetClassName, qual, instanceInfoList);
-
-//		}
-		// no exceptions were thrown validation success
-
-		logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validateCommonParameters");
-		//System.out.println("validateCommonParameters done "+true);
-
-		return true;
-	}
-
-	//collect(refExp, associationname, srcRole, targetRole, targetClass, <target class property>, targetExp)
-	private boolean validateCollectFlavour2() throws SPLException 
-	{
-		logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "validateCollectFlavour2");
-		//System.out.println("validateCollectFlavour2()");
-
-		// validate the common params
-		validateCommonParameters();
-
-		Expression propNameExp = (Expression)paramList.get(5); // the 5th parameter is a property of the targetclass
-		if(propNameExp.getType().getType() != TypeConstants.stringType)
-		{
-
-			logger.severe(Thread.currentThread().getName()+" "+"5th param to collect needs to be a string expression");  
-
-			throw new IllegalExpressionTypeException("5th param to collect needs to be a string expression");	
-		}
-		targetClassPropertyName = (String)propNameExp.evaluate();
-
-		boolean recurse = false;
-		if(!symTab.symbolExists(targetClassName + "." + targetClassPropertyName,recurse )) // make sure this is a valid property
-		{
-
-			logger.severe(targetClassName + "." + targetClassPropertyName + " does not exist");
-
-			throw new NonExistentSymbolException(targetClassName + "." + targetClassPropertyName + " does not exist");
-		}
-		else
-		{
-			Symbol propSymbol = symTab.getSymbol(targetClassName + "." + targetClassPropertyName);
-			this._dataType=new TypeInfo(propSymbol.getType());
-			this._dataType.setIsArray(true);
-			expressionForTarget = (Expression)paramList.get(6); // 6th param is an expression involving properties of the targetclass
-			if(expressionForTarget.validate())
-			{
-				if(expressionForTarget.getType().getType() != TypeConstants.booleanType) // this expression is used to filter instances hence needs to be boolean
-				{	
-
-					logger.severe(Thread.currentThread().getName()+" "+"6th param to collect needs to be a boolean expression");
-
-					throw new IllegalExpressionTypeException("6th param to collect needs to be a boolean expression");
-				}
-				if(!noPostCollectOperation) // if an expression exists that follows collect
-				{	
-
-					// REMOVED BY NRJ
-					//System.out.println("Post collect expression exists");		
-					postCollectOperation.validate(this.targetClassName); // validate the expression
-					if(postCollectOperation.Array2Exists() || postCollectOperation.isMethodOrParamExists())	{
-						this._dataType=new TypeInfo(postCollectOperation.getType());
-					}
-					else{
-						this._dataType.setIsArray(false);
-					}
-				}	
-
-
-			}
-		}
-		//System.out.println(" all went well, validation success validateCollectFlavour2");
-
-		logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validateCollectFlavour2");
-		//System.out.println("validateCollectFlavour2 done "+true);
-		//System.out.println(" Type info "+this._dataType.getType()+" "+this._dataType.getIsArray());
-
-		return true;
-
-	}
-	private boolean validateCollectFlavour1() throws SPLException 
-	{
-		logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "validateCollectFlavour1");
-
-		//System.out.println("validateCollectFlavour1");
-
-		//collect(<refExp>,<assocName>,<role1>,<role2>,<targetClass>,<expression>)[exp].param1[exp]
-		//			       .param1(pList)
-		// validate the common parameters
-		validateCommonParameters();
-
-		// 5th param is an expression used to filter the instances 
-		expressionForTarget = (Expression)paramList.get(5);
-		if(expressionForTarget.validate()) // validate the expression
-		{
-			this._dataType.setReferenceTypeName(this.targetClassName);
-			this._dataType.setType(TypeConstants.referenceType);
-			this._dataType.setIsArray(true);
-			if(expressionForTarget.getType().getType() != TypeConstants.booleanType) // needs to be boolean type
-			{	
-
-				logger.severe(Thread.currentThread().getName()+" "+"6th param to collect needs to be a boolean expression");
-
-				throw new IllegalExpressionTypeException("6th param to collect needs to be a boolean expression");
-			}
-			if(!noPostCollectOperation) // post collect exists e.g. collect(...)[exp].prop
-			{																//		 .prop[exp]		
-
-				// REMOVED BY NRJ
-				//symTab.addCollectAnchor(this.targetClassName, qual, instanceInfoList, true);
-
-				postCollectOperation.validate(this.targetClassName);
-				TypeInfo tpe=null;
-				// validate the expression
-				if(postCollectOperation.isMethodOrParamExists())
-				{
-					tpe = postCollectOperation.getType(); // get the type
-					returnClassName = targetClassName; // return type is same as the targetclass
-
-					this._dataType.setIsArray(tpe.getIsArray());
-					this._dataType.setType(tpe.getType());
-
-				}
-			}
-
-
-
-//			if(tpe != PostCollectExpression.POSTCOLLECT_IS_ARRAY) // implies of the form collect(...)[exp].prop...
-//			{	
-//			dataType = tpe; // return type is same as the type of post collect (either the type of prop or return type of array of type prop
-//			// NEED TO SET isArray IF the Property is an array type with no array subscript expression
-//			isArray = postCollectOperation.isArray();
-//			}	
-//			else
-//			{
-//			dataType = TypeConstants.referenceType; // post collect is simply collect(...)[exp]
-//			returnClassName = targetClassName; // return type is same as the targetclass
-//			isArray = false; // no array
-//			}
-
-
-		}
-
-
-		logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validateCollectFlavour1");
-		//System.out.println("validateCollectFlavour1 done "+true);
-
-		return true;
-	}
-
-	// validate the association
-	private void validateAssociation(String sourceCIMClass, String assocName, String roleName1, String roleName2, String resultclassName) throws SPLException 
-	{
-		logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "validateAssociation");
-
-		//System.out.println("validateCollectFlavour1");
-
-		boolean result = false;
-		DataCollector dc = DataCollectorFactory.getDataCollector();
-		result = dc.associationExists(sourceCIMClass, symTab.getDefaultQualifier(), resultclassName, assocName, roleName1, roleName2);
-		if(!result)
-		{
-
-			logger.severe(Thread.currentThread().getName()+" "+"Invalid association " + " sourceClass :"+sourceCIMClass+" namespace :"+symTab.getDefaultQualifier()+ " resultclassName :" + resultclassName + " assocName :"+ assocName+ " roleName1 :" + roleName1 + " roleName2 :"+ roleName2);
-
-			throw new SPLException("Invalid association " + " sourceClass :"+sourceCIMClass+" namespace :"+symTab.getDefaultQualifier()+ " resultclassName :" + resultclassName + " assocName :"+ assocName+ " roleName1 :" + roleName1 + " roleName2 :"+ roleName2);
-		}
-
-		logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validateAssociation");
-
-
-	}
-	public Object evaluate() throws SPLException 
-	{
-		logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
-
-		Object result = null;
-		if(collectType == COLLECT_FLAVOUR1)
-		{
-			//System.out.println("evaluate COLLECT_FLAVOUR1");
-			result = evaluateFlavour1();
-		}
-		else
-		{
-			//System.out.println("evaluate COLLECT_FLAVOUR2");
-
-			result = evaluateFlavour2();
-		}
-
-		logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
-
-		return result;
-	}
-
-	// evaluating flavour 2 
-	private Object evaluateFlavour2() throws SPLException
-	{
-		logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "evaluateFlavour2");
-
-		//System.out.println("evaluate evaluateFlavour2");
-
-		Object result = null;
-		// evaluate the reference expression to obtain the source instance
-		Object refExpressionResult = referenceExpression.evaluate();
-		String referenceStr=refExpressionResult.toString();
-		DataCollector dc = DataCollectorFactory.getDataCollector();
-
-//		String refTypeName=dc.getReferenceTypeName(referenceStr);
-		List targetClassInstanceReferences = null;
-
-
-		// get instances of the targetclass that satisfy the association conditions
-		if(logger.isLoggable(Level.FINE))
-			logger.fine(Thread.currentThread().getName()+" refExpressionResult evaluateFlavour2 "+referenceStr);
-		//System.out.println("targetClassInstanceReferences to dc :"+refExpressionResult+" "+symTab.getDefaultQualifier()+" "+targetClassName+" "+associationName+" "+sourceRole+" "+targetRole);
-		
-		targetClassInstanceReferences = dc.getAssociatedInstanceReferences(refExpressionResult,symTab.getDefaultQualifier(),targetClassName,associationName,sourceRole,targetRole);
-		//System.out.println("targetClassInstanceReferences "+targetClassInstanceReferences.toString());
-		if (logger.isLoggable(Level.FINE))
-			logger.fine(Thread.currentThread().getName()+" got associated references");
-
-//		targetClassInstance = dc.getAssociatedInstanceReferences(refTypeName, symTab.getDefaultQualifier(), targetClassName,associationName,sourceRole,targetRole, refExpressionResult);
-		if (logger.isLoggable(Level.FINE))
-			logger.fine(Thread.currentThread().getName()+" got associated instances");
-
-		// filter the List based on the target filter expression
-		//System.out.println("filteredTargetClassInstanceReferences to dc :"+targetClassInstanceReferences+" "+symTab.getDefaultQualifier()+" "+this.targetClassName);
-		
-		List filteredTargetClassInstanceReferences = filterTargetClassInstanceReferencesWithTargetExpression(targetClassInstanceReferences , this.targetClassName,this.symTab.getDefaultQualifier());
-		//System.out.println("targetClassInstanceReferences "+filteredTargetClassInstanceReferences.toString());
-		
-		if (logger.isLoggable(Level.FINE))
-			logger.fine(Thread.currentThread().getName()+" got filtered references");
-
-		ArrayList filteredTargetClassInstances = new ArrayList();
-
-		Iterator filteredTargetClassInstanceReferencesIt=filteredTargetClassInstanceReferences.iterator();
-		while(filteredTargetClassInstanceReferencesIt.hasNext())
-		{
-			Object ref=filteredTargetClassInstanceReferencesIt.next();
-			Map instanceProperties=dc.getSymbolsForInstance(this.targetClassName,this.symTab.getDefaultQualifier(), ref);
-			filteredTargetClassInstances.add(instanceProperties);
-		}
-
-
-
-
-		// The return type for flavour 2 is either an array of property values or a property value
-		ArrayList listOfValuesForProperty = createListOfValuesForProperty(targetClassPropertyName,filteredTargetClassInstances);
-
-		if(!noPostCollectOperation) // of the form collect(...)[exp]
-		{
-			result = postCollectOperation.evaluate(listOfValuesForProperty); // evaluation will pick one of the values of the listOfValuesForProperty array
-		}
-		else
-		{
-			//Integer index = (Integer)postCollectOperation.evaluate();
-			//result = listOfValuesForProperty.get(index.intValue());
-			result = listOfValuesForProperty; // there is no post collect therefore result is the entire array of property values
-		}
-
-		// return result;
-		logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "evaluateFlavour2");
-
-		return result;
-
-
-
-	}
-
-	//collect(<refExp>,<assocName>,<role1>,<role2>,<targetClass>,<expression>)[exp].param1[exp]
-	//			       .param1(pList)
-	private Object evaluateFlavour1() throws SPLException 
-	{
-		logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "evaluateFlavour1");
-		//System.out.println("evaluate evaluateFlavour1");
-
-
-		Object result = null;
-
-		//evaluate the the first parameter to get the source instance
-		Object refExpressionResult = referenceExpression.evaluate();
-		String refExpressionStr=refExpressionResult.toString();
-		//System.out.println("self = "+refExpressionResult);
-		DataCollector dc = DataCollectorFactory.getDataCollector();
-		//NRJ verify this works
-//		String refTypeName = referenceExpression.getReferenceTypeName();
-		//String refTypeName=dc.getReferenceTypeName(refExpressionStr);
-		List targetClassInstanceReferences = null;
-
-		// traverse association to get an array of target class instances. Each instance is a Map of key=values
-		if(logger.isLoggable(Level.FINE))
-			logger.fine(Thread.currentThread().getName()+" refExpressionResult evaluateFlavour1 "+refExpressionStr);
-
-		targetClassInstanceReferences = dc.getAssociatedInstanceReferences((Object)refExpressionResult,symTab.getDefaultQualifier(),targetClassName,associationName,sourceRole,targetRole);
-		//System.out.println("targetClassInstanceReferences size "+targetClassInstanceReferences.size());
-		if (logger.isLoggable(Level.FINE))
-			logger.fine(Thread.currentThread().getName()+" got associated references");
-
-//		targetClassInstance = dc.getAssociatedInstanceReferences(refTypeName, symTab.getDefaultQualifier(), targetClassName,associationName,sourceRole,targetRole, refExpressionResult);
-		if (logger.isLoggable(Level.FINE))
-			logger.fine(Thread.currentThread().getName()+" got associated instances");
-
-		// filter the List based on the target filter expression
-		List filteredTargetClassInstanceReferences = filterTargetClassInstanceReferencesWithTargetExpression(targetClassInstanceReferences , this.targetClassName,this.symTab.getDefaultQualifier());
-		//System.out.println("filteredTargetClassInstanceReferences size "+filteredTargetClassInstanceReferences.size());
-
-		if (logger.isLoggable(Level.FINE))
-			logger.fine(Thread.currentThread().getName()+" got filtered references");
-
-		List filteredTargetClassInstances = new ArrayList();
-
-		Iterator filteredTargetClassInstanceReferencesIt=filteredTargetClassInstanceReferences.iterator();
-		while(filteredTargetClassInstanceReferencesIt.hasNext())
-		{
-			Object ref=filteredTargetClassInstanceReferencesIt.next();
-			//System.out.println("filter passed : "+ref.toString());
-			Map instanceProperties=dc.getSymbolsForInstance(this.targetClassName,this.symTab.getDefaultQualifier(), ref);
-			filteredTargetClassInstances.add(instanceProperties);
-		}
-
-		if (logger.isLoggable(Level.FINE))
-			logger.fine(Thread.currentThread().getName()+" got filtered instances");
-
-		if(!noPostCollectOperation) // post collect exists
-		{
-			if(postCollectOperation.getType().getIsArray()) // of the form collect(...)[exp]
-			{	
-				result = postCollectOperation.evaluate(filteredTargetClassInstances); // will return a map corresponding to the instance to be returned
-				int instanceNumber=postCollectOperation.getInstanceNumer();
-				//symTab.populateInstanceValuesForCollect(this.targetClassName, this.targetClassName, filteredTargetClassInstances.get(instanceNumber), (Map)result); // populate it in the hashtable to obtain the string expression for the instance
-				// NRJ
-				symTab.populateInstanceValuesForInstance(this.targetClassName, this.targetClassName, 
-						filteredTargetClassInstances.get(instanceNumber), (Map)result); 
-				// populate it in the hashtable to obtain the string expression for the instance
-				//result = symTab.getInstance();
-
-			}	
-			else // post collect of the form collect(...)[exp].prop
-			{     
-				// the result will be calculated as follows for 
-				// a) in the case prop is not an array 
-				// 1. Of the array of target class instances passed as the parameter
-				// use the exp to pick one of the instances
-				// for this instance obtain the value of prop and return
-				// b) in the case prop is an array
-				// if of the form collect(...)[exp].prop[exp] and exp == 1then the result will be the props[1]
-				// if of the form collect(...)[exp].prop and prop is an array then the result will be an array of prop
-
-				result = postCollectOperation.evaluate(filteredTargetClassInstances);
-
-			}
-		}
-		else // no post collect result is an array of target instances that satisfy the filter
-		{
-			result = filteredTargetClassInstanceReferences;
-
-		}
-
-
-		logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "evaluateFlavour1");
-
-
-		return result;
-	}
-
-	// for flavour 2 need to extract the values for the property and create an array
-	private ArrayList createListOfValuesForProperty(String propertyName, ArrayList filteredTargetClassInstances) 
-	{
-		logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "createListOfValuesForProperty");
-		//System.out.println(" propertyName :"+propertyName);
-		//System.out.println(" filteredTargetClassInstances.size() :"+filteredTargetClassInstances.size());
-		
-		ArrayList propertyList = new ArrayList();
-		for(int i=0; i<filteredTargetClassInstances.size(); i++)
-		{
-			//System.out.println(" inside for");
-			Map currMap = (Map)filteredTargetClassInstances.get(i);
-			//System.out.println("currMap "+currMap.toString());
-			
-			Object s = (Object)currMap.get(propertyName);
-			//System.out.println("adding property "+propertyName);
-			//System.out.println(" object s :"+propertyName+" "+s.toString());
-			propertyList.add(s);
-
-		}
-
-		logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "createListOfValuesForProperty");
-
-		return propertyList;
-	}
-
-	// Given a list of Maps where each map corresponds to an instance of the target class
-	// filter out the instances which satisfy the boolean condition
-	/*   private ArrayList filterTargetClassInstancesWithTargetExpression(List targetClassInstanceReferences) throws SPLException 
-    {
-        logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "filterTargetClassInstancesWithTargetExpression");
-
-
-        ArrayList filteredTargetClassInstances = new ArrayList();
-
-        if(targetClassInstanceReferences!=null)
-        {
-            Iterator targetClassInstancesIt = targetClassInstanceReferences.iterator();
-            while(targetClassInstancesIt.hasNext())
-            {
-
-
-                Object instanceRefernce = targetClassInstancesIt.next();
-                DataCollector dc= DataCollectorFactory.getDataCollector();
-                Map instanceProperties=dc.getSymbolsForInstance(this.targetClassName, symTab.getDefaultQualifier(), instanceRefernce);
-                symTab.populateInstanceValuesForInstance(this.targetClassName, this.targetClassName, instanceRefernce, instanceProperties)populateSymbolTableWithInstanceValues(map);
-                Boolean result = (Boolean)expressionForTarget.evaluate();
-                if(result.booleanValue())
-                {
-                    filteredTargetClassInstances.add(map);
-                }
-            }	
-        }
-        else
-        {
-            if (logger.isLoggable(Level.FINE))
-                logger.fine(Thread.currentThread().getName()+" Zero instances passed in hence zero instance references filtered, therefore returning null ");
-        }
-
-        logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "filterTargetClassInstancesWithTargetExpression");
-
-        return filteredTargetClassInstances;
-    }
-	 */
-
-	private ArrayList filterTargetClassInstanceReferencesWithTargetExpression(List targetClassInstanceReferences , String className,String namespc) throws SPLException 
-	{
-		logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "filterTargetClassInstanceReferencesWithTargetExpression");
-		DataCollector dc = DataCollectorFactory.getDataCollector();
-		ArrayList filteredTargetClassInstanceReferences = new ArrayList();
-		if(targetClassInstanceReferences!=null)
-		{
-
-
-			Iterator it=targetClassInstanceReferences.iterator();
-			while(it.hasNext())
-			{
-				Object cop=(Object)it.next();
-				//System.out.println("getSymbolsForInstance "+className+" "+ namespc+" "+ cop);
-				Map map = dc.getSymbolsForInstance(className, namespc, cop);
-				//System.out.println("map.size() "+map.size()+" "+map.toString());
-				//symTab.populateInstanceValuesForCollect(className, className, cop, map);
-				//NRJ
-				symTab.populateInstanceValuesForInstance(className, className, cop, map);
-				Boolean result = (Boolean)expressionForTarget.evaluate();
-				//System.out.println("result "+result);
-				if(result.booleanValue())
-				{
-					if (logger.isLoggable(Level.FINE))
-						logger.fine(Thread.currentThread().getName()+" cop passed filter "+cop);
-					//System.out.println("adding cop to list "+cop.toString());
-					
-					filteredTargetClassInstanceReferences.add(cop);
-				}
-				else
-				{
-					if (logger.isLoggable(Level.FINE))
-						logger.fine(Thread.currentThread().getName()+" cop did not pass filter "+cop);
-
-
-				}
-			}
-		}
-		else
-		{
-			if (logger.isLoggable(Level.FINE))
-				logger.fine(Thread.currentThread().getName()+" Zero instances passed in hence zero instance references filtered, therefore returning null ");
-		}
-
-
-		logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "filterTargetClassInstanceReferencesWithTargetExpression");
-
-		return filteredTargetClassInstanceReferences;
-	}
-
-
-
-
-	public TypeInfo getType() throws SPLException {
-		logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "BasicCollectionExpression");
-
-		// if dataType is not set call validate so taht it gets set in the process
-		if(_dataType != null)
-		{
-
-			logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "getType");
-			return _dataType;
-
-		}
-
-		else
-		{
-			validate();
-
-			logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "getType");
-
-			return _dataType;
-		}
-
-
-	}
-
-
-	public String getReferenceTypeName() {
-		logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "getReferenceTypeName");
-
-
-		logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "getReferenceTypeName");
-
-		return returnClassName;
-	}
-
-
-
-	public boolean isArray() {
-		logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "isArray");
-
-
-		logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "isArray");
-
-		return this._dataType.getIsArray();
-	}
-
-	public String toString()
-	{
-		logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "toString");
-
-//		String className=this.getClass().getName();
-
-		String str="Collect(";
-
-		Iterator ExpIt=this.paramList.iterator();
-		while(ExpIt.hasNext()){
-			Expression exp=(Expression)ExpIt.next();
-			if(exp!=null){
-
-				String expstr=exp.toString();
-				str+=expstr + " , ";
-			}
-
-		}
-		str=str.substring(0, str.length()-3) +" ) ";
-//		if(this.expressionForTarget!=null){
-//			str+=" "+this.expressionForTarget.toString()+" ";
-//		}
-		if(this.postCollectOperation!=null){
-			str+="."+this.postCollectOperation.toString()+" ";
-		}
-//		if(this.referenceExpression!=null){
-//			str+=" "+this.referenceExpression.toString()+" ";
-//		}
-
-//		str+=" )";
-
-
-		logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "toString");
-
-		return str;
-	}
-
-	public static String getSourceClass()
-	{
-		return sourceClass;
-	}
-
-	public String getAssociationName()
-	{
-		return associationName;
-	}
-
-	public void setAssociationName(String associationName)
-	{
-		this.associationName = associationName;
-	}
-
-	public int getCollectType()
-	{
-		return collectType;
-	}
-
-	public void setCollectType(int collectType)
-	{
-		this.collectType = collectType;
-	}
-
-	public boolean isNoPostCollectOperation()
-	{
-		return noPostCollectOperation;
-	}
-
-	public void setNoPostCollectOperation(boolean noPostCollectOperation)
-	{
-		this.noPostCollectOperation = noPostCollectOperation;
-	}
-
-	public String getReturnClassName()
-	{
-		return returnClassName;
-	}
-
-	public void setReturnClassName(String returnClassName)
-	{
-		this.returnClassName = returnClassName;
-	}
-
-	public String getTargetClassName()
-	{
-		return targetClassName;
-	}
-
-	public void setTargetClassName(String targetClassName)
-	{
-		this.targetClassName = targetClassName;
-	}
-
-
-
-}
+/*
+ * 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 <prabalig@in.ibm.com>
+ *
+ */
+
+
+
+package org.apache.imperius.spl.parser.expression.primary;
+
+import java.security.InvalidParameterException;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.apache.imperius.spl.external.DataCollector;
+import org.apache.imperius.spl.external.Expression;
+import org.apache.imperius.spl.external.TypeConstants;
+import org.apache.imperius.spl.parser.compiler.symboltable.SPLSymbolTable;
+import org.apache.imperius.spl.parser.compiler.symboltable.Symbol;
+import org.apache.imperius.spl.parser.exceptions.IllegalExpressionTypeException;
+import org.apache.imperius.spl.parser.exceptions.MissingParameterException;
+import org.apache.imperius.spl.parser.exceptions.NonExistentSymbolException;
+import org.apache.imperius.spl.parser.exceptions.SPLException;
+import org.apache.imperius.spl.parser.expressions.*;
+import org.apache.imperius.spl.parser.util.*;
+import org.apache.imperius.util.SPLLogger;
+//import org.pegasus.jmpi.CIMObjectPath;
+
+//import com.ibm.ac.cimspl.CIMSPLTypeConstants;
+
+public class CollectOperation implements ReferenceExpression {
+
+	private static final int COLLECT_FLAVOUR1 = 0;
+	private static final int COLLECT_FLAVOUR2 = 1;
+	private static final int INVALID_TYPE = 2;
+	private static Logger logger = SPLLogger.getSPLLogger().getLogger();
+	private static final String sourceClass="CollectOperation";
+
+
+	private int collectType;
+	private ArrayList paramList;
+	private SPLSymbolTable symTab;
+	private String returnClassName;
+	private PostCollectExpression postCollectOperation;
+	private TypeInfo _dataType=new TypeInfo();
+//	private boolean isArray;
+	private boolean noPostCollectOperation;
+	private Expression referenceExpression;
+	private String associationName;
+	private String sourceRole;
+	private String targetRole;
+	private String targetClassName;
+	private String targetClassPropertyName;
+	private Expression expressionForTarget;
+
+
+
+//	#(c:COLLECT_OP #(COLLECT_CALL paramList = exprList[collectSymbolTable]) (postExpr = methodPropArrForCollect[symTab,collectSymbolTable])?  )	
+	public CollectOperation(ArrayList pList, Expression postCollect, SPLSymbolTable sTab) throws SPLException
+	{
+		logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "CollectOperation");
+		//System.out.println("creating collect expression");
+
+
+
+
+
+		this.paramList = pList;
+		// if no of params is 6 then flavour1 collect(refExp, associationname, srcRole, targetRole, targetClass, targetExp)
+		if(pList.size()  == 6) 
+		{	
+			collectType = COLLECT_FLAVOUR1;
+			//System.out.println("COLLECT_FLAVOUR1");
+
+		}	
+		else if(pList.size()  == 7) 
+		{
+//			if no of params is 7 then flavour2 collect(refExp, associationname, srcRole, targetRole, targetClass, <target class param>, targetExp)
+			collectType = COLLECT_FLAVOUR2;
+			//System.out.println("COLLECT_FLAVOUR2");
+
+		}	
+		else
+		{
+			logger.severe(Thread.currentThread().getName()+" "+"No of parameters for collect has to be 6 or 7");
+			throw new InvalidParameterException("No of parameters for collect has to be 6 or 7");
+		}
+
+		if(postCollect != null) //  expression following collect e.g. collect(....)[1].param
+		{	
+			postCollectOperation = (PostCollectExpression)postCollect;
+			noPostCollectOperation = false;
+			//System.out.println(" PostCollectOperation exists");
+
+		}
+		else // no expression following collect e.g. collect(...) implies return is an array of targetclass instances (flavour 1) or param values (flavour 2) 
+		{
+			_dataType.setIsArray(true);
+			noPostCollectOperation = true;
+			//System.out.println("no PostCollectOperation");
+
+		}
+
+		this.symTab = sTab;
+
+
+		// validate the expression
+		if (!validate())
+		{
+			logger.severe(Thread.currentThread().getName()+" "+"validation error:");
+			throw new SPLException("validation error:");
+		}
+
+
+		logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "CollectOperation");
+
+
+	}
+
+	public boolean validate() throws SPLException 
+	{
+		logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "validate");
+
+		boolean result = false;
+		if(collectType != INVALID_TYPE)
+		{
+			if(collectType == COLLECT_FLAVOUR1)
+			{
+				//System.out.println(" validateCollectFlavour1");
+
+				result = validateCollectFlavour1();
+			}
+			else
+			{
+				//System.out.println(" validateCollectFlavour2");
+
+				result = validateCollectFlavour2();
+			}
+		}
+		else
+		{
+			logger.severe(Thread.currentThread().getName()+" "+"Missing parameters");
+			throw new MissingParameterException("Missing parameters");
+		}
+		logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validate");
+		return result;
+
+
+	}
+	// The first 4 parameters are common to both Collect flavours
+	private boolean validateCommonParameters() throws SPLException
+	{
+		logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "validateCommonParameters");
+		//System.out.println("validateCommonParameters ");
+
+		String sourceClassValidate = null;
+		if(symTab.getParentSymbolTable() != null) // the symbol table which is the parent of the collect symbol table
+			sourceClassValidate = (String)symTab.getParentSymbolTable().getAnchorData().getAnchorClassList().get(0);
+
+		//System.out.println("sourceClassValidate "+sourceClassValidate);
+		Expression refExp = (Expression)paramList.get(0);
+		if(refExp.getType().getType() != TypeConstants.referenceType) // param 0 is the source class
+		{
+			logger.severe(Thread.currentThread().getName()+" "+"First param to collect needs to be a reference expression");
+			throw new IllegalExpressionTypeException("First param to collect needs to be a reference expression");
+		}
+		if(refExp instanceof ReferenceExpression)
+		{
+			sourceClassValidate = ((ReferenceExpression)refExp).getReferenceTypeName();
+			referenceExpression = refExp;
+			ReferenceExpression ref=(ReferenceExpression)refExp;
+			//System.out.println(" class of refExp is "+ref.getReferenceTypeName());
+
+			//refExp.
+		}
+		else{
+			referenceExpression = refExp;
+		}
+
+		Expression assocExp = (Expression)paramList.get(1); // param 1 is the assoc Name
+		if(assocExp.getType().getType() != TypeConstants.stringType)
+		{
+			logger.severe(Thread.currentThread().getName()+" "+"2nd param to collect needs to be a string expression");
+
+			throw new IllegalExpressionTypeException("2nd param to collect needs to be a string expression");
+		}
+		associationName = (String)assocExp.evaluate();
+
+		Expression roleExp = (Expression)paramList.get(2); // param 2 is role 1
+		if(roleExp.getType().getType() != TypeConstants.stringType)
+		{
+			logger.severe(Thread.currentThread().getName()+" "+"3rd param to collect needs to be a string expression");
+
+			throw new IllegalExpressionTypeException("3rd param to collect needs to be a string expression");
+		}
+
+		sourceRole = (String)roleExp.evaluate();
+
+		roleExp = (Expression)paramList.get(3); // param 3 is role 2
+		if(roleExp.getType().getType() != TypeConstants.stringType)
+		{
+
+			logger.severe(Thread.currentThread().getName()+" "+"4th param to collect needs to be a string expression");
+
+			throw new IllegalExpressionTypeException("4th param to collect needs to be a string expression");
+		}
+		targetRole = (String)roleExp.evaluate();
+
+		Expression targetClassExp = (Expression)paramList.get(4); // param 4 is the target class name
+		if(targetClassExp.getType().getType() != TypeConstants.stringType)
+		{
+
+			logger.severe(Thread.currentThread().getName()+" "+"5th param to collect needs to be a string expression");
+
+			throw new IllegalExpressionTypeException("5th param to collect needs to be a string expression");
+		}
+		targetClassName = (String)targetClassExp.evaluate();
+
+		List instanceInfoList=new ArrayList();
+		String qual=symTab.getDefaultQualifier();
+
+		symTab.addAnchor(this.targetClassName, qual, instanceInfoList);
+
+		if(refExp instanceof ReferenceExpression)
+		{
+			validateAssociation(sourceClassValidate,associationName,sourceRole,targetRole,targetClassName);
+
+		}
+		// validate that such an association actually exists
+
+		// set the anchor for the collect symbol table to the targetclass name. This will populate static symbol info. for the targetclass
+		//symTab.addCollectAnchor(targetClassName, qual, new ArrayList(), true);
+		// NRJ
+
+//		if(symTab.getAnchorClassList().size() !=1)
+//		{
+//		//System.out.println("symTab.getAnchorClassList().size() "+symTab.getAnchorClassList().size());
+//		throw new SPLException(" symTab.getAnchorClassList().size() !=1 ");
+//		}
+//		else
+//		{
+//		symTab.addAnchor(this.targetClassName, qual, instanceInfoList);
+
+//		}
+		// no exceptions were thrown validation success
+
+		logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validateCommonParameters");
+		//System.out.println("validateCommonParameters done "+true);
+
+		return true;
+	}
+
+	//collect(refExp, associationname, srcRole, targetRole, targetClass, <target class property>, targetExp)
+	private boolean validateCollectFlavour2() throws SPLException 
+	{
+		logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "validateCollectFlavour2");
+		//System.out.println("validateCollectFlavour2()");
+
+		// validate the common params
+		validateCommonParameters();
+
+		Expression propNameExp = (Expression)paramList.get(5); // the 5th parameter is a property of the targetclass
+		if(propNameExp.getType().getType() != TypeConstants.stringType)
+		{
+
+			logger.severe(Thread.currentThread().getName()+" "+"5th param to collect needs to be a string expression");  
+
+			throw new IllegalExpressionTypeException("5th param to collect needs to be a string expression");	
+		}
+		targetClassPropertyName = (String)propNameExp.evaluate();
+
+		boolean recurse = false;
+		if(!symTab.symbolExists(targetClassName + "." + targetClassPropertyName,recurse )) // make sure this is a valid property
+		{
+
+			logger.severe(targetClassName + "." + targetClassPropertyName + " does not exist");
+
+			throw new NonExistentSymbolException(targetClassName + "." + targetClassPropertyName + " does not exist");
+		}
+		else
+		{
+			Symbol propSymbol = symTab.getSymbol(targetClassName + "." + targetClassPropertyName);
+			this._dataType=new TypeInfo(propSymbol.getType());
+			this._dataType.setIsArray(true);
+			expressionForTarget = (Expression)paramList.get(6); // 6th param is an expression involving properties of the targetclass
+			if(expressionForTarget.validate())
+			{
+				if(expressionForTarget.getType().getType() != TypeConstants.booleanType) // this expression is used to filter instances hence needs to be boolean
+				{	
+
+					logger.severe(Thread.currentThread().getName()+" "+"6th param to collect needs to be a boolean expression");
+
+					throw new IllegalExpressionTypeException("6th param to collect needs to be a boolean expression");
+				}
+				if(!noPostCollectOperation) // if an expression exists that follows collect
+				{	
+
+					// REMOVED BY NRJ
+					//System.out.println("Post collect expression exists");		
+					postCollectOperation.validate(this.targetClassName); // validate the expression
+					if(postCollectOperation.Array2Exists() || postCollectOperation.isMethodOrParamExists())	{
+						this._dataType=new TypeInfo(postCollectOperation.getType());
+					}
+					else{
+						this._dataType.setIsArray(false);
+					}
+				}	
+
+
+			}
+		}
+		//System.out.println(" all went well, validation success validateCollectFlavour2");
+
+		logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validateCollectFlavour2");
+		//System.out.println("validateCollectFlavour2 done "+true);
+		//System.out.println(" Type info "+this._dataType.getType()+" "+this._dataType.getIsArray());
+
+		return true;
+
+	}
+	private boolean validateCollectFlavour1() throws SPLException 
+	{
+		logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "validateCollectFlavour1");
+
+		//System.out.println("validateCollectFlavour1");
+
+		//collect(<refExp>,<assocName>,<role1>,<role2>,<targetClass>,<expression>)[exp].param1[exp]
+		//			       .param1(pList)
+		// validate the common parameters
+		validateCommonParameters();
+
+		// 5th param is an expression used to filter the instances 
+		expressionForTarget = (Expression)paramList.get(5);
+		if(expressionForTarget.validate()) // validate the expression
+		{
+			this._dataType.setReferenceTypeName(this.targetClassName);
+			this._dataType.setType(TypeConstants.referenceType);
+			this._dataType.setIsArray(true);
+			if(expressionForTarget.getType().getType() != TypeConstants.booleanType) // needs to be boolean type
+			{	
+
+				logger.severe(Thread.currentThread().getName()+" "+"6th param to collect needs to be a boolean expression");
+
+				throw new IllegalExpressionTypeException("6th param to collect needs to be a boolean expression");
+			}
+			if(!noPostCollectOperation) // post collect exists e.g. collect(...)[exp].prop
+			{																//		 .prop[exp]		
+
+				// REMOVED BY NRJ
+				//symTab.addCollectAnchor(this.targetClassName, qual, instanceInfoList, true);
+
+				postCollectOperation.validate(this.targetClassName);
+				TypeInfo tpe=null;
+				// validate the expression
+				if(postCollectOperation.isMethodOrParamExists())
+				{
+					tpe = postCollectOperation.getType(); // get the type
+					returnClassName = targetClassName; // return type is same as the targetclass
+
+					this._dataType.setIsArray(tpe.getIsArray());
+					this._dataType.setType(tpe.getType());
+
+				}
+			}
+
+
+
+//			if(tpe != PostCollectExpression.POSTCOLLECT_IS_ARRAY) // implies of the form collect(...)[exp].prop...
+//			{	
+//			dataType = tpe; // return type is same as the type of post collect (either the type of prop or return type of array of type prop
+//			// NEED TO SET isArray IF the Property is an array type with no array subscript expression
+//			isArray = postCollectOperation.isArray();
+//			}	
+//			else
+//			{
+//			dataType = TypeConstants.referenceType; // post collect is simply collect(...)[exp]
+//			returnClassName = targetClassName; // return type is same as the targetclass
+//			isArray = false; // no array
+//			}
+
+
+		}
+
+
+		logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validateCollectFlavour1");
+		//System.out.println("validateCollectFlavour1 done "+true);
+
+		return true;
+	}
+
+	// validate the association
+	private void validateAssociation(String sourceCIMClass, String assocName, String roleName1, String roleName2, String resultclassName) throws SPLException 
+	{
+		logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "validateAssociation");
+
+		//System.out.println("validateCollectFlavour1");
+
+		boolean result = false;
+		DataCollector dc = DataCollectorFactory.getDataCollector();
+		result = dc.associationExists(sourceCIMClass, symTab.getDefaultQualifier(), resultclassName, assocName, roleName1, roleName2);
+		if(!result)
+		{
+
+			logger.severe(Thread.currentThread().getName()+" "+"Invalid association " + " sourceClass :"+sourceCIMClass+" namespace :"+symTab.getDefaultQualifier()+ " resultclassName :" + resultclassName + " assocName :"+ assocName+ " roleName1 :" + roleName1 + " roleName2 :"+ roleName2);
+
+			throw new SPLException("Invalid association " + " sourceClass :"+sourceCIMClass+" namespace :"+symTab.getDefaultQualifier()+ " resultclassName :" + resultclassName + " assocName :"+ assocName+ " roleName1 :" + roleName1 + " roleName2 :"+ roleName2);
+		}
+
+		logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validateAssociation");
+
+
+	}
+	public Object evaluate() throws SPLException 
+	{
+		logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
+
+		Object result = null;
+		if(collectType == COLLECT_FLAVOUR1)
+		{
+			//System.out.println("evaluate COLLECT_FLAVOUR1");
+			result = evaluateFlavour1();
+		}
+		else
+		{
+			//System.out.println("evaluate COLLECT_FLAVOUR2");
+
+			result = evaluateFlavour2();
+		}
+
+		logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
+
+		return result;
+	}
+
+	// evaluating flavour 2 
+	private Object evaluateFlavour2() throws SPLException
+	{
+		logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "evaluateFlavour2");
+
+		//System.out.println("evaluate evaluateFlavour2");
+
+		Object result = null;
+		// evaluate the reference expression to obtain the source instance
+		Object refExpressionResult = referenceExpression.evaluate();
+		String referenceStr=refExpressionResult.toString();
+		DataCollector dc = DataCollectorFactory.getDataCollector();
+
+//		String refTypeName=dc.getReferenceTypeName(referenceStr);
+		List targetClassInstanceReferences = null;
+
+
+		// get instances of the targetclass that satisfy the association conditions
+		if(logger.isLoggable(Level.FINE))
+			logger.fine(Thread.currentThread().getName()+" refExpressionResult evaluateFlavour2 "+referenceStr);
+		//System.out.println("targetClassInstanceReferences to dc :"+refExpressionResult+" "+symTab.getDefaultQualifier()+" "+targetClassName+" "+associationName+" "+sourceRole+" "+targetRole);
+		
+		targetClassInstanceReferences = dc.getAssociatedInstanceReferences(refExpressionResult,symTab.getDefaultQualifier(),targetClassName,associationName,sourceRole,targetRole);
+		//System.out.println("targetClassInstanceReferences "+targetClassInstanceReferences.toString());
+		if (logger.isLoggable(Level.FINE))
+			logger.fine(Thread.currentThread().getName()+" got associated references");
+
+//		targetClassInstance = dc.getAssociatedInstanceReferences(refTypeName, symTab.getDefaultQualifier(), targetClassName,associationName,sourceRole,targetRole, refExpressionResult);
+		if (logger.isLoggable(Level.FINE))
+			logger.fine(Thread.currentThread().getName()+" got associated instances");
+
+		// filter the List based on the target filter expression
+		//System.out.println("filteredTargetClassInstanceReferences to dc :"+targetClassInstanceReferences+" "+symTab.getDefaultQualifier()+" "+this.targetClassName);
+		
+		List filteredTargetClassInstanceReferences = filterTargetClassInstanceReferencesWithTargetExpression(targetClassInstanceReferences , this.targetClassName,this.symTab.getDefaultQualifier());
+		//System.out.println("targetClassInstanceReferences "+filteredTargetClassInstanceReferences.toString());
+		
+		if (logger.isLoggable(Level.FINE))
+			logger.fine(Thread.currentThread().getName()+" got filtered references");
+
+		ArrayList filteredTargetClassInstances = new ArrayList();
+
+		Iterator filteredTargetClassInstanceReferencesIt=filteredTargetClassInstanceReferences.iterator();
+		while(filteredTargetClassInstanceReferencesIt.hasNext())
+		{
+			Object ref=filteredTargetClassInstanceReferencesIt.next();
+			Map instanceProperties=dc.getSymbolsForInstance(this.targetClassName,this.symTab.getDefaultQualifier(), ref);
+			filteredTargetClassInstances.add(instanceProperties);
+		}
+
+
+
+
+		// The return type for flavour 2 is either an array of property values or a property value
+		ArrayList listOfValuesForProperty = createListOfValuesForProperty(targetClassPropertyName,filteredTargetClassInstances);
+
+		if(!noPostCollectOperation) // of the form collect(...)[exp]
+		{
+			result = postCollectOperation.evaluate(listOfValuesForProperty); // evaluation will pick one of the values of the listOfValuesForProperty array
+		}
+		else
+		{
+			//Integer index = (Integer)postCollectOperation.evaluate();
+			//result = listOfValuesForProperty.get(index.intValue());
+			result = listOfValuesForProperty; // there is no post collect therefore result is the entire array of property values
+		}
+
+		// return result;
+		logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "evaluateFlavour2");
+
+		return result;
+
+
+
+	}
+
+	//collect(<refExp>,<assocName>,<role1>,<role2>,<targetClass>,<expression>)[exp].param1[exp]
+	//			       .param1(pList)
+	private Object evaluateFlavour1() throws SPLException 
+	{
+		logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "evaluateFlavour1");
+		//System.out.println("evaluate evaluateFlavour1");
+
+
+		Object result = null;
+
+		//evaluate the the first parameter to get the source instance
+		Object refExpressionResult = referenceExpression.evaluate();
+		String refExpressionStr=refExpressionResult.toString();
+		//System.out.println("self = "+refExpressionResult);
+		DataCollector dc = DataCollectorFactory.getDataCollector();
+		//NRJ verify this works
+//		String refTypeName = referenceExpression.getReferenceTypeName();
+		//String refTypeName=dc.getReferenceTypeName(refExpressionStr);
+		List targetClassInstanceReferences = null;
+
+		// traverse association to get an array of target class instances. Each instance is a Map of key=values
+		if(logger.isLoggable(Level.FINE))
+			logger.fine(Thread.currentThread().getName()+" refExpressionResult evaluateFlavour1 "+refExpressionStr);
+
+		targetClassInstanceReferences = dc.getAssociatedInstanceReferences((Object)refExpressionResult,symTab.getDefaultQualifier(),targetClassName,associationName,sourceRole,targetRole);
+		//System.out.println("targetClassInstanceReferences size "+targetClassInstanceReferences.size());
+		if (logger.isLoggable(Level.FINE))
+			logger.fine(Thread.currentThread().getName()+" got associated references");
+
+//		targetClassInstance = dc.getAssociatedInstanceReferences(refTypeName, symTab.getDefaultQualifier(), targetClassName,associationName,sourceRole,targetRole, refExpressionResult);
+		if (logger.isLoggable(Level.FINE))
+			logger.fine(Thread.currentThread().getName()+" got associated instances");
+
+		// filter the List based on the target filter expression
+		List filteredTargetClassInstanceReferences = filterTargetClassInstanceReferencesWithTargetExpression(targetClassInstanceReferences , this.targetClassName,this.symTab.getDefaultQualifier());
+		//System.out.println("filteredTargetClassInstanceReferences size "+filteredTargetClassInstanceReferences.size());
+
+		if (logger.isLoggable(Level.FINE))
+			logger.fine(Thread.currentThread().getName()+" got filtered references");
+
+		List filteredTargetClassInstances = new ArrayList();
+
+		Iterator filteredTargetClassInstanceReferencesIt=filteredTargetClassInstanceReferences.iterator();
+		while(filteredTargetClassInstanceReferencesIt.hasNext())
+		{
+			Object ref=filteredTargetClassInstanceReferencesIt.next();
+			//System.out.println("filter passed : "+ref.toString());
+			Map instanceProperties=dc.getSymbolsForInstance(this.targetClassName,this.symTab.getDefaultQualifier(), ref);
+			filteredTargetClassInstances.add(instanceProperties);
+		}
+
+		if (logger.isLoggable(Level.FINE))
+			logger.fine(Thread.currentThread().getName()+" got filtered instances");
+
+		if(!noPostCollectOperation) // post collect exists
+		{
+			if(postCollectOperation.getType().getIsArray()) // of the form collect(...)[exp]
+			{	
+				result = postCollectOperation.evaluate(filteredTargetClassInstances); // will return a map corresponding to the instance to be returned
+				int instanceNumber=postCollectOperation.getInstanceNumer();
+				//symTab.populateInstanceValuesForCollect(this.targetClassName, this.targetClassName, filteredTargetClassInstances.get(instanceNumber), (Map)result); // populate it in the hashtable to obtain the string expression for the instance
+				// NRJ
+				symTab.populateInstanceValuesForInstance(this.targetClassName, this.targetClassName, 
+						filteredTargetClassInstances.get(instanceNumber), (Map)result); 
+				// populate it in the hashtable to obtain the string expression for the instance
+				//result = symTab.getInstance();
+
+			}	
+			else // post collect of the form collect(...)[exp].prop
+			{     
+				// the result will be calculated as follows for 
+				// a) in the case prop is not an array 
+				// 1. Of the array of target class instances passed as the parameter
+				// use the exp to pick one of the instances
+				// for this instance obtain the value of prop and return
+				// b) in the case prop is an array
+				// if of the form collect(...)[exp].prop[exp] and exp == 1then the result will be the props[1]
+				// if of the form collect(...)[exp].prop and prop is an array then the result will be an array of prop
+
+				result = postCollectOperation.evaluate(filteredTargetClassInstances);
+
+			}
+		}
+		else // no post collect result is an array of target instances that satisfy the filter
+		{
+			result = filteredTargetClassInstanceReferences;
+
+		}
+
+
+		logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "evaluateFlavour1");
+
+
+		return result;
+	}
+
+	// for flavour 2 need to extract the values for the property and create an array
+	private ArrayList createListOfValuesForProperty(String propertyName, ArrayList filteredTargetClassInstances) 
+	{
+		logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "createListOfValuesForProperty");
+		//System.out.println(" propertyName :"+propertyName);
+		//System.out.println(" filteredTargetClassInstances.size() :"+filteredTargetClassInstances.size());
+		
+		ArrayList propertyList = new ArrayList();
+		for(int i=0; i<filteredTargetClassInstances.size(); i++)
+		{
+			//System.out.println(" inside for");
+			Map currMap = (Map)filteredTargetClassInstances.get(i);
+			//System.out.println("currMap "+currMap.toString());
+			
+			Object s = (Object)currMap.get(propertyName);
+			//System.out.println("adding property "+propertyName);
+			//System.out.println(" object s :"+propertyName+" "+s.toString());
+			propertyList.add(s);
+
+		}
+
+		logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "createListOfValuesForProperty");
+
+		return propertyList;
+	}
+
+	// Given a list of Maps where each map corresponds to an instance of the target class
+	// filter out the instances which satisfy the boolean condition
+	/*   private ArrayList filterTargetClassInstancesWithTargetExpression(List targetClassInstanceReferences) throws SPLException 
+    {
+        logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "filterTargetClassInstancesWithTargetExpression");
+
+
+        ArrayList filteredTargetClassInstances = new ArrayList();
+
+        if(targetClassInstanceReferences!=null)
+        {
+            Iterator targetClassInstancesIt = targetClassInstanceReferences.iterator();
+            while(targetClassInstancesIt.hasNext())
+            {
+
+
+                Object instanceRefernce = targetClassInstancesIt.next();
+                DataCollector dc= DataCollectorFactory.getDataCollector();
+                Map instanceProperties=dc.getSymbolsForInstance(this.targetClassName, symTab.getDefaultQualifier(), instanceRefernce);
+                symTab.populateInstanceValuesForInstance(this.targetClassName, this.targetClassName, instanceRefernce, instanceProperties)populateSymbolTableWithInstanceValues(map);
+                Boolean result = (Boolean)expressionForTarget.evaluate();
+                if(result.booleanValue())
+                {
+                    filteredTargetClassInstances.add(map);
+                }
+            }	
+        }
+        else
+        {
+            if (logger.isLoggable(Level.FINE))
+                logger.fine(Thread.currentThread().getName()+" Zero instances passed in hence zero instance references filtered, therefore returning null ");
+        }
+
+        logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "filterTargetClassInstancesWithTargetExpression");
+
+        return filteredTargetClassInstances;
+    }
+	 */
+
+	private ArrayList filterTargetClassInstanceReferencesWithTargetExpression(List targetClassInstanceReferences , String className,String namespc) throws SPLException 
+	{
+		logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "filterTargetClassInstanceReferencesWithTargetExpression");
+		DataCollector dc = DataCollectorFactory.getDataCollector();
+		ArrayList filteredTargetClassInstanceReferences = new ArrayList();
+		if(targetClassInstanceReferences!=null)
+		{
+
+
+			Iterator it=targetClassInstanceReferences.iterator();
+			while(it.hasNext())
+			{
+				Object cop=(Object)it.next();
+				//System.out.println("getSymbolsForInstance "+className+" "+ namespc+" "+ cop);
+				Map map = dc.getSymbolsForInstance(className, namespc, cop);
+				//System.out.println("map.size() "+map.size()+" "+map.toString());
+				//symTab.populateInstanceValuesForCollect(className, className, cop, map);
+				//NRJ
+				symTab.populateInstanceValuesForInstance(className, className, cop, map);
+				Boolean result = (Boolean)expressionForTarget.evaluate();
+				//System.out.println("result "+result);
+				if(result.booleanValue())
+				{
+					if (logger.isLoggable(Level.FINE))
+						logger.fine(Thread.currentThread().getName()+" cop passed filter "+cop);
+					//System.out.println("adding cop to list "+cop.toString());
+					
+					filteredTargetClassInstanceReferences.add(cop);
+				}
+				else
+				{
+					if (logger.isLoggable(Level.FINE))
+						logger.fine(Thread.currentThread().getName()+" cop did not pass filter "+cop);
+
+
+				}
+			}
+		}
+		else
+		{
+			if (logger.isLoggable(Level.FINE))
+				logger.fine(Thread.currentThread().getName()+" Zero instances passed in hence zero instance references filtered, therefore returning null ");
+		}
+
+
+		logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "filterTargetClassInstanceReferencesWithTargetExpression");
+
+		return filteredTargetClassInstanceReferences;
+	}
+
+
+
+
+	public TypeInfo getType() throws SPLException {
+		logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "BasicCollectionExpression");
+
+		// if dataType is not set call validate so taht it gets set in the process
+		if(_dataType != null)
+		{
+
+			logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "getType");
+			return _dataType;
+
+		}
+
+		else
+		{
+			validate();
+
+			logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "getType");
+
+			return _dataType;
+		}
+
+
+	}
+
+
+	public String getReferenceTypeName() {
+		logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "getReferenceTypeName");
+
+
+		logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "getReferenceTypeName");
+
+		return returnClassName;
+	}
+
+
+
+	public boolean isArray() {
+		logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "isArray");
+
+
+		logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "isArray");
+
+		return this._dataType.getIsArray();
+	}
+
+	public String toString()
+	{
+		logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "toString");
+
+//		String className=this.getClass().getName();
+
+		String str="Collect(";
+
+		Iterator ExpIt=this.paramList.iterator();
+		while(ExpIt.hasNext()){
+			Expression exp=(Expression)ExpIt.next();
+			if(exp!=null){
+
+				String expstr=exp.toString();
+				str+=expstr + " , ";
+			}
+
+		}
+		str=str.substring(0, str.length()-3) +" ) ";
+//		if(this.expressionForTarget!=null){
+//			str+=" "+this.expressionForTarget.toString()+" ";
+//		}
+		if(this.postCollectOperation!=null){
+			str+="."+this.postCollectOperation.toString()+" ";
+		}
+//		if(this.referenceExpression!=null){
+//			str+=" "+this.referenceExpression.toString()+" ";
+//		}
+
+//		str+=" )";
+
+
+		logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "toString");
+
+		return str;
+	}
+
+	public static String getSourceClass()
+	{
+		return sourceClass;
+	}
+
+	public String getAssociationName()
+	{
+		return associationName;
+	}
+
+	public void setAssociationName(String associationName)
+	{
+		this.associationName = associationName;
+	}
+
+	public int getCollectType()
+	{
+		return collectType;
+	}
+
+	public void setCollectType(int collectType)
+	{
+		this.collectType = collectType;
+	}
+
+	public boolean isNoPostCollectOperation()
+	{
+		return noPostCollectOperation;
+	}
+
+	public void setNoPostCollectOperation(boolean noPostCollectOperation)
+	{
+		this.noPostCollectOperation = noPostCollectOperation;
+	}
+
+	public String getReturnClassName()
+	{
+		return returnClassName;
+	}
+
+	public void setReturnClassName(String returnClassName)
+	{
+		this.returnClassName = returnClassName;
+	}
+
+	public String getTargetClassName()
+	{
+		return targetClassName;
+	}
+
+	public void setTargetClassName(String targetClassName)
+	{
+		this.targetClassName = targetClassName;
+	}
+
+
+
+}

Propchange: incubator/imperius/trunk/imperius-splcore/src/main/java/org/apache/imperius/spl/parser/expression/primary/CollectOperation.java
------------------------------------------------------------------------------
    svn:eol-style = native

Modified: incubator/imperius/trunk/imperius-splcore/src/main/java/org/apache/imperius/spl/parser/expression/primary/MacroExpression.java
URL: http://svn.apache.org/viewvc/incubator/imperius/trunk/imperius-splcore/src/main/java/org/apache/imperius/spl/parser/expression/primary/MacroExpression.java?rev=611261&r1=611260&r2=611261&view=diff
==============================================================================
--- incubator/imperius/trunk/imperius-splcore/src/main/java/org/apache/imperius/spl/parser/expression/primary/MacroExpression.java (original)
+++ incubator/imperius/trunk/imperius-splcore/src/main/java/org/apache/imperius/spl/parser/expression/primary/MacroExpression.java Fri Jan 11 10:56:30 2008
@@ -1,161 +1,161 @@
-/*
- * 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 Neeraj Joshi <jneeraj@us.ibm.com>
- *
- */
-
-package org.apache.imperius.spl.parser.expression.primary;
-
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.logging.Logger;
-
-import org.apache.imperius.spl.external.Expression;
-import org.apache.imperius.spl.parser.compiler.symboltable.MacroSymbol;
-import org.apache.imperius.spl.parser.compiler.symboltable.PropertySymbol;
-import org.apache.imperius.spl.parser.compiler.symboltable.SPLSymbolTable;
-import org.apache.imperius.spl.parser.compiler.symboltable.Symbol;
-import org.apache.imperius.spl.parser.exceptions.SPLException;
-import org.apache.imperius.spl.parser.statements.impl.MacroDefinition;
-import org.apache.imperius.spl.parser.util.TypeInfo;
-import org.apache.imperius.spl.parser.util.TypeResolver;
-import org.apache.imperius.util.SPLLogger;
-
-
-public class MacroExpression implements Expression
-{
-    
-    private TypeInfo _returnType;
-    
-    private MacroDefinition _macroDefn;
-    
-    private List _passedParams;
-    
-      
-    private static Logger logger = SPLLogger.getSPLLogger().getLogger();
-    private static final String sourceClass="MacroExpression";
-    
-    private boolean _isArray = false;
-    
-    private String _referenceTypeName = "";
-    
-    public boolean isArray()
-    {
-        logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "isArray");
-
-        logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "isArray");
-        
-        return _isArray;
-    }
-    
-    public MacroExpression(MacroSymbol ms, ArrayList pList,
-            SPLSymbolTable symTab) throws SPLException
-    {
-        logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "MacroExpression");
-
-        
-        _returnType = ms.getType();
-        if(TypeResolver.isReference(_returnType))
-        {
-        	_referenceTypeName = ms.getReferenceTypeName();
-        }
-        _macroDefn = ms.getMacroDefn();
-        _passedParams = pList;
-      
-        validate();
-        if(_macroDefn.isArray())
-        {
-           _isArray = true;
-        }
-        logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "MacroExpression");
-        
-    }
-    
-    public Object evaluate() throws SPLException
-    {
-        logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
-
-        // TODO Auto-generated method stub
-        SPLSymbolTable macroSymbolTable = _macroDefn.getMacroSymTab();
-        
-        populateMacroSymbolTable(macroSymbolTable, _passedParams);
-        Object result = _macroDefn.evaluate();
-        logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
-        
-        return result;
-    }
-    
-    private void populateMacroSymbolTable(SPLSymbolTable macroSymbolTable,
-            List passedParams2) throws SPLException
-    {
-        logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "populateMacroSymbolTable");
-
-        Map symbolMap = macroSymbolTable.getSymbolMap();
-        Iterator keySetIt = symbolMap.keySet().iterator();
-        Iterator passedParamIt = passedParams2.iterator();
-        while (keySetIt.hasNext() && passedParamIt.hasNext())
-        {
-            String symbolName = (String) keySetIt.next();
-            Symbol sym = (Symbol) symbolMap.get(symbolName);
-            
-            Expression currentParam = (Expression) passedParamIt.next();
-            Object value = currentParam.evaluate();
-           //System.out.println("symbolName,value : "+symbolName+" "+ value);
-            ((PropertySymbol) sym).setValue(value);
-        }
-        logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "populateMacroSymbolTable");
-        
-        
-    }
-    
-    public TypeInfo getType()
-    {
-        
-        return _returnType;
-    }
-    
-    public boolean validate() throws SPLException
-    {
-        logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "validate");
-
-        List formalParams = _macroDefn.getArgList();
-        TypeResolver.validateActualParameterTypes(formalParams, _passedParams);
-        logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validate");
-        
-        return true;
-    }
-    
-    public String toString()
-    {
-        logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "toString");
-        
-        String str = _macroDefn.getMacroName()+" ( "+_macroDefn.getMacroExpression().toString()+" ) ";
-                
-        logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "toString");
-       
-        return str;
-    }
-
-	public String getReferenceTypeName() throws SPLException 
-	{
-		
-		return _referenceTypeName;
-	}
-    
-}
+/*
+ * 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 Neeraj Joshi <jneeraj@us.ibm.com>
+ *
+ */
+
+package org.apache.imperius.spl.parser.expression.primary;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Logger;
+
+import org.apache.imperius.spl.external.Expression;
+import org.apache.imperius.spl.parser.compiler.symboltable.MacroSymbol;
+import org.apache.imperius.spl.parser.compiler.symboltable.PropertySymbol;
+import org.apache.imperius.spl.parser.compiler.symboltable.SPLSymbolTable;
+import org.apache.imperius.spl.parser.compiler.symboltable.Symbol;
+import org.apache.imperius.spl.parser.exceptions.SPLException;
+import org.apache.imperius.spl.parser.statements.impl.MacroDefinition;
+import org.apache.imperius.spl.parser.util.TypeInfo;
+import org.apache.imperius.spl.parser.util.TypeResolver;
+import org.apache.imperius.util.SPLLogger;
+
+
+public class MacroExpression implements Expression
+{
+    
+    private TypeInfo _returnType;
+    
+    private MacroDefinition _macroDefn;
+    
+    private List _passedParams;
+    
+      
+    private static Logger logger = SPLLogger.getSPLLogger().getLogger();
+    private static final String sourceClass="MacroExpression";
+    
+    private boolean _isArray = false;
+    
+    private String _referenceTypeName = "";
+    
+    public boolean isArray()
+    {
+        logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "isArray");
+
+        logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "isArray");
+        
+        return _isArray;
+    }
+    
+    public MacroExpression(MacroSymbol ms, ArrayList pList,
+            SPLSymbolTable symTab) throws SPLException
+    {
+        logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "MacroExpression");
+
+        
+        _returnType = ms.getType();
+        if(TypeResolver.isReference(_returnType))
+        {
+        	_referenceTypeName = ms.getReferenceTypeName();
+        }
+        _macroDefn = ms.getMacroDefn();
+        _passedParams = pList;
+      
+        validate();
+        if(_macroDefn.isArray())
+        {
+           _isArray = true;
+        }
+        logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "MacroExpression");
+        
+    }
+    
+    public Object evaluate() throws SPLException
+    {
+        logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
+
+        // TODO Auto-generated method stub
+        SPLSymbolTable macroSymbolTable = _macroDefn.getMacroSymTab();
+        
+        populateMacroSymbolTable(macroSymbolTable, _passedParams);
+        Object result = _macroDefn.evaluate();
+        logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "evaluate");
+        
+        return result;
+    }
+    
+    private void populateMacroSymbolTable(SPLSymbolTable macroSymbolTable,
+            List passedParams2) throws SPLException
+    {
+        logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "populateMacroSymbolTable");
+
+        Map symbolMap = macroSymbolTable.getSymbolMap();
+        Iterator keySetIt = symbolMap.keySet().iterator();
+        Iterator passedParamIt = passedParams2.iterator();
+        while (keySetIt.hasNext() && passedParamIt.hasNext())
+        {
+            String symbolName = (String) keySetIt.next();
+            Symbol sym = (Symbol) symbolMap.get(symbolName);
+            
+            Expression currentParam = (Expression) passedParamIt.next();
+            Object value = currentParam.evaluate();
+           //System.out.println("symbolName,value : "+symbolName+" "+ value);
+            ((PropertySymbol) sym).setValue(value);
+        }
+        logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "populateMacroSymbolTable");
+        
+        
+    }
+    
+    public TypeInfo getType()
+    {
+        
+        return _returnType;
+    }
+    
+    public boolean validate() throws SPLException
+    {
+        logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "validate");
+
+        List formalParams = _macroDefn.getArgList();
+        TypeResolver.validateActualParameterTypes(formalParams, _passedParams);
+        logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "validate");
+        
+        return true;
+    }
+    
+    public String toString()
+    {
+        logger.entering(sourceClass,Thread.currentThread().getName()+" "+ "toString");
+        
+        String str = _macroDefn.getMacroName()+" ( "+_macroDefn.getMacroExpression().toString()+" ) ";
+                
+        logger.exiting(sourceClass,Thread.currentThread().getName()+" "+ "toString");
+       
+        return str;
+    }
+
+	public String getReferenceTypeName() throws SPLException 
+	{
+		
+		return _referenceTypeName;
+	}
+    
+}

Propchange: incubator/imperius/trunk/imperius-splcore/src/main/java/org/apache/imperius/spl/parser/expression/primary/MacroExpression.java
------------------------------------------------------------------------------
    svn:eol-style = native



Mime
View raw message