AndLocator.java

/*******************************************************************************
 * Copyright (c) 2000, 2008 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.internal.core.search.matching;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.search.SearchPattern;
import org.eclipse.jdt.internal.compiler.ast.ASTNode;
import org.eclipse.jdt.internal.compiler.ast.Annotation;
import org.eclipse.jdt.internal.compiler.ast.ConstructorDeclaration;
import org.eclipse.jdt.internal.compiler.ast.Expression;
import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
import org.eclipse.jdt.internal.compiler.ast.ImportReference;
import org.eclipse.jdt.internal.compiler.ast.LocalDeclaration;
import org.eclipse.jdt.internal.compiler.ast.MemberValuePair;
import org.eclipse.jdt.internal.compiler.ast.MessageSend;
import org.eclipse.jdt.internal.compiler.ast.MethodDeclaration;
import org.eclipse.jdt.internal.compiler.ast.Reference;
import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
import org.eclipse.jdt.internal.compiler.ast.TypeParameter;
import org.eclipse.jdt.internal.compiler.ast.TypeReference;
import org.eclipse.jdt.internal.compiler.lookup.Binding;

public class AndLocator extends PatternLocator {

	final PatternLocator[] patternLocators;

	final int[] levels;

	public AndLocator(AndPattern pattern) {
		super(pattern);

		SearchPattern[] patterns= pattern.patterns;
		PatternLocator[] locators= new PatternLocator[patterns.length];
		this.levels= new int[patterns.length];
		for (int i= 0, l= patterns.length; i < l; i++) {
			locators[i]= PatternLocator.patternLocator(patterns[i]);
			this.levels[i]= IMPOSSIBLE_MATCH;
		}
		this.patternLocators= locators;
	}

	public void initializePolymorphicSearch(MatchLocator locator) {
		for (int i= 0, length= this.patternLocators.length; i < length; i++) {
			this.patternLocators[i].initializePolymorphicSearch(locator);
		}
	}

	public int match(Annotation node, MatchingNodeSet nodeSet) {
		int level= IMPOSSIBLE_MATCH;
		for (int i= 0, length= this.patternLocators.length; i < length; i++) {
			int newLevel= this.patternLocators[i].match(node, nodeSet);
			if (newLevel > level) {
				if (newLevel == ACCURATE_MATCH)
					return ACCURATE_MATCH;
				level= newLevel;
			}
		}
		return level;
	}

	public int match(ASTNode node, MatchingNodeSet nodeSet) {
		int level= IMPOSSIBLE_MATCH;
		for (int i= 0, length= this.patternLocators.length; i < length; i++) {
			int newLevel= this.patternLocators[i].match(node, nodeSet);
			if (newLevel > level) {
				if (newLevel == ACCURATE_MATCH)
					return ACCURATE_MATCH;
				level= newLevel;
			}
		}
		return level;
	}

	public int match(ConstructorDeclaration node, MatchingNodeSet nodeSet) {
		int level= IMPOSSIBLE_MATCH;
		for (int i= 0, length= this.patternLocators.length; i < length; i++) {
			int newLevel= this.patternLocators[i].match(node, nodeSet);
			if (newLevel > level) {
				if (newLevel == ACCURATE_MATCH)
					return ACCURATE_MATCH;
				level= newLevel;
			}
		}
		return level;
	}

	public int match(Expression node, MatchingNodeSet nodeSet) {
		int level= IMPOSSIBLE_MATCH;
		for (int i= 0, length= this.patternLocators.length; i < length; i++) {
			int newLevel= this.patternLocators[i].match(node, nodeSet);
			if (newLevel > level) {
				if (newLevel == ACCURATE_MATCH)
					return ACCURATE_MATCH;
				level= newLevel;
			}
		}
		return level;
	}

	public int match(FieldDeclaration node, MatchingNodeSet nodeSet) {
		int level= IMPOSSIBLE_MATCH;
		for (int i= 0, length= this.patternLocators.length; i < length; i++) {
			int newLevel= this.patternLocators[i].match(node, nodeSet);
			if (newLevel > level) {
				if (newLevel == ACCURATE_MATCH)
					return ACCURATE_MATCH;
				level= newLevel;
			}
		}
		return level;
	}

	public int match(LocalDeclaration node, MatchingNodeSet nodeSet) {
		int level= IMPOSSIBLE_MATCH;
		for (int i= 0, length= this.patternLocators.length; i < length; i++) {
			int newLevel= this.patternLocators[i].match(node, nodeSet);
			if (newLevel > level) {
				if (newLevel == ACCURATE_MATCH)
					return ACCURATE_MATCH;
				level= newLevel;
			}
		}
		return level;
	}

	public int match(MethodDeclaration node, MatchingNodeSet nodeSet) {
		int level= IMPOSSIBLE_MATCH;
		for (int i= 0, length= this.patternLocators.length; i < length; i++) {
			int newLevel= this.patternLocators[i].match(node, nodeSet);
			if (newLevel > level) {
				if (newLevel == ACCURATE_MATCH)
					return ACCURATE_MATCH;
				level= newLevel;
			}
		}
		return level;
	}

	public int match(MemberValuePair node, MatchingNodeSet nodeSet) {
		int level= IMPOSSIBLE_MATCH;
		for (int i= 0, length= this.patternLocators.length; i < length; i++) {
			int newLevel= this.patternLocators[i].match(node, nodeSet);
			if (newLevel > level) {
				if (newLevel == ACCURATE_MATCH)
					return ACCURATE_MATCH;
				level= newLevel;
			}
		}
		return level;
	}

	public int match(MessageSend node, MatchingNodeSet nodeSet) {
		int level= IMPOSSIBLE_MATCH;
		for (int i= 0, length= this.patternLocators.length; i < length; i++) {
			int newLevel= this.patternLocators[i].match(node, nodeSet);
			if (newLevel > level) {
				if (newLevel == ACCURATE_MATCH)
					return ACCURATE_MATCH;
				level= newLevel;
			}
		}
		return level;
	}

	public int match(Reference node, MatchingNodeSet nodeSet) {
		int level= IMPOSSIBLE_MATCH;
		for (int i= 0, length= this.patternLocators.length; i < length; i++) {
			int newLevel= this.patternLocators[i].match(node, nodeSet);
			if (newLevel > level) {
				if (newLevel == ACCURATE_MATCH)
					return ACCURATE_MATCH;
				level= newLevel;
			}
		}
		return level;
	}

	public int match(TypeDeclaration node, MatchingNodeSet nodeSet) {
		int level= IMPOSSIBLE_MATCH;
		for (int i= 0, length= this.patternLocators.length; i < length; i++) {
			int newLevel= this.patternLocators[i].match(node, nodeSet);
			if (newLevel > level) {
				if (newLevel == ACCURATE_MATCH)
					return ACCURATE_MATCH;
				level= newLevel;
			}
		}
		return level;
	}

	public int match(TypeParameter node, MatchingNodeSet nodeSet) {
		int level= IMPOSSIBLE_MATCH;
		for (int i= 0, length= this.patternLocators.length; i < length; i++) {
			int newLevel= this.patternLocators[i].match(node, nodeSet);
			if (newLevel > level) {
				if (newLevel == ACCURATE_MATCH)
					return ACCURATE_MATCH;
				level= newLevel;
			}
		}
		return level;
	}

	public int match(TypeReference node, MatchingNodeSet nodeSet) {
		int level= IMPOSSIBLE_MATCH;
		for (int i= 0, length= this.patternLocators.length; i < length; i++) {
			int newLevel= this.patternLocators[i].match(node, nodeSet);
			if (newLevel > level) {
				if (newLevel == ACCURATE_MATCH)
					return ACCURATE_MATCH;
				level= newLevel;
			}
		}
		return level;
	}

	protected int matchContainer() {
		int result= ALL_CONTAINER;
		for (int i= 0, length= this.patternLocators.length; i < length; i++) {
			result&= this.patternLocators[i].matchContainer();
		}
		return result;
	}

	protected void matchReportImportRef(ImportReference importRef, Binding binding, IJavaElement element, int accuracy, MatchLocator locator) throws CoreException {
		PatternLocator weakestPattern= null;
		int level= IMPOSSIBLE_MATCH;
		for (int i= 0, length= this.patternLocators.length; i < length; i++) {
			int newLevel= this.patternLocators[i].matchLevel(importRef);
			if (newLevel == IMPOSSIBLE_MATCH)
				return;
			if (weakestPattern == null || newLevel < level) {
				weakestPattern= this.patternLocators[i];
				level= newLevel;
			}
		}
		weakestPattern.matchReportImportRef(importRef, binding, element, accuracy, locator);
	}

	protected void matchReportReference(ASTNode reference, IJavaElement element, IJavaElement localElement, IJavaElement[] otherElements, Binding elementBinding, int accuracy, MatchLocator locator)
			throws CoreException {
		PatternLocator weakestPattern= null;
		int level= IMPOSSIBLE_MATCH;
		for (int i= 0, length= this.patternLocators.length; i < length; i++) {
			if (this.patternLocators[i].referenceType() == 0)
				return; // impossible match
			int newLevel= this.patternLocators[i].resolveLevel(reference);
			if (newLevel == IMPOSSIBLE_MATCH)
				return;
			if (weakestPattern == null || newLevel < level) {
				weakestPattern= this.patternLocators[i];
				level= newLevel;
			}
		}
		weakestPattern.matchReportReference(reference, element, localElement, otherElements, elementBinding, accuracy, locator);
	}

	protected void matchReportReference(ASTNode reference, IJavaElement element, Binding elementBinding, int accuracy, MatchLocator locator) throws CoreException {
		matchReportReference(reference, element, null, null, elementBinding, accuracy, locator);
	}

	public int resolveLevel(ASTNode node) {
		int level= ACCURATE_MATCH;
		for (int i= 0, length= this.patternLocators.length; i < length; i++) {
			int newLevel= this.patternLocators[i].resolveLevel(node);
			if (newLevel == IMPOSSIBLE_MATCH)
				return IMPOSSIBLE_MATCH;
			this.levels[i]= newLevel;
			if (newLevel < level) {
				level= newLevel; // want to answer the weaker match
			}
		}
		return level;
	}

	public int resolveLevel(Binding binding) {
		int level= ACCURATE_MATCH;
		for (int i= 0, length= this.patternLocators.length; i < length; i++) {
			int newLevel= this.patternLocators[i].resolveLevel(binding);
			if (newLevel == IMPOSSIBLE_MATCH)
				return IMPOSSIBLE_MATCH;
			this.levels[i]= newLevel;
			if (newLevel < level) {
				level= newLevel; // want to answer the weaker match
			}
		}
		return level;
	}
}