Java 类org.eclipse.jdt.core.IParent 实例源码

private static void collectCompilationUnits(IJavaElement element, List<ICompilationUnit> compilationUnits) throws JavaModelException {
    if (element instanceof ICompilationUnit) {
        compilationUnits.add((ICompilationUnit) element);
        // don't process children of compilation units
        return;
    }

    if (element instanceof IParent) {
        for (IJavaElement child : ((IParent) element).getChildren()) {
            collectCompilationUnits(child, compilationUnits);
        }
    }
}

private void collectMatches(Set<Match> matches, IJavaElement element) {
  Match[] m = getMatches(element);
  if (m.length != 0) {
    for (int i = 0; i < m.length; i++) {
      matches.add(m[i]);
    }
  }
  if (element instanceof IParent) {
    IParent parent = (IParent) element;
    try {
      IJavaElement[] children = parent.getChildren();
      for (int i = 0; i < children.length; i++) {
        collectMatches(matches, children[i]);
      }
    } catch (JavaModelException e) {
      // we will not be tracking these results
    }
  }
}

private void collectIntersectingJavadocRanges(IJavaElement element, IRegion region, List<ISourceRange> elements) throws JavaModelException {
    if (element instanceof IParent) {
        for (IJavaElement child : ((IParent) element).getChildren()) {
            collectIntersectingJavadocRanges(child, region, elements);
        }
    }

    if (element instanceof IMember) {
        ISourceRange range = ((IMember) element).getJavadocRange();
        if (range != null) {
            if (range.getOffset() <= region.getOffset() + region.getLength() && range.getOffset() + range.getLength() >= region.getOffset()) {
                elements.add(range);
            }
        }
    }

}

private void collectMatches(Set<Match> matches, IJavaElement element) {
    //TODO: copied from JavaSearchResult:
    Match[] m= getMatches(element);
    if (m.length != 0) {
        for (int i= 0; i < m.length; i++) {
            matches.add(m[i]);
        }
    }
    if (element instanceof IParent) {
        IParent parent= (IParent) element;
        try {
            IJavaElement[] children= parent.getChildren();
            for (int i= 0; i < children.length; i++) {
                collectMatches(matches, children[i]);
            }
        } catch (JavaModelException e) {
            // we will not be tracking these results
        }
    }
}

private void collectMatches(Set<Match> matches, IJavaElement element) {
    Match[] m= getMatches(element);
    if (m.length != 0) {
        for (int i= 0; i < m.length; i++) {
            matches.add(m[i]);
        }
    }
    if (element instanceof IParent) {
        IParent parent= (IParent) element;
        try {
            IJavaElement[] children= parent.getChildren();
            for (int i= 0; i < children.length; i++) {
                collectMatches(matches, children[i]);
            }
        } catch (JavaModelException e) {
            // we will not be tracking these results
        }
    }
}

public Object[] getChildren(Object parent) {
    if (parent instanceof IParent) {
        IParent c= (IParent) parent;
        try {
            return filter(c.getChildren());
        } catch (JavaModelException x) {
            // https://bugs.eclipse.org/bugs/show_bug.cgi?id=38341
            // don't log NotExist exceptions as this is a valid case
            // since we might have been posted and the element
            // removed in the meantime.
            if (JavaPlugin.isDebug() || !x.isDoesNotExist())
                JavaPlugin.log(x);
        }
    }
    return NO_CHILDREN;
}

public boolean hasChildren(Object parent) {
    if (parent instanceof IParent) {
        IParent c= (IParent) parent;
        try {
            IJavaElement[] children= filter(c.getChildren());
            return (children != null && children.length > 0);
        } catch (JavaModelException x) {
            // https://bugs.eclipse.org/bugs/show_bug.cgi?id=38341
            // don't log NotExist exceptions as this is a valid case
            // since we might have been posted and the element
            // removed in the meantime.
            if (JavaPlugin.isDebug() || !x.isDoesNotExist())
                JavaPlugin.log(x);
        }
    }
    return false;
}

private Object[] getChildren(IType type) throws JavaModelException{
    IParent parent;
    if (type.isBinary())
        parent= type.getClassFile();
    else {
        parent= type.getCompilationUnit();
    }
    if (type.getDeclaringType() != null)
        return type.getChildren();

    // Add import declarations
    IJavaElement[] members= parent.getChildren();
    ArrayList<IJavaElement> tempResult= new ArrayList<IJavaElement>(members.length);
    for (int i= 0; i < members.length; i++)
        if ((members[i] instanceof IImportContainer))
            tempResult.add(members[i]);
    tempResult.addAll(Arrays.asList(type.getChildren()));
    return tempResult.toArray();
}

