Java ITypeHierarchy.getAllSubtypes方法代码示例

import org.eclipse.jdt.core.ITypeHierarchy; //导入方法依赖的package包/类
/**
 * @see IJavaModel#calculateValue
 */
@Override
public void calculateValue(ICompilationUnit unit) {
	
	try {
		int length = 0;
		
		IType[] types = unit.getAllTypes();
		for (IType type : types) {
			ITypeHierarchy th= type.newTypeHierarchy((IJavaProject) type.getAncestor(IJavaElement.JAVA_PROJECT), null);
			
			if (th != null) subtypesList = th.getAllSubtypes(type);
			
			if (subtypesList != null) length = subtypesList.length;
			
			Double value = new BigDecimal(length, new MathContext(2, RoundingMode.UP)).doubleValue();
			setNocValue(value);
		}
		
	}catch (JavaModelException exception1) {
		logger.error(exception1);
	}catch (NullPointerException exception2){
		logger.error(exception2);
	}
}
 

import org.eclipse.jdt.core.ITypeHierarchy; //导入方法依赖的package包/类
private void findTypesWithSubMethods(IJavaElement element, List<Type> implementations)
    throws JavaModelException {
  IMethod selectedMethod = (IMethod) element;
  IType parentType = selectedMethod.getDeclaringType();
  if (parentType == null) {
    return;
  }
  ITypeHierarchy typeHierarchy = parentType.newTypeHierarchy(new NullProgressMonitor());
  IType[] subTypes = typeHierarchy.getAllSubtypes(parentType);

  MethodOverrideTester methodOverrideTester = new MethodOverrideTester(parentType, typeHierarchy);

  for (IType type : subTypes) {
    IMethod method = methodOverrideTester.findOverridingMethodInType(type, selectedMethod);
    if (method == null) {
      continue;
    }
    Type openDeclaration = convertToTypeDTO(type);
    setRange(openDeclaration, method);
    implementations.add(openDeclaration);
  }
}
 

import org.eclipse.jdt.core.ITypeHierarchy; //导入方法依赖的package包/类
private Map<IMember, Set<IMember>> getMatchingMembers(final ITypeHierarchy hierarchy, final IType type, final boolean includeAbstract) throws JavaModelException {
	final Map<IMember, Set<IMember>> result= new HashMap<IMember, Set<IMember>>();
	result.putAll(getMatchingMembersMapping(type));
	final IType[] subTypes= hierarchy.getAllSubtypes(type);
	for (int i= 0; i < subTypes.length; i++) {
		final Map<IMember, Set<IMember>> map= getMatchingMembersMapping(subTypes[i]);
		mergeMaps(result, map);
		upgradeMap(result, map);
	}
	if (includeAbstract)
		return result;

	for (int i= 0; i < fAbstractMethods.length; i++) {
		if (result.containsKey(fAbstractMethods[i]))
			result.remove(fAbstractMethods[i]);
	}
	return result;
}
 

import org.eclipse.jdt.core.ITypeHierarchy; //导入方法依赖的package包/类
private IType[] findTypesWithMissingUID(IJavaProject project, ICompilationUnit[] compilationUnits, IProgressMonitor monitor) throws CoreException {
	try {
		monitor.beginTask("", compilationUnits.length); //$NON-NLS-1$

		IType serializable = project.findType(SERIALIZABLE_NAME);

		List<IType> types = new ArrayList<>();

		if (compilationUnits.length > 500) {
			//500 is a guess. Building the type hierarchy on serializable is very expensive
			//depending on how many subtypes exit in the project.

			HashSet<ICompilationUnit> cus = new HashSet<>();
			for (int i = 0; i < compilationUnits.length; i++) {
				cus.add(compilationUnits[i]);
			}

			monitor.subTask(Messages.format(FixMessages.Java50Fix_SerialVersion_CalculateHierarchy_description, SERIALIZABLE_NAME));
			ITypeHierarchy hierarchy1 = serializable.newTypeHierarchy(project, new SubProgressMonitor(monitor, compilationUnits.length));
			IType[] allSubtypes1 = hierarchy1.getAllSubtypes(serializable);
			addTypes(allSubtypes1, cus, types);
		} else {
			monitor.subTask(FixMessages.Java50Fix_InitializeSerialVersionId_subtask_description);
			for (int i = 0; i < compilationUnits.length; i++) {
				collectChildrenWithMissingSerialVersionId(compilationUnits[i].getChildren(), serializable, types);
				if (monitor.isCanceled()) {
					throw new OperationCanceledException();
				}
				monitor.worked(1);
			}
		}

		return types.toArray(new IType[types.size()]);
	} finally {
		monitor.done();
	}
}
 

