private ClientConfigRoot getClientFor(VirtualFile file) { ProjectConfigRegistry reg = ProjectConfigRegistry.getInstance(project); return reg == null ? null : reg.getClientFor(file); } }
private ClientConfigRoot getClientFor(VirtualFile file) { ProjectConfigRegistry reg = ProjectConfigRegistry.getInstance(myProject); return reg == null ? null : reg.getClientFor(file); } }
private ClientConfigRoot getClientFor(VirtualFile file) { ProjectConfigRegistry reg = ProjectConfigRegistry.getInstance(project); return reg == null ? null : reg.getClientFor(file); }
@Nullable private ClientConfigRoot getRootFor(VirtualFile f) { if (f == null) { return null; } ProjectConfigRegistry registry = ProjectConfigRegistry.getInstance(project); if (registry == null) { return null; } return registry.getClientFor(f); }
@Nullable private ClientConfigRoot getRootFor(FilePath f) { if (f == null) { return null; } ProjectConfigRegistry registry = ProjectConfigRegistry.getInstance(project); if (registry == null) { return null; } return registry.getClientFor(f); } }
private ClientConfigRoot getClientFor(FilePath file) { ProjectConfigRegistry reg = ProjectConfigRegistry.getInstance(project); return reg == null ? null : reg.getClientFor(file); }
private ClientConfigRoot getClientFor(FilePath file) { ProjectConfigRegistry reg = ProjectConfigRegistry.getInstance(myProject); return reg == null ? null : reg.getClientFor(file); }
private Set<Map.Entry<ClientConfigRoot, List<FilePath>>> groupFilesByClient(@NotNull final ProjectConfigRegistry registry, @NotNull final List<FilePath> files) { // Note: can't use files.stream().collect(Collectors.groupingBy(registry::getClientFor)) // because the root might be null for a file, and the groupingBy doesn't allow for null keys. // See #195. // This fix also moves the null root check into this method, out of the stream processing. Map<ClientConfigRoot, List<FilePath>> ret = new HashMap<>(); files.forEach((f) -> { ClientConfigRoot root = registry.getClientFor(f); if (root != null) { ret.computeIfAbsent(root, (x) -> new ArrayList<>()).add(f); } else { LOG.info("Skipping revert for " + f + ": not in a Perforce root"); } }); return ret.entrySet(); } }
protected Stream<Pair<ClientConfig, List<VirtualFile>>> getFilesByConfiguration(@NotNull final Project project, @NotNull final Collection<VirtualFile> files) { final ProjectConfigRegistry registry = ProjectConfigRegistry.getInstance(project); if (registry == null) { return Stream.empty(); } final Map<ClientConfigRoot, List<VirtualFile>> mapping = new HashMap<>(); files.forEach((file) -> { ClientConfigRoot config = registry.getClientFor(file); if (config != null) { List<VirtualFile> mappedFiles = mapping.computeIfAbsent(config, k -> new ArrayList<>()); mappedFiles.add(file); } }); return mapping.entrySet().stream() .map((entry) -> Pair.create(entry.getKey().getClientConfig(), entry.getValue())); }
@Override public boolean validateOptions(Collection<FilePath> collection) { ProjectConfigRegistry registry = ProjectConfigRegistry.getInstance(project); if (registry == null || registry.isDisposed()) { return false; } for (FilePath filePath : collection) { ClientConfigRoot root = registry.getClientFor(filePath); if (root != null) { return true; } } return false; }
@Nullable private ClientConfigRoot getRootFor(FilePath fp) { if (fp == null || project.isDisposed()) { return null; } ProjectConfigRegistry registry = ProjectConfigRegistry.getInstance(project); if (registry == null || registry.isDisposed()) { return null; } return registry.getClientFor(fp); }
@NotNull private static Map<ClientConfigRoot, List<FilePath>> mapChangedFilesByRoot(@NotNull ProjectConfigRegistry registry, @NotNull Collection<Change> changes) { Map<ClientConfigRoot, List<FilePath>> ret = new HashMap<>(); for (Change change : changes) { { ContentRevision before = change.getBeforeRevision(); if (before != null) { ClientConfigRoot root = registry.getClientFor(before.getFile()); List<FilePath> paths = ret.computeIfAbsent(root, k -> new ArrayList<>()); paths.add(before.getFile()); } } { ContentRevision after = change.getAfterRevision(); if (after != null) { ClientConfigRoot root = registry.getClientFor(after.getFile()); List<FilePath> paths = ret.computeIfAbsent(root, k -> new ArrayList<>()); paths.add(after.getFile()); } } } return ret; }
public static P4RemoteFileContentRevision delayCreation(@NotNull final Project project, @NotNull P4RemoteFile file, @Nullable FilePath path, @NotNull VcsRevisionNumber.Int rev, @Nullable HistoryContentLoader loader, @Nullable Charset charset) { return new P4RemoteFileContentRevision(file, path == null ? new RemoteFilePath(file.getDisplayName(), false) : path, rev, loader, charset, () -> { ProjectConfigRegistry reg = ProjectConfigRegistry.getInstance(project); if (reg == null) { return null; } ClientConfigRoot config = reg.getClientFor(path); if (config == null) { return null; } return config.getClientConfig(); }); }
private List<ServerConfig> getConfigsForChanges(Collection<Change> changes) { ProjectConfigRegistry registry = ProjectConfigRegistry.getInstance(project); if (registry == null) { return Collections.emptyList(); } List<FilePath> files = new ArrayList<>(changes.size() * 2); for (Change change : changes) { ContentRevision before = change.getBeforeRevision(); if (before != null) { files.add(before.getFile()); } ContentRevision after = change.getAfterRevision(); if (after != null) { files.add(after.getFile()); } } Set<ServerConfig> configs = new HashSet<>(); for (FilePath file : files) { ClientConfigRoot config = registry.getClientFor(file); if (config != null) { configs.add(config.getServerConfig()); } } return new ArrayList<>(configs); }
@Nullable @Override public Configurable createConfigurable(Collection<FilePath> collection) { // Note the way this is currently implemented: synchronize options will always be reset. options = SyncOptions.createDefaultSyncOptions(); ProjectConfigRegistry registry = ProjectConfigRegistry.getInstance(project); if (registry == null || registry.isDisposed()) { return new SyncOptionConfigurable(project, options, Collections.emptyList()); } Map<P4ServerName, ServerConfig> configMap = new HashMap<>(); collection.forEach((fp) -> { ClientConfigRoot clientRoot = registry.getClientFor(fp); if (clientRoot != null) { configMap.put(clientRoot.getServerConfig().getServerName(), clientRoot.getServerConfig()); } }); return new SyncOptionConfigurable(project, options, configMap.values()); }
@Nullable @Override public P4LocalFile forIdeFile(@Nullable VirtualFile file) { if (file == null) { return null; } ProjectConfigRegistry registry = ProjectConfigRegistry.getInstance(project); if (registry == null) { return null; } ClientConfigRoot clientConfig = registry.getClientFor(file); if (clientConfig == null) { return null; } for (P4LocalFile openedFile : cache.getCachedOpenedFiles(clientConfig.getClientConfig())) { if (file.equals(openedFile.getFilePath().getVirtualFile())) { return openedFile; } } return null; }
final Map<ClientConfigRoot, List<FilePath>> filesByRoot = new HashMap<>(); for (FilePath filePath : filePaths) { filesByRoot.computeIfAbsent(registry.getClientFor(filePath), k -> new ArrayList<>()).add(filePath);
public ClientConfigRoot addClientConfigRoot(TemporaryFolder tmp, String clientRootDir) { File base = tmp.newFile(clientRootDir); if (!base.mkdirs()) { throw new RuntimeException("Could not create directory " + base); } MockConfigPart cp1 = new MockConfigPart() .withClientname("cn") .withUsername("u") .withServerName("s:123"); ClientConfig cc = ClientConfig.createFrom(ServerConfig.createFrom(cp1), cp1); FilePath fp = VcsUtil.getFilePath(base); VirtualFile rootDir = Objects.requireNonNull(fp.getVirtualFile()); registry.addClientConfig(cc, rootDir); roots.add(rootDir); return Objects.requireNonNull(registry.getClientFor(rootDir)); }
@Override public void rollbackIfUnchanged(VirtualFile file) { if (file == null || project.isDisposed()) { return; } ProjectConfigRegistry registry = ProjectConfigRegistry.getInstance(project); if (registry == null || registry.isDisposed()) { LOG.info("Skipping revert for " + file + ": plugin not in a valid state"); return; } FilePath fp = VcsUtil.getFilePath(file); if (fp == null) { LOG.info("Skipping revert for " + file + ": no FilePath found"); return; } ClientConfigRoot root = registry.getClientFor(file); if (root == null) { LOG.info("SKipping revert for " + file + ": no P4 root found"); return; } P4ServerComponent .perform(project, root.getClientConfig(), new RevertFileAction(fp, true)) .whenCompleted((r) -> ChangeListManager.getInstance(project).scheduleUpdate(true)); }
return null; ClientConfigRoot client = registry.getClientFor(root); if (client == null) { if (LOG.isDebugEnabled()) {