/**
 * Removes any children of this element that are contained within this
 * region as this parent is about to be added to the region.
 *
 * <p>Children are all children, not just direct children.
 */
protected void removeAllChildren(IJavaElement element) {
    if (element instanceof IParent) {
        ArrayList newRootElements = new ArrayList();
        for (int i = 0, size = this.rootElements.size(); i < size; i++) {
            IJavaElement currentRoot = (IJavaElement)this.rootElements.get(i);
            //walk the current root hierarchy
            IJavaElement parent = currentRoot.getParent();
            boolean isChild= false;
            while (parent != null) {
                if (parent.equals(element)) {
                    isChild= true;
                    break;
                }
                parent = parent.getParent();
            }
            if (!isChild) {
                newRootElements.add(currentRoot);
            }
        }
        this.rootElements= newRootElements;
    }
}

/**
 * Looks for changed positioning of elements.
 */
private void findChangesInPositioning(IJavaElement element, int depth) {
    if (depth >= this.maxDepth || this.added.contains(element) || this.removed.contains(element))
        return;

    if (!isPositionedCorrectly(element)) {
        this.delta.changed(element, IJavaElementDelta.F_REORDER);
    }

    if (element instanceof IParent) {
        JavaElementInfo info = null;
        try {
            info = (JavaElementInfo)((JavaElement)element).getElementInfo();
        } catch (JavaModelException npe) {
            return;
        }

        IJavaElement[] children = info.getChildren();
        if (children != null) {
            int length = children.length;
            for(int i = 0; i < length; i++) {
                findChangesInPositioning(children[i], depth + 1);
            }
        }
    }
}

/**
 * Fills the newPositions hashtable with the new position information
 */
private void recordNewPositions(IJavaElement newElement, int depth) {
    if (depth < this.maxDepth && newElement instanceof IParent) {
        JavaElementInfo info = null;
        try {
            info = (JavaElementInfo)((JavaElement)newElement).getElementInfo();
        } catch (JavaModelException npe) {
            return;
        }

        IJavaElement[] children = info.getChildren();
        if (children != null) {
            insertPositions(children, true);
            for(int i = 0, length = children.length; i < length; i++) {
                recordNewPositions(children[i], depth + 1);
            }
        }
    }
}

private void collectMatches(Set<Match> matches, IJavaElement element) {
    //TODO: copied from JavaSearchResult:
    Match[] m= getMatches(element);
    if (m.length != 0) {
        for (int i= 0; i < m.length; i++) {
            matches.add(m[i]);
        }
    }
    if (element instanceof IParent) {
        IParent parent= (IParent) element;
        try {
            IJavaElement[] children= parent.getChildren();
            for (int i= 0; i < children.length; i++) {
                collectMatches(matches, children[i]);
            }
        } catch (JavaModelException e) {
            // we will not be tracking these results
        }
    }
}

private void collectMatches(Set<Match> matches, IJavaElement element) {
    Match[] m= getMatches(element);
    if (m.length != 0) {
        for (int i= 0; i < m.length; i++) {
            matches.add(m[i]);
        }
    }
    if (element instanceof IParent) {
        IParent parent= (IParent) element;
        try {
            IJavaElement[] children= parent.getChildren();
            for (int i= 0; i < children.length; i++) {
                collectMatches(matches, children[i]);
            }
        } catch (JavaModelException e) {
            // we will not be tracking these results
        }
    }
}

public Object[] getChildren(Object parent) {
    if (parent instanceof IParent) {
        IParent c= (IParent) parent;
        try {
            return filter(c.getChildren());
        } catch (JavaModelException x) {
            // https://bugs.eclipse.org/bugs/show_bug.cgi?id=38341
            // don't log NotExist exceptions as this is a valid case
            // since we might have been posted and the element
            // removed in the meantime.
            if (JavaPlugin.isDebug() || !x.isDoesNotExist())
                JavaPlugin.log(x);
        }
    }
    return NO_CHILDREN;
}

