Java BasePsiNode类代码示例

import com.intellij.ide.projectView.impl.nodes.BasePsiNode; //导入依赖的package包/类
private static Collection<BasePsiNode<? extends PsiElement>> findViewsIn(Collection<AbstractTreeNode> children, List<PsiFile> views) {
    if (children.isEmpty() || views.isEmpty()) {
        return Collections.emptyList();
    }
    ArrayList<BasePsiNode<? extends PsiElement>> result = new ArrayList<>();
    HashSet<PsiFile> psiFiles = new HashSet<>(views);
    for (final AbstractTreeNode child : children) {
        if (child instanceof BasePsiNode) {
            BasePsiNode<? extends PsiElement> treeNode = (BasePsiNode<? extends PsiElement>) child;
            if (psiFiles.contains(treeNode.getValue())) {
                result.add(treeNode);
            }
        }
    }
    return result;
}
 

import com.intellij.ide.projectView.impl.nodes.BasePsiNode; //导入依赖的package包/类
/**
 * If {@link IgnoreSettings#hideIgnoredFiles} is set to <code>true</code>, checks if specific
 * nodes are ignored and filters them out.
 *
 * @param parent   the parent node
 * @param children the list of child nodes according to the default project structure
 * @param settings the current project view settings
 * @return the modified collection of child nodes
 */
@NotNull
@Override
public Collection<AbstractTreeNode> modify(@NotNull AbstractTreeNode parent,
                                           @NotNull Collection<AbstractTreeNode> children,
                                           @NotNull ViewSettings settings) {
    if (!ignoreSettings.isHideIgnoredFiles() || children.isEmpty()) {
        return children;
    }

    return ContainerUtil.filter(children, new Condition<AbstractTreeNode>() {
        @Override
        public boolean value(AbstractTreeNode node) {
            if (node instanceof BasePsiNode) {
                final VirtualFile file = ((BasePsiNode) node).getVirtualFile();
                if (file == null || (ignoreManager.isFileIgnored(file) && !ignoreManager.isFileTracked(file))) {
                    return false;
                }
            }
            return true;
        }
    });
}
 

import com.intellij.ide.projectView.impl.nodes.BasePsiNode; //导入依赖的package包/类
private static Collection<BasePsiNode<? extends PsiElement>> findFormsIn(Collection<AbstractTreeNode> children, List<PsiFile> forms)
{
	if(children.isEmpty() || forms.isEmpty())
	{
		return Collections.emptyList();
	}
	ArrayList<BasePsiNode<? extends PsiElement>> result = new ArrayList<>();
	HashSet<PsiFile> psiFiles = new HashSet<>(forms);
	for(final AbstractTreeNode child : children)
	{
		if(child instanceof BasePsiNode)
		{
			//noinspection unchecked
			BasePsiNode<? extends PsiElement> treeNode = (BasePsiNode<? extends PsiElement>) child;
			//noinspection SuspiciousMethodCalls
			if(psiFiles.contains(treeNode.getValue()))
			{
				result.add(treeNode);
			}
		}
	}
	return result;
}
 

import com.intellij.ide.projectView.impl.nodes.BasePsiNode; //导入依赖的package包/类
public static VirtualFile[] getFiles(AbstractTreeNode kid, Function<AbstractTreeNode, VirtualFile[]> converterFunction) {
  if (kid instanceof BasePsiNode) {
    Object value = kid.getValue();
    VirtualFile virtualFile = PsiUtilCore.getVirtualFile((PsiElement)value);
    return new VirtualFile[]{virtualFile};
  }
  if (converterFunction != null) {
    final VirtualFile[] result = converterFunction.fun(kid);
    if (result != null) {
      return result;
    }
  }
  return new VirtualFile[0];
}
 

import com.intellij.ide.projectView.impl.nodes.BasePsiNode; //导入依赖的package包/类
@Override
public FileStatus getFileStatus() {
  for(BasePsiNode<? extends PsiElement> child: myChildren) {
    final PsiElement value = child.getValue();
    if (value == null || !value.isValid()) continue;
    final FileStatus fileStatus = NavigationItemFileStatus.get(child);
    if (fileStatus != FileStatus.NOT_CHANGED) {
      return fileStatus;
    }
  }
  return FileStatus.NOT_CHANGED;
}
 

import com.intellij.ide.projectView.impl.nodes.BasePsiNode; //导入依赖的package包/类
@Override
public boolean canHaveChildrenMatching(final Condition<PsiFile> condition) {
  for(BasePsiNode<? extends PsiElement> child: myChildren) {
    if (condition.value(child.getValue().getContainingFile())) {
      return true;
    }
  }
  return false;
}
 

import com.intellij.ide.projectView.impl.nodes.BasePsiNode; //导入依赖的package包/类
private static Collection<BasePsiNode<? extends PsiElement>> getChildren(final Project project, final Form form, final ViewSettings settings) {
  final Set<BasePsiNode<? extends PsiElement>> children = new LinkedHashSet<BasePsiNode<? extends PsiElement>>();
  children.add(new ClassTreeNode(project, form.getClassToBind(), settings));
  for (PsiFile formBoundToClass : form.getFormFiles()) {
    children.add(new PsiFileNode(project, formBoundToClass, settings));
  }
  return children;
}
 

import com.intellij.ide.projectView.impl.nodes.BasePsiNode; //导入依赖的package包/类
private static Collection<PsiFile> convertToFiles(Collection<BasePsiNode<? extends PsiElement>> formNodes) {
  ArrayList<PsiFile> psiFiles = new ArrayList<PsiFile>();
  for (AbstractTreeNode treeNode : formNodes) {
    psiFiles.add((PsiFile)treeNode.getValue());
  }
  return psiFiles;
}
 

