Java ITypeHierarchy.getAllSuperInterfaces方法代码示例

import org.eclipse.jdt.core.ITypeHierarchy; //导入方法依赖的package包/类
/**
 * Find all default extensions for this resource type. If the type itself does
 * not declare any extensions, it may inherit extensions from any of the
 * interfaces in its super type hierarchy.
 */
public static String[] getDefaultExtensions(IType resourceType)
    throws JavaModelException {
  String[] extensions = getDeclaredDefaultExtensions(resourceType);

  // Check the super interface hierarchy for @DefaultExtensions
  if (extensions.length == 0) {
    ITypeHierarchy superHierarchy = resourceType.newSupertypeHierarchy(null);
    IType[] superInterfaces = superHierarchy.getAllSuperInterfaces(resourceType);
    for (IType superInterface : superInterfaces) {
      extensions = getDeclaredDefaultExtensions(superInterface);
      if (extensions.length > 0) {
        break;
      }
    }
  }
  return extensions;
}
 

import org.eclipse.jdt.core.ITypeHierarchy; //导入方法依赖的package包/类
public static IMethod isDeclaredInInterface(IMethod method, ITypeHierarchy hierarchy, IProgressMonitor monitor) throws JavaModelException {
	Assert.isTrue(isVirtual(method));
	IProgressMonitor subMonitor= new SubProgressMonitor(monitor, 1);
	try {
		IType[] classes= hierarchy.getAllClasses();
		subMonitor.beginTask("", classes.length); //$NON-NLS-1$
		for (int i= 0; i < classes.length; i++) {
			final IType clazz= classes[i];
			IType[] superinterfaces= null;
			if (clazz.equals(hierarchy.getType()))
				superinterfaces= hierarchy.getAllSuperInterfaces(clazz);
			else
				superinterfaces= clazz.newSupertypeHierarchy(new SubProgressMonitor(subMonitor, 1)).getAllSuperInterfaces(clazz);
			for (int j= 0; j < superinterfaces.length; j++) {
				IMethod found= Checks.findSimilarMethod(method, superinterfaces[j]);
				if (found != null && !found.equals(method))
					return found;
			}
			subMonitor.worked(1);
		}
		return null;
	} finally {
		subMonitor.done();
	}
}
 

import org.eclipse.jdt.core.ITypeHierarchy; //导入方法依赖的package包/类
public Collection<IType> findInterfaces(IType type, IProgressMonitor progressMonitor) {
    ITypeHierarchy typeHierarchy;

    try {
        typeHierarchy = type.newSupertypeHierarchy(progressMonitor);

        IType[] interfaces = typeHierarchy.getAllSuperInterfaces(type);
        HashSet<IType> result = new HashSet<IType>(Arrays.asList(interfaces));

        return result;
    } catch (JavaModelException e) {
        JavaPlugin.log(e);
    }

    return null;
}
 

import org.eclipse.jdt.core.ITypeHierarchy; //导入方法依赖的package包/类
private void collectChildrenWithMissingSerialVersionId(IJavaElement[] children, IType serializable, List<IType> result) throws JavaModelException {
	for (int i = 0; i < children.length; i++) {
		IJavaElement child = children[i];
		if (child instanceof IType) {
			IType type = (IType) child;

			if (type.isClass()) {
				IField field = type.getField(NAME_FIELD);
				if (!field.exists()) {
					ITypeHierarchy hierarchy = type.newSupertypeHierarchy(new NullProgressMonitor());
					IType[] interfaces = hierarchy.getAllSuperInterfaces(type);
					for (int j = 0; j < interfaces.length; j++) {
						if (interfaces[j].equals(serializable)) {
							result.add(type);
							break;
						}
					}
				}
			}

			collectChildrenWithMissingSerialVersionId(type.getChildren(), serializable, result);
		} else if (child instanceof IMethod) {
			collectChildrenWithMissingSerialVersionId(((IMethod) child).getChildren(), serializable, result);
		} else if (child instanceof IField) {
			collectChildrenWithMissingSerialVersionId(((IField) child).getChildren(), serializable, result);
		}
	}
}
 