public boolean hasChildren(Object parent) {
    if (parent instanceof IParent) {
        IParent c= (IParent) parent;
        try {
            IJavaElement[] children= filter(c.getChildren());
            return (children != null && children.length > 0);
        } catch (JavaModelException x) {
            // https://bugs.eclipse.org/bugs/show_bug.cgi?id=38341
            // don't log NotExist exceptions as this is a valid case
            // since we might have been posted and the element
            // removed in the meantime.
            if (JavaPlugin.isDebug() || !x.isDoesNotExist())
                JavaPlugin.log(x);
        }
    }
    return false;
}

private Object[] getChildren(IType type) throws JavaModelException{
    IParent parent;
    if (type.isBinary())
        parent= type.getClassFile();
    else {
        parent= type.getCompilationUnit();
    }
    if (type.getDeclaringType() != null)
        return type.getChildren();

    // Add import declarations
    IJavaElement[] members= parent.getChildren();
    ArrayList<IJavaElement> tempResult= new ArrayList<IJavaElement>(members.length);
    for (int i= 0; i < members.length; i++)
        if ((members[i] instanceof IImportContainer))
            tempResult.add(members[i]);
    tempResult.addAll(Arrays.asList(type.getChildren()));
    return tempResult.toArray();
}

/**
 * Removes any children of this element that are contained within this
 * region as this parent is about to be added to the region.
 *
 * <p>Children are all children, not just direct children.
 */
protected void removeAllChildren(IJavaElement element) {
    if (element instanceof IParent) {
        ArrayList newRootElements = new ArrayList();
        for (int i = 0, size = this.rootElements.size(); i < size; i++) {
            IJavaElement currentRoot = (IJavaElement)this.rootElements.get(i);
            //walk the current root hierarchy
            IJavaElement parent = currentRoot.getParent();
            boolean isChild= false;
            while (parent != null) {
                if (parent.equals(element)) {
                    isChild= true;
                    break;
                }
                parent = parent.getParent();
            }
            if (!isChild) {
                newRootElements.add(currentRoot);
            }
        }
        this.rootElements= newRootElements;
    }
}

/**
 * Looks for changed positioning of elements.
 */
private void findChangesInPositioning(IJavaElement element, int depth) {
    if (depth >= this.maxDepth || this.added.contains(element) || this.removed.contains(element))
        return;

    if (!isPositionedCorrectly(element)) {
        this.delta.changed(element, IJavaElementDelta.F_REORDER);
    }

    if (element instanceof IParent) {
        JavaElementInfo info = null;
        try {
            info = (JavaElementInfo)((JavaElement)element).getElementInfo();
        } catch (JavaModelException npe) {
            return;
        }

        IJavaElement[] children = info.getChildren();
        if (children != null) {
            int length = children.length;
            for(int i = 0; i < length; i++) {
                findChangesInPositioning(children[i], depth + 1);
            }
        }
    }
}

/**
 * Fills the newPositions hashtable with the new position information
 */
private void recordNewPositions(IJavaElement newElement, int depth) {
    if (depth < this.maxDepth && newElement instanceof IParent) {
        JavaElementInfo info = null;
        try {
            info = (JavaElementInfo)((JavaElement)newElement).getElementInfo();
        } catch (JavaModelException npe) {
            return;
        }

        IJavaElement[] children = info.getChildren();
        if (children != null) {
            insertPositions(children, true);
            for(int i = 0, length = children.length; i < length; i++) {
                recordNewPositions(children[i], depth + 1);
            }
        }
    }
}

private static int findInnerClassSourceLine(IJavaElement parentType, String name) throws JavaModelException {
    String elemName = parentType.getElementName();
    if (name.equals(elemName)) {
        if (parentType instanceof IType) {
            return getLineStart((IType) parentType);
        }
    }
    if (parentType instanceof IParent) {
        IJavaElement[] children = ((IParent) parentType).getChildren();
        for (int i = 0; i < children.length; i++) {
            // recursive call
            int line = findInnerClassSourceLine(children[i], name);
            if (line > 0) {
                return line;
            }
        }
    }
    return START_LINE_OF_ENCLOSING_TYPE;
}

