@NotNull
public TIntObjectHashMap<T> preLoadCommitData(@NotNull TIntHashSet commits) throws VcsException {
TIntObjectHashMap<T> result = new TIntObjectHashMap<>();
final MultiMap<VirtualFile, String> rootsAndHashes = MultiMap.create();
commits.forEach(
commit -> {
CommitId commitId = myHashMap.getCommitId(commit);
if (commitId != null) {
rootsAndHashes.putValue(commitId.getRoot(), commitId.getHash().asString());
}
return true;
});
for (Map.Entry<VirtualFile, Collection<String>> entry : rootsAndHashes.entrySet()) {
VcsLogProvider logProvider = myLogProviders.get(entry.getKey());
if (logProvider != null) {
List<? extends T> details =
readDetails(logProvider, entry.getKey(), ContainerUtil.newArrayList(entry.getValue()));
for (T data : details) {
int index = myHashMap.getCommitIndex(data.getId(), data.getRoot());
result.put(index, data);
}
saveInCache(result);
} else {
LOG.error(
"No log provider for root "
+ entry.getKey().getPath()
+ ". All known log providers "
+ myLogProviders);
}
}
return result;
}
public static JqlFieldType typeOf(String name) {
for (Map.Entry<JqlFieldType, Collection<String>> entry : TYPE_LOOKUP.entrySet()) {
if (entry.getValue().contains(name)) {
return entry.getKey();
}
}
return JqlFieldType.UNKNOWN;
}
private void refreshLogOnVcsEvents(@NotNull Map<VirtualFile, VcsLogProvider> logProviders) {
MultiMap<VcsLogProvider, VirtualFile> providers2roots = MultiMap.create();
for (Map.Entry<VirtualFile, VcsLogProvider> entry : logProviders.entrySet()) {
providers2roots.putValue(entry.getValue(), entry.getKey());
}
for (Map.Entry<VcsLogProvider, Collection<VirtualFile>> entry : providers2roots.entrySet()) {
entry.getKey().subscribeToRootRefreshEvents(entry.getValue(), myLogRefresher);
}
}
@NotNull
public static Set<GoImportSpec> findDuplicatedEntries(
@NotNull MultiMap<String, GoImportSpec> importMap) {
Set<GoImportSpec> duplicatedEntries = ContainerUtil.newLinkedHashSet();
for (Map.Entry<String, Collection<GoImportSpec>> imports : importMap.entrySet()) {
Collection<GoImportSpec> importsWithSameName = imports.getValue();
if (importsWithSameName.size() > 1) {
MultiMap<String, GoImportSpec> importsWithSameString =
collectImportsWithSameString(importsWithSameName);
for (Map.Entry<String, Collection<GoImportSpec>> importWithSameString :
importsWithSameString.entrySet()) {
List<GoImportSpec> duplicates =
ContainerUtil.newArrayList(importWithSameString.getValue());
if (duplicates.size() > 1) {
duplicatedEntries.addAll(duplicates.subList(1, duplicates.size()));
}
}
}
}
return duplicatedEntries;
}
void submitPasses(
@NotNull Map<FileEditor, HighlightingPass[]> passesMap,
@NotNull DaemonProgressIndicator updateProgress) {
if (isDisposed()) return;
// null keys are ok
MultiMap<Document, FileEditor> documentToEditors = MultiMap.createSet();
MultiMap<FileEditor, TextEditorHighlightingPass> documentBoundPasses = MultiMap.createSmart();
MultiMap<FileEditor, EditorBoundHighlightingPass> editorBoundPasses = MultiMap.createSmart();
List<Pair<FileEditor, TextEditorHighlightingPass>> passesWithNoDocuments = new ArrayList<>();
Set<VirtualFile> vFiles = new HashSet<>();
for (Map.Entry<FileEditor, HighlightingPass[]> entry : passesMap.entrySet()) {
FileEditor fileEditor = entry.getKey();
HighlightingPass[] passes = entry.getValue();
Document document;
if (fileEditor instanceof TextEditor) {
Editor editor = ((TextEditor) fileEditor).getEditor();
LOG.assertTrue(!(editor instanceof EditorWindow));
document = editor.getDocument();
} else {
VirtualFile virtualFile =
((FileEditorManagerEx) FileEditorManager.getInstance(myProject)).getFile(fileEditor);
document =
virtualFile == null ? null : FileDocumentManager.getInstance().getDocument(virtualFile);
}
if (document != null) {
vFiles.add(FileDocumentManager.getInstance().getFile(document));
}
int prevId = 0;
for (final HighlightingPass pass : passes) {
if (pass instanceof EditorBoundHighlightingPass) {
EditorBoundHighlightingPass editorPass = (EditorBoundHighlightingPass) pass;
editorPass.setId(
nextPassId.incrementAndGet()); // have to make ids unique for this document
editorBoundPasses.putValue(fileEditor, editorPass);
} else {
TextEditorHighlightingPass textEditorHighlightingPass =
convertToTextHighlightingPass(pass, document, nextPassId, prevId);
document = textEditorHighlightingPass.getDocument();
documentBoundPasses.putValue(fileEditor, textEditorHighlightingPass);
if (document == null) {
passesWithNoDocuments.add(Pair.create(fileEditor, textEditorHighlightingPass));
} else {
documentToEditors.putValue(document, fileEditor);
}
prevId = textEditorHighlightingPass.getId();
}
}
}
List<ScheduledPass> freePasses = new ArrayList<>(documentToEditors.size() * 5);
List<ScheduledPass> dependentPasses = new ArrayList<>(documentToEditors.size() * 10);
// (fileEditor, passId) -> created pass
Map<Pair<FileEditor, Integer>, ScheduledPass> toBeSubmitted = new THashMap<>(passesMap.size());
final AtomicInteger threadsToStartCountdown = new AtomicInteger(0);
for (Map.Entry<Document, Collection<FileEditor>> entry : documentToEditors.entrySet()) {
Collection<FileEditor> fileEditors = entry.getValue();
Document document = entry.getKey();
FileEditor preferredFileEditor = getPreferredFileEditor(document, fileEditors);
List<TextEditorHighlightingPass> passes =
(List<TextEditorHighlightingPass>) documentBoundPasses.get(preferredFileEditor);
if (passes.isEmpty()) {
continue;
}
sortById(passes);
for (TextEditorHighlightingPass currentPass : passes) {
createScheduledPass(
preferredFileEditor,
currentPass,
toBeSubmitted,
passes,
freePasses,
dependentPasses,
updateProgress,
threadsToStartCountdown);
}
}
for (Map.Entry<FileEditor, Collection<EditorBoundHighlightingPass>> entry :
editorBoundPasses.entrySet()) {
FileEditor fileEditor = entry.getKey();
Collection<EditorBoundHighlightingPass> createdEditorBoundPasses = entry.getValue();
List<TextEditorHighlightingPass> createdDocumentBoundPasses =
(List<TextEditorHighlightingPass>) documentBoundPasses.get(fileEditor);
List<TextEditorHighlightingPass> allCreatedPasses =
new ArrayList<>(createdDocumentBoundPasses);
allCreatedPasses.addAll(createdEditorBoundPasses);
for (EditorBoundHighlightingPass pass : createdEditorBoundPasses) {
createScheduledPass(
fileEditor,
pass,
toBeSubmitted,
allCreatedPasses,
freePasses,
dependentPasses,
updateProgress,
threadsToStartCountdown);
}
}
for (Pair<FileEditor, TextEditorHighlightingPass> pair : passesWithNoDocuments) {
FileEditor fileEditor = pair.first;
TextEditorHighlightingPass pass = pair.second;
createScheduledPass(
fileEditor,
pass,
toBeSubmitted,
ContainerUtil.emptyList(),
freePasses,
dependentPasses,
updateProgress,
threadsToStartCountdown);
}
if (CHECK_CONSISTENCY && !ApplicationInfoImpl.isInPerformanceTest()) {
assertConsistency(freePasses, toBeSubmitted, threadsToStartCountdown);
}
log(
updateProgress,
null,
vFiles + " ----- starting " + threadsToStartCountdown.get(),
freePasses);
for (ScheduledPass dependentPass : dependentPasses) {
mySubmittedPasses.put(dependentPass, Job.NULL_JOB);
}
for (ScheduledPass freePass : freePasses) {
submit(freePass);
}
}
public <Kk extends K, Vv extends V> void putAllValues(@NotNull MultiMap<Kk, Vv> from) {
for (Map.Entry<Kk, Collection<Vv>> entry : from.entrySet()) {
putValues(entry.getKey(), entry.getValue());
}
}
private static void removeStaleJarFilesIfNeeded(
File snapshotInfoFile, PersistentHashMap<String, CacheLibraryInfo> info)
throws IOException {
File versionFile = getVersionFile(snapshotInfoFile);
long lastModified = versionFile.lastModified();
if ((System.currentTimeMillis() - lastModified) < 30 * 24 * 60 * 60 * 1000L) {
return;
}
// snapshotInfo is persistent mapping of project library path -> jar snapshot path
// Stale jars are the jars that do not exist with registered paths, to remove them:
// - Take all snapshot library files in jar directory
// - Collect librarySnapshot -> projectLibraryPaths and existing projectLibraryPath ->
// librarySnapshot
// - Remove all projectLibraryPaths that doesn't exist from persistent mapping
// - Remove jar library snapshots that have no projectLibraryPath
Set<String> availableLibrarySnapshots =
new THashSet<String>(
Arrays.asList(
snapshotInfoFile
.getParentFile()
.list(
new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {
int lastDotPosition = name.lastIndexOf('.');
if (lastDotPosition == -1) return false;
String extension = name.substring(lastDotPosition + 1);
if (extension.length() != 40 || !consistsOfHexLetters(extension))
return false;
return true;
}
private boolean consistsOfHexLetters(String extension) {
for (int i = 0; i < extension.length(); ++i) {
if (Character.digit(extension.charAt(i), 16) == -1) return false;
}
return true;
}
})));
final List<String> invalidLibraryFilePaths = ContainerUtil.newArrayList();
final List<String> allLibraryFilePaths = ContainerUtil.newArrayList();
MultiMap<String, String> jarSnapshotFileToLibraryFilePaths = new MultiMap<String, String>();
Set<String> validLibraryFilePathToJarSnapshotFilePaths = ContainerUtil.newTroveSet();
info.processKeys(new CommonProcessors.CollectProcessor<String>(allLibraryFilePaths));
for (String filePath : allLibraryFilePaths) {
CacheLibraryInfo libraryInfo = info.get(filePath);
if (libraryInfo == null) continue;
jarSnapshotFileToLibraryFilePaths.putValue(libraryInfo.mySnapshotPath, filePath);
if (new File(filePath).exists()) {
validLibraryFilePathToJarSnapshotFilePaths.add(filePath);
} else {
invalidLibraryFilePaths.add(filePath);
}
}
for (String invalidLibraryFilePath : invalidLibraryFilePaths) {
LOG.info("removing stale library reference:" + invalidLibraryFilePath);
info.remove(invalidLibraryFilePath);
}
for (Map.Entry<String, Collection<String>> e : jarSnapshotFileToLibraryFilePaths.entrySet()) {
for (String libraryFilePath : e.getValue()) {
if (validLibraryFilePathToJarSnapshotFilePaths.contains(libraryFilePath)) {
availableLibrarySnapshots.remove(e.getKey());
break;
}
}
}
for (String availableLibrarySnapshot : availableLibrarySnapshots) {
File librarySnapshotFileToDelete =
new File(snapshotInfoFile.getParentFile(), availableLibrarySnapshot);
LOG.info("removing stale library snapshot:" + librarySnapshotFileToDelete);
FileUtil.delete(librarySnapshotFileToDelete);
}
saveVersion(
versionFile); // time stamp will change to start another time interval when stale jar
// files are tracked
}
public KeymapGroup createGroup(Condition<AnAction> condition, final Project project) {
KeymapGroup result =
KeymapGroupFactory.getInstance()
.createGroup(
ExternalSystemBundle.message("external.system.keymap.group"),
ExternalSystemIcons.TaskGroup);
if (project == null) return result;
MultiMap<ProjectSystemId, String> projectToActionsMapping = MultiMap.create();
for (ExternalSystemManager<?, ?, ?, ?, ?> manager : ExternalSystemApiUtil.getAllManagers()) {
projectToActionsMapping.putValues(manager.getSystemId(), ContainerUtil.<String>emptyList());
}
ActionManager actionManager = ActionManager.getInstance();
if (actionManager != null) {
for (String eachId : actionManager.getActionIds(getActionPrefix(project, null))) {
AnAction eachAction = actionManager.getAction(eachId);
if (!(eachAction instanceof MyExternalSystemAction)) continue;
if (condition != null && !condition.value(actionManager.getActionOrStub(eachId))) continue;
MyExternalSystemAction taskAction = (MyExternalSystemAction) eachAction;
projectToActionsMapping.putValue(taskAction.getSystemId(), eachId);
}
}
Map<ProjectSystemId, KeymapGroup> keymapGroupMap = ContainerUtil.newHashMap();
for (ProjectSystemId systemId : projectToActionsMapping.keySet()) {
if (!keymapGroupMap.containsKey(systemId)) {
final Icon projectIcon = ExternalSystemUiUtil.getUiAware(systemId).getProjectIcon();
KeymapGroup group =
KeymapGroupFactory.getInstance().createGroup(systemId.getReadableName(), projectIcon);
result.addGroup(group);
keymapGroupMap.put(systemId, group);
}
}
for (Map.Entry<ProjectSystemId, Collection<String>> each : projectToActionsMapping.entrySet()) {
Collection<String> tasks = each.getValue();
final ProjectSystemId systemId = each.getKey();
final KeymapGroup systemGroup = keymapGroupMap.get(systemId);
for (String actionId : tasks) {
systemGroup.addActionId(actionId);
}
if (systemGroup instanceof Group) {
Icon icon =
SystemInfoRt.isMac ? AllIcons.ToolbarDecorator.Mac.Add : AllIcons.ToolbarDecorator.Add;
((Group) systemGroup)
.addHyperlink(
new Hyperlink(icon, "Choose a task to assign a shortcut") {
@Override
public void onClick(MouseEvent e) {
SelectExternalTaskDialog dialog =
new SelectExternalTaskDialog(systemId, project);
if (dialog.showAndGet() && dialog.getResult() != null) {
TaskData taskData = dialog.getResult().second;
String ownerModuleName = dialog.getResult().first;
ExternalSystemTaskAction externalSystemAction =
(ExternalSystemTaskAction)
getOrRegisterAction(project, ownerModuleName, taskData);
ApplicationManager.getApplication()
.getMessageBus()
.syncPublisher(KeymapListener.CHANGE_TOPIC)
.processCurrentKeymapChanged();
Settings allSettings =
Settings.KEY.getData(
DataManager.getInstance().getDataContext(e.getComponent()));
KeymapPanel keymapPanel =
allSettings != null ? allSettings.find(KeymapPanel.class) : null;
if (keymapPanel != null) {
// clear actions filter
keymapPanel.showOption("");
keymapPanel.selectAction(externalSystemAction.myId);
}
}
}
});
}
}
for (ActionsProvider extension : ActionsProvider.EP_NAME.getExtensions()) {
KeymapGroup group = extension.createGroup(condition, project);
if (group != null) {
result.addGroup(group);
}
}
return result;
}