Java ITypeBinding.getInterfaces方法代碼示例

import org.eclipse.jdt.core.dom.ITypeBinding; //導入方法依賴的package包/類
private static boolean isContext(ITypeBinding tbinding) {
	String executionContextClass = org.graphwalker.core.machine.ExecutionContext.class.getName();
	String contextClass = org.graphwalker.core.machine.Context.class.getName();
	while (tbinding != null) {
		String clazz = tbinding.getQualifiedName();
		if (executionContextClass.equals(clazz))
			return true;
		if (contextClass.equals(clazz))
			return true;
		ITypeBinding[] interfaces = tbinding.getInterfaces();
		for (int i = 0; i < interfaces.length; i++) {
			ITypeBinding interf = interfaces[i];
			if (contextClass.equals(interf.getQualifiedName()))
				return true;
		}
		tbinding = tbinding.getSuperclass();
	}
	return false;

}
 

import org.eclipse.jdt.core.dom.ITypeBinding; //導入方法依賴的package包/類
/**
 * Finds the field specified by <code>fieldName</code> in
 * the type hierarchy denoted by the given type. Returns <code>null</code> if no such field
 * exists. If the field is defined in more than one super type only the first match is
 * returned. First the super class is examined and then the implemented interfaces.
 * @param type The type to search the field in
 * @param fieldName The name of the field to find
 * @return the variable binding representing the field
 */
public static IVariableBinding findFieldInHierarchy(ITypeBinding type, String fieldName) {
	IVariableBinding field= findFieldInType(type, fieldName);
	if (field != null) {
		return field;
	}
	ITypeBinding superClass= type.getSuperclass();
	if (superClass != null) {
		field= findFieldInHierarchy(superClass, fieldName);
		if (field != null) {
			return field;
		}
	}
	ITypeBinding[] interfaces= type.getInterfaces();
	for (int i= 0; i < interfaces.length; i++) {
		field= findFieldInHierarchy(interfaces[i], fieldName);
		if (field != null) {
			return field;
		}
	}
	return null;
}
 

import org.eclipse.jdt.core.dom.ITypeBinding; //導入方法依賴的package包/類
/**
 * Finds the method specified by <code>methodName</code> and <code>parameters</code> in
 * the type hierarchy denoted by the given type. Returns <code>null</code> if no such method
 * exists. If the method is defined in more than one super type only the first match is
 * returned. First the super class is examined and then the implemented interfaces.
 *
 * @param type The type to search the method in
 * @param methodName The name of the method to find
 * @param parameters The parameter types of the method to find. If <code>null</code> is passed, only the name is matched and parameters are ignored.
 * @return the method binding representing the method
 */
public static IMethodBinding findMethodInHierarchy(ITypeBinding type, String methodName, ITypeBinding[] parameters) {
	IMethodBinding method= findMethodInType(type, methodName, parameters);
	if (method != null) {
		return method;
	}
	ITypeBinding superClass= type.getSuperclass();
	if (superClass != null) {
		method= findMethodInHierarchy(superClass, methodName, parameters);
		if (method != null) {
			return method;
		}
	}
	ITypeBinding[] interfaces= type.getInterfaces();
	for (int i= 0; i < interfaces.length; i++) {
		method= findMethodInHierarchy(interfaces[i], methodName, parameters);
		if (method != null) {
			return method;
		}
	}
	return null;
}
 

import org.eclipse.jdt.core.dom.ITypeBinding; //導入方法依賴的package包/類
/**
 * Finds a method in the hierarchy of <code>type</code> that is overridden by <code>binding</code>.
 * Returns <code>null</code> if no such method exists. If the method is defined in more than one super type only the first match is
 * returned. First the super class is examined and then the implemented interfaces.
 * @param type The type to search the method in
 * @param binding The method that overrides
 * @return the method binding overridden the method
 */
public static IMethodBinding findOverriddenMethodInHierarchy(ITypeBinding type, IMethodBinding binding) {
	IMethodBinding method= findOverriddenMethodInType(type, binding);
	if (method != null) {
		return method;
	}
	ITypeBinding superClass= type.getSuperclass();
	if (superClass != null) {
		method= findOverriddenMethodInHierarchy(superClass, binding);
		if (method != null) {
			return method;
		}
	}
	ITypeBinding[] interfaces= type.getInterfaces();
	for (int i= 0; i < interfaces.length; i++) {
		method= findOverriddenMethodInHierarchy(interfaces[i], binding);
		if (method != null) {
			return method;
		}
	}
	return null;
}
 

import org.eclipse.jdt.core.dom.ITypeBinding; //導入方法依賴的package包/類
private static boolean visitInterfaces(ITypeBinding type, TypeBindingVisitor visitor, HashSet<ITypeBinding> visited) {
	boolean unvisited= visited.add(type);
	if (!unvisited) {
		return true;
	}
	ITypeBinding[] interfaces= type.getInterfaces();
	for (int i= 0; i < interfaces.length; i++) {
		if (!visitor.visit(interfaces[i])) {
			return false;
		}
		if (!visitInterfaces(interfaces[i], visitor, visited)) {
			return false;
		}
	}
	return true;
}
 