private static void populateClasses(final Shell shell,
        final IParent parent,
        final List<IType> types,
        final Filter filter) {
    try {
        for (final IJavaElement element : parent.getChildren()) {
            if (element instanceof IType) {
                final IType type = (IType) element;
                if (type.isClass() && type.isStructureKnown() && !type.isAnonymous()
                        && !type.isLocal()
                        && !Flags.isAbstract(type.getFlags())
                        && Flags.isPublic(type.getFlags())
                        && (filter == null || filter.accept(type)))
                    types.add(type);
            } else if (element instanceof IParent
                    && !element.getPath().toString().contains("/test/")
                    && (!(element instanceof IPackageFragmentRoot)
                    || !((IPackageFragmentRoot) element).isExternal()))
                populateClasses(shell, (IParent) element, types, filter);
        }
    } catch (final JavaModelException e) {
        Activator.error(e);
    }
}

private TapestryFile searchNonJavaResources(IParent root, String path) throws JavaModelException
{
    String[] segments = path.split("/");

    if (root instanceof IPackageFragmentRoot)
    {
        for (Object nonJava : ((IPackageFragmentRoot) root).getNonJavaResources())
        {
            if (nonJava instanceof IJarEntryResource)
            {
                IJarEntryResource resource = (IJarEntryResource) nonJava;

                if (StringUtils.equals(segments[0], resource.getName()))
                {
                    return searchRecursively(resource, path, segments, 1);
                }
            }
        }
    }

    return null;
}

/**
 * Ensure that the positioned element is in the correct position within the parent.
 */
public void ensureCorrectPositioning(IParent container, IJavaElement sibling, IJavaElement positioned) throws JavaModelException {
    IJavaElement[] children = container.getChildren();
    if (sibling != null) {
        // find the sibling
        boolean found = false;
        for (int i = 0; i < children.length; i++) {
            if (children[i].equals(sibling)) {
                assertTrue("element should be before sibling", i > 0 && children[i - 1].equals(positioned));
                found = true;
                break;
            }
        }
        assertTrue("Did not find sibling", found);
    }
}

/**
 * Returns all folders configured as source folders for the given project.
 *
 * @param javaProject
 *            the java project to examine
 * @return a List of all source folders as IJavaElements
 * @throws JavaModelException
 * @see {@link #getJavaProjects(IJavaModel)}
 */
private List<IJavaElement> getSourceFolders(IJavaElement javaProject) throws JavaModelException {
    List<IJavaElement> folders = new ArrayList<>();
    IJavaElement[] children = ((IParent) javaProject).getChildren();
    for (IJavaElement child : children) {
        if (child instanceof IPackageFragmentRoot) {
            IPackageFragmentRoot packageFragmentRoot = (IPackageFragmentRoot) child;
            if (packageFragmentRoot.getKind() == IPackageFragmentRoot.K_SOURCE) {
                folders.add(packageFragmentRoot);
            }
        }
    }
    return folders;
}

/**
 * Tarverses a hierarchy of IJavaElements and returns all IJavaElements, which names match the given name.
 *
 * @param result
 *            A List of IJavaElements, which match the given name
 * @param parent
 *            The root element to start the search at
 * @param name
 *            The element name ({@link IJavaElement#getElementName()}) to search for
 * @throws JavaModelException
 */
void findRecursive(List<IJavaElement> result, IJavaElement parent, String name) throws JavaModelException {
    if (parent.getElementName().equals(name)) {
        result.add(parent);
    }

    if (parent instanceof IParent) {
        IJavaElement[] children = ((IParent) parent).getChildren();
        for (IJavaElement child : children) {
            findRecursive(result, child, name);
        }
    }
}

private void collectChildren(ITypeRoot unit, IJavaElement[] elements, ArrayList<SymbolInformation> symbols,
        IProgressMonitor monitor)
        throws JavaModelException {
    for(IJavaElement element : elements ){
        if (monitor.isCanceled()) {
            return;
        }
        if(element instanceof IParent){
            collectChildren(unit, filter(((IParent) element).getChildren()), symbols, monitor);
        }
        int type = element.getElementType();
        if (type != IJavaElement.TYPE && type != IJavaElement.FIELD && type != IJavaElement.METHOD) {
            continue;
        }

        Location location = JDTUtils.toLocation(element);
        if (location != null) {
            SymbolInformation si = new SymbolInformation();
            String name = JavaElementLabels.getElementLabel(element, JavaElementLabels.ALL_DEFAULT);
            si.setName(name == null ? element.getElementName() : name);
            si.setKind(mapKind(element));
            if (element.getParent() != null) {
                si.setContainerName(element.getParent().getElementName());
            }
            location.setUri(ResourceUtils.toClientUri(location.getUri()));
            si.setLocation(location);
            if (!symbols.contains(si)) {
                symbols.add(si);
            }
        }
    }
}

