Unnamed: 0 int64 0 305k | body stringlengths 7 52.9k | name stringlengths 1 185 |
|---|---|---|
279,100 | boolean () { return myShowing; } | isTreeShowing |
279,101 | void () { if (isPassthroughMode()) return; if (isEdt()) { LOG.error("Must not be in event-dispatch thread"); } } | assertNotDispatchThread |
279,102 | void () { processDeferredActions(myDeferredSelections); processDeferredActions(myDeferredExpansions); } | processDeferredActions |
279,103 | void (@NotNull Set<Runnable> actions) { Runnable[] runnables = actions.toArray(ArrayUtil.EMPTY_RUNNABLE_ARRAY); actions.clear(); for (Runnable runnable : runnables) { runnable.run(); } } | processDeferredActions |
279,104 | ActionCallback (Object element) { return queueUpdate(element, true); } | queueUpdate |
279,105 | ActionCallback (Object fromElement, boolean updateStructure) { assertIsDispatchThread(); try { if (getUpdater() == null) { return ActionCallback.REJECTED; } ActionCallback result = new ActionCallback(); DefaultMutableTreeNode nodeToUpdate = null; boolean updateElementStructure = updateStructure; for (Object element = f... | queueUpdate |
279,106 | void () { result.setDone(); } | perform |
279,107 | void () { updateSubtree(getRootNode(), false); } | doUpdateFromRoot |
279,108 | void (@NotNull DefaultMutableTreeNode node, boolean canSmartExpand) { updateSubtree(new TreeUpdatePass(node), canSmartExpand); } | updateSubtree |
279,109 | void (@NotNull TreeUpdatePass pass, boolean canSmartExpand) { AbstractTreeUpdater updater = getUpdater(); if (updater != null) { updater.addSubtreeToUpdate(pass); } else { updateSubtreeNow(pass, canSmartExpand); } } | updateSubtree |
279,110 | void (@NotNull TreeUpdatePass pass, boolean canSmartExpand) { maybeSetBusyAndScheduleWaiterForReady(true, getElementFor(pass.getNode())); setHoldSize(true); boolean consumed = initRootNodeNowIfNeeded(pass); if (consumed) return; DefaultMutableTreeNode node = pass.getNode(); NodeDescriptor<?> descriptor = getDescriptorF... | updateSubtreeNow |
279,111 | void (int row, @NotNull TreeUpdatePass pass) { LOG.debug("updateRow: ", row, " - ", pass); invokeLaterIfNeeded(false, new TreeRunnable("AbstractTreeUi.updateRow") { @Override public void perform() { if (row >= getTree().getRowCount()) return; TreePath path = getTree().getPathForRow(row); if (path != null) { NodeDescrip... | updateRow |
279,112 | void () { if (row >= getTree().getRowCount()) return; TreePath path = getTree().getPathForRow(row); if (path != null) { NodeDescriptor<?> descriptor = getDescriptorFrom(path.getLastPathComponent()); if (descriptor != null) { DefaultMutableTreeNode node = (DefaultMutableTreeNode)path.getLastPathComponent(); maybeYield((... | perform |
279,113 | void () { updateRow(row + 1, pass); } | perform |
279,114 | boolean (NodeDescriptor<?> descriptor) { return isToBuildChildrenInBackground(getElementFromDescriptor(descriptor)); } | isToBuildInBackground |
279,115 | UpdaterTreeState (@NotNull UpdaterTreeState state) { if (state.equals(myUpdaterState)) return state; UpdaterTreeState oldState = myUpdaterState; if (oldState == null) { myUpdaterState = state; return state; } else { oldState.addAll(state); return oldState; } } | setUpdaterState |
279,116 | Object (NodeDescriptor<?> descriptor) { return getBuilder().getTreeStructureElement(descriptor); } | getElementFromDescriptor |
279,117 | ActionCallback (@NotNull DefaultMutableTreeNode node, @NotNull TreeUpdatePass pass, @Nullable LoadedChildren loadedChildren, boolean forcedNow, boolean toSmartExpand, boolean forceUpdate, boolean descriptorIsUpToDate, boolean updateChildren) { AbstractTreeStructure treeStructure = getTreeStructure(); ActionCallback res... | updateNodeChildren |
279,118 | void () { try { removeFromCancelled(node); execute(new TreeRunnable("AbstractTreeUi.updateNodeChildren: execute") { @Override public void perform() { doUpdateChildren(node, pass, loadedChildren, forcedNow, toSmartExpand, forceUpdate, descriptorIsUpToDate, updateChildren); } }); } catch (ProcessCanceledException e) { ad... | perform |
279,119 | void () { doUpdateChildren(node, pass, loadedChildren, forcedNow, toSmartExpand, forceUpdate, descriptorIsUpToDate, updateChildren); } | perform |
279,120 | void (@NotNull DefaultMutableTreeNode node, @NotNull TreeUpdatePass pass, @Nullable LoadedChildren loadedChildren, boolean forcedNow, boolean toSmartExpand, boolean forceUpdate, boolean descriptorIsUpToDate, boolean updateChildren) { try { NodeDescriptor<?> descriptor = getDescriptorFrom(node); if (descriptor == null) ... | doUpdateChildren |
279,121 | void () { if (processAlwaysLeaf(node) || !updateChildren) return; updateNodeChildrenNow(node, pass, preloaded.get(), toSmartExpand, wasExpanded, childForceUpdate); } | perform |
279,122 | boolean (@NotNull DefaultMutableTreeNode node) { Object element = getElementFor(node); NodeDescriptor<?> desc = getDescriptorFrom(node); if (desc == null) return false; if (element != null && getTreeStructure().isAlwaysLeaf(element)) { removeFromUnbuilt(node); removeLoading(node, true); if (node.getChildCount() > 0) { ... | processAlwaysLeaf |
279,123 | void () { for (TreeNode each : children) { removeNodeFromParent((MutableTreeNode)each, true); disposeNode((DefaultMutableTreeNode)each); } } | perform |
279,124 | boolean (@NotNull DefaultMutableTreeNode node, boolean parentForceUpdate, boolean parentExpanded) { TreePath path = getPathFor(node); return parentForceUpdate && (parentExpanded || myTree.isExpanded(path)); } | isChildNodeForceUpdate |
279,125 | void (@NotNull DefaultMutableTreeNode node, @NotNull TreeUpdatePass pass, @Nullable LoadedChildren preloadedChildren, boolean toSmartExpand, boolean wasExpanded, boolean forceUpdate) { if (isUpdatingChildrenNow(node)) return; if (!canInitiateNewActivity()) { throw new ProcessCanceledException(); } NodeDescriptor<?> des... | updateNodeChildrenNow |
279,126 | void () { if (isDisposed(node)) { removeFromUpdatingChildren(node); return; } removeLoading(node, false); boolean expanded = isExpanded(node, wasExpanded); if (expanded) { myWillBeExpanded.add(node); } else { myWillBeExpanded.remove(node); } collectNodesToInsert(descriptor, elementToIndexMap, node, expanded, loadedChil... | perform |
279,127 | void () { removeLoading(node, false); removeFromUpdatingChildren(node); if (node.getChildCount() > 0) { if (expanded) { expand(node, canSmartExpand); } } if (!canInitiateNewActivity()) { throw new ProcessCanceledException(); } Object element = getElementFor(node); addNodeAction(element, false, node1 -> removeLoading(no... | perform |
279,128 | void () { myWillBeExpanded.remove(node); removeFromUpdatingChildren(node); processNodeActionsIfReady(node); } | perform |
279,129 | void () { removeFromUpdatingChildren(node); processNodeActionsIfReady(node); } | perform |
279,130 | boolean (@NotNull DefaultMutableTreeNode node) { return !node.isNodeAncestor((DefaultMutableTreeNode)myTree.getModel().getRoot()); } | isDisposed |
279,131 | void (TreePath path) { assertIsDispatchThread(); try { mySilentExpand = path; getTree().expandPath(path); } finally { mySilentExpand = null; } } | expandSilently |
279,132 | void (TreePath path) { assertIsDispatchThread(); try { mySilentSelect = path; getTree().getSelectionModel().addSelectionPath(path); } finally { mySilentSelect = null; } } | addSelectionSilently |
279,133 | void (@NotNull DefaultMutableTreeNode node, boolean canSmartExpand) { expand(new TreePath(node.getPath()), canSmartExpand); } | expand |
279,134 | void (@NotNull TreePath path, boolean canSmartExpand) { Object last = path.getLastPathComponent(); boolean isLeaf = myTree.getModel().isLeaf(path.getLastPathComponent()); boolean isRoot = last == myTree.getModel().getRoot(); TreePath parent = path.getParentPath(); if (isRoot && !myTree.isExpanded(path)) { if (myTree.is... | expand |
279,135 | void (DefaultMutableTreeNode node) { myUnbuiltNodes.add(node); } | addToUnbuilt |
279,136 | void (DefaultMutableTreeNode node) { myUnbuiltNodes.remove(node); } | removeFromUnbuilt |
279,137 | void () { if (!isExpanded && getBuilder().isAlwaysShowPlus(descriptor)) { result.set(new Pair<>(true, null)); return; } Object element = getElementFor(node); if (element == null) { trace("null element for node " + node); result.set(new Pair<>(true, null)); return; } addToUpdatingChildren(node); try { LoadedChildren chi... | perform |
279,138 | boolean (@NotNull TreeNode node) { if (isLoadingNode(node)) { moveSelectionToParentIfNeeded(node); removeNodeFromParent((MutableTreeNode)node, false); return true; } return false; } | removeIfLoading |
279,139 | void (@NotNull TreeNode node) { TreePath path = getPathFor(node); if (myTree.getSelectionModel().isPathSelected(path)) { TreePath parentPath = path.getParentPath(); myTree.getSelectionModel().removeSelectionPath(path); if (parentPath != null) { myTree.getSelectionModel().addSelectionPath(parentPath); } } } | moveSelectionToParentIfNeeded |
279,140 | Object[] (Object element) { Ref<Object[]> passOne = new Ref<>(); try (LockToken ignored = acquireLock()) { execute(new TreeRunnable("AbstractTreeUi.getChildrenFor") { @Override public void perform() { passOne.set(getTreeStructure().getChildElements(element)); } }); } catch (IndexNotReadyException e) { warnOnIndexNotRea... | getChildrenFor |
279,141 | void () { passOne.set(getTreeStructure().getChildElements(element)); } | perform |
279,142 | void (IndexNotReadyException e) { if (!myWasEverIndexNotReady) { myWasEverIndexNotReady = true; LOG.error("Tree is not dumb-mode-aware; treeBuilder=" + getBuilder() + " treeStructure=" + getTreeStructure(), e); } } | warnOnIndexNotReady |
279,143 | ActionCallback (@NotNull List<? extends TreeNode> nodesToInsert, @NotNull TreeUpdatePass pass, boolean canSmartExpand, boolean forceUpdate) { ActionCallback.Chunk chunk = new ActionCallback.Chunk(); for (TreeNode node : nodesToInsert) { DefaultMutableTreeNode childNode = (DefaultMutableTreeNode)node; ActionCallback cal... | updateNodesToInsert |
279,144 | boolean (@NotNull TreeUpdatePass pass) { if (pass.isExpired() || !canInitiateNewActivity()) return false; boolean rerunBecauseTreeIsHidden = !pass.isExpired() && !isTreeShowing() && getUpdater().isInPostponeMode(); return rerunBecauseTreeIsHidden || getUpdater().isRerunNeededFor(pass); } | isRerunNeeded |
279,145 | void () { if (pass.isExpired()) { result.setError("expired"); return; } if (isRerunNeeded(pass)) { runDone(new TreeRunnable("AbstractTreeUi.maybeYield: rerun") { @Override public void perform() { if (!pass.isExpired()) { queueUpdate(getElementFor(node)); } } }); result.setError("requeue"); } else { try { //noinspection... | perform |
279,146 | void () { if (!pass.isExpired()) { queueUpdate(getElementFor(node)); } } | perform |
279,147 | boolean () { return !isCancelProcessed() && !myReleaseRequested && !isReleased(); } | canInitiateNewActivity |
279,148 | void () { if (isReady()) { return; } if (myResettingToReadyNow.get()) { _getReady(); return; } myResettingToReadyNow.set(true); invokeLaterIfNeeded(false, new TreeRunnable("AbstractTreeUi.resetToReady: later") { @Override public void perform() { if (!myResettingToReadyNow.get()) { return; } Progressive[] progressives =... | resetToReady |
279,149 | void () { if (!myResettingToReadyNow.get()) { return; } Progressive[] progressives = myBatchIndicators.keySet().toArray(new Progressive[0]); for (Progressive each : progressives) { myBatchIndicators.remove(each).cancel(); myBatchCallbacks.remove(each).setRejected(); } resetToReadyNow(); } | perform |
279,150 | ActionCallback () { if (isReleased()) return ActionCallback.REJECTED; assertIsDispatchThread(); DefaultMutableTreeNode[] uc; synchronized (myUpdatingChildren) { uc = myUpdatingChildren.toArray(new DefaultMutableTreeNode[0]); } for (DefaultMutableTreeNode each : uc) { resetIncompleteNode(each); } Object[] bg = ArrayUtil... | resetToReadyNow |
279,151 | void () { myResettingToReadyNow.set(false); setCancelRequested(false); } | perform |
279,152 | void (@NotNull DefaultMutableTreeNode node) { myCancelledBuild.remove(node); } | removeFromCancelled |
279,153 | boolean (@NotNull Object node) { return node instanceof DefaultMutableTreeNode && myCancelledBuild.containsKey(node); } | isCancelled |
279,154 | void (@NotNull DefaultMutableTreeNode node) { if (myReleaseRequested) return; addToCancelled(node); if (!isExpanded(node, false)) { node.removeAllChildren(); Object element = getElementFor(node); if (element != null && !getTreeStructure().isAlwaysLeaf(element)) { insertLoadingNode(node, true); } } else { removeFromUnbu... | resetIncompleteNode |
279,155 | boolean (@NotNull Runnable runnable, @NotNull TreeUpdatePass pass) { myYieldingPasses.add(pass); myYieldingNow = true; yieldToEDT(new TreeRunnable("AbstractTreeUi.yieldAndRun") { @Override public void perform() { if (isReleased()) return; runOnYieldingDone(new TreeRunnable("AbstractTreeUi.yieldAndRun: inner") { @Overri... | yieldAndRun |
279,156 | void () { if (isReleased()) return; runOnYieldingDone(new TreeRunnable("AbstractTreeUi.yieldAndRun: inner") { @Override public void perform() { if (isReleased()) return; executeYieldingRequest(runnable, pass); } }); } | perform |
279,157 | void () { if (isReleased()) return; executeYieldingRequest(runnable, pass); } | perform |
279,158 | boolean () { return myYieldingNow; } | isYieldingNow |
279,159 | boolean () { return getUpdater().hasNodesToUpdate(); } | hasScheduledUpdates |
279,160 | boolean () { return isReady(false); } | isReady |
279,161 | boolean (boolean attempt) { if (attempt && myStateLock.isLocked()) return false; try (LockToken ignored = attempt ? attemptLock() : acquireLock()) { return isIdle() && !hasPendingWork() && !isNodeActionsPending(); } catch (InterruptedException e) { LOG.info(e); return false; } } | isReady |
279,162 | boolean () { return hasNodesToUpdate() || myUpdaterState != null && myUpdaterState.isProcessingNow() || hasScheduledUpdates() && !getUpdater().isInPostponeMode(); } | hasPendingWork |
279,163 | boolean () { return !isYieldingNow() && !isWorkerBusy() && !hasUpdatingChildrenNow() && !isLoadingInBackgroundNow(); } | isIdle |
279,164 | void (@NotNull Runnable runnable, @NotNull TreeUpdatePass pass) { try { try { myYieldingPasses.remove(pass); if (!canInitiateNewActivity()) { throw new ProcessCanceledException(); } runnable.run(); } finally { if (!isReleased()) { maybeYieldingFinished(); } } } catch (ProcessCanceledException e) { resetToReady(); } } | executeYieldingRequest |
279,165 | void () { if (myYieldingPasses.isEmpty()) { myYieldingNow = false; flushPendingNodeActions(); } } | maybeYieldingFinished |
279,166 | void () { DefaultMutableTreeNode[] nodes = myPendingNodeActions.toArray(new DefaultMutableTreeNode[0]); myPendingNodeActions.clear(); for (DefaultMutableTreeNode each : nodes) { processNodeActionsIfReady(each); } Runnable[] actions = myYieldingDoneRunnables.toArray(ArrayUtil.EMPTY_RUNNABLE_ARRAY); for (Runnable each : ... | flushPendingNodeActions |
279,167 | void (@NotNull Runnable onDone) { getBuilder().runOnYieldingDone(onDone); } | runOnYieldingDone |
279,168 | void (@NotNull Runnable runnable) { getBuilder().yieldToEDT(runnable); } | yieldToEDT |
279,169 | boolean (Object node) { return node instanceof LoadingNode; } | isLoadingNode |
279,170 | AsyncResult<List<TreeNode>> (NodeDescriptor<?> descriptor, @NotNull MutualMap<Object, Integer> elementToIndexMap, DefaultMutableTreeNode parent, boolean addLoadingNode, @NotNull LoadedChildren loadedChildren) { AsyncResult<List<TreeNode>> result = new AsyncResult<>(); List<TreeNode> nodesToInsert = new ArrayList<>(); C... | collectNodesToInsert |
279,171 | void () { Object element = getElementFromDescriptor(childDescr); if (!isNodeNull(element)) { DefaultMutableTreeNode node = getNodeForElement(element, false); if (node == null || node.getParent() != parent) { DefaultMutableTreeNode childNode = createChildNode(childDescr); if (addLoadingNode || getBuilder().isAlwaysShowP... | perform |
279,172 | void () { result.setDone(nodesToInsert); } | perform |
279,173 | DefaultMutableTreeNode (NodeDescriptor<?> descriptor) { return new ElementNode(this, descriptor); } | createChildNode |
279,174 | boolean () { return myCanYield && myYieldingUpdate.asBoolean(); } | canYield |
279,175 | long () { return myClearOnHideDelay; } | getClearOnHideDelay |
279,176 | ActionCallback () { return myInitialized; } | getInitialized |
279,177 | ActionCallback (@NotNull Object requestor) { return myBusyObject.getReady(requestor); } | getReady |
279,178 | ActionCallback () { return getReady(this); } | _getReady |
279,179 | void (@NotNull DefaultMutableTreeNode node) { synchronized (myUpdatingChildren) { myUpdatingChildren.add(node); } } | addToUpdatingChildren |
279,180 | void (@NotNull DefaultMutableTreeNode node) { synchronized (myUpdatingChildren) { myUpdatingChildren.remove(node); } } | removeFromUpdatingChildren |
279,181 | boolean () { synchronized (myUpdatingChildren) { return !myUpdatingChildren.isEmpty(); } } | hasUpdatingChildrenNow |
279,182 | List<Object> () { List<Object> result = new ArrayList<>(); if (isReleased()) return result; Enumeration<TreePath> enumeration = myTree.getExpandedDescendants(getPathFor(getRootNode())); if (enumeration != null) { while (enumeration.hasMoreElements()) { TreePath each = enumeration.nextElement(); Object eachElement = get... | getExpandedElements |
279,183 | ActionCallback () { if (isReleased()) return ActionCallback.REJECTED; setCancelRequested(true); ActionCallback done = new ActionCallback(); invokeLaterIfNeeded(false, new TreeRunnable("AbstractTreeUi.cancelUpdate") { @Override public void perform() { if (isReleased()) { done.setRejected(); return; } if (myResettingToRe... | cancelUpdate |
279,184 | void () { if (isReleased()) { done.setRejected(); return; } if (myResettingToReadyNow.get()) { _getReady().notify(done); } else if (isReady()) { resetToReadyNow(); done.setDone(); } else { if (isIdle() && hasPendingWork()) { resetToReadyNow(); done.setDone(); } else { _getReady().notify(done); } } maybeReady(); } | perform |
279,185 | void (boolean requested) { try (LockToken ignored = isUnitTestingMode() ? acquireLock() : attemptLock()) { myCancelRequest.set(requested); } catch (InterruptedException ignored) { } } | setCancelRequested |
279,186 | LockToken () { return LockToken.acquireLock(myStateLock); } | acquireLock |
279,187 | ActionCallback (@NotNull Progressive progressive) { assertIsDispatchThread(); EmptyProgressIndicator indicator = new EmptyProgressIndicator(); ActionCallback callback = new ActionCallback(); myBatchIndicators.put(progressive, indicator); myBatchCallbacks.put(progressive, callback); try { progressive.run(indicator); } c... | batch |
279,188 | void () { callback.setRejected(); } | perform |
279,189 | void () { if (myBatchIndicators.containsKey(progressive)) { ProgressIndicator indicator = myBatchIndicators.remove(progressive); myBatchCallbacks.remove(progressive); if (indicator.isCanceled()) { callback.setRejected(); } else { callback.setDone(); } } else { callback.setRejected(); } } | perform |
279,190 | void (@NotNull Runnable runnable) { try { myUserRunnables.add(runnable); runnable.run(); } finally { myUserRunnables.remove(runnable); } } | executeUserRunnable |
279,191 | void (MutableTreeNode newChild, int childIndex) { super.insert(newChild, childIndex); Object element = myUi.getElementFor(newChild); if (element != null) { myElements.add(element); } } | insert |
279,192 | void (int childIndex) { TreeNode node = getChildAt(childIndex); super.remove(childIndex); Object element = myUi.getElementFor(node); if (element != null) { myElements.remove(element); } } | remove |
279,193 | String () { return String.valueOf(getUserObject()); } | toString |
279,194 | boolean (DefaultMutableTreeNode kid) { return getUpdatingParent(kid) != null; } | isUpdatingParent |
279,195 | boolean (Object element) { return getLoadedInBackground(element) != null; } | isLoadedInBackground |
279,196 | UpdateInfo (Object element) { synchronized (myLoadedInBackground) { return isNodeNull(element) ? null : myLoadedInBackground.get(element); } } | getLoadedInBackground |
279,197 | void (Object element, UpdateInfo info) { if (isNodeNull(element)) return; synchronized (myLoadedInBackground) { warnMap("put into myLoadedInBackground: ", myLoadedInBackground); myLoadedInBackground.put(element, info); } } | addToLoadedInBackground |
279,198 | void (Object element) { if (isNodeNull(element)) return; synchronized (myLoadedInBackground) { warnMap("remove from myLoadedInBackground: ", myLoadedInBackground); myLoadedInBackground.remove(element); } } | removeFromLoadedInBackground |
279,199 | boolean () { synchronized (myLoadedInBackground) { return !myLoadedInBackground.isEmpty(); } } | isLoadingInBackgroundNow |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.