import org.eclipse.jdt.core.dom.ITypeBinding; //導入方法依賴的package包/類
/**
 * Normalizes a type binding received from an expression to a type binding that can be used inside a
 * declaration signature, but <em>not</em> as type of a declaration (use {@link #normalizeForDeclarationUse(ITypeBinding, AST)} for that).
 * <p>
 * Anonymous types are normalized to the super class or interface. For
 * null or void bindings, <code>null</code> is returned.
 * </p>
 *
 * @param binding the binding to normalize
 * @return the normalized binding, can be <code>null</code>
 *
 * @see #normalizeForDeclarationUse(ITypeBinding, AST)
 */
public static ITypeBinding normalizeTypeBinding(ITypeBinding binding) {
	if (binding != null && !binding.isNullType() && !isVoidType(binding)) {
		if (binding.isAnonymous()) {
			ITypeBinding[] baseBindings= binding.getInterfaces();
			if (baseBindings.length > 0) {
				return baseBindings[0];
			}
			return binding.getSuperclass();
		}
		if (binding.isCapture()) {
			return binding.getWildcard();
		}
		return binding;
	}
	return null;
}
 

import org.eclipse.jdt.core.dom.ITypeBinding; //導入方法依賴的package包/類
protected void addNewTypeBinding(ITypeBinding typeBinding) {
	// Skip over primitive types, which includes void
	if (typeBinding == null || typeBinding.isPrimitive()) {
		return;
	}
	String key = typeBinding.getKey();
	if (!mapKeyToType.containsKey(key)) {
		mapKeyToType.put(key, typeBinding);
	}
	
	String qualifiedName = typeBinding.getQualifiedName();
	if (!mapNameToType.containsKey(qualifiedName)) {
		mapNameToType.put(qualifiedName, typeBinding);
	}
	
	// Add supertypes, and implemented interfaces as well!
	ITypeBinding superclassType = typeBinding.getSuperclass();
	if ( superclassType != null ) {
		addNewTypeBinding(superclassType);
	}
	
	ITypeBinding[] interfaces = typeBinding.getInterfaces();
	for(ITypeBinding itfBinding : interfaces)  { 
		addNewTypeBinding(itfBinding);
	}
}
 

import org.eclipse.jdt.core.dom.ITypeBinding; //導入方法依賴的package包/類
private boolean isDefinedInTypeOrSuperType(final IMethodBinding methodBinding, ITypeBinding declaringClass) {
	while (declaringClass != null) {
		for (final IMethodBinding method : declaringClass.getDeclaredMethods()) {
			if (methodBinding.overrides(method)) {
				return true;
			}
		}
		for (final ITypeBinding type : declaringClass.getInterfaces()) {
			if (isDefinedInTypeOrSuperType(methodBinding, type)) {
				return true;
			}
		}
		declaringClass = declaringClass.getSuperclass();
	}
	return false;
}
 

import org.eclipse.jdt.core.dom.ITypeBinding; //導入方法依賴的package包/類
private static void collectSuperTypes(ITypeBinding curr, Set<ITypeBinding> collection) {
	if (collection.add(curr)) {
		ITypeBinding[] interfaces= curr.getInterfaces();
		for (int i= 0; i < interfaces.length; i++) {
			collectSuperTypes(interfaces[i], collection);
		}
		ITypeBinding superClass= curr.getSuperclass();
		if (superClass != null) {
			collectSuperTypes(superClass, collection);
		}
	}
}
 

import org.eclipse.jdt.core.dom.ITypeBinding; //導入方法依賴的package包/類
/**
 * Returns <code>true</code> if the given type is a super type of a candidate.
 * <code>true</code> is returned if the two type bindings are identical (TODO)
 * @param possibleSuperType the type to inspect
 * @param type the type whose super types are looked at
 * @param considerTypeArguments if <code>true</code>, consider type arguments of <code>type</code>
 * @return <code>true</code> iff <code>possibleSuperType</code> is
 * 		a super type of <code>type</code> or is equal to it
 */
public static boolean isSuperType(ITypeBinding possibleSuperType, ITypeBinding type, boolean considerTypeArguments) {
	if (type.isArray() || type.isPrimitive()) {
		return false;
	}
	if (! considerTypeArguments) {
		type= type.getTypeDeclaration();
	}
	if (Bindings.equals(type, possibleSuperType)) {
		return true;
	}
	ITypeBinding superClass= type.getSuperclass();
	if (superClass != null) {
		if (isSuperType(possibleSuperType, superClass, considerTypeArguments)) {
			return true;
		}
	}

	if (possibleSuperType.isInterface()) {
		ITypeBinding[] superInterfaces= type.getInterfaces();
		for (int i= 0; i < superInterfaces.length; i++) {
			if (isSuperType(possibleSuperType, superInterfaces[i], considerTypeArguments)) {
				return true;
			}
		}
	}
	return false;
}
 

