Case Study: adding data and statistics

[ifi-stolz-refaktor.git] / case-study / refaktor-before / src / no / uio / ifi / refaktor / analyze / analyzers / StatementListsCreator.java

package no.uio.ifi.refaktor.analyze.analyzers;

import java.util.Arrays;
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;

import no.uio.ifi.refaktor.analyze.exceptions.GenericAnalyzerException;
import no.uio.ifi.refaktor.utils.ParseUtils;
import no.uio.ifi.refaktor.utils.RefaktorASTNodeSearchUtil;

import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.dom.ASTVisitor;
import org.eclipse.jdt.core.dom.Block;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.DoStatement;
import org.eclipse.jdt.core.dom.EnhancedForStatement;
import org.eclipse.jdt.core.dom.ForStatement;
import org.eclipse.jdt.core.dom.IfStatement;
import org.eclipse.jdt.core.dom.LabeledStatement;
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jdt.core.dom.Statement;
import org.eclipse.jdt.core.dom.SwitchCase;
import org.eclipse.jdt.core.dom.SwitchStatement;
import org.eclipse.jdt.core.dom.WhileStatement;

public class StatementListsCreator extends ASTVisitor {

	private final IMethod method;
	private final Collection<List<Statement>> statementLists;
	private MethodDeclaration methodDeclaration;

	public StatementListsCreator(IMethod method) {
		this.method = method;
		statementLists = new LinkedList<List<Statement>>();
	}

	Collection<List<Statement>> getStatementLists() {
		createStatements();
		return statementLists;
	}

	private void createStatements() {
		clearStatementLists();
		createMethodDeclaration();
		addStatementListsFromMethodDeclaration();
	}

	private void clearStatementLists() {
		statementLists.clear();
	}

	private void createMethodDeclaration() {
		try {
			methodDeclaration = getMethodDeclarationNode(method);
			assert methodDeclaration != null;
		} catch (JavaModelException e) {
			throw new GenericAnalyzerException(e);
		}
	}

	public static MethodDeclaration getMethodDeclarationNode(IMethod method) throws JavaModelException {
		CompilationUnit compilationUnit = ParseUtils.parse(method.getCompilationUnit());
		return RefaktorASTNodeSearchUtil.getMethodDeclarationNode(method, compilationUnit);
	}

	private void addStatementListsFromMethodDeclaration() {
		methodDeclaration.accept(this);
	}

	public int getNumberOfStatements() {
		int size = 0;
		for (List<Statement> list: statementLists)
			size += list.size();
		return size;
	}

	@Override
	public boolean visit(Block node) {
		statementLists.add(new LinkedList<Statement>(node.statements()));
		return true;
	}

	@Override
	public boolean visit(DoStatement node) {
		addIfNotBlockOrNull(node.getBody());
		return true;
	}

	@Override
	public boolean visit(EnhancedForStatement node) {
		addIfNotBlockOrNull(node.getBody());
		return true;
	}

	@Override
	public boolean visit(ForStatement node) {
		addIfNotBlockOrNull(node.getBody());
		return true;
	}

	@Override
	public boolean visit(IfStatement node) {
		addIfNotBlockOrNull(node.getThenStatement());
		addIfNotBlockOrNull(node.getElseStatement());
		return true;
	}

	@Override
	public boolean visit(LabeledStatement node) {
		addIfNotBlockOrNull(node.getBody());
		return true;
	}

	@Override
	public boolean visit(SwitchStatement node) {
		List<Statement> statementList = new LinkedList<Statement>();

		for (Object stmtObject: node.statements()) {
			assert stmtObject instanceof Statement;
			Statement statement = (Statement) stmtObject;

			if (statement instanceof SwitchCase) {
				if (!statementList.isEmpty()) {
					statementLists.add(statementList);
					statementList = new LinkedList<Statement>();
				}
			} else {
				statementList.add(statement);
			}
		}
		
		if (!statementList.isEmpty())
			statementLists.add(statementList);

		return true;
	}

	@Override
	public boolean visit(WhileStatement node) {
		addIfNotBlockOrNull(node.getBody());
		return true;
	}

	private void addIfNotBlockOrNull(Statement body) {
		if (!(body instanceof Block) && body != null)
			statementLists.add(new LinkedList<Statement>(Arrays.asList(body)));
	}

}