Java ITypeHierarchy.getSuperclass方法代码示例

import org.eclipse.jdt.core.ITypeHierarchy; //导入方法依赖的package包/类
private static boolean superClassImplementsDestinationInterface(IType type, IType destinationInterface,
		Optional<IProgressMonitor> monitor) throws JavaModelException {
	monitor.ifPresent(m -> m.beginTask("Checking superclass ...", IProgressMonitor.UNKNOWN));
	try {
		if (type.getSuperclassName() != null) { // there's a superclass.
			ITypeHierarchy superTypeHierarchy = MigrateSkeletalImplementationToInterfaceRefactoringProcessor
					.getSuperTypeHierarchy(type,
							monitor.map(m -> new SubProgressMonitor(m, IProgressMonitor.UNKNOWN)));
			IType superclass = superTypeHierarchy.getSuperclass(type);
			return Arrays.stream(superTypeHierarchy.getAllSuperInterfaces(superclass))
					.anyMatch(i -> i.equals(destinationInterface));
		}
	} finally {
		monitor.ifPresent(IProgressMonitor::done);
	}

	return true; // vacuously true since there's no superclass.
}
 

import org.eclipse.jdt.core.ITypeHierarchy; //导入方法依赖的package包/类
private Set<IType> getSkippedSuperTypes(final IProgressMonitor monitor) throws JavaModelException {
	monitor.beginTask(RefactoringCoreMessages.PullUpRefactoring_checking, 1);
	try {
		if (fCachedSkippedSuperTypes != null && getDestinationTypeHierarchy(new SubProgressMonitor(monitor, 1)).getType().equals(getDestinationType()))
			return fCachedSkippedSuperTypes;
		final ITypeHierarchy hierarchy= getDestinationTypeHierarchy(new SubProgressMonitor(monitor, 1));
		fCachedSkippedSuperTypes= new HashSet<IType>(2);
		IType current= hierarchy.getSuperclass(getDeclaringType());
		while (current != null && !current.equals(getDestinationType())) {
			fCachedSkippedSuperTypes.add(current);
			current= hierarchy.getSuperclass(current);
		}
		return fCachedSkippedSuperTypes;
	} finally {
		monitor.done();
	}
}
 

import org.eclipse.jdt.core.ITypeHierarchy; //导入方法依赖的package包/类
public static boolean isSuperType(ITypeHierarchy hierarchy, IType possibleSuperType, IType type) {
	// filed bug 112635 to add this method to ITypeHierarchy
	IType superClass= hierarchy.getSuperclass(type);
	if (superClass != null && (possibleSuperType.equals(superClass) || isSuperType(hierarchy, possibleSuperType, superClass))) {
		return true;
	}
	if (Flags.isInterface(hierarchy.getCachedFlags(possibleSuperType))) {
		IType[] superInterfaces= hierarchy.getSuperInterfaces(type);
		for (int i= 0; i < superInterfaces.length; i++) {
			IType curr= superInterfaces[i];
			if (possibleSuperType.equals(curr) || isSuperType(hierarchy, possibleSuperType, curr)) {
				return true;
			}
		}
	}
	return false;
}
 

import org.eclipse.jdt.core.ITypeHierarchy; //导入方法依赖的package包/类
public static List<DtoField> parseKasper5DtoFields(IType type) {
	List<DtoField> fields = new ArrayList<>();
	try {
		/* Extraire le type parent */
		ITypeHierarchy hierarchy = type.newSupertypeHierarchy(null);
		IType superclass = hierarchy.getSuperclass(type);
		for (IMethod method : superclass.getMethods()) {
			parseKasper5DtoField(method, fields);
		}
	} catch (JavaModelException e) {
		ErrorUtils.handle(e);
	}
	return fields;
}
 

