Making the ExtractAndMoveMethodAnalysisResult lightweight enough for it

[ifi-stolz-refaktor.git] / software / no.uio.ifi.refaktor.benchmark / src / no / uio / ifi / refaktor / benchmark / ProjectWideSearchBasedExtractAndMoveMethodAnalyzer.java

package no.uio.ifi.refaktor.benchmark;

import java.util.LinkedList;
import java.util.List;

import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodAnalysisResult;
import no.uio.ifi.refaktor.analyze.FavorNoUnfixesAnalysisResultComparator;
import no.uio.ifi.refaktor.analyze.NoTargetFoundException;
import no.uio.ifi.refaktor.analyze.SearchBasedExtractAndMoveMethodAnalyzer;
import no.uio.ifi.refaktor.utils.CompilationUnitCacheManager;
import no.uio.ifi.refaktor.utils.RefaktorDebug;
import no.uio.ifi.refaktor.utils.RefaktorHandleUtils;

import org.eclipse.core.resources.IProject;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaModelException;

public class ProjectWideSearchBasedExtractAndMoveMethodAnalyzer {

	private final IProject project;
	private final List<ExtractAndMoveMethodAnalysisResult> results;
	private int methodCount;
	private long analysisStart;

	public ProjectWideSearchBasedExtractAndMoveMethodAnalyzer(IProject project) {
		this.project = project;
		results = new LinkedList<ExtractAndMoveMethodAnalysisResult>();
		methodCount = 0;
	}

	public void analyze() {
		try {
			CompilationUnitCacheManager.activateRecentlyUsedCaching();
			analyzeProject();
		} finally {
			CompilationUnitCacheManager.deactivateCaching();
		}
	}

	private void analyzeProject() {
		IJavaProject javaProject = RefaktorHandleUtils.createJavaProjectFrom(project);
		analysisStart = System.currentTimeMillis();
		try {
			for (IPackageFragment packageFragment: javaProject.getPackageFragments())
				analyzeMethodsInPackage(packageFragment);
		} catch (JavaModelException e) {
			throw new RuntimeException(e);
		} finally {
			debugPrintFinalStatistics();
		}
	}

	private void debugPrintFinalStatistics() {
		for (ExtractAndMoveMethodAnalysisResult result: results)
			RefaktorDebug.println(result);

		RefaktorDebug.println("Number of results: " + results.size());
		RefaktorDebug.println("Time used on analysis: " + timeSinceAnalysisStart());
		RefaktorDebug.println(methodCount + " methods analyzed");
	}

	private void analyzeMethodsInPackage(IPackageFragment packageFragment) throws JavaModelException {
		for (ICompilationUnit compilationUnit: packageFragment.getCompilationUnits())
			analyzeMethodsInCompilationUnit(compilationUnit);
	}

	private void analyzeMethodsInCompilationUnit(ICompilationUnit compilationUnit) throws JavaModelException {
		for (IType type: compilationUnit.getAllTypes())
			analyzeMethodsInType(type);
	}

	private void analyzeMethodsInType(IType type) throws JavaModelException {
		for (IMethod method: type.getMethods()) {
			analyze(method);
		}
	}

	private void analyze(IMethod method) {
		SearchBasedExtractAndMoveMethodAnalyzer analyzer = null;
		try {
			methodCount++;
			try {
				RefaktorDebug.println("#" + methodCount + " (" + timeSinceAnalysisStart() + "): " + method.getDeclaringType().getElementName() + "." + method.getElementName() + " (" + "offset: "
						+ method.getSourceRange().getOffset() + ", length: " + method.getSourceRange().getLength() + ")");
			} catch (JavaModelException e) {
				RefaktorDebug.println("No info about " + method.getElementName());
			}
			analyzer = new SearchBasedExtractAndMoveMethodAnalyzer(method, new FavorNoUnfixesAnalysisResultComparator());
			analyzer.analyze();
			results.add(analyzer.getResult());
		} catch (NoTargetFoundException e) {
//			RefaktorDebug.println("No target found for " + method + "\n(" + analyzer.getNumberOfStatementsAnalyzed() + " statements analyzed)");
		}
	}

	private String timeSinceAnalysisStart() {
		long secondsSinceAnalysisStart = secondsSinceAnalysisStart();
		return secondsSinceAnalysisStart/60 + "m" + secondsSinceAnalysisStart % 60 + "s";
	}

	private long secondsSinceAnalysisStart() {
		return (System.currentTimeMillis() - analysisStart)/1000;
	}
}