Adding some JavaDoc and cleaning up a bit.

[ifi-stolz-refaktor.git] / software / no.uio.ifi.refaktor / src / no / uio / ifi / refaktor / extractors / Prefix.java

package no.uio.ifi.refaktor.extractors;

import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;

import no.uio.ifi.refaktor.utils.ParseUtils;

import org.eclipse.jdt.core.dom.ASTMatcher;
import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.ASTVisitor;
import org.eclipse.jdt.core.dom.AbstractTypeDeclaration;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.Expression;
import org.eclipse.jdt.core.dom.IBinding;
import org.eclipse.jdt.core.dom.IVariableBinding;
import org.eclipse.jdt.core.dom.Name;
import org.eclipse.jface.text.IDocument;

/**
 * A class for representing a prefix of an Expression/Statement.
 * 
 * It has an Expression member for the prefix.
 */
public class Prefix {

	private class SubExpressionsFinder extends ASTVisitor {

		private Expression topExpression;
		private LinkedList<Expression> expressions;

		public SubExpressionsFinder(Expression expression) {
			this.topExpression = expression;
			this.expressions = new LinkedList<Expression>();
			if (expression != null)
				expression.accept(this);
		}

		@Override
		public void preVisit(ASTNode node) {
			if (nodeIsSubExpressionOfTopExpression(node))
				expressions.add((Expression) node);
		}

		private boolean nodeIsSubExpressionOfTopExpression(ASTNode node) {
			return node instanceof Expression && node.getStartPosition() == topExpression.getStartPosition();
		}

		public List<Expression> getExpressions() {
			return expressions;
		}

	}

	private final Expression prefixExpression;
	private final IDocument document;
	private final String prefixString;
	private int count;
	private PrefixSet possiblePrefixes;

	/**
	 * Represent a prefix on the base of an Expression.
	 * 
	 * @param expression the Expression that is the base of the prefix.
	 * @param document the IDocument that is the base of the source code
	 * 		that contains the expression.
	 */
	public Prefix(Expression expression, IDocument document) {
		this.prefixExpression = expression;
		this.document = document;
		this.count = 1;

		if (expression != null)
			prefixString = ParseUtils.getNodeText(expression, document);
		else prefixString = "";
	}

	public void incrementCount() {
		count++;
	}

	@Override
	public String toString() {
		return getPrefixString();
	}

	public String getPrefixString() {
		return prefixString;
	}

	public int getCount() {
		return count;
	}

	/**
	 * Intersect this prefix with another prefix.
	 * 
	 * @param other the prefix to intersect with this one.
	 * @return If the Prefix is empty, the null-prefix will be returned. 
	 * 		If other is equal to this, a copy of this will be returned,
	 * 		or else the longest common prefix of other and this is returned.
	 */
	public Prefix intersectWith(Prefix other) {
		if (prefixIsEmpty(other))
			return new Prefix(null, document);
		if (this.equals(other))
			// TODO: return this?
			return new Prefix(prefixExpression, document);

		// TODO: statement??
		return new Prefix(longestCommonExpressionWith(other), document);
	}

	private boolean prefixIsEmpty(Prefix prefix) {
		return prefix == null || prefix.getPrefixExpression() == null;
	}

	public Expression longestCommonExpressionWith(Prefix other) {
		Expression longestCommonExpression = null;

		for (Expression thisExp: getSubExpressions(prefixExpression)) {
			for (Expression otherExp: getSubExpressions(other.getPrefixExpression())) {
				if (expressionsMatch(otherExp, thisExp)) {
					if (longestCommonExpression == null) {
						longestCommonExpression = thisExp;
					} else if (thisExp.getLength() > longestCommonExpression.getLength()) {
						longestCommonExpression = thisExp;
					}
					break;
				}
			}
		}
		return longestCommonExpression;
	}

	private List<Expression> getSubExpressions(Expression expression) {
		return new SubExpressionsFinder(expression).getExpressions();
	}

	@Override
	public int hashCode() {
		return getPrefixString().hashCode();
	}

	@Override
	public boolean equals(Object other) {
		if (this == other)
			return true;
		if (other == null || !(other instanceof Prefix))
			return false;
		return hasExpressionEqualTo((Prefix) other);
	}

	private boolean hasExpressionEqualTo(Prefix other) {
		Expression otherPrefixExpression = other.getPrefixExpression();

		if (prefixExpression == null && otherPrefixExpression == null)
			return true;
		if (prefixExpression == null || otherPrefixExpression == null)
			return false;
		return expressionsMatch(prefixExpression, otherPrefixExpression);
	}

	private boolean expressionsMatch(Expression a, Expression b) {
		if (a == null || b == null)
			return false;
		return a.subtreeMatch(new ASTMatcher(), b);
	}

	private Expression getPrefixExpression() {
		return prefixExpression;
	}

	/**
	 * @return the list of possible sub-prefixes, including a copy of this one.
	 */
	public PrefixSet getSubPrefixes() {
		if (possiblePrefixes == null) {
			possiblePrefixes = new PrefixSet();
			for (Expression exp: getSubExpressions(prefixExpression))
				possiblePrefixes.add(new Prefix(exp, document));
		}
		return possiblePrefixes;
	}

	public int length() {
		return prefixExpression.getLength();
	}

	public int startPosition() {
		return prefixExpression.getStartPosition();
	}

	public String getPackageName() {
		return getCompilationUnit().getPackage().getName().getFullyQualifiedName();
	}

	public String getSimpleTypeName() {
		List<?> types = getCompilationUnit().types();
		if (types.isEmpty())
			return null;
		Object first = types.get(0);
		assert first instanceof AbstractTypeDeclaration;
		AbstractTypeDeclaration absTypeDecl = (AbstractTypeDeclaration) first;
		return absTypeDecl.getName().getFullyQualifiedName();
	}

	private CompilationUnit getCompilationUnit() {
		ASTNode root = prefixExpression.getRoot();
		assert root instanceof CompilationUnit;
		return (CompilationUnit) root;
	}

	public IVariableBinding getVariableBindingOfFirstExpression() {
		Expression firstExpression = getFirstExpression();
		assert firstExpression instanceof Name;
		IBinding binding = ((Name) firstExpression).resolveBinding();
		assert binding != null;
		assert binding instanceof IVariableBinding;
		return (IVariableBinding) binding;
	}

	private Expression getFirstExpression() {
		List<Expression> subExpressions = getSubExpressions(prefixExpression);
		Collections.sort(subExpressions, new Comparator<Expression>() {
			@Override
			public int compare(Expression e1, Expression e2) {
				if (e1.getLength() < e2.getLength())
					return -1;
				else if (e1.getLength() > e2.getLength())
					return 1;
				else
					return 0;
			}
		});
		return subExpressions.get(0);
	}

	/**
	 * Tests if this prefix encloses another prefix.
	 * 
	 * Example: "a.b.c" encloses "a.b"
	 * @param other
	 * @return
	 */
	public boolean encloses(Prefix other) {
		return getSubPrefixes().contains(other);
	}

}