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.lo... | 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. //... | 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 != ... | 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 | ExecutionExc... | 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 { chang... | 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); progres... | 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.get... | 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 (... | 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.getNa... | 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("Sche... | 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(... | 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 = ((VcsLogStr... | 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 =... | 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 ? ((VcsLogMultiplePatternsTextFilt... | 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.