/*******************************************************************************
* Copyright (c) 2000, 2010 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 java.io.IOException;
import org.eclipse.jdt.core.BindingKey;
import org.eclipse.jdt.core.Flags;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.core.search.IJavaSearchConstants;
import org.eclipse.jdt.core.search.SearchPattern;
import org.eclipse.jdt.internal.core.index.EntryResult;
import org.eclipse.jdt.internal.core.index.Index;
import org.eclipse.jdt.internal.core.util.Util;
public class MethodPattern extends JavaSearchPattern {
protected boolean findDeclarations= true;
protected boolean findReferences= true;
public char[] selector;
public char[] declaringQualification;
public char[] declaringSimpleName;
public char[] returnQualification;
public char[] returnSimpleName;
public char[][] parameterQualifications;
public char[][] parameterSimpleNames;
public int parameterCount;
public boolean varargs= false;
// extra reference info
protected IType declaringType;
// Signatures and arguments for generic search
char[][] returnTypeSignatures;
char[][][] parametersTypeSignatures;
char[][][][] parametersTypeArguments;
boolean methodParameters= false;
char[][] methodArguments;
protected static char[][] REF_CATEGORIES= { METHOD_REF };
protected static char[][] REF_AND_DECL_CATEGORIES= { METHOD_REF, METHOD_DECL };
protected static char[][] DECL_CATEGORIES= { METHOD_DECL };
public final static int FINE_GRAIN_MASK=
IJavaSearchConstants.SUPER_REFERENCE |
IJavaSearchConstants.QUALIFIED_REFERENCE |
IJavaSearchConstants.THIS_REFERENCE |
IJavaSearchConstants.IMPLICIT_THIS_REFERENCE;
/**
* Method entries are encoded as selector '/' Arity: e.g. 'foo/0'
*/
public static char[] createIndexKey(char[] selector, int argCount) {
char[] countChars= argCount < 10
? COUNTS[argCount]
: ("/" + String.valueOf(argCount)).toCharArray(); //$NON-NLS-1$
return CharOperation.concat(selector, countChars);
}
MethodPattern(int matchRule) {
super(METHOD_PATTERN, matchRule);
}
public MethodPattern(
char[] selector,
char[] declaringQualification,
char[] declaringSimpleName,
char[] returnQualification,
char[] returnSimpleName,
char[][] parameterQualifications,
char[][] parameterSimpleNames,
IType declaringType,
int limitTo,
int matchRule) {
this(matchRule);
this.fineGrain= limitTo & FINE_GRAIN_MASK;
if (this.fineGrain == 0) {
switch (limitTo & 0xF) {
case IJavaSearchConstants.DECLARATIONS:
this.findReferences= false;
break;
case IJavaSearchConstants.REFERENCES:
this.findDeclarations= false;
break;
case IJavaSearchConstants.ALL_OCCURRENCES:
break;
}
} else {
this.findDeclarations= false;
}
this.selector= (this.isCaseSensitive || this.isCamelCase) ? selector : CharOperation.toLowerCase(selector);
this.declaringQualification= this.isCaseSensitive ? declaringQualification : CharOperation.toLowerCase(declaringQualification);
this.declaringSimpleName= this.isCaseSensitive ? declaringSimpleName : CharOperation.toLowerCase(declaringSimpleName);
this.returnQualification= this.isCaseSensitive ? returnQualification : CharOperation.toLowerCase(returnQualification);
this.returnSimpleName= this.isCaseSensitive ? returnSimpleName : CharOperation.toLowerCase(returnSimpleName);
if (parameterSimpleNames != null) {
this.parameterCount= parameterSimpleNames.length;
this.parameterQualifications= new char[this.parameterCount][];
this.parameterSimpleNames= new char[this.parameterCount][];
for (int i= 0; i < this.parameterCount; i++) {
this.parameterQualifications[i]= this.isCaseSensitive ? parameterQualifications[i] : CharOperation.toLowerCase(parameterQualifications[i]);
this.parameterSimpleNames[i]= this.isCaseSensitive ? parameterSimpleNames[i] : CharOperation.toLowerCase(parameterSimpleNames[i]);
}
} else {
this.parameterCount= -1;
}
this.declaringType= declaringType;
this.mustResolve= mustResolve();
}
/*
* Instanciate a method pattern with signatures for generics search
*/
public MethodPattern(
char[] selector,
char[] declaringQualification,
char[] declaringSimpleName,
char[] returnQualification,
char[] returnSimpleName,
String returnSignature,
char[][] parameterQualifications,
char[][] parameterSimpleNames,
String[] parameterSignatures,
IMethod method,
int limitTo,
int matchRule) {
this(selector,
declaringQualification,
declaringSimpleName,
returnQualification,
returnSimpleName,
parameterQualifications,
parameterSimpleNames,
method.getDeclaringType(),
limitTo,
matchRule);
// Set flags
try {
this.varargs= (method.getFlags() & Flags.AccVarargs) != 0;
} catch (JavaModelException e) {
// do nothing
}
// Get unique key for parameterized constructors
String genericDeclaringTypeSignature= null;
if (method.isResolved()) {
String key= method.getKey();
BindingKey bindingKey= new BindingKey(key);
if (bindingKey.isParameterizedType()) {
genericDeclaringTypeSignature= Util.getDeclaringTypeSignature(key);
// Store type signature and arguments for declaring type
if (genericDeclaringTypeSignature != null) {
this.typeSignatures= Util.splitTypeLevelsSignature(genericDeclaringTypeSignature);
setTypeArguments(Util.getAllTypeArguments(this.typeSignatures));
}
}
} else {
this.methodParameters= true;
storeTypeSignaturesAndArguments(this.declaringType);
}
// Store type signatures and arguments for return type
if (returnSignature != null) {
this.returnTypeSignatures= Util.splitTypeLevelsSignature(returnSignature);
}
// Store type signatures and arguments for method parameters type
if (parameterSignatures != null) {
int length= parameterSignatures.length;
if (length > 0) {
this.parametersTypeSignatures= new char[length][][];
this.parametersTypeArguments= new char[length][][][];
for (int i= 0; i < length; i++) {
this.parametersTypeSignatures[i]= Util.splitTypeLevelsSignature(parameterSignatures[i]);
this.parametersTypeArguments[i]= Util.getAllTypeArguments(this.parametersTypeSignatures[i]);
}
}
}
// Store type signatures and arguments for method
this.methodArguments= extractMethodArguments(method);
if (hasMethodArguments())
this.mustResolve= true;
}
/*
* Instanciate a method pattern with signatures for generics search
*/
public MethodPattern(
char[] selector,
char[] declaringQualification,
char[] declaringSimpleName,
String declaringSignature,
char[] returnQualification,
char[] returnSimpleName,
String returnSignature,
char[][] parameterQualifications,
char[][] parameterSimpleNames,
String[] parameterSignatures,
char[][] arguments,
int limitTo,
int matchRule) {
this(selector,
declaringQualification,
declaringSimpleName,
returnQualification,
returnSimpleName,
parameterQualifications,
parameterSimpleNames,
null,
limitTo,
matchRule);
// Store type signature and arguments for declaring type
if (declaringSignature != null) {
this.typeSignatures= Util.splitTypeLevelsSignature(declaringSignature);
setTypeArguments(Util.getAllTypeArguments(this.typeSignatures));
}
// Store type signatures and arguments for return type
if (returnSignature != null) {
this.returnTypeSignatures= Util.splitTypeLevelsSignature(returnSignature);
}
// Store type signatures and arguments for method parameters type
if (parameterSignatures != null) {
int length= parameterSignatures.length;
if (length > 0) {
this.parametersTypeSignatures= new char[length][][];
this.parametersTypeArguments= new char[length][][][];
for (int i= 0; i < length; i++) {
this.parametersTypeSignatures[i]= Util.splitTypeLevelsSignature(parameterSignatures[i]);
this.parametersTypeArguments[i]= Util.getAllTypeArguments(this.parametersTypeSignatures[i]);
}
}
}
// Store type signatures and arguments for method
this.methodArguments= arguments;
if (hasMethodArguments())
this.mustResolve= true;
}
public void decodeIndexKey(char[] key) {
int last= key.length - 1;
this.parameterCount= 0;
this.selector= null;
int power= 1;
for (int i= last; i >= 0; i--) {
if (key[i] == SEPARATOR) {
System.arraycopy(key, 0, this.selector= new char[i], 0, i);
break;
}
if (i == last) {
this.parameterCount= key[i] - '0';
} else {
power*= 10;
this.parameterCount+= power * (key[i] - '0');
}
}
}
public SearchPattern getBlankPattern() {
return new MethodPattern(R_EXACT_MATCH | R_CASE_SENSITIVE);
}
public char[][] getIndexCategories() {
if (this.findReferences)
return this.findDeclarations ? REF_AND_DECL_CATEGORIES : REF_CATEGORIES;
if (this.findDeclarations)
return DECL_CATEGORIES;
return CharOperation.NO_CHAR_CHAR;
}
boolean hasMethodArguments() {
return this.methodArguments != null && this.methodArguments.length > 0;
}
boolean hasMethodParameters() {
return this.methodParameters;
}
public boolean isPolymorphicSearch() {
return this.findReferences;
}
public boolean matchesDecodedKey(SearchPattern decodedPattern) {
MethodPattern pattern= (MethodPattern)decodedPattern;
return (this.parameterCount == pattern.parameterCount || this.parameterCount == -1 || this.varargs)
&& matchesName(this.selector, pattern.selector);
}
/**
* Returns whether a method declaration or message send must be resolved to find out if this
* method pattern matches it.
*/
protected boolean mustResolve() {
// declaring type
// If declaring type is specified - even with simple name - always resolves
if (this.declaringSimpleName != null || this.declaringQualification != null)
return true;
// return type
// If return type is specified - even with simple name - always resolves
if (this.returnSimpleName != null || this.returnQualification != null)
return true;
// parameter types
if (this.parameterSimpleNames != null)
for (int i= 0, max= this.parameterSimpleNames.length; i < max; i++)
if (this.parameterQualifications[i] != null)
return true;
return false;
}
public EntryResult[] queryIn(Index index) throws IOException {
char[] key= this.selector; // can be null
int matchRule= getMatchRule();
switch (getMatchMode()) {
case R_EXACT_MATCH:
if (this.selector != null && this.parameterCount >= 0 && !this.varargs)
key= createIndexKey(this.selector, this.parameterCount);
else { // do a prefix query with the selector
matchRule&= ~R_EXACT_MATCH;
matchRule|= R_PREFIX_MATCH;
}
break;
case R_PREFIX_MATCH:
// do a prefix query with the selector
break;
case R_PATTERN_MATCH:
if (this.parameterCount >= 0 && !this.varargs)
key= createIndexKey(this.selector == null ? ONE_STAR : this.selector, this.parameterCount);
else if (this.selector != null && this.selector[this.selector.length - 1] != '*')
key= CharOperation.concat(this.selector, ONE_STAR, SEPARATOR);
// else do a pattern query with just the selector
break;
case R_REGEXP_MATCH:
// TODO (frederic) implement regular expression match
break;
case R_CAMELCASE_MATCH:
case R_CAMELCASE_SAME_PART_COUNT_MATCH:
// do a prefix query with the selector
break;
}
return index.query(getIndexCategories(), key, matchRule); // match rule is irrelevant when the key is null
}
protected StringBuffer print(StringBuffer output) {
if (this.findDeclarations) {
output.append(this.findReferences
? "MethodCombinedPattern: " //$NON-NLS-1$
: "MethodDeclarationPattern: "); //$NON-NLS-1$
} else {
output.append("MethodReferencePattern: "); //$NON-NLS-1$
}
if (this.declaringQualification != null)
output.append(this.declaringQualification).append('.');
if (this.declaringSimpleName != null)
output.append(this.declaringSimpleName).append('.');
else if (this.declaringQualification != null)
output.append("*."); //$NON-NLS-1$
if (this.selector != null)
output.append(this.selector);
else
output.append("*"); //$NON-NLS-1$
output.append('(');
if (this.parameterSimpleNames == null) {
output.append("..."); //$NON-NLS-1$
} else {
for (int i= 0, max= this.parameterSimpleNames.length; i < max; i++) {
if (i > 0)
output.append(", "); //$NON-NLS-1$
if (this.parameterQualifications[i] != null)
output.append(this.parameterQualifications[i]).append('.');
if (this.parameterSimpleNames[i] == null)
output.append('*');
else
output.append(this.parameterSimpleNames[i]);
}
}
output.append(')');
if (this.returnQualification != null)
output.append(" --> ").append(this.returnQualification).append('.'); //$NON-NLS-1$
else if (this.returnSimpleName != null)
output.append(" --> "); //$NON-NLS-1$
if (this.returnSimpleName != null)
output.append(this.returnSimpleName);
else if (this.returnQualification != null)
output.append("*"); //$NON-NLS-1$
return super.print(output);
}
}