public Object[] getChildren(Object element) {
  if (!exists(element)) return NO_CHILDREN;

  try {
    if (element instanceof IJavaModel) return getJavaProjects((IJavaModel) element);

    if (element instanceof IJavaProject) return getPackageFragmentRoots((IJavaProject) element);

    if (element instanceof IPackageFragmentRoot)
      return getPackageFragmentRootContent((IPackageFragmentRoot) element);

    if (element instanceof IPackageFragment) return getPackageContent((IPackageFragment) element);

    if (element instanceof IFolder) return getFolderContent((IFolder) element);

    if (element instanceof IJarEntryResource) {
      return ((IJarEntryResource) element).getChildren();
    }

    if (getProvideMembers()
        && element instanceof ISourceReference
        && element instanceof IParent) {
      return ((IParent) element).getChildren();
    }
  } catch (CoreException e) {
    return NO_CHILDREN;
  }
  return NO_CHILDREN;
}

public boolean hasChildren(Object element) {
  if (getProvideMembers()) {
    // assume CUs and class files are never empty
    if (element instanceof ICompilationUnit || element instanceof IClassFile) {
      return true;
    }
  } else {
    // don't allow to drill down into a compilation unit or class file
    if (element instanceof ICompilationUnit
        || element instanceof IClassFile
        || element instanceof IFile) return false;
  }

  if (element instanceof IJavaProject) {
    IJavaProject jp = (IJavaProject) element;
    if (!jp.getProject().isOpen()) {
      return false;
    }
  }

  if (element instanceof IParent) {
    try {
      // when we have Java children return true, else we fetch all the children
      if (((IParent) element).hasChildren()) return true;
    } catch (JavaModelException e) {
      return true;
    }
  }
  Object[] children = getChildren(element);
  return (children != null) && children.length > 0;
}

/**
 * Returns the element after the give element.
 *
 * @param member a Java element
 * @return the next sibling of the given element or <code>null</code>
 * @throws JavaModelException thrown if the element could not be accessed
 */
public static IJavaElement findNextSibling(IJavaElement member) throws JavaModelException {
  IJavaElement parent = member.getParent();
  if (parent instanceof IParent) {
    IJavaElement[] elements = ((IParent) parent).getChildren();
    for (int i = elements.length - 2; i >= 0; i--) {
      if (member.equals(elements[i])) {
        return elements[i + 1];
      }
    }
  }
  return null;
}

private static void collectJavadocRanges(IJavaElement element, List<ISourceRange> javadocRanges) throws JavaModelException {
    if (element instanceof IParent) {
        for (IJavaElement child : ((IParent) element).getChildren()) {
            collectJavadocRanges(child, javadocRanges);
        }
    }
    if (element instanceof IMember) {
        ISourceRange range = ((IMember) element).getJavadocRange();
        if (range != null) {
            javadocRanges.add(range);
        }
    }
}

/**
 * Returns the element after the give element.
 * 
 * @param member a Java element
 * @return the next sibling of the given element or <code>null</code>
 * @throws JavaModelException thrown if the element could not be accessed
 */
public static IJavaElement findNextSibling(IJavaElement member) throws JavaModelException {
    IJavaElement parent= member.getParent();
    if (parent instanceof IParent) {
        IJavaElement[] elements= ((IParent)parent).getChildren();
        for (int i= elements.length - 2; i >= 0; i--) {
            if (member.equals(elements[i])) {
                return elements[i + 1];
            }
        }
    }
    return null;
}

public Object[] getChildren(Object element) {
    if (!exists(element))
        return NO_CHILDREN;

    try {
        if (element instanceof IJavaModel)
            return getJavaProjects((IJavaModel)element);

        if (element instanceof IJavaProject)
            return getPackageFragmentRoots((IJavaProject)element);

        if (element instanceof IPackageFragmentRoot)
            return getPackageFragmentRootContent((IPackageFragmentRoot)element);

        if (element instanceof IPackageFragment)
            return getPackageContent((IPackageFragment)element);

        if (element instanceof IFolder)
            return getFolderContent((IFolder)element);

        if (element instanceof IJarEntryResource) {
            return ((IJarEntryResource) element).getChildren();
        }

        if (getProvideMembers() && element instanceof ISourceReference && element instanceof IParent) {
            return ((IParent)element).getChildren();
        }
    } catch (CoreException e) {
        return NO_CHILDREN;
    }
    return NO_CHILDREN;
}