import org.eclipse.jdt.core.ITypeHierarchy; //导入方法依赖的package包/类
private RefactoringStatus checkValidInterfacesInDeclaringTypeHierarchy(IMethod sourceMethod,
		Optional<IProgressMonitor> monitor) throws JavaModelException {
	RefactoringStatus status = new RefactoringStatus();

	monitor.ifPresent(m -> m.beginTask("Checking valid interfaces in declaring type hierarchy ...",
			IProgressMonitor.UNKNOWN));
	try {
		ITypeHierarchy hierarchy = this.getDeclaringTypeHierarchy(sourceMethod, monitor);
		IType[] declaringTypeSuperInterfaces = hierarchy.getAllSuperInterfaces(sourceMethod.getDeclaringType());

		// the number of methods sourceMethod is implementing.
		long numberOfImplementedMethods = Arrays.stream(declaringTypeSuperInterfaces).parallel().distinct().flatMap(
				i -> Arrays.stream(Optional.ofNullable(i.findMethods(sourceMethod)).orElse(new IMethod[] {})))
				.count();

		if (numberOfImplementedMethods > 1)
			addErrorAndMark(status, PreconditionFailure.SourceMethodImplementsMultipleMethods, sourceMethod);

		// for each subclass of the declaring type.
		for (IType subclass : hierarchy.getSubclasses(sourceMethod.getDeclaringType()))
			status.merge(checkClassForMissingSourceMethodImplementation(sourceMethod, subclass, hierarchy,
					monitor.map(m -> new SubProgressMonitor(m, IProgressMonitor.UNKNOWN))));
	} finally {
		monitor.ifPresent(IProgressMonitor::done);
	}
	return status;
}
 

import org.eclipse.jdt.core.ITypeHierarchy; //导入方法依赖的package包/类
private void collectChildrenWithMissingSerialVersionId(
    IJavaElement[] children, IType serializable, List<IType> result) throws JavaModelException {
  for (int i = 0; i < children.length; i++) {
    IJavaElement child = children[i];
    if (child instanceof IType) {
      IType type = (IType) child;

      if (type.isClass()) {
        IField field = type.getField(NAME_FIELD);
        if (!field.exists()) {
          ITypeHierarchy hierarchy = type.newSupertypeHierarchy(new NullProgressMonitor());
          IType[] interfaces = hierarchy.getAllSuperInterfaces(type);
          for (int j = 0; j < interfaces.length; j++) {
            if (interfaces[j].equals(serializable)) {
              result.add(type);
              break;
            }
          }
        }
      }

      collectChildrenWithMissingSerialVersionId(type.getChildren(), serializable, result);
    } else if (child instanceof IMethod) {
      collectChildrenWithMissingSerialVersionId(
          ((IMethod) child).getChildren(), serializable, result);
    } else if (child instanceof IField) {
      collectChildrenWithMissingSerialVersionId(
          ((IField) child).getChildren(), serializable, result);
    }
  }
}
 

import org.eclipse.jdt.core.ITypeHierarchy; //导入方法依赖的package包/类
public static IMethod isDeclaredInInterface(
    IMethod method, ITypeHierarchy hierarchy, IProgressMonitor monitor)
    throws JavaModelException {
  Assert.isTrue(isVirtual(method));
  IProgressMonitor subMonitor = new SubProgressMonitor(monitor, 1);
  try {
    IType[] classes = hierarchy.getAllClasses();
    subMonitor.beginTask("", classes.length); // $NON-NLS-1$
    for (int i = 0; i < classes.length; i++) {
      final IType clazz = classes[i];
      IType[] superinterfaces = null;
      if (clazz.equals(hierarchy.getType()))
        superinterfaces = hierarchy.getAllSuperInterfaces(clazz);
      else
        superinterfaces =
            clazz
                .newSupertypeHierarchy(new SubProgressMonitor(subMonitor, 1))
                .getAllSuperInterfaces(clazz);
      for (int j = 0; j < superinterfaces.length; j++) {
        IMethod found = Checks.findSimilarMethod(method, superinterfaces[j]);
        if (found != null && !found.equals(method)) return found;
      }
      subMonitor.worked(1);
    }
    return null;
  } finally {
    subMonitor.done();
  }
}
 

import org.eclipse.jdt.core.ITypeHierarchy; //导入方法依赖的package包/类
private void collectChildrenWithMissingSerialVersionId(IJavaElement[] children, IType serializable, List<IType> result) throws JavaModelException {
	for (int i= 0; i < children.length; i++) {
		IJavaElement child= children[i];
		if (child instanceof IType) {
			IType type= (IType)child;

			if (type.isClass()) {
  					IField field= type.getField(NAME_FIELD);
  					if (!field.exists()) {
  						ITypeHierarchy hierarchy= type.newSupertypeHierarchy(new NullProgressMonitor());
  						IType[] interfaces= hierarchy.getAllSuperInterfaces(type);
  						for (int j= 0; j < interfaces.length; j++) {
  							if (interfaces[j].equals(serializable)) {
  								result.add(type);
  								break;
  							}
  						}
				}
			}

			collectChildrenWithMissingSerialVersionId(type.getChildren(), serializable, result);
		} else if (child instanceof IMethod) {
			collectChildrenWithMissingSerialVersionId(((IMethod)child).getChildren(), serializable, result);
		} else if (child instanceof IField) {
			collectChildrenWithMissingSerialVersionId(((IField)child).getChildren(), serializable, result);
		}
	}
}