public boolean addRoots(final String name, final Collection<AbstractTreeNode> nodes) {
final Collection<TreeItem<Pair<AbstractUrl, String>>> list = getFavoritesListRootUrls(name);
final HashSet<AbstractUrl> set =
new HashSet<AbstractUrl>(
ObjectsConvertor.convert(
list,
new Convertor<TreeItem<Pair<AbstractUrl, String>>, AbstractUrl>() {
@Override
public AbstractUrl convert(TreeItem<Pair<AbstractUrl, String>> o) {
return o.getData().getFirst();
}
}));
for (AbstractTreeNode node : nodes) {
final Pair<AbstractUrl, String> pair = createPairForNode(node);
if (pair != null) {
if (set.contains(pair.getFirst())) continue;
final TreeItem<Pair<AbstractUrl, String>> treeItem =
new TreeItem<Pair<AbstractUrl, String>>(pair);
list.add(treeItem);
set.add(pair.getFirst());
appendChildNodes(node, treeItem);
}
}
fireListeners.rootsChanged(name);
return true;
}
private Pair<AbstractUrl, String> createPairForNode(AbstractTreeNode node) {
final String className = node.getClass().getName();
final Object value = node.getValue();
final AbstractUrl url = createUrlByElement(value, myProject);
if (url == null) return null;
return Pair.create(url, className);
}
private static void readFavoritesOneLevel(
Element list, Project project, Collection<TreeItem<Pair<AbstractUrl, String>>> result) {
final List listChildren = list.getChildren(FAVORITES_ROOT);
if (listChildren == null || listChildren.isEmpty()) return;
for (Object favorite : listChildren) {
final Element favoriteElement = (Element) favorite;
final String className = favoriteElement.getAttributeValue(CLASS_NAME);
final AbstractUrl abstractUrl = readUrlFromElement(favoriteElement, project);
if (abstractUrl != null) {
final TreeItem<Pair<AbstractUrl, String>> treeItem =
new TreeItem<Pair<AbstractUrl, String>>(Pair.create(abstractUrl, className));
result.add(treeItem);
readFavoritesOneLevel(favoriteElement, project, treeItem.getChildren());
}
}
}
public synchronized boolean editRoot(
@NotNull String name,
@NotNull List<Integer> elementsIndexes,
final AbstractTreeNode newElement) {
List<TreeItem<Pair<AbstractUrl, String>>> list = getFavoritesListRootUrls(name);
assert list != null;
for (Integer index : elementsIndexes.subList(0, elementsIndexes.size() - 1)) {
assert index >= 0 && index < list.size();
final TreeItem<Pair<AbstractUrl, String>> item = list.get(index);
list = item.getChildren();
}
assert list != null && !list.isEmpty();
final Object value = newElement.getValue();
final AbstractUrl urlByElement = createUrlByElement(value, myProject);
if (urlByElement == null) return false;
list.set(
elementsIndexes.get(elementsIndexes.size() - 1).intValue(),
new TreeItem<Pair<AbstractUrl, String>>(
Pair.create(urlByElement, newElement.getClass().getName())));
return true;
}
private void updateOutputItemsList(
final String outputDir,
final VirtualFile srcFile,
VirtualFile sourceRoot,
final String packagePrefix,
final List<File> filesToRefresh,
Map<String, Collection<TranslatingCompiler.OutputItem>> results,
final GlobalSearchScope srcRootScope)
throws CacheCorruptedException {
CompositeDependencyCache dependencyCache = myCompileContext.getDependencyCache();
JavaDependencyCache child = dependencyCache.findChild(JavaDependencyCache.class);
final Cache newCache = child.getNewClassesCache();
final Set<CompiledClass> paths = myFileNameToSourceMap.get(srcFile.getName());
if (paths == null || paths.isEmpty()) {
return;
}
final String filePath = "/" + calcPackagePath(srcFile, sourceRoot, packagePrefix);
for (final CompiledClass cc : paths) {
myCompileContext.getProgressIndicator().checkCanceled();
if (LOG.isDebugEnabled()) {
LOG.debug("Checking [pathToClass; relPathToSource] = " + cc);
}
boolean pathsEquals = FileUtil.pathsEqual(filePath, cc.relativePathToSource);
if (!pathsEquals) {
final String qName = child.resolve(cc.qName);
if (qName != null) {
pathsEquals =
ApplicationManager.getApplication()
.runReadAction(
new Computable<Boolean>() {
public Boolean compute() {
final JavaPsiFacade facade = JavaPsiFacade.getInstance(myProject);
PsiClass psiClass = facade.findClass(qName, srcRootScope);
if (psiClass == null) {
final int dollarIndex = qName.indexOf("$");
if (dollarIndex >= 0) {
final String topLevelClassName = qName.substring(0, dollarIndex);
psiClass = facade.findClass(topLevelClassName, srcRootScope);
}
}
if (psiClass != null) {
final VirtualFile vFile = psiClass.getContainingFile().getVirtualFile();
return vFile != null && vFile.equals(srcFile);
}
return false;
}
});
}
}
if (pathsEquals) {
final String outputPath = cc.pathToClass.replace(File.separatorChar, '/');
final Pair<String, String> realLocation =
moveToRealLocation(outputDir, outputPath, srcFile, filesToRefresh);
if (realLocation != null) {
Collection<TranslatingCompiler.OutputItem> outputs = results.get(realLocation.getFirst());
if (outputs == null) {
outputs = new ArrayList<TranslatingCompiler.OutputItem>();
results.put(realLocation.getFirst(), outputs);
}
outputs.add(new OutputItemImpl(realLocation.getSecond(), srcFile));
if (PACKAGE_ANNOTATION_FILE_NAME.equals(srcFile.getName())) {
myProcessedPackageInfos.add(srcFile);
}
if (CompilerManager.MAKE_ENABLED) {
newCache.setPath(cc.qName, realLocation.getSecond());
}
if (LOG.isDebugEnabled()) {
LOG.debug(
"Added output item: [outputDir; outputPath; sourceFile] = ["
+ realLocation.getFirst()
+ "; "
+ realLocation.getSecond()
+ "; "
+ srcFile.getPresentableUrl()
+ "]");
}
} else {
myCompileContext.addMessage(
CompilerMessageCategory.ERROR,
"Failed to copy from temporary location to output directory: "
+ outputPath
+ " (see idea.log for details)",
null,
-1,
-1);
if (LOG.isDebugEnabled()) {
LOG.debug("Failed to move to real location: " + outputPath + "; from " + outputDir);
}
}
}
}
}
public synchronized boolean addRoot(
@NotNull String name,
@NotNull List<AbstractTreeNode> parentElements,
final AbstractTreeNode newElement,
@Nullable AbstractTreeNode sibling) {
final List<TreeItem<Pair<AbstractUrl, String>>> items = myName2FavoritesRoots.get(name);
if (items == null) return false;
AbstractUrl url = createUrlByElement(newElement.getValue(), myProject);
if (url == null) return false;
final TreeItem<Pair<AbstractUrl, String>> newItem =
new TreeItem<Pair<AbstractUrl, String>>(Pair.create(url, newElement.getClass().getName()));
if (parentElements.isEmpty()) {
// directly to list
if (sibling != null) {
TreeItem<Pair<AbstractUrl, String>> after = null;
AbstractUrl siblingUrl = createUrlByElement(sibling.getValue(), myProject);
int idx = -1;
for (int i = 0; i < items.size(); i++) {
TreeItem<Pair<AbstractUrl, String>> item = items.get(i);
if (item.getData().getFirst().equals(siblingUrl)) {
idx = i;
break;
}
}
if (idx != -1) {
items.add(idx, newItem);
} else {
items.add(newItem);
}
} else {
items.add(newItem);
}
fireListeners.rootsChanged(name);
return true;
}
Collection<TreeItem<Pair<AbstractUrl, String>>> list = items;
TreeItem<Pair<AbstractUrl, String>> item = null;
for (AbstractTreeNode obj : parentElements) {
AbstractUrl objUrl = createUrlByElement(obj.getValue(), myProject);
item = findNextItem(objUrl, list);
if (item == null) return false;
list = item.getChildren();
}
if (sibling != null) {
TreeItem<Pair<AbstractUrl, String>> after = null;
AbstractUrl siblingUrl = createUrlByElement(sibling.getValue(), myProject);
for (TreeItem<Pair<AbstractUrl, String>> treeItem : list) {
if (treeItem.getData().getFirst().equals(siblingUrl)) {
after = treeItem;
break;
}
}
if (after == null) {
item.addChild(newItem);
} else {
item.addChildAfter(newItem, after);
}
} else {
item.addChild(newItem);
}
fireListeners.rootsChanged(name);
return true;
}
