Unnamed: 0 int64 0 305k | body stringlengths 7 52.9k | name stringlengths 1 185 |
|---|---|---|
246,900 | boolean (@NotNull JTree tree, @NotNull TreePath parent, @NotNull Predicate<? super TreePath> predicate, @NotNull Consumer<? super TreePath[]> consumer) { ArrayList<TreePath> list = new ArrayList<>(); testDescendants(tree, parent, child -> { if (predicate.test(child)) list.add(child); return true; // visit all descendan... | acceptDescendants |
246,901 | Structure () { return structure; } | getTreeStructure |
246,902 | void (@Nullable Comparator<? super NodeDescriptor<?>> comparator) { if (disposed) return; if (comparator != null) { this.comparator = wrapToNodeComparator(comparator); invalidateAsync(); } else if (this.comparator != null) { this.comparator = null; invalidateAsync(); } } | setComparator |
246,903 | void () { comparator = null; Node node = root.set(null); if (node != null) node.dispose(); // notify tree to clean up inner structures treeStructureChanged(null, null, null); super.dispose(); // remove listeners after notification } | dispose |
246,904 | Invoker () { return invoker; } | getInvoker |
246,905 | boolean () { if (invoker.isValidThread()) return true; LOG.warn(new IllegalStateException("StructureTreeModel is used from unexpected thread")); return false; } | isValidThread |
246,906 | Promise<TreePath> (@NotNull TreePath path, boolean structure) { return Promises.asPromise(onValidThread(path, node -> invalidateInternal(node, structure))); } | invalidate |
246,907 | Promise<TreePath> (@NotNull Object element, boolean structure) { return Promises.asPromise(invalidateAsync(element, structure)); } | invalidate |
246,908 | CompletableFuture<TreePath> (@NotNull Object element, boolean structure) { return onValidThread(element, node -> invalidateInternal(node, structure)); } | invalidateAsync |
246,909 | void (@NotNull Object element, @NotNull JTree tree, @NotNull Consumer<? super TreePath> consumer) { promiseVisitor(element).onSuccess(visitor -> TreeUtil.expand(tree, visitor, consumer)); } | expand |
246,910 | void (@NotNull Object element, @NotNull JTree tree, @NotNull Consumer<? super TreePath> consumer) { promiseVisitor(element).onSuccess(visitor -> TreeUtil.makeVisible(tree, visitor, consumer)); } | makeVisible |
246,911 | void (@NotNull Object element, @NotNull JTree tree, @NotNull Consumer<? super TreePath> consumer) { promiseVisitor(element).onSuccess(visitor -> TreeUtil.promiseSelect(tree, visitor).onSuccess(consumer)); } | select |
246,912 | Promise<TreeVisitor> (@NotNull Object element) { return Promises.asPromise(onValidThread(struct -> { return new TreeVisitor.ByTreePath<>( TreePathUtil.pathToCustomNode(element, struct::getParentElement), node -> node instanceof Node ? ((Node)node).getElement() : null ); })); } | promiseVisitor |
246,913 | TreeNode () { if (disposed || !isValidThread()) return null; if (!root.isValid()) { Node newRoot = getValidRoot(); root.set(newRoot); if (LOG.isTraceEnabled()) LOG.debug("root updated: ", newRoot); } return root.get(); } | getRoot |
246,914 | Node (Object object, boolean validateChildren) { if (disposed || !(object instanceof Node node) || !isValidThread()) return null; if (isNodeRemoved(node)) return null; if (validateChildren) validateChildren(node); return node; } | getNode |
246,915 | void (@NotNull Node node) { if (!node.children.isValid()) { List<Node> newChildren = getValidChildren(node); List<Node> oldChildren = node.children.set(newChildren); if (oldChildren != null) oldChildren.forEach(child -> child.setParent(null)); if (newChildren != null) newChildren.forEach(child -> child.setParent(node))... | validateChildren |
246,916 | boolean (@NotNull Node node) { return !node.isNodeAncestor(root.get()); } | isNodeRemoved |
246,917 | List<TreeNode> (Object object) { Node node = getNode(object, true); List<Node> list = node == null ? null : node.children.get(); if (list == null || list.isEmpty()) return emptyList(); list.forEach(Node::update); return unmodifiableList(list); } | getChildren |
246,918 | int (Object object) { Node node = getNode(object, true); return node == null ? 0 : node.getChildCount(); } | getChildCount |
246,919 | TreeNode (Object object, int index) { Node node = getNode(object, true); return node == null ? null : node.getChildAt(index); } | getChild |
246,920 | boolean (Object object) { Node node = getNode(object, false); return node == null || node.isModelLeaf(this::validateChildren); } | isLeaf |
246,921 | int (Object object, Object child) { return object instanceof Node && child instanceof Node ? ((Node)object).getIndex((TreeNode)child) : -1; } | getIndexOfChild |
246,922 | boolean (@NotNull Node node) { return isValid(structure, node.getElement()); } | isValid |
246,923 | boolean (@NotNull AbstractTreeStructure structure, Object element) { if (element == null) return false; if (element instanceof AbstractTreeNode) { AbstractTreeNode<?> node = (AbstractTreeNode<?>)element; if (null == node.getValue()) { return false; } } if (element instanceof ValidateableNode) { ValidateableNode node = ... | isValid |
246,924 | void () { setParent(null); List<Node> list = children.set(null); if (list != null) list.forEach(Node::dispose); } | dispose |
246,925 | boolean (@NotNull Node node, Object element) { if (allowsChildren != node.allowsChildren || hashCode != node.hashCode) return false; if (element != null && !matches(element)) return false; userObject = node.userObject; // replace old descriptor setLeafState(leafState); return true; } | canReuse |
246,926 | boolean () { NodeDescriptor<?> descriptor = getDescriptor(); return descriptor != null && descriptor.update(); } | update |
246,927 | void () { if (leafState != LeafState.ALWAYS) { getChildren().forEach(Node::invalidate); children.invalidate(); if (LOG.isTraceEnabled()) LOG.debug("node invalidated: ", this); } } | invalidate |
246,928 | boolean (@NotNull Object element) { return matches(element, element.hashCode()); } | matches |
246,929 | boolean (@NotNull Object element, int hashCode) { return this.hashCode == hashCode && element.equals(getElement()); } | matches |
246,930 | Node (@NotNull Object element) { List<Node> list = children.get(); if (list != null) { if (!list.isEmpty()) { int hashCode = element.hashCode(); Node result = ContainerUtil.find(list, node -> node.matches(element, hashCode)); if (result != null) return result; // found child node that matches given element } if (LOG.is... | findChild |
246,931 | List<Node> () { List<Node> list = children.get(); return list != null ? list : emptyList(); } | getChildren |
246,932 | Object () { NodeDescriptor<?> descriptor = getDescriptor(); return descriptor == null ? null : descriptor.getElement(); } | getElement |
246,933 | void (Object object) { throw new UnsupportedOperationException("cannot modify node"); } | setUserObject |
246,934 | void (boolean value) { throw new UnsupportedOperationException("cannot modify node"); } | setAllowsChildren |
246,935 | Object () { throw new UnsupportedOperationException("cannot clone node"); } | clone |
246,936 | void (MutableTreeNode child, int index) { throw new UnsupportedOperationException("cannot insert node"); } | insert |
246,937 | void (int index) { throw new UnsupportedOperationException("cannot remove node"); } | remove |
246,938 | Enumeration () { return enumeration((Collection)getChildren()); } | children |
246,939 | TreeNode (int index) { List<Node> list = getChildren(); return 0 <= index && index < list.size() ? list.get(index) : null; } | getChildAt |
246,940 | int () { return getChildren().size(); } | getChildCount |
246,941 | void (@NotNull LeafState leafState) { this.leafState = leafState; if (leafState == LeafState.ALWAYS) children.set(null); // validate children for leaf node } | setLeafState |
246,942 | int (@NotNull TreeNode child) { return child instanceof Node && isNodeChild(child) ? getChildren().indexOf(child) : -1; } | getIndex |
246,943 | LeafState () { return leafState; } | getLeafState |
246,944 | TreeNode () { if (!root.isValid()) { root.set(getValidRoot()); } return root.get(); } | getRootImmediately |
246,945 | String () { return description; } | toString |
246,946 | String (@NotNull String prefix) { for (StackTraceElement element : new Exception().getStackTrace()) { if (!StructureTreeModel.class.getName().equals(element.getClassName())) { return prefix + " @ " + element.getFileName() + " : " + element.getLineNumber(); } } return prefix; } | format |
246,947 | boolean (Object object) { return 0 == getChildCount(object); } | isLeaf |
246,948 | int (Object object) { List<? extends T> list = getChildren(object); return list == null ? 0 : list.size(); } | getChildCount |
246,949 | int (Object object, Object child) { List<? extends T> list = getChildren(object); return list == null ? -1 : list.indexOf(child); } | getIndexOfChild |
246,950 | FilteringTreeModel (AbstractTreeStructure structure, @NotNull ElementFilter<?> filter, @NotNull Invoker invoker, @NotNull Disposable parent) { FilteringTreeStructure filteringTreeStructure = new FilteringTreeStructure(filter, structure); return new FilteringTreeModel(filteringTreeStructure, invoker, parent); } | createModel |
246,951 | FilteringTreeModel (AbstractTreeStructure structure, @NotNull ElementFilter<?> filter, @NotNull Disposable parent) { FilteringTreeStructure filteringTreeStructure = new FilteringTreeStructure(filter, structure); return new FilteringTreeModel(filteringTreeStructure, Invoker.forBackgroundThreadWithReadAction(parent), par... | createModel |
246,952 | void (@NotNull JTree tree, boolean expand, @Nullable Object preferredSelection) { getInvoker().invoke(() -> { getTreeStructure().refilter(); invalidateAsync().thenRun(() -> { if (expand) { List<FilteringTreeStructure.FilteringNode> leaves = getTreeStructure().getVisibleLeaves(); Set<FilteringTreeStructure.FilteringNode... | updateTree |
246,953 | void (JTree tree, @Nullable Object preferredSelection) { if (preferredSelection == null) { return; } FilteringTreeStructure.FilteringNode node = getTreeStructure().getVisibleNodeFor(preferredSelection); promiseVisitor(node).onSuccess(visitor -> TreeUtil.promiseMakeVisible(tree, visitor).onSuccess(path -> { tree.setSele... | adjustSelection |
246,954 | void (@NotNull TreeModelEvent event, @NotNull EventType type) { TreePath path = event.getTreePath(); if (path == null) { // request a new root from model according to the specification submit(new CmdGetRoot("Reload root", null)); return; } Object object = path.getLastPathComponent(); if (object == null) { LOG.warn("uns... | process |
246,955 | void () { EDT.assertIsEdt(); super.dispose(); model.removeTreeModelListener(listener); } | dispose |
246,956 | Promise<TreePath> (Object object) { if (disposed) return rejectedPromise(); return resolve(model instanceof Searchable ? ((Searchable)model).getTreePath(object) : null); } | getTreePath |
246,957 | Promise<TreePath> (TreePath path) { AsyncPromise<TreePath> async = new AsyncPromise<>(); onValidThread(() -> resolve(async, path)); return async; } | resolve |
246,958 | Promise<TreePath> (Promise<? extends TreePath> promise) { if (promise == null && isValidThread()) { return rejectedPromise(); } AsyncPromise<TreePath> async = new AsyncPromise<>(); if (promise == null) { onValidThread(() -> async.setError("rejected")); } else { promise.onError(onValidThread(async::setError)); promise.o... | resolve |
246,959 | void (@NotNull AsyncPromise<? super TreePath> async, TreePath path) { if (LOG.isTraceEnabled()) LOG.debug("resolve path: ", path); if (path == null) { async.setError("path is null"); return; } Object object = path.getLastPathComponent(); if (object == null) { async.setError("path is wrong"); return; } accept(new TreeVi... | resolve |
246,960 | Object () { if (disposed) return null; onValidThread(this::promiseRootEntry); Node node = tree.root; return node == null ? null : node.object; } | getRoot |
246,961 | Object (Object object, int index) { List<Node> children = getEntryChildren(object); return 0 <= index && index < children.size() ? children.get(index).object : null; } | getChild |
246,962 | int (Object object) { return getEntryChildren(object).size(); } | getChildCount |
246,963 | boolean (Object object) { Node node = getEntry(object); if (node == null) return true; if (node.leafState == LeafState.ALWAYS) return true; if (node.leafState == LeafState.NEVER) return false; if (node.leafState == LeafState.ASYNC && node.children == null) promiseChildren(node); List<Node> children = node.children; // ... | isLeaf |
246,964 | void (@NotNull TreePath path, Object value) { background.invoke(() -> model.valueForPathChanged(path, value)); } | valueForPathChanged |
246,965 | int (Object object, Object child) { if (child != null) { List<Node> children = getEntryChildren(object); for (int i = 0; i < children.size(); i++) { if (child.equals(children.get(i).object)) return i; } } return -1; } | getIndexOfChild |
246,966 | Promise<TreePath> (@NotNull TreeVisitor visitor) { return accept(visitor, true); } | accept |
246,967 | Promise<TreePath> (@NotNull TreeVisitor visitor, boolean allowLoading) { var walker = createWalker(visitor, allowLoading); if (allowLoading) { // start visiting on the background thread to ensure that root node is already invalidated background.invokeLater(() -> onValidThread(() -> promiseRootEntry().onSuccess(walker::... | accept |
246,968 | TreeWalkerBase<Node> (@NotNull TreeVisitor visitor, boolean allowLoading) { if (visitor.visitThread() == TreeVisitor.VisitThread.BGT) { return new BgtTreeWalker<>(visitor, background, foreground, node -> node.object) { @Override protected @Nullable Collection<Node> getChildren(@NotNull AsyncTreeModel.Node node) { retur... | createWalker |
246,969 | boolean () { if (foreground.getTaskCount() > 0) return true; if (background.getTaskCount() > 0) return true; Command command = tree.queue.get(); return command != null && command.isPending(); } | isProcessing |
246,970 | void (@NotNull Command command) { computeTreeDataOnBgt(command).thenAsync(value -> applyToUiTree(command, value)); } | submit |
246,971 | CancellablePromise<Node> (@NotNull Command command) { if (command.canRunAsync()) { return background.computeAsync(command::computeAsync); } return background.compute(command::computeNode); } | computeTreeDataOnBgt |
246,972 | Promise<Void> (@NotNull Command command, Node value) { return foreground.compute(() -> { command.applyToUiTree(value); return null; }); } | applyToUiTree |
246,973 | boolean () { if (foreground.isValidThread()) return true; LOG.warn(new IllegalStateException("AsyncTreeModel is used from unexpected thread")); return false; } | isValidThread |
246,974 | void (@NotNull Runnable runnable) { foreground.invoke(runnable); } | onValidThread |
246,975 | Promise<Node> () { if (disposed) return rejectedPromise(); return tree.queue.promise(this::submit, () -> new CmdGetRoot("Load root", null)); } | promiseRootEntry |
246,976 | Promise<Node> (@NotNull Node node) { if (disposed) return rejectedPromise(); return node.queue.promise(this::submit, () -> { node.setLoading(!showLoadingNode ? null : new Node(new LoadingNode(), LeafState.ALWAYS)); return new CmdGetChildren("Load children", node, false); }); } | promiseChildren |
246,977 | Node (Object object) { return disposed || object == null || !isValidThread() ? null : tree.map.get(object); } | getEntry |
246,978 | List<Node> (Object object) { Node node = getEntry(object); if (node == null) return emptyList(); if (node.isLoadingRequired()) promiseChildren(node); return node.getChildren(); } | getEntryChildren |
246,979 | TreeModelEvent (@NotNull TreePath path, Map<Object, Integer> map) { if (map == null || map.isEmpty()) return new TreeModelEvent(this, path, null, null); int i = 0; int size = map.size(); int[] indices = new int[size]; Object[] children = new Object[size]; for (Entry<Object, Integer> entry : map.entrySet()) { indices[i]... | createEvent |
246,980 | void (@NotNull Node node, Map<Object, Integer> map) { if (!listeners.isEmpty()) { for (TreePath path : node.paths) { listeners.treeNodesChanged(createEvent(path, map)); } } } | treeNodesChanged |
246,981 | void (@NotNull Node node, Map<Object, Integer> map) { if (!listeners.isEmpty()) { for (TreePath path : node.paths) { listeners.treeNodesInserted(createEvent(path, map)); } } } | treeNodesInserted |
246,982 | void (@NotNull Node node, Map<Object, Integer> map) { if (!listeners.isEmpty()) { for (TreePath path : node.paths) { listeners.treeNodesRemoved(createEvent(path, map)); } } } | treeNodesRemoved |
246,983 | int (@NotNull Map<Object, Integer> indices, @NotNull Iterable<Object> objects) { int count = 0; int last = -1; for (Object object : objects) { Integer index = indices.get(object); if (index != null && last < index.intValue()) { last = index; count++; } } return count; } | getIntersectionCount |
246,984 | List<Object> (@NotNull Map<Object, Integer> indices, @NotNull Iterable<Object> objects) { List<Object> list = new ArrayList<>(indices.size()); int last = -1; for (Object object : objects) { Integer index = indices.get(object); if (index != null && last < index.intValue()) { last = index; list.add(object); } } return li... | getIntersection |
246,985 | List<Object> (@NotNull Map<Object, Integer> removed, @NotNull Map<Object, Integer> inserted) { if (removed.isEmpty() || inserted.isEmpty()) return emptyList(); int countOne = getIntersectionCount(removed, inserted.keySet()); int countTwo = getIntersectionCount(inserted, removed.keySet()); if (countOne > countTwo) retur... | getIntersection |
246,986 | String () { return object == null ? name : name + ": " + object; } | toString |
246,987 | Node () { started = true; if (isObsolete()) { if (LOG.isTraceEnabled()) LOG.debug("obsolete command: ", this); return null; } else { if (LOG.isTraceEnabled()) LOG.debug("background command: ", this); return computeNode(object); } } | computeNode |
246,988 | void (Node node) { if (isObsolete()) { if (LOG.isTraceEnabled()) LOG.debug("obsolete command: ", this); } else { if (LOG.isTraceEnabled()) LOG.debug("foreground command: ", this); applyNodeToUiTree(node); } } | applyToUiTree |
246,989 | boolean () { return disposed || this != tree.queue.get(); } | isObsolete |
246,990 | boolean () { return disposed || this != node.queue.get(); } | isObsolete |
246,991 | Promise<Node> (Object object) { Node loaded = new Node(object, LeafState.get(object, model)); if (loaded.leafState == LeafState.ALWAYS || isObsolete()) return resolvedPromise(loaded); if (model instanceof AsyncChildrenProvider<?> provider) { Promise<? extends List<?>> childrenPromise = provider.getChildrenAsync(object)... | computeAsync |
246,992 | List<Node> (@Nullable List<?> children) { if (children == null) throw new ProcessCanceledException(); // cancel this command return load(children.size(), index -> children.get(index)); } | load |
246,993 | Iterable<AsyncPromise<Node>> (T command) { ArrayList<AsyncPromise<Node>> list = new ArrayList<>(); while (true) { T last = deque.pollLast(); if (last == null) break; if (last.isPending()) list.add(last.promise); if (last.equals(command)) break; } return list; } | getPromises |
246,994 | void (@NotNull Node child) { child.forEachChildExceptLoading(this::removeEmpty); if (child.paths.isEmpty()) { child.queue.close(); Node node = map.remove(child.object); if (node != child) { LOG.warn("invalid node: " + child.object); if (node != null) map.put(node.object, node); } } } | removeEmpty |
246,995 | void (@NotNull Node node, @NotNull Object object) { if (object == node.object) return; // always use new instance of user's object, because // some trees provide equal nodes with different behavior map.remove(node.object); node.updatePaths(node.object, object); node.object = object; map.put(object, node); // update key... | fixEqualButNotSame |
246,996 | void (@NotNull LeafState leafState) { this.leafState = leafState; this.children = leafState == LeafState.ALWAYS ? null : emptyList(); this.loading = null; } | setLeafState |
246,997 | void (@NotNull List<Node> children) { this.leafState = LeafState.NEVER; this.children = children; this.loading = null; } | setChildren |
246,998 | void (Node loading) { this.leafState = LeafState.NEVER; this.children = ContainerUtil.createMaybeSingletonList(loading); this.loading = loading; } | setLoading |
246,999 | boolean () { return leafState != LeafState.ALWAYS && children == null; } | isLoadingRequired |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.