org.eclipse.modisco.usecase.modelfilter.methodcalls.discoverer/src/org/eclipse/modisco/usecase/modelfilter/methodcalls/discoverer/internal/converter/MethodCallsGraphConverter.java - modisco/org.eclipse.modisco - Git at Google

 /**
  * Copyright (c) 2010, 2011 Mia-Software.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *    Gabriel Barbier (Mia-Software) - initial API and implementation
  *    Fabien Giquel (Mia-Software) - Bug 339720 : MoDisco Discoverers (infra + techno) API clean
  *    Nicolas Bros (Mia-Software) - Bug 335003 - [Discoverer] : Existing Discoverers Refactoring based on new framework
  *******************************************************************************/

 package org.eclipse.modisco.usecase.modelfilter.methodcalls.discoverer.internal.converter;

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;

 import org.eclipse.emf.common.util.TreeIterator;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.resource.Resource;
 import org.eclipse.gmt.modisco.java.AbstractMethodDeclaration;
 import org.eclipse.gmt.modisco.java.AbstractMethodInvocation;
 import org.eclipse.gmt.modisco.java.Assignment;
 import org.eclipse.gmt.modisco.java.Block;
 import org.eclipse.gmt.modisco.java.BodyDeclaration;
 import org.eclipse.gmt.modisco.java.ClassDeclaration;
 import org.eclipse.gmt.modisco.java.ClassInstanceCreation;
 import org.eclipse.gmt.modisco.java.Expression;
 import org.eclipse.gmt.modisco.java.MethodInvocation;
 import org.eclipse.gmt.modisco.java.SingleVariableAccess;
 import org.eclipse.gmt.modisco.java.TypeAccess;
 import org.eclipse.gmt.modisco.java.TypeDeclaration;
 import org.eclipse.gmt.modisco.java.VariableDeclaration;
 import org.eclipse.modisco.usecase.modelfilter.methodcalls.methodcalls.CallNode;
 import org.eclipse.modisco.usecase.modelfilter.methodcalls.methodcalls.CallsModel;
 import org.eclipse.modisco.usecase.modelfilter.methodcalls.methodcalls.MethodCall;
 import org.eclipse.modisco.usecase.modelfilter.methodcalls.methodcalls.MethodcallsFactory;

 /**
  * From a java model, we will extract method calls informations to initialise a
  * method calls model.
  */
 public class MethodCallsGraphConverter {

 	private final MethodcallsFactory factory = MethodcallsFactory.eINSTANCE;
 	private final Map<AbstractMethodDeclaration, CallNode> javaOperationToCallNode = new HashMap<AbstractMethodDeclaration, CallNode>();
 	private final List<AbstractMethodInvocation> allInvocations = new ArrayList<AbstractMethodInvocation>();
 	private final List<TypeDeclaration> allTypes = new ArrayList<TypeDeclaration>();

 	/**
 	 * From a java resource, we will compute method calls graph then initialize
 	 * a method calls model.
 	 *
 	 * @param javaResource
 	 * @return corresponding method calls model
 	 */
 	public CallsModel convertJavaResourceToMethodCallsModel(
 			final Resource javaResource, final String targetModelName) {
 		/*
 		 * Create method calls model root
 		 */
 		CallsModel callsModel = this.factory.createCallsModel();
 		callsModel.setName(targetModelName);

 		List<AbstractMethodDeclaration> allOperations = getAllOperations(javaResource);
 		/*
 		 * iterate over all operations to initialize call nodes
 		 */
 		for (AbstractMethodDeclaration javaOperation : allOperations) {
 			/*
 			 * create calls node
 			 */
 			CallNode callNode = this.factory.createCallNode();
 			callNode.setJavaMethod(javaOperation);
 			callsModel.getCallNodes().add(callNode);
 			if (javaOperation.getUsages().isEmpty()) {
 				callsModel.getRootNodes().add(callNode);
 			}
 			// init also convenient hashmap ...
 			this.javaOperationToCallNode.put(javaOperation, callNode);
 		}
 		/*
 		 * iterate over all operations to compute method calls informations
 		 */
 		for (AbstractMethodDeclaration javaOperation : allOperations) {
 			CallNode callNode = this.javaOperationToCallNode.get(javaOperation);
 			List<AbstractMethodInvocation> calledMethods = getCalledMethods(javaOperation);
 			/*
 			 * Compute call node name
 			 */
 			String parentName = ""; //$NON-NLS-1$
 			if (javaOperation.getAbstractTypeDeclaration() != null) {
 				parentName = javaOperation.getAbstractTypeDeclaration()
 						.getName();
 			}
 			String name = parentName + " :: " + javaOperation.getName(); //$NON-NLS-1$
 			if (!calledMethods.isEmpty()) {
 				name = name + " (" + calledMethods.size() + ")"; //$NON-NLS-1$ //$NON-NLS-2$
 			}
 			callNode.setName(name);
 			/*
 			 * initialize method call elements
 			 */
 			for (int index = 0; index < calledMethods.size(); index++) {
 				MethodCall methodCall = this.factory.createMethodCall();
 				methodCall.setOrder(index);
 				CallNode callee = this.javaOperationToCallNode
 						.get(calledMethods.get(index).getMethod());
 				methodCall.setCallee(callee);
 				/*
 				 * compute filtered methods 1. we have to retrieve variable
 				 * declaration which contains this method invocation, if it
 				 * exists. 2. get collection of filtered potential types
 				 */
 				VariableDeclaration variableDeclaration = getVariableDeclaration(calledMethods
 						.get(index));
 				if (variableDeclaration != null) {
 					for (TypeDeclaration subtype : getFilteredPotentialTypes(variableDeclaration)) {
 						/*
 						 * we have to retrieve corresponding method same name,
 						 * same number of parameters same name of parameters ?
 						 * -> may change same type of parameters ? may be a
 						 * subtype
 						 */
 						for (BodyDeclaration body : subtype
 								.getBodyDeclarations()) {
 							if (body instanceof AbstractMethodDeclaration) {
 								AbstractMethodDeclaration subMethod = (AbstractMethodDeclaration) body;
 								if (javaOperation.getName().equals(
 										body.getName())) {
 									if (javaOperation.getParameters().size() == subMethod
 											.getParameters().size()) {
 										CallNode subNode = this.javaOperationToCallNode
 												.get(subMethod);
 										methodCall.getFilteredSubMethods().add(
 												subNode);
 									}
 								}
 							}
 						}
 					}
 				}
 				/*
 				 * if everything is ok, we could add this method call to current
 				 * call node element.
 				 */
 				callNode.getMethodCalls().add(methodCall);
 			}
 			/*
 			 * initialize collection of sub methods
 			 */
 			TypeDeclaration parentType = getTypeDeclaration(javaOperation);
 			for (TypeDeclaration subtype : getAllSubTypes(parentType)) {
 				/*
 				 * we have to retrieve corresponding method same name, same
 				 * number of parameters same name of parameters ? -> may change
 				 * same type of parameters ? may be a subtype
 				 */
 				for (BodyDeclaration body : subtype.getBodyDeclarations()) {
 					if (body instanceof AbstractMethodDeclaration) {
 						AbstractMethodDeclaration subMethod = (AbstractMethodDeclaration) body;
 						if (javaOperation.getName().equals(body.getName())) {
 							if (javaOperation.getParameters().size() == subMethod
 									.getParameters().size()) {
 								CallNode subNode = this.javaOperationToCallNode
 										.get(subMethod);
 								callNode.getSubMethods().add(subNode);
 							}
 						}
 					}
 				}
 			}
 		}
 		return callsModel;
 	}

 	/**
 	 * To retrieve all method declarations from java model.
 	 *
 	 * We will also initialize collections of types and method invocations to
 	 * iterate only once on all java elements.
 	 *
 	 * @param javaResource
 	 * @return
 	 */
 	private final List<AbstractMethodDeclaration> getAllOperations(
 			final Resource javaResource) {
 		List<AbstractMethodDeclaration> result = new ArrayList<AbstractMethodDeclaration>();
 		TreeIterator<EObject> iterator = javaResource.getAllContents();
 		while (iterator.hasNext()) {
 			EObject object = iterator.next();
 			if (object instanceof AbstractMethodDeclaration) {
 				AbstractMethodDeclaration operation = (AbstractMethodDeclaration) object;
 				result.add(operation);
 			} else if (object instanceof AbstractMethodInvocation) {
 				AbstractMethodInvocation invocation = (AbstractMethodInvocation) object;
 				this.allInvocations.add(invocation);
 			} else if (object instanceof TypeDeclaration) {
 				TypeDeclaration currentClassDeclaration = (TypeDeclaration) object;
 				this.allTypes.add(currentClassDeclaration);
 			}
 		}
 		return result;
 	}

 	/**
 	 * If we want to get all the called methods from this method declaration, we
 	 * have to select all usages which are contained by this method declaration.
 	 * It means all instances of AbstractMethodInvocation Yet, we have also to
 	 * sort this collection by its order in call sequence
 	 *
 	 * @param parent
 	 * @return
 	 */
 	private final List<AbstractMethodInvocation> getCalledMethods(
 			final AbstractMethodDeclaration parent) {
 		List<AbstractMethodInvocation> invocations = getInvocations(parent);
 		// sort invocations ...
 		Collections.sort(invocations, new MethodInvocationComparator());
 		return invocations;
 	}

 	/**
 	 * To retrieve all method invocations that are contained by this method
 	 * declaration element.
 	 *
 	 * @param parent
 	 * @return
 	 */
 	private final List<AbstractMethodInvocation> getInvocations(
 			final AbstractMethodDeclaration parent) {
 		List<AbstractMethodInvocation> invocations = new ArrayList<AbstractMethodInvocation>();
 		for (AbstractMethodInvocation invocation : this.allInvocations) {
 			if (parent == getInvoker(invocation)) {
 				invocations.add(invocation);
 			}
 		}
 		return invocations;
 	}

 	/**
 	 * To retrieve the method declaration element which contains the source
 	 * method invocation. Type of parameter element is EObject, because we have
 	 * to navigate into statements hierarchy which many different kinds of
 	 * elements
 	 *
 	 * @param element
 	 * @return
 	 */
 	private final AbstractMethodDeclaration getInvoker(final EObject element) {
 		AbstractMethodDeclaration result = null;
 		if (element != null) {
 			if (element instanceof AbstractMethodDeclaration) {
 				result = (AbstractMethodDeclaration) element;
 			} else {
 				result = getInvoker(element.eContainer());
 			}
 		}
 		return result;
 	}

 	protected static class MethodInvocationComparator implements
 			Comparator<AbstractMethodInvocation> {

 		public int compare(final AbstractMethodInvocation invocation1,
 				final AbstractMethodInvocation invocation2) {
 			int result = -1;
 			/*
 			 * Initially, I used location in file to sort invocations, but
 			 * needed information is no longer retained in java model ...
 			 *
 			 * Perhaps could I use index of parent element which is directly
 			 * contained in block statement of the declaring method ?
 			 */
 			Block rootBlock1 = getRootBlock(invocation1);
 			Block rootBlock2 = getRootBlock(invocation2);
 			if ((rootBlock1 == null) || (rootBlock2 == null)) {
 				result = 0;
 			} else {
 				int index1 = computeIndex(invocation1, rootBlock1);
 				int index2 = computeIndex(invocation2, rootBlock2);
 				/*
 				 * specific case: both invocations have the same index and are
 				 * contained in the same block.
 				 *
 				 * So we have to retrieve first common parent block and use it
 				 * to compute index ...
 				 */
 				if ((index1 == index2) && (rootBlock1 == rootBlock2)) {
 					Block commonBlock = getFirstCommonParentBlock(invocation1,
 							invocation2, rootBlock1);
 					index1 = computeIndex(invocation1, commonBlock);
 					index2 = computeIndex(invocation2, commonBlock);
 				}

 				result = Integer.valueOf(index1).compareTo(
 						Integer.valueOf(index2));
 			}
 			return result;
 		}

 		private static final int INVALID_INDEX = -2;
 		private final int computeIndex(final EObject element,
 				final Block rootBlock) {
 			int result = MethodCallsGraphConverter.MethodInvocationComparator.INVALID_INDEX;
 			if (element.eContainer() == rootBlock) {
 				result = rootBlock.getStatements().indexOf(element);
 			} else {
 				result = computeIndex(element.eContainer(), rootBlock);
 			}
 			return result;
 		}

 		private final Block getRootBlock(final EObject element) {
 			Block result = null;
 			if (element != null) {
 				if (element instanceof AbstractMethodDeclaration) {
 					result = ((AbstractMethodDeclaration) element).getBody();
 				} else {
 					result = getRootBlock(element.eContainer());
 				}
 			}
 			return result;
 		}

 		/*
 		 * To retrieve the first common parent block of two elements lets start
 		 * from an example: block A contains another block B (with other
 		 * statements) block B contains two blocks C and D which contains
 		 * respectively element1 and element2
 		 *
 		 * Here the algorithm: From element1, I get the nearest parent block
 		 * Then I will iterate on all parent blocks of element2 and test
 		 * identity If not found, I have to iterate on parent block of element1
 		 * And test again on all parent blocks of element2 ...
 		 */
 		private final Block getFirstCommonParentBlock(
 				final EObject sourceElement, final EObject element2,
 				final Block stopper) {
 			Block result = getParentBlock(sourceElement);
 			if (result != stopper) {
 				if (!isParentBlock(element2, result, stopper)) {
 					result = getFirstCommonParentBlock(result, element2,
 							stopper);
 				} // else, result is the first common parent block
 			}
 			return result;
 		}

 		private final boolean isParentBlock(final EObject element,
 				final Block target, final Block stopper) {
 			boolean result = false;
 			Block parent = getParentBlock(element);
 			if (parent != stopper) {
 				if (parent == target) {
 					result = true;
 				} else {
 					result = isParentBlock(parent, target, stopper);
 				}
 			}
 			return result;
 		}

 		private final Block getParentBlock(final EObject element) {
 			Block result = null;
 			if (element != null) {
 				if (element.eContainer() instanceof Block) {
 					result = (Block) element.eContainer();
 				} else {
 					result = getParentBlock(element.eContainer());
 				}
 			}
 			return result;
 		}
 	}

 	/**
 	 * To retrieve the type declaration which contains source element (which is
 	 * at the beginning a method declaration element)
 	 *
 	 * @param element
 	 * @return
 	 */
 	private final TypeDeclaration getTypeDeclaration(final EObject element) {
 		TypeDeclaration result = null;
 		if (element != null) {
 			if (element instanceof TypeDeclaration) {
 				result = (TypeDeclaration) element;
 			} else {
 				result = getTypeDeclaration(element.eContainer());
 			}
 		}
 		return result;
 	}

 	/**
 	 * To retrieve all sub types of parameter (type declaration element)
 	 *
 	 * @param contextClass
 	 * @return
 	 */
 	private final Set<TypeDeclaration> getAllSubTypes(
 			final TypeDeclaration contextClass) {
 		Set<TypeDeclaration> result = new HashSet<TypeDeclaration>();
 		if (contextClass != null) {
 			for (TypeDeclaration currentClassDeclaration : this.allTypes) {
 				if (isSuperTypeOf(contextClass, currentClassDeclaration)) {
 					result.add(currentClassDeclaration);
 					result.addAll(getAllSubTypes(currentClassDeclaration));
 				}
 			}
 		}
 		return result;
 	}

 	/**
 	 * To compute a boolean which indicate if a type (self) is in parent
 	 * hierarchy of an other type (typeDeclaration).
 	 *
 	 * @param self
 	 * @param typeDeclaration
 	 * @return true if self is a super type of typeDeclaration
 	 */
 	private final boolean isSuperTypeOf(final TypeDeclaration self,
 			final TypeDeclaration typeDeclaration) {
 		if (typeDeclaration.getSuperInterfaces().contains(self)) {
 			return true;
 		}
 		for (TypeAccess superTypeAccess : typeDeclaration.getSuperInterfaces()) {
 			if (superTypeAccess.getType() instanceof TypeDeclaration) {
 				TypeDeclaration superType = (TypeDeclaration) superTypeAccess
 						.getType();
 				if (superType == self || isSuperTypeOf(self, superType)) {
 					return true;
 				}
 			}
 		}
 		if (typeDeclaration instanceof ClassDeclaration) {
 			ClassDeclaration classDeclaration = (ClassDeclaration) typeDeclaration;
 			if (classDeclaration.getSuperClass() != null
 					&& classDeclaration.getSuperClass().getType() == self) {
 				return true;
 			}
 			if (classDeclaration.getSuperClass() != null
 					&& classDeclaration.getSuperClass().getType() instanceof TypeDeclaration) {
 				TypeDeclaration superType = (TypeDeclaration) classDeclaration
 						.getSuperClass().getType();
 				if (isSuperTypeOf(self, superType)) {
 					return true;
 				}
 			}
 		}
 		return false;
 	}

 	private static final VariableDeclaration getVariableDeclaration(
 			final AbstractMethodInvocation abstractMethodInvocation) {
 		VariableDeclaration result = null;
 		if (abstractMethodInvocation instanceof MethodInvocation) {
 			MethodInvocation methodInvocation = (MethodInvocation) abstractMethodInvocation;
 			if ((methodInvocation.getExpression() != null)
 					&& (methodInvocation.getExpression() instanceof SingleVariableAccess)) {
 				SingleVariableAccess singleVariableAccess = (SingleVariableAccess) methodInvocation
 						.getExpression();
 				result = singleVariableAccess.getVariable();
 			}
 		}
 		return result;
 	}

 	private final Set<TypeDeclaration> getFilteredPotentialTypes(
 			final VariableDeclaration variableDeclaration) {
 		List<VariableDeclaration> parents = new ArrayList<VariableDeclaration>();
 		Set<TypeDeclaration> result = getBasicFilteredPotentialTypes(
 				variableDeclaration, parents);
 		return result;
 	}

 	private final Set<TypeDeclaration> getBasicFilteredPotentialTypes(
 			final VariableDeclaration source,
 			final List<VariableDeclaration> parents) {
 		Set<TypeDeclaration> result = new HashSet<TypeDeclaration>();
 		if (!parents.contains(source)) {
 			parents.add(source);

 			Expression initializer = source.getInitializer();
 			if ((initializer != null)
 					&& (initializer instanceof ClassInstanceCreation)) {
 				ClassInstanceCreation classInstanceCreation = (ClassInstanceCreation) initializer;
 				if (classInstanceCreation.getType().getType() instanceof TypeDeclaration) {
 					result.add((TypeDeclaration) classInstanceCreation
 							.getType().getType());
 				}
 			}
 			result.addAll(filterAssignement(source, parents));
 		}
 		return result;
 	}

 	private final Set<TypeDeclaration> filterAssignement(
 			final VariableDeclaration source,
 			final List<VariableDeclaration> parents) {
 		Set<TypeDeclaration> result = new HashSet<TypeDeclaration>();
 		for (SingleVariableAccess access : source.getUsageInVariableAccess()) {
 			EObject container = access.eContainer();
 			if (container instanceof Assignment) {
 				Assignment assignment = (Assignment) container;
 				Expression expression = assignment.getRightHandSide();
 				if (expression instanceof ClassInstanceCreation) {
 					ClassInstanceCreation classInstanceCreation = (ClassInstanceCreation) expression;
 					if (classInstanceCreation.getType().getType() instanceof TypeDeclaration) {
 						result.add((TypeDeclaration) classInstanceCreation
 								.getType().getType());
 					}
 				} else if (expression instanceof SingleVariableAccess) {
 					/*
 					 * potential infinite recursion
 					 *
 					 * Object tmp; Object src = tmp; ... tmp = src;
 					 */
 					SingleVariableAccess singleVariableAccess = (SingleVariableAccess) expression;
 					result.addAll(getBasicFilteredPotentialTypes(
 							singleVariableAccess.getVariable(), parents));
 				}
 			}
 		}
 		return result;
 	}

 }
	/**
	* Copyright (c) 2010, 2011 Mia-Software.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* Gabriel Barbier (Mia-Software) - initial API and implementation
	* Fabien Giquel (Mia-Software) - Bug 339720 : MoDisco Discoverers (infra + techno) API clean
	* Nicolas Bros (Mia-Software) - Bug 335003 - [Discoverer] : Existing Discoverers Refactoring based on new framework
	*******************************************************************************/

	package org.eclipse.modisco.usecase.modelfilter.methodcalls.discoverer.internal.converter;

	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.Comparator;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;

	import org.eclipse.emf.common.util.TreeIterator;
	import org.eclipse.emf.ecore.EObject;
	import org.eclipse.emf.ecore.resource.Resource;
	import org.eclipse.gmt.modisco.java.AbstractMethodDeclaration;
	import org.eclipse.gmt.modisco.java.AbstractMethodInvocation;
	import org.eclipse.gmt.modisco.java.Assignment;
	import org.eclipse.gmt.modisco.java.Block;
	import org.eclipse.gmt.modisco.java.BodyDeclaration;
	import org.eclipse.gmt.modisco.java.ClassDeclaration;
	import org.eclipse.gmt.modisco.java.ClassInstanceCreation;
	import org.eclipse.gmt.modisco.java.Expression;
	import org.eclipse.gmt.modisco.java.MethodInvocation;
	import org.eclipse.gmt.modisco.java.SingleVariableAccess;
	import org.eclipse.gmt.modisco.java.TypeAccess;
	import org.eclipse.gmt.modisco.java.TypeDeclaration;
	import org.eclipse.gmt.modisco.java.VariableDeclaration;
	import org.eclipse.modisco.usecase.modelfilter.methodcalls.methodcalls.CallNode;
	import org.eclipse.modisco.usecase.modelfilter.methodcalls.methodcalls.CallsModel;
	import org.eclipse.modisco.usecase.modelfilter.methodcalls.methodcalls.MethodCall;
	import org.eclipse.modisco.usecase.modelfilter.methodcalls.methodcalls.MethodcallsFactory;

	/**
	* From a java model, we will extract method calls informations to initialise a
	* method calls model.
	*/
	public class MethodCallsGraphConverter {

	private final MethodcallsFactory factory = MethodcallsFactory.eINSTANCE;
	private final Map<AbstractMethodDeclaration, CallNode> javaOperationToCallNode = new HashMap<AbstractMethodDeclaration, CallNode>();
	private final List<AbstractMethodInvocation> allInvocations = new ArrayList<AbstractMethodInvocation>();
	private final List<TypeDeclaration> allTypes = new ArrayList<TypeDeclaration>();

	/**
	* From a java resource, we will compute method calls graph then initialize
	* a method calls model.
	*
	* @param javaResource
	* @return corresponding method calls model
	*/
	public CallsModel convertJavaResourceToMethodCallsModel(
	final Resource javaResource, final String targetModelName) {
	/*
	* Create method calls model root
	*/
	CallsModel callsModel = this.factory.createCallsModel();
	callsModel.setName(targetModelName);

	List<AbstractMethodDeclaration> allOperations = getAllOperations(javaResource);
	/*
	* iterate over all operations to initialize call nodes
	*/
	for (AbstractMethodDeclaration javaOperation : allOperations) {
	/*
	* create calls node
	*/
	CallNode callNode = this.factory.createCallNode();
	callNode.setJavaMethod(javaOperation);
	callsModel.getCallNodes().add(callNode);
	if (javaOperation.getUsages().isEmpty()) {
	callsModel.getRootNodes().add(callNode);
	}
	// init also convenient hashmap ...
	this.javaOperationToCallNode.put(javaOperation, callNode);
	}
	/*
	* iterate over all operations to compute method calls informations
	*/
	for (AbstractMethodDeclaration javaOperation : allOperations) {
	CallNode callNode = this.javaOperationToCallNode.get(javaOperation);
	List<AbstractMethodInvocation> calledMethods = getCalledMethods(javaOperation);
	/*
	* Compute call node name
	*/
	String parentName = ""; //$NON-NLS-1$
	if (javaOperation.getAbstractTypeDeclaration() != null) {
	parentName = javaOperation.getAbstractTypeDeclaration()
	.getName();
	}
	String name = parentName + " :: " + javaOperation.getName(); //$NON-NLS-1$
	if (!calledMethods.isEmpty()) {
	name = name + " (" + calledMethods.size() + ")"; //$NON-NLS-1$ //$NON-NLS-2$
	}
	callNode.setName(name);
	/*
	* initialize method call elements
	*/
	for (int index = 0; index < calledMethods.size(); index++) {
	MethodCall methodCall = this.factory.createMethodCall();
	methodCall.setOrder(index);
	CallNode callee = this.javaOperationToCallNode
	.get(calledMethods.get(index).getMethod());
	methodCall.setCallee(callee);
	/*
	* compute filtered methods 1. we have to retrieve variable
	* declaration which contains this method invocation, if it
	* exists. 2. get collection of filtered potential types
	*/
	VariableDeclaration variableDeclaration = getVariableDeclaration(calledMethods
	.get(index));
	if (variableDeclaration != null) {
	for (TypeDeclaration subtype : getFilteredPotentialTypes(variableDeclaration)) {
	/*
	* we have to retrieve corresponding method same name,
	* same number of parameters same name of parameters ?
	* -> may change same type of parameters ? may be a
	* subtype
	*/
	for (BodyDeclaration body : subtype
	.getBodyDeclarations()) {
	if (body instanceof AbstractMethodDeclaration) {
	AbstractMethodDeclaration subMethod = (AbstractMethodDeclaration) body;
	if (javaOperation.getName().equals(
	body.getName())) {
	if (javaOperation.getParameters().size() == subMethod
	.getParameters().size()) {
	CallNode subNode = this.javaOperationToCallNode
	.get(subMethod);
	methodCall.getFilteredSubMethods().add(
	subNode);
	}
	}
	}
	}
	}
	}
	/*
	* if everything is ok, we could add this method call to current
	* call node element.
	*/
	callNode.getMethodCalls().add(methodCall);
	}
	/*
	* initialize collection of sub methods
	*/
	TypeDeclaration parentType = getTypeDeclaration(javaOperation);
	for (TypeDeclaration subtype : getAllSubTypes(parentType)) {
	/*
	* we have to retrieve corresponding method same name, same
	* number of parameters same name of parameters ? -> may change
	* same type of parameters ? may be a subtype
	*/
	for (BodyDeclaration body : subtype.getBodyDeclarations()) {
	if (body instanceof AbstractMethodDeclaration) {
	AbstractMethodDeclaration subMethod = (AbstractMethodDeclaration) body;
	if (javaOperation.getName().equals(body.getName())) {
	if (javaOperation.getParameters().size() == subMethod
	.getParameters().size()) {
	CallNode subNode = this.javaOperationToCallNode
	.get(subMethod);
	callNode.getSubMethods().add(subNode);
	}
	}
	}
	}
	}
	}
	return callsModel;
	}

	/**
	* To retrieve all method declarations from java model.
	*
	* We will also initialize collections of types and method invocations to
	* iterate only once on all java elements.
	*
	* @param javaResource
	* @return
	*/
	private final List<AbstractMethodDeclaration> getAllOperations(
	final Resource javaResource) {
	List<AbstractMethodDeclaration> result = new ArrayList<AbstractMethodDeclaration>();
	TreeIterator<EObject> iterator = javaResource.getAllContents();
	while (iterator.hasNext()) {
	EObject object = iterator.next();
	if (object instanceof AbstractMethodDeclaration) {
	AbstractMethodDeclaration operation = (AbstractMethodDeclaration) object;
	result.add(operation);
	} else if (object instanceof AbstractMethodInvocation) {
	AbstractMethodInvocation invocation = (AbstractMethodInvocation) object;
	this.allInvocations.add(invocation);
	} else if (object instanceof TypeDeclaration) {
	TypeDeclaration currentClassDeclaration = (TypeDeclaration) object;
	this.allTypes.add(currentClassDeclaration);
	}
	}
	return result;
	}

	/**
	* If we want to get all the called methods from this method declaration, we
	* have to select all usages which are contained by this method declaration.
	* It means all instances of AbstractMethodInvocation Yet, we have also to
	* sort this collection by its order in call sequence
	*
	* @param parent
	* @return
	*/
	private final List<AbstractMethodInvocation> getCalledMethods(
	final AbstractMethodDeclaration parent) {
	List<AbstractMethodInvocation> invocations = getInvocations(parent);
	// sort invocations ...
	Collections.sort(invocations, new MethodInvocationComparator());
	return invocations;
	}

	/**
	* To retrieve all method invocations that are contained by this method
	* declaration element.
	*
	* @param parent
	* @return
	*/
	private final List<AbstractMethodInvocation> getInvocations(
	final AbstractMethodDeclaration parent) {
	List<AbstractMethodInvocation> invocations = new ArrayList<AbstractMethodInvocation>();
	for (AbstractMethodInvocation invocation : this.allInvocations) {
	if (parent == getInvoker(invocation)) {
	invocations.add(invocation);
	}
	}
	return invocations;
	}

	/**
	* To retrieve the method declaration element which contains the source
	* method invocation. Type of parameter element is EObject, because we have
	* to navigate into statements hierarchy which many different kinds of
	* elements
	*
	* @param element
	* @return
	*/
	private final AbstractMethodDeclaration getInvoker(final EObject element) {
	AbstractMethodDeclaration result = null;
	if (element != null) {
	if (element instanceof AbstractMethodDeclaration) {
	result = (AbstractMethodDeclaration) element;
	} else {
	result = getInvoker(element.eContainer());
	}
	}
	return result;
	}

	protected static class MethodInvocationComparator implements
	Comparator<AbstractMethodInvocation> {

	public int compare(final AbstractMethodInvocation invocation1,
	final AbstractMethodInvocation invocation2) {
	int result = -1;
	/*
	* Initially, I used location in file to sort invocations, but
	* needed information is no longer retained in java model ...
	*
	* Perhaps could I use index of parent element which is directly
	* contained in block statement of the declaring method ?
	*/
	Block rootBlock1 = getRootBlock(invocation1);
	Block rootBlock2 = getRootBlock(invocation2);
	if ((rootBlock1 == null) \|\| (rootBlock2 == null)) {
	result = 0;
	} else {
	int index1 = computeIndex(invocation1, rootBlock1);
	int index2 = computeIndex(invocation2, rootBlock2);
	/*
	* specific case: both invocations have the same index and are
	* contained in the same block.
	*
	* So we have to retrieve first common parent block and use it
	* to compute index ...
	*/
	if ((index1 == index2) && (rootBlock1 == rootBlock2)) {
	Block commonBlock = getFirstCommonParentBlock(invocation1,
	invocation2, rootBlock1);
	index1 = computeIndex(invocation1, commonBlock);
	index2 = computeIndex(invocation2, commonBlock);
	}

	result = Integer.valueOf(index1).compareTo(
	Integer.valueOf(index2));
	}
	return result;
	}

	private static final int INVALID_INDEX = -2;
	private final int computeIndex(final EObject element,
	final Block rootBlock) {
	int result = MethodCallsGraphConverter.MethodInvocationComparator.INVALID_INDEX;
	if (element.eContainer() == rootBlock) {
	result = rootBlock.getStatements().indexOf(element);
	} else {
	result = computeIndex(element.eContainer(), rootBlock);
	}
	return result;
	}

	private final Block getRootBlock(final EObject element) {
	Block result = null;
	if (element != null) {
	if (element instanceof AbstractMethodDeclaration) {
	result = ((AbstractMethodDeclaration) element).getBody();
	} else {
	result = getRootBlock(element.eContainer());
	}
	}
	return result;
	}

	/*
	* To retrieve the first common parent block of two elements lets start
	* from an example: block A contains another block B (with other
	* statements) block B contains two blocks C and D which contains
	* respectively element1 and element2
	*
	* Here the algorithm: From element1, I get the nearest parent block
	* Then I will iterate on all parent blocks of element2 and test
	* identity If not found, I have to iterate on parent block of element1
	* And test again on all parent blocks of element2 ...
	*/
	private final Block getFirstCommonParentBlock(
	final EObject sourceElement, final EObject element2,
	final Block stopper) {
	Block result = getParentBlock(sourceElement);
	if (result != stopper) {
	if (!isParentBlock(element2, result, stopper)) {
	result = getFirstCommonParentBlock(result, element2,
	stopper);
	} // else, result is the first common parent block
	}
	return result;
	}

	private final boolean isParentBlock(final EObject element,
	final Block target, final Block stopper) {
	boolean result = false;
	Block parent = getParentBlock(element);
	if (parent != stopper) {
	if (parent == target) {
	result = true;
	} else {
	result = isParentBlock(parent, target, stopper);
	}
	}
	return result;
	}

	private final Block getParentBlock(final EObject element) {
	Block result = null;
	if (element != null) {
	if (element.eContainer() instanceof Block) {
	result = (Block) element.eContainer();
	} else {
	result = getParentBlock(element.eContainer());
	}
	}
	return result;
	}
	}

	/**
	* To retrieve the type declaration which contains source element (which is
	* at the beginning a method declaration element)
	*
	* @param element
	* @return
	*/
	private final TypeDeclaration getTypeDeclaration(final EObject element) {
	TypeDeclaration result = null;
	if (element != null) {
	if (element instanceof TypeDeclaration) {
	result = (TypeDeclaration) element;
	} else {
	result = getTypeDeclaration(element.eContainer());
	}
	}
	return result;
	}

	/**
	* To retrieve all sub types of parameter (type declaration element)
	*
	* @param contextClass
	* @return
	*/
	private final Set<TypeDeclaration> getAllSubTypes(
	final TypeDeclaration contextClass) {
	Set<TypeDeclaration> result = new HashSet<TypeDeclaration>();
	if (contextClass != null) {
	for (TypeDeclaration currentClassDeclaration : this.allTypes) {
	if (isSuperTypeOf(contextClass, currentClassDeclaration)) {
	result.add(currentClassDeclaration);
	result.addAll(getAllSubTypes(currentClassDeclaration));
	}
	}
	}
	return result;
	}

	/**
	* To compute a boolean which indicate if a type (self) is in parent
	* hierarchy of an other type (typeDeclaration).
	*
	* @param self
	* @param typeDeclaration
	* @return true if self is a super type of typeDeclaration
	*/
	private final boolean isSuperTypeOf(final TypeDeclaration self,
	final TypeDeclaration typeDeclaration) {
	if (typeDeclaration.getSuperInterfaces().contains(self)) {
	return true;
	}
	for (TypeAccess superTypeAccess : typeDeclaration.getSuperInterfaces()) {
	if (superTypeAccess.getType() instanceof TypeDeclaration) {
	TypeDeclaration superType = (TypeDeclaration) superTypeAccess
	.getType();
	if (superType == self \|\| isSuperTypeOf(self, superType)) {
	return true;
	}
	}
	}
	if (typeDeclaration instanceof ClassDeclaration) {
	ClassDeclaration classDeclaration = (ClassDeclaration) typeDeclaration;
	if (classDeclaration.getSuperClass() != null
	&& classDeclaration.getSuperClass().getType() == self) {
	return true;
	}
	if (classDeclaration.getSuperClass() != null
	&& classDeclaration.getSuperClass().getType() instanceof TypeDeclaration) {
	TypeDeclaration superType = (TypeDeclaration) classDeclaration
	.getSuperClass().getType();
	if (isSuperTypeOf(self, superType)) {
	return true;
	}
	}
	}
	return false;
	}

	private static final VariableDeclaration getVariableDeclaration(
	final AbstractMethodInvocation abstractMethodInvocation) {
	VariableDeclaration result = null;
	if (abstractMethodInvocation instanceof MethodInvocation) {
	MethodInvocation methodInvocation = (MethodInvocation) abstractMethodInvocation;
	if ((methodInvocation.getExpression() != null)
	&& (methodInvocation.getExpression() instanceof SingleVariableAccess)) {
	SingleVariableAccess singleVariableAccess = (SingleVariableAccess) methodInvocation
	.getExpression();
	result = singleVariableAccess.getVariable();
	}
	}
	return result;
	}

	private final Set<TypeDeclaration> getFilteredPotentialTypes(
	final VariableDeclaration variableDeclaration) {
	List<VariableDeclaration> parents = new ArrayList<VariableDeclaration>();
	Set<TypeDeclaration> result = getBasicFilteredPotentialTypes(
	variableDeclaration, parents);
	return result;
	}

	private final Set<TypeDeclaration> getBasicFilteredPotentialTypes(
	final VariableDeclaration source,
	final List<VariableDeclaration> parents) {
	Set<TypeDeclaration> result = new HashSet<TypeDeclaration>();
	if (!parents.contains(source)) {
	parents.add(source);

	Expression initializer = source.getInitializer();
	if ((initializer != null)
	&& (initializer instanceof ClassInstanceCreation)) {
	ClassInstanceCreation classInstanceCreation = (ClassInstanceCreation) initializer;
	if (classInstanceCreation.getType().getType() instanceof TypeDeclaration) {
	result.add((TypeDeclaration) classInstanceCreation
	.getType().getType());
	}
	}
	result.addAll(filterAssignement(source, parents));
	}
	return result;
	}

	private final Set<TypeDeclaration> filterAssignement(
	final VariableDeclaration source,
	final List<VariableDeclaration> parents) {
	Set<TypeDeclaration> result = new HashSet<TypeDeclaration>();
	for (SingleVariableAccess access : source.getUsageInVariableAccess()) {
	EObject container = access.eContainer();
	if (container instanceof Assignment) {
	Assignment assignment = (Assignment) container;
	Expression expression = assignment.getRightHandSide();
	if (expression instanceof ClassInstanceCreation) {
	ClassInstanceCreation classInstanceCreation = (ClassInstanceCreation) expression;
	if (classInstanceCreation.getType().getType() instanceof TypeDeclaration) {
	result.add((TypeDeclaration) classInstanceCreation
	.getType().getType());
	}
	} else if (expression instanceof SingleVariableAccess) {
	/*
	* potential infinite recursion
	*
	* Object tmp; Object src = tmp; ... tmp = src;
	*/
	SingleVariableAccess singleVariableAccess = (SingleVariableAccess) expression;
	result.addAll(getBasicFilteredPotentialTypes(
	singleVariableAccess.getVariable(), parents));
	}
	}
	}
	return result;
	}

	}