Unnamed: 0 int64 0 305k | body stringlengths 7 52.9k | name stringlengths 1 185 |
|---|---|---|
274,600 | Collection<Integer> () { Set<Integer> result = new HashSet<>(); myBranches.keySet().intStream().forEach(result::add); myTags.keySet().intStream().forEach(result::add); return result; } | getCommits |
274,601 | VirtualFile (int headIndex) { return myRootForHead.get(headIndex); } | rootAtHead |
274,602 | List<VcsRef> (int index) { if (myRefs.size() <= 10) { for (CompressedRefs refs : myRefs.values()) { if (refs.contains(index)) { return refs.refsToCommit(index); } } return Collections.emptyList(); } CommitId id = myStorage.getCommitId(index); if (id == null) return Collections.emptyList(); VirtualFile root = id.getRoot... | refsToCommit |
274,603 | Collection<VcsRef> () { return myRefs.values().stream().flatMap(CompressedRefs::streamBranches).collect(Collectors.toList()); } | getBranches |
274,604 | Stream<VcsRef> () { ApplicationManager.getApplication().assertIsNonDispatchThread(); return myRefs.values().stream().flatMap(CompressedRefs::stream); } | stream |
274,605 | RefsModel (@NotNull VcsLogStorage storage) { return new RefsModel(Collections.emptyMap(), Collections.emptySet(), storage, Collections.emptyMap()); } | createEmptyInstance |
274,606 | List<Commit> (@NotNull Collection<? extends List<Commit>> logsFromRepos) { if (logsFromRepos.size() == 1) { return logsFromRepos.iterator().next(); } int size = 0; for (List<Commit> repo : logsFromRepos) { size += repo.size(); } List<Commit> result = new ArrayList<>(size); Map<Commit, Iterator<Commit>> nextCommits = ne... | join |
274,607 | Commit (@NotNull Set<? extends Commit> commits) { long maxTimeStamp = Long.MIN_VALUE; Commit lastCommit = null; for (Commit commit : commits) { if (commit.getTimestamp() >= maxTimeStamp) { maxTimeStamp = commit.getTimestamp(); lastCommit = commit; } } assert lastCommit != null; return lastCommit; } | findLatestCommit |
274,608 | PermanentGraph<Integer> () { return INSTANCE; } | getInstance |
274,609 | VisibleGraph<Integer> (@NotNull SortType sortType, @Nullable Set<? extends Integer> headsOfVisibleBranches, @Nullable Set<? extends Integer> filter) { return EmptyVisibleGraph.getInstance(); } | createVisibleGraph |
274,610 | List<GraphCommit<Integer>> () { return Collections.emptyList(); } | getAllCommits |
274,611 | List<Integer> (@NotNull Integer commit) { return Collections.emptyList(); } | getChildren |
274,612 | Set<Integer> (@NotNull Integer commit) { return Collections.emptySet(); } | getContainingBranches |
274,613 | Predicate<Integer> (@NotNull Collection<? extends Integer> currentBranchHead) { return Predicates.alwaysFalse(); } | getContainedInBranchCondition |
274,614 | int (@NotNull Hash hash, @NotNull VirtualFile root) { return getOrPut(hash, root); } | getCommitIndex |
274,615 | int (@NotNull Hash hash, @NotNull VirtualFile root) { return myCommitIdEnumerator.enumerate(new CommitId(hash, root)); } | getOrPut |
274,616 | CommitId (int commitIndex) { return myCommitIdEnumerator.getValue(commitIndex); } | getCommitId |
274,617 | boolean (@NotNull CommitId id) { return myCommitIdEnumerator.contains(id); } | containsCommit |
274,618 | void (@NotNull Predicate<? super CommitId> consumer) { myCommitIdEnumerator.forEachValue(consumer); } | iterateCommits |
274,619 | int (@NotNull VcsRef ref) { return myRefsEnumerator.enumerate(ref); } | getRefIndex |
274,620 | VcsRef (int refIndex) { return myRefsEnumerator.getValue(refIndex); } | getVcsRef |
274,621 | void () { // nothing to flush } | flush |
274,622 | int (@NotNull Hash hash, @NotNull VirtualFile root) { checkDisposed(); try { return getOrPut(hash, root); } catch (IOException e) { myErrorHandler.handleError(VcsLogErrorHandler.Source.Storage, e); } return NO_INDEX; } | getCommitIndex |
274,623 | boolean (@NotNull CommitId id) { checkDisposed(); try { return myCommitIdEnumerator.contains(id); } catch (IOException e) { myErrorHandler.handleError(VcsLogErrorHandler.Source.Storage, e); } return false; } | containsCommit |
274,624 | void (@NotNull Predicate<? super CommitId> consumer) { checkDisposed(); try { myCommitIdEnumerator.iterateData(new CommonProcessors.FindProcessor<>() { @Override protected boolean accept(CommitId commitId) { return !consumer.test(commitId); } }); } catch (IOException e) { myErrorHandler.handleError(VcsLogErrorHandler.S... | iterateCommits |
274,625 | boolean (CommitId commitId) { return !consumer.test(commitId); } | accept |
274,626 | int (@NotNull VcsRef ref) { checkDisposed(); try { return myRefsEnumerator.enumerate(ref); } catch (IOException e) { myErrorHandler.handleError(VcsLogErrorHandler.Source.Storage, e); } return NO_INDEX; } | getRefIndex |
274,627 | void () { checkDisposed(); myCommitIdEnumerator.force(); myRefsEnumerator.force(); } | flush |
274,628 | StorageId () { return myHashesStorageId; } | getHashesStorageId |
274,629 | StorageId () { return myRefsStorageId; } | getRefsStorageId |
274,630 | void () { } | dispose |
274,631 | void () { if (myDisposed) throw new ProcessCanceledException(); } | checkDisposed |
274,632 | int (CommitId value) { int result = value.getHash().hashCode(); result = 31 * result + myRootsReversed.getInt(value); return result; } | getHashCode |
274,633 | boolean (@Nullable CommitId val1, @Nullable CommitId val2) { if (val1 == val2) return true; if (val1 == null || val2 == null) return false; return val1.getHash().equals(val2.getHash()) && myRootsReversed.getInt(val1.getRoot()) == myRootsReversed.getInt(val2.getRoot()); } | isEqual |
274,634 | int (@NotNull VcsRef value) { return value.hashCode(); } | getHashCode |
274,635 | boolean (@Nullable VcsRef val1, @Nullable VcsRef val2) { return Objects.equals(val1, val2); } | isEqual |
274,636 | void (boolean full) { } | scheduleIndex |
274,637 | boolean (int commit) { return false; } | isIndexed |
274,638 | boolean (@NotNull VirtualFile root) { return false; } | isIndexed |
274,639 | boolean (@NotNull VirtualFile root) { return false; } | isIndexingEnabled |
274,640 | void (int commit, @NotNull VirtualFile root) { } | markForIndexing |
274,641 | Set<VirtualFile> () { return Collections.emptySet(); } | getIndexingRoots |
274,642 | void (@NotNull IndexingFinishedListener l) { } | addListener |
274,643 | void (@NotNull IndexingFinishedListener l) { } | removeListener |
274,644 | void () { } | markCorrupted |
274,645 | int (@NotNull List<? extends Commit> commits, @NotNull Set<CommitId> searchHashes) { int lastIndex; for (lastIndex = 0; lastIndex < commits.size(); lastIndex++) { Commit commit = commits.get(lastIndex); if (searchHashes.isEmpty()) { return lastIndex; } searchHashes.remove(commit.getId()); } if (!searchHashes.isEmpty())... | getFirstUnTrackedIndex |
274,646 | Set<Commit> (@NotNull List<? extends Commit> unsafeGreenPartSavedLog, @NotNull List<? extends Commit> firstBlock) { Set<CommitId> existedCommitHashes = new HashSet<>(); for (Commit commit : unsafeGreenPartSavedLog) { existedCommitHashes.add(commit.getId()); } Set<Commit> allNewsCommits = new HashSet<>(); for (Commit ne... | getAllNewCommits |
274,647 | void (@NotNull CommitId node) { if (!currentRed.remove(node)) { throw new IllegalStateException(ILLEGAL_DATA_RELOAD_ALL); // see VcsLogJoinerTest#illegalStateExceptionTest2 } allRedCommit.add(node); } | markRealRedNode |
274,648 | int () { for (int lastIndex = 0; lastIndex < savedLog.size(); lastIndex++) { Commit commit = savedLog.get(lastIndex); boolean isGreen = currentGreen.contains(commit.getId()); if (isGreen) { currentRed.remove(commit.getId()); currentGreen.addAll(commit.getParents()); } else { markRealRedNode(commit.getId()); currentRed.... | getFirstSaveIndex |
274,649 | Set<CommitId> () { return allRedCommit; } | getAllRedCommit |
274,650 | void () { while (!newCommitsMap.isEmpty()) { visitCommit(Objects.requireNonNull(ContainerUtil.getFirstItem(newCommitsMap.values()))); while (!commitsStack.isEmpty()) { Commit currentCommit = commitsStack.peek(); boolean allParentsWereAdded = true; for (CommitId parentHash : currentCommit.getParents()) { Commit parentCo... | insertAllUseStack |
274,651 | void (@NotNull Commit commit) { commitsStack.push(commit); newCommitsMap.remove(commit.getId()); } | visitCommit |
274,652 | List<Commit> () { insertAllUseStack(); return list; } | getResultList |
274,653 | ProgressIndicator (@NotNull ProgressKey key) { return createProgressIndicator(true, key); } | createProgressIndicator |
274,654 | ProgressIndicator (boolean visible, @NotNull ProgressKey key) { if (ApplicationManager.getApplication().isHeadlessEnvironment()) { return new EmptyProgressIndicator(); } return new VcsLogProgressIndicator(visible, key); } | createProgressIndicator |
274,655 | void (@NotNull ProgressListener listener, @Nullable Disposable parentDisposable) { synchronized (myLock) { myListeners.add(listener); if (parentDisposable != null) { Disposer.register(parentDisposable, () -> removeProgressIndicatorListener(listener)); } if (isRunning()) { Set<ProgressKey> keys = getRunningKeys(); Appli... | addProgressIndicatorListener |
274,656 | void (@NotNull ProgressListener listener) { synchronized (myLock) { myListeners.remove(listener); } } | removeProgressIndicatorListener |
274,657 | boolean () { synchronized (myLock) { return !myTasksWithVisibleProgress.isEmpty(); } } | isRunning |
274,658 | Set<ProgressKey> () { synchronized (myLock) { return ContainerUtil.map2Set(myTasksWithVisibleProgress, VcsLogProgressIndicator::getKey); } } | getRunningKeys |
274,659 | void (@NotNull VcsLogProgressIndicator indicator) { synchronized (myLock) { if (myDisposed) { indicator.cancel(); return; } if (indicator.isVisible()) { Set<ProgressKey> oldKeys = getRunningKeys(); myTasksWithVisibleProgress.add(indicator); if (myTasksWithVisibleProgress.size() == 1) { ProgressKey key = indicator.getKe... | started |
274,660 | void (@NotNull VcsLogProgressIndicator indicator) { synchronized (myLock) { if (indicator.isVisible()) { myTasksWithVisibleProgress.remove(indicator); if (myTasksWithVisibleProgress.isEmpty()) fireNotification(ProgressListener::progressStopped); } else { myTasksWithSilentProgress.remove(indicator); } } } | stopped |
274,661 | void (@NotNull Set<ProgressKey> oldKeys) { synchronized (myLock) { Set<ProgressKey> newKeys = getRunningKeys(); if (!oldKeys.equals(newKeys)) { fireNotification(listener -> listener.progressChanged(newKeys)); } } } | keysUpdated |
274,662 | void (@NotNull Consumer<? super ProgressListener> action) { synchronized (myLock) { List<ProgressListener> list = new ArrayList<>(myListeners); ApplicationManager.getApplication().invokeLater(() -> list.forEach(action), o -> myDisposableFlag.isDisposed()); } } | fireNotification |
274,663 | void () { synchronized (myLock) { myDisposed = true; for (ProgressIndicator indicator : myTasksWithVisibleProgress) { indicator.cancel(); } for (ProgressIndicator indicator : myTasksWithSilentProgress) { indicator.cancel(); } } } | dispose |
274,664 | void () { synchronized (getLock()) { super.start(); started(this); } } | start |
274,665 | void () { synchronized (getLock()) { super.stop(); stopped(this); } } | stop |
274,666 | void (@NotNull ProgressKey key) { synchronized (myLock) { Set<ProgressKey> oldKeys = getRunningKeys(); myKey = key; keysUpdated(oldKeys); } } | updateKey |
274,667 | boolean () { return myVisible; } | isVisible |
274,668 | ProgressKey () { synchronized (myLock) { return myKey; } } | getKey |
274,669 | boolean (Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; ProgressKey key = (ProgressKey)o; return Objects.equals(myName, key.myName); } | equals |
274,670 | int () { return Objects.hash(myName); } | hashCode |
274,671 | void (@NotNull ProgressKey key) { ProgressIndicator indicator = ProgressManager.getInstance().getProgressIndicator(); if (indicator instanceof VcsLogProgressIndicator) { ((VcsLogProgressIndicator)indicator).updateKey(key); } } | updateCurrentKey |
274,672 | RefsModel () { return myRefsModel; } | getRefsModel |
274,673 | boolean () { return myIsFull; } | isFull |
274,674 | DataPack (@NotNull List<? extends GraphCommit<Integer>> commits, @NotNull Map<VirtualFile, CompressedRefs> refs, @NotNull Map<VirtualFile, VcsLogProvider> providers, @NotNull VcsLogStorage storage, boolean full) { RefsModel refsModel; PermanentGraph<Integer> permanentGraph; if (commits.isEmpty()) { refsModel = new Refs... | build |
274,675 | Set<Integer> (@NotNull List<? extends GraphCommit<Integer>> commits) { IntSet parents = new IntOpenHashSet(); for (GraphCommit<Integer> commit : commits) { for (int parent : commit.getParents()) { parents.add(parent); } } Set<Integer> heads = new HashSet<>(); for (GraphCommit<Integer> commit : commits) { if (!parents.c... | getHeads |
274,676 | Set<Integer> (@NotNull Collection<? extends VcsRef> branches, @NotNull VcsLogStorage storage) { Set<Integer> result = new HashSet<>(); for (VcsRef vcsRef : branches) { result.add(storage.getCommitIndex(vcsRef.getCommitHash(), vcsRef.getRoot())); } return result; } | getBranchCommitHashIndexes |
274,677 | PermanentGraph<Integer> () { return myPermanentGraph; } | getPermanentGraph |
274,678 | Throwable () { return myError; } | getError |
274,679 | int (@NotNull VcsCommitMetadata metadata) { return myStorage.getCommitIndex(metadata.getId(), metadata.getRoot()); } | getIndex |
274,680 | void (@NotNull List<? extends VcsCommitMetadata> sortedDetails) { List<VcsCommitMetadata> newDetails = ContainerUtil.filter(sortedDetails, metadata -> !myCache.containsValue(metadata)); if (newDetails.isEmpty()) return; Iterator<VcsCommitMetadata> it = new MergingIterator(mySortedDetails, newDetails); List<VcsCommitMet... | storeDetails |
274,681 | void () { myCache.clear(); mySortedDetails.clear(); } | clear |
274,682 | boolean () { return myFirst.hasNext() || mySecond.hasNext(); } | hasNext |
274,683 | VcsCommitMetadata () { if (!myFirst.hasNext()) return mySecond.next(); if (!mySecond.hasNext()) return myFirst.next(); VcsCommitMetadata data1 = myFirst.peek(); VcsCommitMetadata data2 = mySecond.peek(); // more recent commits (with bigger timestamp) should go first // if timestamp is the same, commit from the second l... | next |
274,684 | SingleTask () { return VcsLogRefresherImpl.this.startNewBackgroundTask(new MyRefreshTask(myDataPack)); } | startNewBackgroundTask |
274,685 | DataPack () { return myDataPack; } | getCurrentDataPack |
274,686 | void () { try { LogInfo data = loadRecentData(new CommitCountRequirements(myRecentCommitCount).asMap(myProviders.keySet())); Collection<List<GraphCommit<Integer>>> commits = data.getCommits(); Map<VirtualFile, CompressedRefs> refs = data.getRefs(); List<GraphCommit<Integer>> compoundList = multiRepoJoin(commits); compo... | readFirstBlock |
274,687 | void (@NotNull Collection<VirtualFile> rootsToRefresh) { if (!rootsToRefresh.isEmpty()) { mySingleTaskController.request(new RefreshRequest(rootsToRefresh)); } } | refresh |
274,688 | List<GraphCommit<Integer>> (@NotNull List<? extends TimedVcsCommit> commits, @NotNull VirtualFile root) { return computeWithSpan(myTracer, LogData.CompactingCommits.getName(), (span -> { if (commits.isEmpty()) { return Collections.emptyList(); } List<GraphCommit<Integer>> list = new ArrayList<>(commits.size()); for (Ti... | compactCommits |
274,689 | GraphCommit<Integer> (@NotNull TimedVcsCommit commit, @NotNull VirtualFile root) { List<Integer> parents; Collection<? extends Hash> collection = commit.getParents(); if (collection.isEmpty()) { parents = Collections.emptyList(); } else { parents = new ArrayList<>(collection.size()); for (Hash t : collection) { parents... | compactCommit |
274,690 | void (@NotNull List<? extends VcsCommitMetadata> metadatas) { for (VcsCommitMetadata detail : metadatas) { myUserRegistry.addUser(detail.getAuthor()); myUserRegistry.addUser(detail.getCommitter()); } myTopCommitsDetailsCache.storeDetails(metadatas); } | storeUsersAndDetails |
274,691 | VcsLogProgress () { return myProgress; } | getProgress |
274,692 | void () { } | dispose |
274,693 | void (@NotNull ProgressIndicator indicator) { LOG.debug("Refresh task started"); indicator.setIndeterminate(true); DataPack dataPack = myCurrentDataPack; while (true) { List<RefreshRequest> requests = mySingleTaskController.popRequests(); Collection<VirtualFile> rootsToRefresh = getRootsToRefresh(requests); LOG.debug("... | run |
274,694 | Collection<VirtualFile> (@NotNull List<? extends RefreshRequest> requests) { Collection<VirtualFile> rootsToRefresh = new ArrayList<>(); for (RefreshRequest request : requests) { if (request == RefreshRequest.RELOAD_ALL) { myCurrentDataPack = DataPack.EMPTY; return myProviders.keySet(); } rootsToRefresh.addAll(request.... | getRootsToRefresh |
274,695 | DataPack (@NotNull Collection<? extends VirtualFile> roots) { return computeWithSpanThrows(myTracer, LogData.Refreshing.getName(), span -> { try { PermanentGraph<Integer> permanentGraph = myCurrentDataPack.isFull() ? myCurrentDataPack.getPermanentGraph() : null; Map<VirtualFile, CompressedRefs> currentRefs = myCurrentD... | doRefresh |
274,696 | String () { return "{" + rootsToRefresh + "}"; } | toString |
274,697 | int () { return myCommitCount; } | getCommitCount |
274,698 | int (@NotNull Hash hash, @NotNull VirtualFile root) { return 0; } | getCommitIndex |
274,699 | CommitId (int commitIndex) { throw new UnsupportedOperationException("Illegal access to empty hash map by index " + commitIndex); } | getCommitId |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.