import org.eclipse.jdt.core.ITypeHierarchy; //导入方法依赖的package包/类
private static void parseKasper3PersistedDtoFields(IType type, List<DtoField> fields) throws JavaModelException {

		/* Chercher les fields sur le type directement. */
		parseKasper3DtoFields(type.getCompilationUnit(), fields);

		if (fields.isEmpty()) {
			/* Chercher les fields sur le parent. */
			ITypeHierarchy hierarchy = type.newSupertypeHierarchy(null);
			IType superclass = hierarchy.getSuperclass(type);
			parseKasper3DtoFields(superclass.getCompilationUnit(), fields);
		}
	}
 

import org.eclipse.jdt.core.ITypeHierarchy; //导入方法依赖的package包/类
private static void parseKasper3BeanFields(IType type, List<DtoField> fields) throws JavaModelException {
	/* Extraire le type parent Abstract. */
	ITypeHierarchy hierarchy = type.newSupertypeHierarchy(null);
	IType superclass = hierarchy.getSuperclass(type);

	for (IMethod method : superclass.getMethods()) {
		DtoField field = parseKasper3BeanFieldGetter(method);
		if (field != null) {
			fields.add(field);
		}
	}
}
 

import org.eclipse.jdt.core.ITypeHierarchy; //导入方法依赖的package包/类
/**
 * Visits the super types of the given <code>currentType</code>.
 *
 * @param currentType the starting type
 * @param typeHierarchy a super type hierarchy that contains <code>currentType</code>
 * @return the result from a call to {@link #visit(org.eclipse.jdt.core.IType)}, or <code>null
 *     </code> if none of the calls returned a result
 * @throws org.eclipse.jdt.core.JavaModelException unexpected problem
 */
public Object visitInheritDoc(IType currentType, ITypeHierarchy typeHierarchy)
    throws JavaModelException {
  ArrayList<IType> visited = new ArrayList<IType>();
  visited.add(currentType);
  Object result = visitInheritDocInterfaces(visited, currentType, typeHierarchy);
  if (result != InheritDocVisitor.CONTINUE) return result;

  IType superClass;
  if (currentType.isInterface())
    superClass = currentType.getJavaProject().findType("java.lang.Object"); // $NON-NLS-1$
  else superClass = typeHierarchy.getSuperclass(currentType);

  while (superClass != null && !visited.contains(superClass)) {
    result = visit(superClass);
    if (result == InheritDocVisitor.STOP_BRANCH) {
      return null;
    } else if (result == InheritDocVisitor.CONTINUE) {
      visited.add(superClass);
      result = visitInheritDocInterfaces(visited, superClass, typeHierarchy);
      if (result != InheritDocVisitor.CONTINUE) return result;
      else superClass = typeHierarchy.getSuperclass(superClass);
    } else {
      return result;
    }
  }

  return null;
}
 

import org.eclipse.jdt.core.ITypeHierarchy; //导入方法依赖的package包/类
public static IField findFieldInHierarchy(ITypeHierarchy hierarchy,
    IType type, String fieldName) {

  IField field = findField(type, fieldName);

  // Check super class
  if (field == null) {
    IType superClass = hierarchy.getSuperclass(type);
    if (superClass != null) {
      field = findFieldInHierarchy(hierarchy, superClass, fieldName);
    }
  }

  return field;
}
 

import org.eclipse.jdt.core.ITypeHierarchy; //导入方法依赖的package包/类
private static IMethod findMethodOrCtorInHierarchy(ITypeHierarchy hierarchy,
    IType type, String methodName, String[] paramTypes, boolean isConstructor) {
  IMethod method = findMethodOrCtor(type, methodName, paramTypes,
      isConstructor);
  if (method != null) {
    return method;
  }

  // Check super class
  IType superClass = hierarchy.getSuperclass(type);
  if (superClass != null) {
    method = findMethodOrCtorInHierarchy(hierarchy, superClass, methodName,
        paramTypes, isConstructor);
    if (method != null) {
      return method;
    }
  }

  if (!isConstructor) {
    // Check interfaces
    IType[] superInterfaces = hierarchy.getSuperInterfaces(type);
    for (IType superInterface : superInterfaces) {
      method = findMethodOrCtorInHierarchy(hierarchy, superInterface,
          methodName, paramTypes, false);
      if (method != null) {
        return method;
      }
    }
  }

  return method;
}
 