import org.eclipse.jdt.core.dom.ITypeBinding; //導入方法依賴的package包/類
private static void getOverridableMethods(AST ast, ITypeBinding superBinding, List<IMethodBinding> allMethods) {
	IMethodBinding[] methods= superBinding.getDeclaredMethods();
	for (int offset= 0; offset < methods.length; offset++) {
		final int modifiers= methods[offset].getModifiers();
		if (!methods[offset].isConstructor() && !Modifier.isStatic(modifiers) && !Modifier.isPrivate(modifiers)) {
			if (findOverridingMethod(methods[offset], allMethods) == null) {
				allMethods.add(methods[offset]);
			}
		}
	}
	ITypeBinding[] superInterfaces= superBinding.getInterfaces();
	for (int index= 0; index < superInterfaces.length; index++) {
		getOverridableMethods(ast, superInterfaces[index], allMethods);
	}
}
 

import org.eclipse.jdt.core.dom.ITypeBinding; //導入方法依賴的package包/類
public void checkInput(RefactoringStatus status, String methodName, ASTNode destination) {
	ITypeBinding[] arguments = getArgumentTypes();
	ITypeBinding type = ASTNodes.getEnclosingType(destination);
	status.merge(Checks.checkMethodInType(type, methodName, arguments));
	ITypeBinding superClass = type.getSuperclass();
	if (superClass != null) {
		status.merge(Checks.checkMethodInHierarchy(superClass, methodName, null, arguments));
	}
	for (ITypeBinding superInterface : type.getInterfaces()) {
		status.merge(Checks.checkMethodInHierarchy(superInterface, methodName, null, arguments));
	}
}
 

import org.eclipse.jdt.core.dom.ITypeBinding; //導入方法依賴的package包/類
/**
 * General, recursive version.
 * @param declaringClass
 * @param methodBinding
 * @return
 */
private static IMethodBinding getOverriddenMethod(ITypeBinding declaringClass, IMethodBinding methodBinding) {
	IMethodBinding overriddenMethod = null;

	ITypeBinding[] paramTypes = methodBinding.getParameterTypes();
	String methodName = methodBinding.getName();

	ITypeBinding returnType = methodBinding.getReturnType();

	// Look at superclass
	ITypeBinding superclass = declaringClass.getSuperclass();
	if (superclass != null) {
		overriddenMethod = getMethodBinding(superclass, methodName, paramTypes, returnType);
		// Recursively look at superclass
		if (overriddenMethod == null ) {
			overriddenMethod = getOverriddenMethod(superclass, methodBinding);
		}
	}
	// Look at interfaces
	if (overriddenMethod == null) {
		for (ITypeBinding itfTypeBinding : declaringClass.getInterfaces()) {
			overriddenMethod = getMethodBinding(itfTypeBinding, methodName, paramTypes, returnType);
			if (  overriddenMethod != null ) {
				break;
			}
		}
	}

	return overriddenMethod;
}
 

import org.eclipse.jdt.core.dom.ITypeBinding; //導入方法依賴的package包/類
public static List<String> getDomainDeclsRecursive(ITypeBinding typeBinding, AnnotationDatabase annoDB) {
	Set<String> domDecl = new HashSet<String>();
	domDecl.addAll(getDomainDecls(typeBinding, annoDB));
	if (typeBinding.getSuperclass() != null)
		domDecl.addAll(getDomainDecls(typeBinding.getSuperclass(), annoDB));
	ITypeBinding[] interfaces = typeBinding.getInterfaces();
	for (ITypeBinding iTypeBinding : interfaces) {
		domDecl.addAll(getDomainDecls(iTypeBinding, annoDB));
	}
	List<String> domDeclList = new ArrayList<String>();
	domDeclList.addAll(domDecl);
	return domDeclList;
}
 

import org.eclipse.jdt.core.dom.ITypeBinding; //導入方法依賴的package包/類
public void reviveTypeFromBinding(Type type, ITypeBinding typeBinding) {
	// First process superclass
	ITypeBinding superTypeBinding = typeBinding.getSuperclass();
	if (superTypeBinding != null) {
		String superTypeBindingName = superTypeBinding.getQualifiedName();
		Type superType = getType(superTypeBindingName);
		if (superType != null) {
			reviveSuperType(type, superTypeBinding, superType);
		}
		else {
			// TODO: Do something. This should not have happened!
			// Probably due to java.lang.Object
			superType = Type.createFrom(superTypeBinding);
			// NOTE: Type.createFrom calls TypeAdapter.addType()
			// typeAdapter.addType(superType);
			
			reviveSuperType(type, superTypeBinding, superType);				
		}

	}

	// Then process super interfaces
	for (ITypeBinding itfTypeBinding : typeBinding.getInterfaces()) {
		String itfName = itfTypeBinding.getQualifiedName();
		Type itfType = getType(itfName);
		if (itfType != null) {
			reviveSuperType(type, itfTypeBinding, itfType);
		}
		else {
			// TODO: Do something. This should not have happened!
			itfType = Type.createFrom(itfTypeBinding);
				// NOTE: Type.createFrom calls TypeAdapter.addType()
			// typeAdapter.addType(itfType);
			
			reviveSuperType(type, itfTypeBinding, itfType);			
		}
	}
}