public boolean hasChildren(Object element) {
    if (getProvideMembers()) {
        // assume CUs and class files are never empty
        if (element instanceof ICompilationUnit ||
            element instanceof IClassFile) {
            return true;
        }
    } else {
        // don't allow to drill down into a compilation unit or class file
        if (element instanceof ICompilationUnit ||
            element instanceof IClassFile ||
            element instanceof IFile)
        return false;
    }

    if (element instanceof IJavaProject) {
        IJavaProject jp= (IJavaProject)element;
        if (!jp.getProject().isOpen()) {
            return false;
        }
    }

    if (element instanceof IParent) {
        try {
            // when we have Java children return true, else we fetch all the children
            if (((IParent)element).hasChildren())
                return true;
        } catch(JavaModelException e) {
            return true;
        }
    }
    Object[] children= getChildren(element);
    return (children != null) && children.length > 0;
}

private boolean hasMembersToSort(IJavaElement[] members) throws JavaModelException {
    if (members.length > 1) {
        return true;
    }
    if (members.length == 1) {
        IJavaElement elem= members[0];
        if (elem instanceof IParent) {
            return hasMembersToSort(((IParent) elem).getChildren());
        }
    }
    return false;
}

private void computeFoldingStructure(FoldingStructureComputationContext ctx) {
    IParent parent= (IParent) fInput;
    try {
        if (!(fInput instanceof ISourceReference))
            return;
        String source= ((ISourceReference)fInput).getSource();
        if (source == null)
            return;

        ctx.getScanner().setSource(source.toCharArray());
        computeFoldingStructure(parent.getChildren(), ctx);
    } catch (JavaModelException x) {
    }
}

private void computeFoldingStructure(IJavaElement[] elements, FoldingStructureComputationContext ctx) throws JavaModelException {
    for (int i= 0; i < elements.length; i++) {
        IJavaElement element= elements[i];

        computeFoldingStructure(element, ctx);

        if (element instanceof IParent) {
            IParent parent= (IParent) element;
            computeFoldingStructure(parent.getChildren(), ctx);
        }
    }
}

public Object[] getChildren(Object element) {
    IJavaElement je= getJavaElement(element);
    if (je instanceof IParent) {
        try {
            return ((IParent)je).getChildren();
        } catch(JavaModelException e) {
            JavaPlugin.log(e);
        }
    }
    return NO_CHILDREN;
}

private boolean hasMembersToSort(IJavaElement[] members) throws JavaModelException {
    if (members.length > 1)
        return true;

    if (members.length == 0)
        return false;

    IJavaElement elem= members[0];
    if (!(elem instanceof IParent))
        return false;

    return hasMembersToSort(((IParent)elem).getChildren());
}

private boolean hasUnfilteredChild(TreeViewer viewer, Object element) {
    if (element instanceof IParent) {
        Object[] children=  ((ITreeContentProvider) viewer.getContentProvider()).getChildren(element);
        for (int i= 0; i < children.length; i++)
            if (select(viewer, element, children[i]))
                return true;
    }
    return false;
}

@Override
public Object[] getChildren(Object element) {
    if (!exists(element))
        return NO_CHILDREN;

    startReadInDisplayThread();
    try {
        if (element instanceof Collection) {
            Collection<?> elements= (Collection<?>)element;
            if (elements.isEmpty())
                return NO_CHILDREN;
            Object[] result= new Object[0];
            Iterator<?> iter= ((Collection<?>)element).iterator();
            while (iter.hasNext()) {
                Object[] children= getChildren(iter.next());
                if (children != NO_CHILDREN)
                    result= concatenate(result, children);
            }
            return result;
        }
        if (element instanceof IPackageFragment)
            return getPackageContents((IPackageFragment)element);
        if (fProvideMembers && element instanceof IType)
            return getChildren((IType)element);
        if (fProvideMembers && element instanceof ISourceReference && element instanceof IParent)
            return removeImportAndPackageDeclarations(super.getChildren(element));
        if (element instanceof IJavaProject)
            return getPackageFragmentRoots((IJavaProject)element);
        return super.getChildren(element);
    } catch (JavaModelException e) {
        return NO_CHILDREN;
    } finally {
        finishedReadInDisplayThread();
    }
}