import com.intellij.ide.projectView.impl.nodes.BasePsiNode; //导入依赖的package包/类
private static Collection<BasePsiNode<? extends PsiElement>> findFormsIn(Collection<AbstractTreeNode> children, List<PsiFile> forms) {
  if (children.isEmpty() || forms.isEmpty()) return Collections.emptyList();
  ArrayList<BasePsiNode<? extends PsiElement>> result = new ArrayList<BasePsiNode<? extends PsiElement>>();
  HashSet<PsiFile> psiFiles = new HashSet<PsiFile>(forms);
  for (final AbstractTreeNode child : children) {
    if (child instanceof BasePsiNode) {
      //noinspection unchecked
      BasePsiNode<? extends PsiElement> treeNode = (BasePsiNode<? extends PsiElement>)child;
      //noinspection SuspiciousMethodCalls
      if (psiFiles.contains(treeNode.getValue())) result.add(treeNode);
    }
  }
  return result;
}
 

import com.intellij.ide.projectView.impl.nodes.BasePsiNode; //导入依赖的package包/类
private static Collection<PsiFile> convertToFiles(Collection<BasePsiNode<? extends PsiElement>> formNodes) {
    List<PsiFile> psiFiles = new ArrayList<PsiFile>();
    for (AbstractTreeNode treeNode : formNodes) {
        psiFiles.add((PsiFile) treeNode.getValue());
    }
    return psiFiles;
}
 

import com.intellij.ide.projectView.impl.nodes.BasePsiNode; //导入依赖的package包/类
private static Collection<BasePsiNode<? extends PsiElement>> findFormsIn(Collection<AbstractTreeNode> children, List<PsiFile> forms) {
    if (children.isEmpty() || forms.isEmpty()) return Collections.emptyList();
    List<BasePsiNode<? extends PsiElement>> result = new ArrayList<BasePsiNode<? extends PsiElement>>();
    Set<PsiFile> psiFiles = new HashSet<PsiFile>(forms);
    for (final AbstractTreeNode child : children) {
        if (child instanceof BasePsiNode) {
            //noinspection unchecked
            BasePsiNode<? extends PsiElement> treeNode = (BasePsiNode<? extends PsiElement>) child;
            //noinspection SuspiciousMethodCalls
            if (psiFiles.contains(treeNode.getValue())) result.add(treeNode);
        }
    }
    return result;
}
 

import com.intellij.ide.projectView.impl.nodes.BasePsiNode; //导入依赖的package包/类
private static Collection<PsiFile> convertToFiles(Collection<BasePsiNode<? extends PsiElement>> viewNodes) {
    ArrayList<PsiFile> psiFiles = new ArrayList<>();
    for (AbstractTreeNode treeNode : viewNodes) {
        psiFiles.add((PsiFile) treeNode.getValue());
    }
    return psiFiles;
}
 

import com.intellij.ide.projectView.impl.nodes.BasePsiNode; //导入依赖的package包/类
public static VirtualFile[] getFiles(AbstractTreeNode kid, Function<AbstractTreeNode, VirtualFile[]> converterFunction) {
  if (kid instanceof BasePsiNode) {
    Object value = kid.getValue();
    VirtualFile virtualFile = PsiUtilBase.getVirtualFile((PsiElement)value);
    return new VirtualFile[]{virtualFile};
  }
  if (converterFunction != null) {
    final VirtualFile[] result = converterFunction.fun(kid);
    if (result != null) {
      return result;
    }
  }
  return new VirtualFile[0];
}
 

import com.intellij.ide.projectView.impl.nodes.BasePsiNode; //导入依赖的package包/类
private static Collection<PsiFile> convertToFiles(Collection<BasePsiNode<? extends PsiElement>> formNodes)
{
	ArrayList<PsiFile> psiFiles = new ArrayList<>();
	for(AbstractTreeNode treeNode : formNodes)
	{
		psiFiles.add((PsiFile) treeNode.getValue());
	}
	return psiFiles;
}
 

import com.intellij.ide.projectView.impl.nodes.BasePsiNode; //导入依赖的package包/类
@NotNull
protected Collection<AbstractTreeNode> processJunkFiles(
    @NotNull final Collection<AbstractTreeNode> children,
    @Nullable final ViewSettings settings
) {
    Validate.notNull(children);

    final List<String> junkFileNames = this.getJunkFileNames();

    if (junkFileNames == null || junkFileNames.isEmpty()) {
        return children;
    }

    final List<AbstractTreeNode> junkTreeNodes = new ArrayList<AbstractTreeNode>();
    final Collection<AbstractTreeNode> treeNodes = new ArrayList<AbstractTreeNode>();

    for (AbstractTreeNode child : children) {
        if (child instanceof BasePsiNode) {
            final VirtualFile virtualFile = ((BasePsiNode) child).getVirtualFile();

            if (null == virtualFile) {
                continue;
            }

            if (this.isJunk(virtualFile, junkFileNames)) {
                junkTreeNodes.add(child);
            } else {
                treeNodes.add(child);
            }

        } else {
            treeNodes.add(child);
        }
    }

    if (!junkTreeNodes.isEmpty()) {
        treeNodes.add(new JunkProjectViewNode(this.project, junkTreeNodes, settings));
    }

    return treeNodes;
}