Unnamed: 0 int64 0 305k | body stringlengths 7 52.9k | name stringlengths 1 185 |
|---|---|---|
274,700 | boolean (@NotNull CommitId id) { return false; } | containsCommit |
274,701 | void (@NotNull Predicate<? super CommitId> consumer) { } | iterateCommits |
274,702 | int (@NotNull VcsRef ref) { return 0; } | getRefIndex |
274,703 | void () { } | flush |
274,704 | void (@NotNull VcsLogErrorHandler.Source source, @NotNull Throwable throwable) { myLogger.error(throwable); } | handleError |
274,705 | void (@Nls @NotNull String message) { myLogger.error(message); } | displayMessage |
274,706 | void () { synchronized (myLock) { if (myState.equals(State.CREATED)) { myState = State.INITIALIZED; Span span = TelemetryManager.getInstance().getTracer(VcsScope).spanBuilder(LogData.Initializing.getName()).startSpan(); Task.Backgroundable backgroundable = new Task.Backgroundable(myProject, VcsLogBundle.message("vcs.log.initial.loading.process"), false) { @Override public void run(@NotNull ProgressIndicator indicator) { runSpanWithScope(span, () -> { indicator.setIndeterminate(true); resetState(); readCurrentUser(); myRefresher.readFirstBlock(); fireDataPackChangeEvent(myRefresher.getCurrentDataPack()); }); } @Override public void onCancel() { synchronized (myLock) { // Here be dragons: // VcsLogProgressManager can cancel us when it's getting disposed, // and we can also get cancelled by invalid git executable. // Since we do not know what's up, we just restore the state, // and it is entirely possible to start another initialization after that. // Eventually, everything gets cancelled for good in VcsLogData.dispose. // But still. if (myState.equals(State.INITIALIZED)) { myState = State.CREATED; myInitialization = null; } } } @Override public void onThrowable(@NotNull Throwable error) { synchronized (myLock) { LOG.error(error); if (myState.equals(State.INITIALIZED)) { myState = State.CREATED; myInitialization = null; } } } @Override public void onSuccess() { synchronized (myLock) { if (myState.equals(State.INITIALIZED)) { myInitialization = null; } } } }; CoreProgressManager manager = (CoreProgressManager)ProgressManager.getInstance(); ProgressIndicator indicator = myRefresher.getProgress().createProgressIndicator(DATA_PACK_REFRESH); Future<?> future = manager.runProcessWithProgressAsynchronously(backgroundable, indicator, null); myInitialization = new SingleTaskController.SingleTaskImpl(future, indicator); } } } | initialize |
274,707 | void (@NotNull ProgressIndicator indicator) { runSpanWithScope(span, () -> { indicator.setIndeterminate(true); resetState(); readCurrentUser(); myRefresher.readFirstBlock(); fireDataPackChangeEvent(myRefresher.getCurrentDataPack()); }); } | run |
274,708 | void () { synchronized (myLock) { // Here be dragons: // VcsLogProgressManager can cancel us when it's getting disposed, // and we can also get cancelled by invalid git executable. // Since we do not know what's up, we just restore the state, // and it is entirely possible to start another initialization after that. // Eventually, everything gets cancelled for good in VcsLogData.dispose. // But still. if (myState.equals(State.INITIALIZED)) { myState = State.CREATED; myInitialization = null; } } } | onCancel |
274,709 | void (@NotNull Throwable error) { synchronized (myLock) { LOG.error(error); if (myState.equals(State.INITIALIZED)) { myState = State.CREATED; myInitialization = null; } } } | onThrowable |
274,710 | void () { synchronized (myLock) { if (myState.equals(State.INITIALIZED)) { myInitialization = null; } } } | onSuccess |
274,711 | void () { Span span = TelemetryManager.getInstance().getTracer(VcsScope).spanBuilder(LogData.ReadingCurrentUser.getName()).startSpan(); for (Map.Entry<VirtualFile, VcsLogProvider> entry : myLogProviders.entrySet()) { VirtualFile root = entry.getKey(); try { VcsUser me = entry.getValue().getCurrentUser(root); if (me != null) { myCurrentUser.put(root, me); } else { LOG.info("Username not configured for root " + root); } } catch (VcsException e) { LOG.warn("Couldn't read the username from root " + root, e); } } span.end(); } | readCurrentUser |
274,712 | void (final @NotNull DataPack dataPack) { ApplicationManager.getApplication().invokeLater(() -> { for (DataPackChangeListener listener : myDataPackChangeListeners) { listener.onDataPackChange(dataPack); } }, o -> myDisposableFlag.isDisposed()); myIndexDiagnosticRunner.onDataPackChange(); } | fireDataPackChangeEvent |
274,713 | void (final @NotNull DataPackChangeListener listener) { myDataPackChangeListeners.add(listener); } | addDataPackChangeListener |
274,714 | void (@NotNull DataPackChangeListener listener) { myDataPackChangeListeners.remove(listener); } | removeDataPackChangeListener |
274,715 | DataPack () { return myRefresher.getCurrentDataPack(); } | getDataPack |
274,716 | int (@NotNull Hash hash, @NotNull VirtualFile root) { return myStorage.getCommitIndex(hash, root); } | getCommitIndex |
274,717 | VcsLogStorage () { return myStorage; } | getStorage |
274,718 | void () { myTopCommitsDetailsCache.clear(); } | resetState |
274,719 | Set<VcsUser> () { return myUserRegistry.getUsers(); } | getAllUsers |
274,720 | Project () { return myProject; } | getProject |
274,721 | Collection<VirtualFile> () { return myLogProviders.keySet(); } | getRoots |
274,722 | ContainingBranchesGetter () { return myContainingBranchesGetter; } | getContainingBranchesGetter |
274,723 | void (@NotNull Collection<VirtualFile> roots) { initialize(); myRefresher.refresh(roots); } | refresh |
274,724 | CommitDetailsGetter () { return myDetailsGetter; } | getCommitDetailsGetter |
274,725 | MiniDetailsGetter () { return myMiniDetailsGetter; } | getMiniDetailsGetter |
274,726 | void () { SingleTaskController.SingleTask initialization; synchronized (myLock) { initialization = myInitialization; myInitialization = null; myState = State.DISPOSED; } if (initialization != null) { initialization.cancel(); try { initialization.waitFor(1, TimeUnit.MINUTES); } catch (InterruptedException | ExecutionException | TimeoutException e) { LOG.warn(e); } } resetState(); } | dispose |
274,727 | VcsLogProvider (@NotNull VirtualFile root) { return myLogProviders.get(root); } | getLogProvider |
274,728 | VcsUserRegistryImpl () { return myUserRegistry; } | getUserRegistry |
274,729 | VcsLogUserResolver () { return myUserResolver; } | getUserNameResolver |
274,730 | VcsLogProgress () { return myRefresher.getProgress(); } | getProgress |
274,731 | TopCommitsCache () { return myTopCommitsDetailsCache; } | getTopCommitsCache |
274,732 | VcsLogIndex () { //noinspection TestOnlyProblems return getModifiableIndex(); } | getIndex |
274,733 | Set<VcsUser> () { return VcsLogData.this.getAllUsers(); } | getAllUsers |
274,734 | void () { removeDataPackChangeListener(myListener); } | dispose |
274,735 | boolean () { return getIndexingRegistryValue().asBoolean(); } | isIndexSwitchedOnInRegistry |
274,736 | RegistryValue () { return Registry.get("vcs.log.index.enable"); } | getIndexingRegistryValue |
274,737 | void () { super.dispose(); try { myPathsIndexer.myPathsEnumerator.close(); } catch (IOException e) { LOG.warn(e); } } | dispose |
274,738 | void (@NotNull Consumer<? super Exception> fatalErrorConsumer) { myFatalErrorConsumer = fatalErrorConsumer; } | setFatalErrorConsumer |
274,739 | List<ChangeKind> (@NotNull Int2ObjectMap<List<ChangeKind>> pathIdToChangeDataListsMap, int pathId, int parentsCount) { List<ChangeKind> changeDataList = pathIdToChangeDataListsMap.get(pathId); if (changeDataList == null) { if (parentsCount == 1) { changeDataList = new SmartList<>(ChangeKind.NOT_CHANGED); } else { changeDataList = new ArrayList<>(parentsCount); for (int i = 0; i < parentsCount; i++) { changeDataList.add(ChangeKind.NOT_CHANGED); } } pathIdToChangeDataListsMap.put(pathId, changeDataList); } return changeDataList; } | getOrCreateChangeKindList |
274,740 | ChangeKind (@NotNull Change.Type type) { return switch (type) { case NEW -> ChangeKind.ADDED; case DELETED -> ChangeKind.REMOVED; case MOVED, MODIFICATION -> ChangeKind.MODIFIED; }; } | createChangeData |
274,741 | VirtualFile () { return myRoot; } | getRoot |
274,742 | String () { return myRelativePath; } | getRelativePath |
274,743 | boolean (Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; LightFilePath path = (LightFilePath)o; return myRoot.getPath().equals(path.myRoot.getPath()) && myRelativePath.equals(path.myRelativePath); } | equals |
274,744 | int () { return Objects.hash(myRoot.getPath(), myRelativePath); } | hashCode |
274,745 | int (@NotNull LightFilePath path) { return path.hashCode(); } | getHashCode |
274,746 | boolean (@Nullable LightFilePath path1, @Nullable LightFilePath path2) { return Objects.equals(path1, path2); } | isEqual |
274,747 | State () { synchronized (myLock) { return new State(myState); } } | getState |
274,748 | void (@NotNull State state) { synchronized (myLock) { myState = new State(state); } } | loadState |
274,749 | void (@NotNull VirtualFile root) { boolean added; synchronized (myLock) { added = myState.repositories.add(root.getPath()); } if (added) myDispatcher.getMulticaster().onRepositoryAdded(root); } | addRepository |
274,750 | boolean (@NotNull VirtualFile root) { boolean removed; synchronized (myLock) { removed = myState.repositories.remove(root.getPath()); } if (removed) myDispatcher.getMulticaster().onRepositoryRemoved(root); return removed; } | removeRepository |
274,751 | boolean (@NotNull VirtualFile root) { return isBig(root.getPath()); } | isBig |
274,752 | boolean (@NotNull String path) { synchronized (myLock) { return myState.repositories.contains(path); } } | isBig |
274,753 | int () { synchronized (myLock) { return myState.repositories.size(); } } | getRepositoryCount |
274,754 | void (@NotNull Listener listener, @NotNull Disposable disposable) { myDispatcher.addListener(listener, disposable); } | addListener |
274,755 | VcsLogBigRepositoriesList () { return ApplicationManager.getApplication().getService(VcsLogBigRepositoriesList.class); } | getInstance |
274,756 | int () { int limitValue = Registry.intValue("vcs.log.index.limit.minutes"); if (limitValue < 0) return -1; return Math.max(1, limitValue); } | getIndexingLimit |
274,757 | void (boolean full) { if (myHeavyAwareListener.isHeavy()) { LOG.debug("Indexing is postponed due to heavy activity"); myPostponedIndex.updateAndGet(oldFull -> { if (oldFull == null) return full; return oldFull || full; }); } else { doScheduleIndex(full); } } | scheduleIndex |
274,758 | void (boolean full) { TrackingUtil.trackActivity(myProject, VcsActivityKey.INSTANCE, () -> { doScheduleIndex(full, request -> mySingleTaskController.request(request)); }); } | doScheduleIndex |
274,759 | boolean () { if (myBackend.isFresh()) return true; return myBackend.isEmpty() && !ContainerUtil.exists(myRoots, root -> isIndexingIsProgress(root)); } | isFreshOrEmpty |
274,760 | void (@NotNull VcsLogIndexer.CompressedDetails detail, @NotNull VcsLogWriter mutator) { try { mutator.putCommit(myStorage.getCommitIndex(detail.getId(), detail.getRoot()), detail); } catch (IOException | UncheckedIOException e) { myErrorHandler.handleError(VcsLogErrorHandler.Source.Index, e); } } | storeDetail |
274,761 | void () { myBackend.markCorrupted(); } | markCorrupted |
274,762 | boolean (int commit) { try { return myBackend.containsCommit(commit); } catch (IOException e) { myErrorHandler.handleError(VcsLogErrorHandler.Source.Index, e); } return false; } | isIndexed |
274,763 | boolean (@NotNull VirtualFile root) { return myNumberOfTasks.get(root).get() != 0; } | isIndexingIsProgress |
274,764 | boolean (@NotNull VirtualFile root) { return myRoots.contains(root) && !(myBigRepositoriesList.isBig(root)); } | isIndexingEnabled |
274,765 | IndexDataGetter () { return myDataGetter; } | getDataGetter |
274,766 | void (@NotNull IndexingFinishedListener l) { myListeners.add(l); } | addListener |
274,767 | void (@NotNull IndexingFinishedListener l) { myListeners.remove(l); } | removeListener |
274,768 | StorageId () { return myBackend.getStorageId(); } | getIndexStorageId |
274,769 | void () { myPostponedIndex.set(null); } | dispose |
274,770 | Set<VirtualFile> () { return myRoots; } | getIndexingRoots |
274,771 | Collection<VcsLogIndexer> (@NotNull Project project) { return getAvailableIndexers(VcsProjectLog.getLogProviders(project)).values(); } | getAvailableIndexers |
274,772 | void () { Boolean indexRequest = myPostponedIndex.getAndSet(null); if (indexRequest == null) return; doScheduleIndex(indexRequest); } | heavyActivityEnded |
274,773 | void () { if (isPostponeOnHeavyActivity()) { mySingleTaskController.cancelCurrentTask(); } } | heavyActivityStarted |
274,774 | boolean () { return super.isHeavy() && isPostponeOnHeavyActivity(); } | isHeavy |
274,775 | boolean () { return Registry.is("vcs.log.index.postpone.on.heavy.activity.or.power.save"); } | isPostponeOnHeavyActivity |
274,776 | SingleTask () { ProgressIndicator indicator = myProgress.createProgressIndicator(true, INDEXING); Consumer<ProgressIndicator> task = progressIndicator -> { int previousPriority = setMinimumPriority(); try { IndexingRequest request; while ((request = popRequest()) != null) { try { request.run(progressIndicator); progressIndicator.checkCanceled(); } catch (ProcessCanceledException reThrown) { throw reThrown; } catch (Throwable t) { indicator.checkCanceled(); request.processException(t); } } } finally { taskCompleted(null); resetPriority(previousPriority); } }; Future<?> future = AppExecutorUtil.getAppExecutorService().submit(() -> { ProgressManager.getInstance().runProcess(() -> { task.accept(indicator); }, indicator); }); return new SingleTaskImpl(future, indicator); } | startNewBackgroundTask |
274,777 | void (int previousPriority) { if (Thread.currentThread().getPriority() == LOW_PRIORITY) Thread.currentThread().setPriority(previousPriority); } | resetPriority |
274,778 | int () { int previousPriority = Thread.currentThread().getPriority(); try { Thread.currentThread().setPriority(LOW_PRIORITY); } catch (SecurityException e) { LOG.debug("Could not set indexing thread priority", e); } return previousPriority; } | setMinimumPriority |
274,779 | void (@NotNull ProgressIndicator indicator) { if (myBigRepositoriesList.isBig(myRoot)) { LOG.info("Indexing repository " + myRoot.getName() + " is skipped"); markCommits(); myNumberOfTasks.get(myRoot).decrementAndGet(); return; } indicator.setIndeterminate(false); indicator.setFraction(0); mySpan = TelemetryManager.getInstance().getTracer(VcsScope).spanBuilder(VcsTelemetrySpan.LogIndex.Indexing.getName()).startSpan(); myScope = mySpan.makeCurrent(); myStartTime = getCurrentTimeMillis(); LOG.info("Indexing " + (myFull ? "full repository" : myCommits.size() + " commits") + " in " + myRoot.getName()); VcsLogStorageBackend indexStorageBackend = Objects.requireNonNull(myBackend); final var mutator = indexStorageBackend.createWriter(); boolean performCommit = false; try { if (myFull) { indexAll(indicator, mutator); } else { IntStream commits = myCommits.intStream().filter(c -> { if (isIndexed(c)) { myOldCommits.incrementAndGet(); return false; } return true; }); indexOneByOne(commits, indicator, mutator); } performCommit = true; } catch (AlreadyClosedException e) { throw new ProcessCanceledException(e); } catch (ProcessCanceledException e) { performCommit = true; scheduleReindex(); throw e; } catch (VcsException e) { if (indicator.isCanceled()) { performCommit = true; scheduleReindex(); throw new ProcessCanceledException(); } processException(e); scheduleReindex(); } finally { try { if (myDisposableFlag.isDisposed()) { mutator.interrupt(); } else { mutator.close(performCommit); } } catch (AlreadyClosedException | ProcessCanceledException ignored) { } catch (Exception e) { myErrorHandler.handleError(VcsLogErrorHandler.Source.Index, e); } myNumberOfTasks.get(myRoot).decrementAndGet(); myIndexingTime.get(myRoot).updateAndGet(t -> t + (getCurrentTimeMillis() - myStartTime)); boolean isIndexed = isIndexed(myRoot); if (isIndexed || myBigRepositoriesList.isBig(myRoot)) { long time = myIndexingTime.get(myRoot).getAndSet(0); myIndexCollector.reportIndexingTime(myRoot, time); if (isIndexed) myListeners.forEach(listener -> listener.indexingFinished(myRoot)); } report(); } } | run |
274,780 | void (@NotNull Throwable e) { int errorHash = ThrowableInterner.computeTraceHashCode(e); int errors = myIndexingErrors.get(myRoot).cacheOrGet(errorHash, 0); myIndexingErrors.get(myRoot).put(errorHash, errors + 1); if (errors <= LOGGED_ERRORS_COUNT) { LOG.error("Error while indexing " + myRoot.getName(), e); } else if (errors >= STOPPING_ERROR_COUNT) { myBigRepositoriesList.addRepository(myRoot); LOG.error("Stopping indexing of " + myRoot.getName() + " due to the large amount of exceptions.", e); } } | processException |
274,781 | long () { return TimeUnit.NANOSECONDS.toMillis(System.nanoTime()); } | getCurrentTimeMillis |
274,782 | void () { String formattedTime = StopWatch.formatTime(getCurrentTimeMillis() - myStartTime); mySpan.setAttribute("numberOfCommits", myNewIndexedCommits.get()); mySpan.setAttribute("rootName", myRoot.getName()); if (myFull) { LOG.info(formattedTime + " for indexing " + myNewIndexedCommits + " commits in " + myRoot.getName()); } else { int leftCommits = myCommits.size() - myNewIndexedCommits.get() - myOldCommits.get(); String leftCommitsMessage = (leftCommits > 0) ? ". " + leftCommits + " commits left" : ""; mySpan.setAttribute("totalCommits", myCommits.size()); mySpan.setAttribute("commitsLeft", leftCommits); LOG.info(formattedTime + " for indexing " + myNewIndexedCommits + " new commits out of " + myCommits.size() + " in " + myRoot.getName() + leftCommitsMessage); } mySpan.end(); myScope.close(); } | report |
274,783 | void () { int unindexedCommits = myCommits.size() - myNewIndexedCommits.get() - myOldCommits.get(); if (mySingleTaskController.isClosed()) { LOG.debug("Reindexing of " + myRoot.getName() + " is not scheduled since dispose has already started. " + unindexedCommits + " unindexed commits left."); return; } LOG.debug("Schedule reindexing of " + unindexedCommits + " commits in " + myRoot.getName()); markCommits(); scheduleIndex(false); } | scheduleReindex |
274,784 | void () { if (!myRoots.contains(myRoot)) return; try { IntSet missingCommits = myBackend.collectMissingCommits(myCommits); markForIndexing(missingCommits, myRoot); } catch (IOException e) { myErrorHandler.handleError(VcsLogErrorHandler.Source.Index, e); } } | markCommits |
274,785 | void (@NotNull ProgressIndicator indicator) { long time = myIndexingTime.get(myRoot).get() + (getCurrentTimeMillis() - myStartTime); int limit = myIndexingLimit.get(myRoot).get(); boolean isBigRoot = myBigRepositoriesList.isBig(myRoot); boolean isOvertime = !myIdleIndexer.isEnabled() && (limit > 0 && time >= (Math.max(limit, 1L) * 60 * 1000) && !isBigRoot); if (isOvertime || (isBigRoot && !indicator.isCanceled())) { mySpan.setAttribute("cancelled", true); String cause = isOvertime ? "by timeout (" + limit + " min)" : "externally"; LOG.warn("Indexing " + myRoot.getName() + " was cancelled " + cause + " after " + StopWatch.formatTime(time)); if (!isBigRoot) { myBigRepositoriesList.addRepository(myRoot); } if (isOvertime) { myIndexingLimit.get(myRoot).compareAndSet(limit, Math.max(limit + getIndexingLimit(), (int)((time / (getIndexingLimit() * 60000) + 1) * getIndexingLimit()))); } indicator.cancel(); } } | checkShouldCancel |
274,786 | String () { return "IndexingRequest of " + myCommits.size() + " commits in " + myRoot.getName() + (myFull ? " (full)" : ""); } | toString |
274,787 | void () { super.dispose(); try { myUserIndexer.close(); } catch (IOException e) { LOG.warn(e); } } | dispose |
274,788 | void (@NotNull Consumer<? super Exception> fatalErrorConsumer) { myFatalErrorConsumer = fatalErrorConsumer; } | setFatalErrorConsumer |
274,789 | void () { myUserEnumerator.force(); } | flush |
274,790 | boolean (@NotNull List<VcsLogDetailsFilter> filters) { if (filters.isEmpty()) return false; return ContainerUtil.all(filters, filter -> { if (filter instanceof VcsLogTextFilter || filter instanceof VcsLogUserFilter) { return true; } if (filter instanceof VcsLogStructureFilter) { Collection<FilePath> files = ((VcsLogStructureFilter)filter).getFiles(); return ContainerUtil.find(files, file -> file.isDirectory() && myProviders.containsKey(file.getVirtualFile())) == null; } return false; }); } | canFilter |
274,791 | IntSet (@NotNull List<VcsLogDetailsFilter> detailsFilters) { return filter(detailsFilters, null); } | filter |
274,792 | IntSet (@NotNull List<VcsLogDetailsFilter> detailsFilters, @Nullable IntSet candidates) { VcsLogTextFilter textFilter = ContainerUtil.findInstance(detailsFilters, VcsLogTextFilter.class); VcsLogUserFilter userFilter = ContainerUtil.findInstance(detailsFilters, VcsLogUserFilter.class); VcsLogStructureFilter pathFilter = ContainerUtil.findInstance(detailsFilters, VcsLogStructureFilter.class); IntSet filteredByUser = null; if (userFilter != null) { Set<VcsUser> users = new HashSet<>(); for (VirtualFile root : myProviders.keySet()) { users.addAll(userFilter.getUsers(root)); } filteredByUser = filterUsers(users); } IntSet filteredByPath = null; if (pathFilter != null) { filteredByPath = filterPaths(pathFilter.getFiles()); } IntSet filteredByUserAndPath = IntCollectionUtil.intersect(filteredByUser, filteredByPath, candidates); if (textFilter == null) { return filteredByUserAndPath == null ? IntSets.EMPTY_SET : filteredByUserAndPath; } return filterMessages(textFilter, filteredByUserAndPath); } | filter |
274,793 | IntSet (@NotNull Set<? extends VcsUser> users) { return executeAndCatch(() -> myIndexStorageBackend.getCommitsForUsers(users), new IntOpenHashSet()); } | filterUsers |
274,794 | IntSet (@NotNull Collection<? extends FilePath> paths) { return executeAndCatch(() -> { IntSet result = new IntOpenHashSet(); for (FilePath path : paths) { result.addAll(createFileHistoryData(path).build().getCommits()); ProgressManager.checkCanceled(); } return result; }, new IntOpenHashSet()); } | filterPaths |
274,795 | IntSet (@NotNull VcsLogTextFilter filter, @Nullable IntSet candidates) { IntSet result = new IntOpenHashSet(); filterMessages(filter, candidates, result::add); return result; } | filterMessages |
274,796 | void (@NotNull VcsLogTextFilter filter, @NotNull IntConsumer consumer) { filterMessages(filter, null, consumer); } | filterMessages |
274,797 | void (@NotNull VcsLogTextFilter filter, @Nullable IntSet candidates, @NotNull IntConsumer consumer) { if (!filter.isRegex() || filter instanceof VcsLogMultiplePatternsTextFilter) { executeAndCatch(() -> { List<String> trigramSources = filter instanceof VcsLogMultiplePatternsTextFilter ? ((VcsLogMultiplePatternsTextFilter)filter).getPatterns() : Collections.singletonList(filter.getText()); List<String> noTrigramSources = new ArrayList<>(); for (String string : trigramSources) { myIndexStorageBackend.getCommitsForSubstring(string, candidates, noTrigramSources, consumer, filter); } if (!noTrigramSources.isEmpty()) { VcsLogTextFilter noTrigramFilter = VcsLogFilterObject.fromPatternsList(noTrigramSources, filter.matchesCase()); filter(candidates, noTrigramFilter::matches, consumer); } }); } else { executeAndCatch(() -> { filter(candidates, filter::matches, consumer); }); } } | filterMessages |
274,798 | FileHistoryData (@NotNull FilePath path) { return createFileHistoryData(Collections.singletonList(path)); } | createFileHistoryData |
274,799 | FileHistoryData (@NotNull Collection<? extends FilePath> paths) { if (paths.size() == 1 && ContainerUtil.getFirstItem(paths).isDirectory()) { return new DirectoryHistoryData(ContainerUtil.getFirstItem(paths)); } return new FileHistoryDataImpl(paths); } | createFileHistoryData |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.