private <T> boolean findListToRemoveFrom(
@NotNull String name,
@NotNull final List<T> elements,
final Convertor<T, AbstractUrl> convertor) {
Collection<TreeItem<Pair<AbstractUrl, String>>> list = getFavoritesListRootUrls(name);
if (elements.size() > 1) {
final List<T> sublist = elements.subList(0, elements.size() - 1);
for (T obj : sublist) {
AbstractUrl objUrl = convertor.convert(obj);
final TreeItem<Pair<AbstractUrl, String>> item = findNextItem(objUrl, list);
if (item == null || item.getChildren() == null) return false;
list = item.getChildren();
}
}
TreeItem<Pair<AbstractUrl, String>> found = null;
AbstractUrl url = convertor.convert(elements.get(elements.size() - 1));
if (url == null) return false;
for (TreeItem<Pair<AbstractUrl, String>> pair : list) {
if (url.equals(pair.getData().getFirst())) {
found = pair;
break;
}
}
if (found != null) {
list.remove(found);
fireListeners.rootsChanged(name);
return true;
}
return false;
}
private static void writeRoots(
Element element, Collection<TreeItem<Pair<AbstractUrl, String>>> roots) {
for (TreeItem<Pair<AbstractUrl, String>> root : roots) {
final AbstractUrl url = root.getData().getFirst();
if (url == null) continue;
final Element list = new Element(FAVORITES_ROOT);
url.write(list);
list.setAttribute(CLASS_NAME, root.getData().getSecond());
element.addContent(list);
final List<TreeItem<Pair<AbstractUrl, String>>> children = root.getChildren();
if (children != null && !children.isEmpty()) {
writeRoots(list, children);
}
}
}
private TreeItem<Pair<AbstractUrl, String>> findNextItem(
AbstractUrl url, Collection<TreeItem<Pair<AbstractUrl, String>>> list) {
for (TreeItem<Pair<AbstractUrl, String>> pair : list) {
if (url.equals(pair.getData().getFirst())) {
return pair;
}
}
return null;
}
@Nullable
private static AbstractUrl readUrlFromElement(Element element, Project project) {
final String type = element.getAttributeValue(ATTRIBUTE_TYPE);
final String urlValue = element.getAttributeValue(ATTRIBUTE_URL);
final String moduleName = element.getAttributeValue(ATTRIBUTE_MODULE);
for (FavoriteNodeProvider nodeProvider :
Extensions.getExtensions(FavoriteNodeProvider.EP_NAME, project)) {
if (nodeProvider.getFavoriteTypeId().equals(type)) {
return new AbstractUrlFavoriteAdapter(urlValue, moduleName, nodeProvider);
}
}
for (AbstractUrl urlProvider : ourAbstractUrlProviders) {
AbstractUrl url = urlProvider.createUrl(type, moduleName, urlValue);
if (url != null) return url;
}
return null;
}
@Nullable
public static AbstractUrl createUrlByElement(Object element, final Project project) {
if (element instanceof SmartPsiElementPointer)
element = ((SmartPsiElementPointer) element).getElement();
for (FavoriteNodeProvider nodeProvider :
Extensions.getExtensions(FavoriteNodeProvider.EP_NAME, project)) {
String url = nodeProvider.getElementUrl(element);
if (url != null) {
return new AbstractUrlFavoriteAdapter(
url, nodeProvider.getElementModuleName(element), nodeProvider);
}
}
for (AbstractUrl urlProvider : ourAbstractUrlProviders) {
AbstractUrl url = urlProvider.createUrlByElement(element);
if (url != null) return url;
}
return null;
}
// currently only one level here..
public boolean contains(@NotNull String name, @NotNull final VirtualFile vFile) {
final ProjectFileIndex projectFileIndex =
ProjectRootManager.getInstance(myProject).getFileIndex();
final Set<Boolean> find = new HashSet<Boolean>();
final ContentIterator contentIterator =
new ContentIterator() {
public boolean processFile(VirtualFile fileOrDir) {
if (fileOrDir != null && fileOrDir.getPath().equals(vFile.getPath())) {
find.add(Boolean.TRUE);
}
return true;
}
};
Collection<TreeItem<Pair<AbstractUrl, String>>> urls = getFavoritesListRootUrls(name);
for (TreeItem<Pair<AbstractUrl, String>> pair : urls) {
AbstractUrl abstractUrl = pair.getData().getFirst();
if (abstractUrl == null) {
continue;
}
final Object[] path = abstractUrl.createPath(myProject);
if (path == null || path.length < 1 || path[0] == null) {
continue;
}
Object element = path[path.length - 1];
if (element instanceof SmartPsiElementPointer) {
final VirtualFile virtualFile =
PsiUtilBase.getVirtualFile(((SmartPsiElementPointer) element).getElement());
if (virtualFile == null) continue;
if (vFile.getPath().equals(virtualFile.getPath())) {
return true;
}
if (!virtualFile.isDirectory()) {
continue;
}
projectFileIndex.iterateContentUnderDirectory(virtualFile, contentIterator);
}
if (element instanceof PsiElement) {
final VirtualFile virtualFile = PsiUtilBase.getVirtualFile((PsiElement) element);
if (virtualFile == null) continue;
if (vFile.getPath().equals(virtualFile.getPath())) {
return true;
}
if (!virtualFile.isDirectory()) {
continue;
}
projectFileIndex.iterateContentUnderDirectory(virtualFile, contentIterator);
}
if (element instanceof Module) {
ModuleRootManager.getInstance((Module) element)
.getFileIndex()
.iterateContent(contentIterator);
}
if (element instanceof LibraryGroupElement) {
final boolean inLibrary =
ModuleRootManager.getInstance(((LibraryGroupElement) element).getModule())
.getFileIndex()
.isInContent(vFile)
&& projectFileIndex.isInLibraryClasses(vFile);
if (inLibrary) {
return true;
}
}
if (element instanceof NamedLibraryElement) {
NamedLibraryElement namedLibraryElement = (NamedLibraryElement) element;
final VirtualFile[] files =
namedLibraryElement.getOrderEntry().getRootFiles(OrderRootType.CLASSES);
if (files != null && ArrayUtil.find(files, vFile) > -1) {
return true;
}
}
if (element instanceof ModuleGroup) {
ModuleGroup group = (ModuleGroup) element;
final Collection<Module> modules = group.modulesInGroup(myProject, true);
for (Module module : modules) {
ModuleRootManager.getInstance(module).getFileIndex().iterateContent(contentIterator);
}
}
for (FavoriteNodeProvider provider :
Extensions.getExtensions(FavoriteNodeProvider.EP_NAME, myProject)) {
if (provider.elementContainsFile(element, vFile)) {
return true;
}
}
if (!find.isEmpty()) {
return true;
}
}
return false;
}