import org.eclipse.jdt.core.ITypeHierarchy; //导入方法依赖的package包/类
private void findSubTypes(IJavaElement element, List<Type> implementations)
    throws JavaModelException {
  IType type = (IType) element;
  ITypeHierarchy typeHierarchy = type.newTypeHierarchy(new NullProgressMonitor());
  IType[] implTypes = typeHierarchy.getAllSubtypes(type);

  for (IType implType : implTypes) {
    Type dto = convertToTypeDTO(implType);
    implementations.add(dto);
  }
}
 

import org.eclipse.jdt.core.ITypeHierarchy; //导入方法依赖的package包/类
private static IType[] getNonBinarySubtypes(WorkingCopyOwner owner, IType type, IProgressMonitor monitor) throws JavaModelException{
	ITypeHierarchy hierarchy= null;
	if (owner == null)
		hierarchy= type.newTypeHierarchy(monitor);
	else
		hierarchy= type.newSupertypeHierarchy(owner, monitor);
	IType[] subTypes= hierarchy.getAllSubtypes(type);
	List<IType> result= new ArrayList<IType>(subTypes.length);
	for (int i= 0; i < subTypes.length; i++) {
		if (! subTypes[i].isBinary()) {
			result.add(subTypes[i]);
		}
	}
	return result.toArray(new IType[result.size()]);
}
 

import org.eclipse.jdt.core.ITypeHierarchy; //导入方法依赖的package包/类
private static Set<IType> computeShowableSubtypesOfMainType(final ITypeHierarchy hierarchy, final Map<IType, IMember[]> typeToMemberArray) {
	final Set<IType> result= new HashSet<IType>();
	final IType[] subtypes= hierarchy.getAllSubtypes(hierarchy.getType());
	for (int i= 0; i < subtypes.length; i++) {
		final IType subtype= subtypes[i];
		if (canBeShown(subtype, typeToMemberArray, hierarchy))
			result.add(subtype);
	}
	return result;
}
 

import org.eclipse.jdt.core.ITypeHierarchy; //导入方法依赖的package包/类
private IType[] findTypesWithMissingUID(IJavaProject project, ICompilationUnit[] compilationUnits, IProgressMonitor monitor) throws CoreException {
	try {
		monitor.beginTask("", compilationUnits.length); //$NON-NLS-1$

		IType serializable= project.findType(SERIALIZABLE_NAME);

		List<IType> types= new ArrayList<IType>();

		if (compilationUnits.length > 500) {
			//500 is a guess. Building the type hierarchy on serializable is very expensive
			//depending on how many subtypes exit in the project.

			HashSet<ICompilationUnit> cus= new HashSet<ICompilationUnit>();
			for (int i= 0; i < compilationUnits.length; i++) {
				cus.add(compilationUnits[i]);
			}

			monitor.subTask(Messages.format(FixMessages.Java50Fix_SerialVersion_CalculateHierarchy_description, SERIALIZABLE_NAME));
			ITypeHierarchy hierarchy1= serializable.newTypeHierarchy(project, new SubProgressMonitor(monitor, compilationUnits.length));
			IType[] allSubtypes1= hierarchy1.getAllSubtypes(serializable);
			addTypes(allSubtypes1, cus, types);
		} else {
			monitor.subTask(FixMessages.Java50Fix_InitializeSerialVersionId_subtask_description);
                  for (int i= 0; i < compilationUnits.length; i++) {
                  	collectChildrenWithMissingSerialVersionId(compilationUnits[i].getChildren(), serializable, types);
                  	if (monitor.isCanceled())
                  		throw new OperationCanceledException();
                  	monitor.worked(1);
                  }
		}

		return types.toArray(new IType[types.size()]);
	} finally {
		monitor.done();
	}
}
 

