Java IMethod.getDeclaringType方法代码示例

import org.eclipse.jdt.core.IMethod; //导入方法依赖的package包/类
private static final boolean resolveTypeParameter(final IMethod method,
    final String identifier, final StringBuilder result)
    throws JavaModelException {
  IType type = method.getDeclaringType();
  if (resolveTypeParameter(type, method.getTypeParameters(), identifier,
      result)) {
    return true;
  }
  while (type != null) {
    if (resolveTypeParameter(type, type.getTypeParameters(), identifier,
        result)) {
      return true;
    }
    type = type.getDeclaringType();
  }
  return false;
}
 

import org.eclipse.jdt.core.IMethod; //导入方法依赖的package包/类
private static boolean sameParameters(IMethodBinding method, IMethod candidate) throws JavaModelException {
	ITypeBinding[] methodParamters= method.getParameterTypes();
	String[] candidateParameters= candidate.getParameterTypes();
	if (methodParamters.length != candidateParameters.length) {
		return false;
	}
	IType scope= candidate.getDeclaringType();
	for (int i= 0; i < methodParamters.length; i++) {
		ITypeBinding methodParameter= methodParamters[i];
		String candidateParameter= candidateParameters[i];
		if (!sameParameter(methodParameter, candidateParameter, scope)) {
			return false;
		}
	}
	return true;
}
 

import org.eclipse.jdt.core.IMethod; //导入方法依赖的package包/类
private static Reader findDocInHierarchy(IMethod method, boolean useAttachedJavadoc) throws JavaModelException {
	/*
	 * Catch ExternalJavaProject in which case
	 * no hierarchy can be built.
	 */
	if (!method.getJavaProject().exists()) {
		return null;
	}

	IType type= method.getDeclaringType();
	ITypeHierarchy hierarchy= type.newSupertypeHierarchy(null);

	MethodOverrideTester tester= new MethodOverrideTester(type, hierarchy);

	IType[] superTypes= hierarchy.getAllSupertypes(type);
	for (IType curr : superTypes) {
		IMethod overridden= tester.findOverriddenMethodInType(curr, method);
		if (overridden != null) {
			Reader reader = getHTMLContentReader(overridden, false, useAttachedJavadoc);
			if (reader != null) {
				return reader;
			}
		}
	}
	return null;
}
 

import org.eclipse.jdt.core.IMethod; //导入方法依赖的package包/类
/**
 * Returns the resolved type signature for the given signature in the given
 * method, or <code>null</code> if unable to resolve.
 *
 * @param method method containing the type signature
 * @param typeSignature the type signature to resolve
 * @return the resolved type signature
 * @throws JavaModelException
 */
private static String resolveTypeSignature(IMethod method, String typeSignature) throws JavaModelException {
	int count = Signature.getArrayCount(typeSignature);
	String elementTypeSignature = Signature.getElementType(typeSignature);
	if (elementTypeSignature.length() == 1) {
		// no need to resolve primitive types
		return typeSignature;
	}
	String elementTypeName = Signature.toString(elementTypeSignature);
	IType type = method.getDeclaringType();
	String[][] resolvedElementTypeNames = type.resolveType(elementTypeName);
	if (resolvedElementTypeNames == null || resolvedElementTypeNames.length != 1) {
		// check if type parameter
		ITypeParameter typeParameter = method.getTypeParameter(elementTypeName);
		if (!typeParameter.exists()) {
			typeParameter = type.getTypeParameter(elementTypeName);
		}
		if (typeParameter.exists()) {
			String[] bounds = typeParameter.getBounds();
			if (bounds.length == 0) {
				return "Ljava/lang/Object;"; //$NON-NLS-1$
			}
			String bound = Signature.createTypeSignature(bounds[0], false);
			return Signature.createArraySignature(resolveTypeSignature(method, bound), count);
		}
		// the type name cannot be resolved
		return null;
	}

	String[] types = resolvedElementTypeNames[0];
	types[1] = types[1].replace('.', '$');

	String resolvedElementTypeName = Signature.toQualifiedName(types);
	String resolvedElementTypeSignature = "";
	if(types[0].equals("")) {
		resolvedElementTypeName = resolvedElementTypeName.substring(1);
		resolvedElementTypeSignature = Signature.createTypeSignature(resolvedElementTypeName, true);
	}
	else {
		resolvedElementTypeSignature = Signature.createTypeSignature(resolvedElementTypeName, true).replace('.', '/');
	}

	return Signature.createArraySignature(resolvedElementTypeSignature, count);
}