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;
}
public void removeRootByIndexes(String name, List<Integer> elementsIndexes) {
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();
list.remove(elementsIndexes.get(elementsIndexes.size() - 1).intValue());
fireListeners.rootsChanged(name);
}
private static void logStats(Collection<PsiFile> otherFiles, long start) {
long time = System.currentTimeMillis() - start;
final Multiset<String> stats = HashMultiset.create();
for (PsiFile file : otherFiles) {
stats.add(
StringUtil.notNullize(file.getViewProvider().getVirtualFile().getExtension())
.toLowerCase());
}
List<String> extensions = ContainerUtil.newArrayList(stats.elementSet());
Collections.sort(
extensions,
new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return stats.count(o2) - stats.count(o1);
}
});
String message =
"Search in "
+ otherFiles.size()
+ " files with unknown types took "
+ time
+ "ms.\n"
+ "Mapping their extensions to an existing file type (e.g. Plain Text) might speed up the search.\n"
+ "Most frequent non-indexed file extensions: ";
for (int i = 0; i < Math.min(10, extensions.size()); i++) {
String extension = extensions.get(i);
message += extension + "(" + stats.count(extension) + ") ";
}
LOG.info(message);
}
public void listRemoved(String listName) {
FavoritesListener[] listeners =
myListeners.toArray(new FavoritesListener[myListeners.size()]);
for (FavoritesListener listener : listeners) {
listener.listRemoved(listName);
}
}
public void rootsChanged(String listName) {
FavoritesListener[] listeners =
myListeners.toArray(new FavoritesListener[myListeners.size()]);
for (FavoritesListener listener : listeners) {
listener.rootsChanged(listName);
}
}
public ExecutionResult execute(Executor executor, CommandLinePatcher... patchers)
throws ExecutionException {
final ProcessHandler processHandler = startProcess(patchers);
final ConsoleView console =
createAndAttachConsole(myConfig.getProject(), processHandler, executor);
List<AnAction> actions = Lists.newArrayList(createActions(console, processHandler));
return new DefaultExecutionResult(
console, processHandler, actions.toArray(new AnAction[actions.size()]));
}
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;
}
public synchronized boolean removeRoot(
@NotNull String name, @NotNull List<AbstractTreeNode> elements) {
final Convertor<AbstractTreeNode, AbstractUrl> convertor =
new Convertor<AbstractTreeNode, AbstractUrl>() {
@Override
public AbstractUrl convert(AbstractTreeNode obj) {
return createUrlByElement(obj.getValue(), myProject);
}
};
boolean result = true;
for (AbstractTreeNode element : elements) {
final List<AbstractTreeNode> path =
TaskDefaultFavoriteListProvider.getPathToUsualNode(element);
result &= findListToRemoveFrom(name, path.subList(1, path.size()), convertor);
}
return result;
}
@NotNull
public VirtualFile[] getPackageRoots() {
return myPackageRoots.toArray(new VirtualFile[myPackageRoots.size()]);
}
private void runTransformingCompilers(final ModuleChunk chunk) {
final JavaSourceTransformingCompiler[] transformers =
CompilerManager.getInstance(myProject).getCompilers(JavaSourceTransformingCompiler.class);
if (transformers.length == 0) {
return;
}
if (LOG.isDebugEnabled()) {
LOG.debug("Running transforming compilers...");
}
final Module[] modules = chunk.getModules();
for (final JavaSourceTransformingCompiler transformer : transformers) {
final Map<VirtualFile, VirtualFile> originalToCopyFileMap =
new HashMap<VirtualFile, VirtualFile>();
final Application application = ApplicationManager.getApplication();
application.invokeAndWait(
new Runnable() {
public void run() {
for (final Module module : modules) {
for (final VirtualFile file : chunk.getFilesToCompile(module)) {
final VirtualFile untransformed = chunk.getOriginalFile(file);
if (transformer.isTransformable(untransformed)) {
application.runWriteAction(
new Runnable() {
public void run() {
try {
// if untransformed != file, the file is already a (possibly
// transformed) copy of the original 'untransformed' file.
// If this is the case, just use already created copy and do not copy
// file content once again
final VirtualFile fileCopy =
untransformed.equals(file)
? createFileCopy(getTempDir(module), file)
: file;
originalToCopyFileMap.put(file, fileCopy);
} catch (IOException e) {
// skip it
}
}
});
}
}
}
}
},
myCompileContext.getProgressIndicator().getModalityState());
// do actual transform
for (final Module module : modules) {
final List<VirtualFile> filesToCompile = chunk.getFilesToCompile(module);
for (int j = 0; j < filesToCompile.size(); j++) {
final VirtualFile file = filesToCompile.get(j);
final VirtualFile fileCopy = originalToCopyFileMap.get(file);
if (fileCopy != null) {
final boolean ok =
transformer.transform(myCompileContext, fileCopy, chunk.getOriginalFile(file));
if (ok) {
chunk.substituteWithTransformedVersion(module, j, fileCopy);
}
}
}
}
}
}
public static void generate(GeneratingCompiler compiler, final CompileContext context) {
if (context == null) {
return;
}
final Set<Module> affectedModules = new HashSet<Module>();
Collections.addAll(affectedModules, context.getCompileScope().getAffectedModules());
ApplicationManager.getApplication()
.invokeAndWait(
new Runnable() {
@Override
public void run() {
for (Module module : affectedModules) {
if (module.isDisposed() || module.getProject().isDisposed()) {
continue;
}
final AndroidFacet facet = AndroidFacet.getInstance(module);
if (facet != null) {
AndroidCompileUtil.createGenModulesAndSourceRoots(facet);
}
}
}
},
ModalityState.defaultModalityState());
List<GeneratingCompiler.GenerationItem> itemsToGenerate =
new ArrayList<GeneratingCompiler.GenerationItem>();
for (GeneratingCompiler.GenerationItem item : compiler.getGenerationItems(context)) {
if (affectedModules.contains(item.getModule())) {
itemsToGenerate.add(item);
}
}
GeneratingCompiler.GenerationItem[] items =
itemsToGenerate.toArray(new GeneratingCompiler.GenerationItem[itemsToGenerate.size()]);
final boolean[] run = {true};
final VirtualFile[] files = getFilesToCheckReadonlyStatus(items);
if (files.length > 0) {
ApplicationManager.getApplication()
.invokeAndWait(
new Runnable() {
@Override
public void run() {
ApplicationManager.getApplication()
.runReadAction(
new Runnable() {
@Override
public void run() {
final Project project = context.getProject();
run[0] =
!project.isDisposed()
&& ReadonlyStatusHandler.ensureFilesWritable(project, files);
}
});
}
},
ModalityState.defaultModalityState());
}
if (run[0]) {
compiler.generate(context, items, null);
}
}