import org.eclipse.jdt.core.ITypeHierarchy; //导入方法依赖的package包/类
private static IType[] getAllDeclaringTypeSubtypes(IMethod method) throws JavaModelException {
	IType declaringType = method.getDeclaringType();
	ITypeHierarchy typeHierarchy = declaringType.newTypeHierarchy(new NullProgressMonitor());
	IType[] allSubtypes = typeHierarchy.getAllSubtypes(declaringType);
	return allSubtypes;
}
 

import org.eclipse.jdt.core.ITypeHierarchy; //导入方法依赖的package包/类
private IType[] findTypesWithMissingUID(
    IJavaProject project, ICompilationUnit[] compilationUnits, IProgressMonitor monitor)
    throws CoreException {
  try {
    monitor.beginTask("", compilationUnits.length); // $NON-NLS-1$

    IType serializable = project.findType(SERIALIZABLE_NAME);

    List<IType> types = new ArrayList<IType>();

    if (compilationUnits.length > 500) {
      // 500 is a guess. Building the type hierarchy on serializable is very expensive
      // depending on how many subtypes exit in the project.

      HashSet<ICompilationUnit> cus = new HashSet<ICompilationUnit>();
      for (int i = 0; i < compilationUnits.length; i++) {
        cus.add(compilationUnits[i]);
      }

      monitor.subTask(
          Messages.format(
              FixMessages.Java50Fix_SerialVersion_CalculateHierarchy_description,
              SERIALIZABLE_NAME));
      ITypeHierarchy hierarchy1 =
          serializable.newTypeHierarchy(
              project, new SubProgressMonitor(monitor, compilationUnits.length));
      IType[] allSubtypes1 = hierarchy1.getAllSubtypes(serializable);
      addTypes(allSubtypes1, cus, types);
    } else {
      monitor.subTask(FixMessages.Java50Fix_InitializeSerialVersionId_subtask_description);
      for (int i = 0; i < compilationUnits.length; i++) {
        collectChildrenWithMissingSerialVersionId(
            compilationUnits[i].getChildren(), serializable, types);
        if (monitor.isCanceled()) throw new OperationCanceledException();
        monitor.worked(1);
      }
    }

    return types.toArray(new IType[types.size()]);
  } finally {
    monitor.done();
  }
}
 

import org.eclipse.jdt.core.ITypeHierarchy; //导入方法依赖的package包/类
private RefactoringStatus updateTargetVisibility(IProgressMonitor monitor)
    throws JavaModelException, CoreException {

  RefactoringStatus result = new RefactoringStatus();

  // Adjust the visibility of the method and of the referenced type. Note that
  // the target method may not be in the target type; and in this case, the type
  // of the target method does not need a visibility adjustment.

  // This method is called after all other changes have been
  // created. Changes induced by this method will be attached to those changes.

  result.merge(
      adjustVisibility(
          (IType) fIntermediaryFirstParameterType.getJavaElement(), fIntermediaryType, monitor));
  if (result.hasError()) return result; // binary

  ModifierKeyword neededVisibility = getNeededVisibility(fTargetMethod, fIntermediaryType);
  if (neededVisibility != null) {

    result.merge(adjustVisibility(fTargetMethod, neededVisibility, monitor));
    if (result.hasError()) return result; // binary

    // Need to adjust the overridden methods of the target method.
    ITypeHierarchy hierarchy = fTargetMethod.getDeclaringType().newTypeHierarchy(null);
    MethodOverrideTester tester =
        new MethodOverrideTester(fTargetMethod.getDeclaringType(), hierarchy);
    IType[] subtypes = hierarchy.getAllSubtypes(fTargetMethod.getDeclaringType());
    for (int i = 0; i < subtypes.length; i++) {
      IMethod method = tester.findOverridingMethodInType(subtypes[i], fTargetMethod);
      if (method != null && method.exists()) {
        result.merge(adjustVisibility(method, neededVisibility, monitor));
        if (monitor.isCanceled()) throw new OperationCanceledException();

        if (result.hasError()) return result; // binary
      }
    }
  }

  return result;
}
 