import org.eclipse.jdt.core.ITypeHierarchy; //导入方法依赖的package包/类
private void checkAllParents(final IType parent) {
	final ITypeHierarchy th= getTreeInput();
	final IType root= getTreeInput().getType();
	IType type= parent;
	while (!root.equals(type)) {
		fTreeViewer.setChecked(type, true);
		type= th.getSuperclass(type);
	}
	fTreeViewer.setChecked(root, true);
}
 

import org.eclipse.jdt.core.ITypeHierarchy; //导入方法依赖的package包/类
private IStatus checkException(final IType type) throws JavaModelException {
	ITypeHierarchy hierarchy= type.newSupertypeHierarchy(new NullProgressMonitor());
	IType curr= type;
	while (curr != null) {
		String name= curr.getFullyQualifiedName();
		if ("java.lang.Throwable".equals(name)) //$NON-NLS-1$
			return StatusInfo.OK_STATUS;
		curr= hierarchy.getSuperclass(curr);
	}
	return JavaUIStatus.createError(IStatus.ERROR,
			RefactoringMessages.ChangeExceptionsControl_not_exception, null);
}
 

import org.eclipse.jdt.core.ITypeHierarchy; //导入方法依赖的package包/类
@Override
protected IType getParentType(IType type) {
	ITypeHierarchy hierarchy= getHierarchy();
	if (hierarchy != null) {
		return hierarchy.getSuperclass(type);
		// dont handle interfaces
	}
	return null;
}
 

import org.eclipse.jdt.core.ITypeHierarchy; //导入方法依赖的package包/类
private int getDepth(ITypeHierarchy hierarchy, IType input) {
	int count= 0;
	IType superType= hierarchy.getSuperclass(input);
	while (superType != null) {
		count++;
		superType= hierarchy.getSuperclass(superType);
	}
	return count;
}
 

import org.eclipse.jdt.core.ITypeHierarchy; //导入方法依赖的package包/类
@Override
protected IType getParentType(IType type) {
	ITypeHierarchy hierarchy= getHierarchy();
	if (hierarchy != null) {
		return hierarchy.getSuperclass(type);
		// don't handle interfaces
	}
	return null;
}
 

import org.eclipse.jdt.core.ITypeHierarchy; //导入方法依赖的package包/类
/**
 * Visits the super types of the given <code>currentType</code>.
 *
 * @param currentType the starting type
 * @param typeHierarchy a super type hierarchy that contains <code>currentType</code>
 * @return the result from a call to {@link #visit(IType)}, or <code>null</code> if none of
 *         the calls returned a result
 * @throws JavaModelException unexpected problem
 */
public Object visitInheritDoc(IType currentType, ITypeHierarchy typeHierarchy) throws JavaModelException {
	ArrayList<IType> visited= new ArrayList<IType>();
	visited.add(currentType);
	Object result= visitInheritDocInterfaces(visited, currentType, typeHierarchy);
	if (result != InheritDocVisitor.CONTINUE)
		return result;

	IType superClass;
	if (currentType.isInterface())
		superClass= currentType.getJavaProject().findType("java.lang.Object"); //$NON-NLS-1$
	else
		superClass= typeHierarchy.getSuperclass(currentType);

	while (superClass != null && ! visited.contains(superClass)) {
		result= visit(superClass);
		if (result == InheritDocVisitor.STOP_BRANCH) {
			return null;
		} else if (result == InheritDocVisitor.CONTINUE) {
			visited.add(superClass);
			result= visitInheritDocInterfaces(visited, superClass, typeHierarchy);
			if (result != InheritDocVisitor.CONTINUE)
				return result;
			else
				superClass= typeHierarchy.getSuperclass(superClass);
		} else {
			return result;
		}
	}

	return null;
}