Attachment 7564 Details for Bug 50615 – Source code

Source code

MetricProvider.java (text/plain), 11.75 KB, created by Olivier Thomann

on 2004-01-26 11:09:32 EST

(hide)

Description:

Filename:

MIME Type:

Creator: Olivier Thomann

Created: 2004-01-26 11:09:32 EST

Size: 11.75 KB

patch

obsolete

>v/*
> * Created on 08.01.2004
> *
> */
>package de.fhg.iese.Homes.eclipse.javaMetrics.qmoodMetrics;
>
>import java.util.ArrayList;
>import java.util.List;
>import org.eclipse.jdt.core.IJavaProject;
>import org.eclipse.jdt.core.IMethod;
>import org.eclipse.jdt.core.IType;
>import org.eclipse.jdt.core.JavaModelException;
>import org.eclipse.jdt.core.ICompilationUnit;
>import org.eclipse.jdt.core.dom.AST;
>import org.eclipse.jdt.core.dom.ASTVisitor;
>import org.eclipse.jdt.core.dom.CompilationUnit;
>import org.eclipse.jdt.core.dom.IMethodBinding;
>import org.eclipse.jdt.core.dom.IVariableBinding;
>import org.eclipse.jdt.core.dom.VariableDeclarationExpression;
>import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
>import org.eclipse.jdt.core.dom.VariableDeclarationStatement;
>import org.eclipse.jdt.core.dom.Name;
>import org.eclipse.jdt.core.dom.TypeDeclaration;
>import org.eclipse.jdt.core.dom.FieldDeclaration;
>import org.eclipse.jdt.core.dom.ITypeBinding;
>import org.eclipse.jdt.core.dom.IPackageBinding;
>import org.eclipse.jdt.core.Flags;
>
>/**
> * @author Sebastian Weber
> * 
> */
>public class MetricProvider extends ASTVisitor {
>	
>	private IType type;
>	private String name;
>	private ICompilationUnit cu;
>	private int numberMethods;
>	private int publicMethods = 0;
>	private int inheritedMethods;
>	private int inheritedFields = 0;
>	private boolean isClass;
>	private ArrayList ancestors;
>	private ArrayList polymorphismSet;
>	private int fieldCount = 0;
>	private int protectedFieldCount = 0;		
>	private IJavaProject project;	
>	private ITypeBinding typeBinding;
>	private double DAM;	
>	private double MFM;
>	private double MFA;
>	private int MOA = 0;
>	private ArrayList userDefinedTypes;
>		
>	public MetricProvider() {
>		ancestors = new ArrayList();
>		polymorphismSet = new ArrayList();
>		userDefinedTypes = new ArrayList();
>		numberMethods = -1;
>		boolean isClass = false;
>	}
>		
>	public void calculateMetrics(IType type, ICompilationUnit cu) {
>		this.cu = cu;
>		this.type = type;		
>		project = cu.getJavaProject();		
>		name = type.getElementName();			
>		try {			
>			isClass = type.isClass();	
>			//fieldCount = type.getFields().length;					
>			// traverse compilation unit and identify type 
>			// definition (IType type)
>			CompilationUnit ast = AST.parseCompilationUnit(cu, true);
>			ast.accept(this);
>			// compute complex metric value
>			computeCIS();
>			computeMFM();
>			computeDAM();			
>			computeNIM();			
>			computeNOP();						
>		} catch (JavaModelException e) {			
>			e.printStackTrace();
>		}	
>	}
>	
>	private void computeCIS() {		
>		try {			
>			IMethod[] methods = type.getMethods();
>			numberMethods = methods.length;
>			// all methods in interfaces are implicit public 
>			// (whether the public modifier is explicit given or not)			
>			if (type.isInterface()) {
>				publicMethods = methods.length;
>				return;
>			}			
>			IMethod method;
>			int modifiers;			
>			int i;
>			for (i = 0; i < numberMethods; i++) {
>				method = methods[i];
>				modifiers = method.getFlags();
>				if (isPublic(modifiers)) publicMethods++; 
>			}			
>		} catch (JavaModelException e) {
>			System.out.println("error while trying to get all methods");
>			e.printStackTrace();
>		}		
>	}
>	
>	private boolean isPublic(int modifiers) {		
>		if (Flags.isPublic(modifiers)) return true;
>		return false;
>	}
>	
>	public boolean visit(TypeDeclaration node) {		
>		String currentName = node.getName().getIdentifier();		
>		if (currentName.equals(name)) {
>			// get possible interfaces			
>			typeBinding = node.resolveBinding();			
>			//System.out.println("get ancestors of " + name);								
>			Name superclass = node.getSuperclass();
>			if (superclass != null) {				
>				ITypeBinding binding  = superclass.resolveTypeBinding();				
>				countAncestors(binding);							
>			}
>			CloserVisitor closerVisitor = new CloserVisitor();
>			node.accept(closerVisitor);							
>		}
>		return true;
>	}	
>	
>	// TODO: unnecessary overhead...add element to ancestor list
>	// in computeNOP() ! 
>	private void countAncestors(ITypeBinding binding) {
>		if (binding != null) {
>			/*String currentName = binding.getName();
>			System.out.println("superklasse: " + currentName);*/
>			ancestors.add(new SuperClass(binding));
>			ITypeBinding next = binding.getSuperclass();						
>			countAncestors(next);					
>		}		
>	}	
>	
>	public int getNumberMethods() {
>		return numberMethods;
>	}
>		
>	public int getInterfaceSize() {
>		return publicMethods;
>	}
>	
>	public boolean isClass() {
>		return isClass;
>	}	
>	
>	public double getDataAccessMetric() {
>		return DAM;
>	}
>	
>	private double computeDAM() {
>		DAM = 0;
>		//System.out.println("class: " + name + ", all fields: " + fieldCount + ", -/#: " + protectedFieldCount);		
>		if (fieldCount > 0) DAM = (double) protectedFieldCount / (double) fieldCount;		
>		return DAM;
>	}
>	
>	public int getProtectedData() {
>		return protectedFieldCount;
>	}
>
>	public int getData() {		
>		return fieldCount;
>	}
>	
>	public int getInheritedData() {
>		return inheritedFields;
>	}
>	
>	public int getNumberAncestors() {
>		int size = ancestors.size();
>		// this type inherits implicitly from Object.
>		// thus the number of ancestors is always >= 1
>		if (size == 0) return 1;
>		return size;
>	}
>	
>	public int getInheritedMethodCount() {
>		return inheritedMethods;
>	}
>	
>	private void computeNIM() {
>		inheritedMethods = 0;
>		SuperClass current;
>		int i;
>		int size = ancestors.size();
>		for (i = 0; i < size; i++) {
>			current = (SuperClass) ancestors.get(i);
>			//System.out.println("superklasse: " + current.getName() + ", #M: " + current.getNumberMethods() + ", #F: " + current.getFieldCount());
>			inheritedMethods += current.getNumberMethods();
>		}
>	}
>	
>	public double getFunctionalModularity() {
>		return MFM;
>	}
>	
>	private void computeMFM() {
>		MFM = 0;		
>		if (fieldCount > 0) {			
>			SuperClass current;
>			int i;
>			int size = ancestors.size();
>			for (i = 0; i < size; i++) {
>				current = (SuperClass) ancestors.get(i);
>				inheritedFields += current.getFieldCount();
>			}
>			double x = inheritedFields;
>			double y = fieldCount;
>			double overall = x + y;
>			MFM = x / overall;
>			//System.out.println("class: " + name + " #fields: " + fieldCount + " #inherited: " + inheritedFields);
>		}			
>	}	
>	
>	
>	
>	public double getFunctionalAbstraction() {
>		return MFA;
>	}
>	
>	private void computeMFA() {
>		MFA = 0;		
>		if (numberMethods > 0) {
>			inheritedMethods = getInheritedMethodCount();
>			double x = inheritedMethods;
>			double y = numberMethods;			
>			double overall = inheritedMethods + numberMethods;
>			MFA = x / overall;
>		}		
>	}	
>	
>	
>	
>	/**
>	 * method getNumberPolymorphicVarieties
>	 * returns the number of varieties this class
>	 * can adopt.
>	 * 
>	 * @return varieties
>	 */
>	public int getNumberPolymorphicVarieties() {
>		// return polymorphicVarities;
>		return polymorphismSet.size();
>	}
>	
>	private void computeNOP() {
>		// start with base type				
>		computeNOP(typeBinding);		
>		
>	}
>	
>	private void computeNOP(ITypeBinding binding) {	
>		// add binding to set
>		insertSet(binding);					
>		// check for interfaces (type == class)
>		// or check for superinterfaces (type == interface).
>		// returns empty list if type (class) doesn't implement
>		// interfaces or if type (interface) doesn't extend 
>		// interfaces.
>		ITypeBinding[] interfaces = binding.getInterfaces();
>		int size = interfaces.length;
>		// there is an implements clause (class) or an extends clausse (interface)!		
>		if (size > 0) {			
>			int i;
>			for (i = 0; i < size; i++) {
>				// check recursive every interface for superinterfaces
>				computeNOP(interfaces[i]);
>			} 
>		}
>		// check for a super class
>		ITypeBinding superClass = binding.getSuperclass();
>		// if type == interface than superClass == null. If 
>		// type == class and the class extends an other class
>		// than superClass != null.
>		if (superClass != null) {						
>			computeNOP(superClass);
>		}
>	}
>	
>	public int getAggregation() {
>		return MOA;
>	}
>	
>	// TODO: geht noch net
>	public void calculateMOA(QMOODMetrics qmoodMetrics) {		
>		int i;
>		int size = userDefinedTypes.size();
>		String currentType;
>		for (i = 0; i < size; i++) {
>			currentType = (String) userDefinedTypes.get(i);
>			if (qmoodMetrics.isUserDefined(project.getElementName(), currentType)) {
>				//System.out.println("user package? " + currentType);
>				MOA++;				
>			}
>		}
>	}
>	
>	private void insertSet(ITypeBinding binding) {
>		String name = binding.getQualifiedName();
>		String current;
>		int i;
>		int size = polymorphismSet.size();
>		for (i = 0; i < size; i++) {
>			current = (String) polymorphismSet.get(i);
>			// do not insert into set. element already exists!
>			if (current.equals(name)) return;
>		}
>		// new element
>		polymorphismSet.add(name);
>	}
>	
>	public SuperClass[] getAncestors() {
>		int i;
>		int size = ancestors.size();
>		SuperClass[] superClasses = new SuperClass[size];
>		for (i = 0; i < size; i++) {
>			superClasses[i] = (SuperClass) ancestors.get(i);
>		}
>		return superClasses;
>	}
>	
>	class CloserVisitor extends ASTVisitor {
>		
>		public boolean visit(FieldDeclaration node) {
>						System.out.println("class: " + cu.getElementName());							
>						List list = node.fragments();
>						int i, size;
>						size = list.size();
>						VariableDeclarationFragment fragment;
>						for (i = 0; i < size; i++) {
>							fragment = (VariableDeclarationFragment) list.get(i);
>							fieldCount++;
>							System.out.println("identifier: " + fragment.getName().getIdentifier());	
>						}				
>						return true;
>		}
>		
>		/*public boolean visit(FieldDeclaration node) {			
>			fieldCount++;
>			String n = "";
>			if (node.getType().resolveBinding() != null) n = node.getType().resolveBinding().getName();
>			System.out.println("class: " + name + ", field: " + n);
>			resolveModifiers(node.getFlags());
>			return true;
>		}*/
>		
>		private void resolveModifiers(int flags) {
>			boolean protectedModifier;
>			boolean privateModifier;
>			protectedModifier = false;
>			privateModifier = false;
>			if (Flags.isPrivate(flags)) privateModifier = true;
>			if (Flags.isProtected(flags)) protectedModifier = true;
>			if (privateModifier | protectedModifier) protectedFieldCount++;						
>			
>		}
>		
>		public boolean visit(VariableDeclarationStatement node) {
>			List liveList = node.fragments();
>			if (liveList.size() > 0) {
>				VariableDeclarationFragment fragment =(VariableDeclarationFragment) liveList.get(0);				
>				IVariableBinding variableBinding = fragment.resolveBinding();
>				if (variableBinding != null) {
>					ITypeBinding binding = variableBinding.getType();
>					if (binding != null) {
>						// check if this package is an user defined package
>						// than the type (which is defined in this package) is user
>						// defined, too.
>						// Therefor save package name in a list. after all compilation units
>						// are proceeded computeMOA() will be invoked and the list is used to
>						// compute MOA value
>						IPackageBinding packageBinding = binding.getPackage();
>						if (packageBinding != null) userDefinedTypes.add(packageBinding.getName());						
>					}
>					
>				}				
>			}						
>			return true;
>		}	
>		
>		// TODO: !!!
>		public boolean visit(VariableDeclarationExpression node) {
>			return true;
>		}
>	}
>}
>
>class SuperClass {	
>	private String name;	
>	private int methodCount;
>	private int fieldCount;		
>	
>	public SuperClass(ITypeBinding binding) {		
>		name = binding.getName();					
>		IMethodBinding[] methods = binding.getDeclaredMethods();
>		IVariableBinding[] fields = binding.getDeclaredFields();
>		methodCount = methods.length;
>		fieldCount = fields.length;			
>	}	
>	
>	public String getName() {
>		return name;		
>	}		
>	
>	public int getNumberMethods() {
>		return methodCount;
>	}
>	
>	public int getFieldCount() {
>		return fieldCount;
>	}		
>}

Actions: View

Attachments on bug 50615: 7564