import org.eclipse.jdt.core.ITypeHierarchy; //导入方法依赖的package包/类
private RefactoringStatus updateTargetVisibility(IProgressMonitor monitor) throws JavaModelException, CoreException {

		RefactoringStatus result= new RefactoringStatus();

		// Adjust the visibility of the method and of the referenced type. Note that
		// the target method may not be in the target type; and in this case, the type
		// of the target method does not need a visibility adjustment.

		// This method is called after all other changes have been
		// created. Changes induced by this method will be attached to those changes.

		result.merge(adjustVisibility((IType) fIntermediaryFirstParameterType.getJavaElement(), fIntermediaryType, monitor));
		if (result.hasError())
			return result; // binary

		ModifierKeyword neededVisibility= getNeededVisibility(fTargetMethod, fIntermediaryType);
		if (neededVisibility != null) {

			result.merge(adjustVisibility(fTargetMethod, neededVisibility,  monitor));
			if (result.hasError())
				return result; // binary

			// Need to adjust the overridden methods of the target method.
			ITypeHierarchy hierarchy= fTargetMethod.getDeclaringType().newTypeHierarchy(null);
			MethodOverrideTester tester= new MethodOverrideTester(fTargetMethod.getDeclaringType(), hierarchy);
			IType[] subtypes= hierarchy.getAllSubtypes(fTargetMethod.getDeclaringType());
			for (int i= 0; i < subtypes.length; i++) {
				IMethod method= tester.findOverridingMethodInType(subtypes[i], fTargetMethod);
				if (method != null && method.exists()) {
					result.merge(adjustVisibility(method, neededVisibility, monitor));
					if (monitor.isCanceled())
						throw new OperationCanceledException();

					if (result.hasError())
						return result; // binary
				}
			}
		}

		return result;
	}
 

import org.eclipse.jdt.core.ITypeHierarchy; //导入方法依赖的package包/类
private RefactoringStatus updateTargetVisibility(IProgressMonitor monitor) throws JavaModelException, CoreException {

		RefactoringStatus result= new RefactoringStatus();

		// Adjust the visibility of the method and of the referenced type. Note that
		// the target method may not be in the target type; and in this case, the type
		// of the target method does not need a visibility adjustment.

		// This method is called after all other changes have been
		// created. Changes induced by this method will be attached to those changes.

		result.merge(adjustVisibility((IType) fIntermediaryFirstParameterType.getJavaElement(), fIntermediaryClass, monitor));
		if (result.hasError())
			return result; // binary

		ModifierKeyword neededVisibility= getNeededVisibility(fTargetMethod, fIntermediaryClass);
		if (neededVisibility != null) {

			result.merge(adjustVisibility(fTargetMethod, neededVisibility,  monitor));
			if (result.hasError())
				return result; // binary

			// Need to adjust the overridden methods of the target method.
			ITypeHierarchy hierarchy= fTargetMethod.getDeclaringType().newTypeHierarchy(null);
			MethodOverrideTester tester= new MethodOverrideTester(fTargetMethod.getDeclaringType(), hierarchy);
			IType[] subtypes= hierarchy.getAllSubtypes(fTargetMethod.getDeclaringType());
			for (int i= 0; i < subtypes.length; i++) {
				IMethod method= tester.findOverridingMethodInType(subtypes[i], fTargetMethod);
				if (method != null && method.exists()) {
					result.merge(adjustVisibility(method, neededVisibility, monitor));
					if (monitor.isCanceled())
						throw new OperationCanceledException();

					if (result.hasError())
						return result; // binary
				}
			}
		}

		return result;
	}