EntryInfo info = newState2Info.get(entry); if (info == null) { info = new EntryInfo(this, entry); if (createNodes) { Node n = info.getNode(); if (isDummyNode(n)) { newState2Info.put(entry, info.changeIndex(-2)); continue; if (info.isHidden()) { continue; newState2Info.put(entry, info.changeIndex(inx++)); newStateVisibleEntries.add(entry);
if (info.isHidden()) { if (!justHide) { if (new2Infos == null) { idxs[removedIdx++] = info.getIndex(); if (previousInfos == null) { previousInfos = new HashMap<Entry, EntryInfo>(oldState2Info); Node node = info.currentNode(); if (!info.isHidden() && node != null && !isDummyNode(node)) { if (removedNodes == null) { removedNodes = new Node[expectedSize]; EntryInfo dup = newEntryInfo != null ? newEntryInfo : info.changeNode(null); new2Infos.put(info.entry(), dup.changeIndex(-2)); } else { new2Infos.remove(entry); new2Infos = new HashMap<Entry, EntryInfo>(oldState2Info); if (!info.isHidden()) { newStateVisibleEntries.add(info.entry()); new2Infos.put(info.entry(), info.changeIndex(index++)); } else { new2Infos.put(info.entry(), info.changeIndex(-2)); newEntries.add(info.entry());
Node node; boolean creating = false; synchronized (lock()) { if (refresh) { refNode = null; lock().wait(); } catch (InterruptedException ex) { synchronized (lock()) { if (!creating) { if (refNode != null) { if (creating) { creatingNodeThread = null; lock().notifyAll(); final Children ch = lazy().children;
if (info.isHidden()) { continue; int oldPos = info.getIndex(); new2Infos.put(entry, info.changeIndex(currentPos)); perm[oldPos] = 1 + currentPos; permSize++;
Node oldNode = info.currentNode(); EntryInfo newInfo = null; Node newNode = null; if (info.isHidden()) { newNode = info.getNode(true, null); newInfo = info.changeIndex(-1); } else { newInfo = info.changeNode(null); newNode = newInfo.getNode(true, null); if (newIsDummy && info.isHidden()) { if (!info.isHidden() || newIsDummy) { removeEntries(stateHolder, null, entry, newInfo, true, true); tmpInfo = state.getEntryToInfo().get(tmpEntry); if (tmpInfo.isHidden()) { continue; new2Info.put(tmpEntry, tmpInfo.changeIndex(index++)); arr.add(tmpEntry);
EntryInfo info = newState2Info.get(entry); if (info == null) { info = new EntryInfo(this, entry); newState2Info.put(entry, info.changeIndex(i));
for (Entry entry : notNull(state.getVisibleEntries())) { EntryInfo info = state.getEntryToInfo().get(entry); if (info.currentNode() != null) { cnt++; break;
@Override public Node getNodeAt(int index) { if (!checkInit()) { return null; } Node node = null; while (true) { try { Children.PR.enterReadAccess(); EntrySupportLazyState state = internal.get(); List<Entry> e = notNull(state.getVisibleEntries()); if (index >= e.size()) { return node; } Entry entry = e.get(index); EntryInfo info = state.getEntryToInfo().get(entry); node = info.getNode(); if (!isDummyNode(node)) { return node; } hideEmpty(null, entry); } finally { Children.PR.exitReadAccess(); } if (Children.MUTEX.isReadAccess()) { return node; } } }
@Override public Node[] testNodes() { EntrySupportLazyState state = internal.get(); if (!state.isInited()) { return null; } List<Node> created = new ArrayList<Node>(); try { Children.PR.enterReadAccess(); for (Entry entry : notNull(state.getVisibleEntries())) { EntryInfo info = state.getEntryToInfo().get(entry); Node node = info.currentNode(); if (node != null) { created.add(node); } } } finally { Children.PR.exitReadAccess(); } return created.isEmpty() ? null : created.toArray(new Node[created.size()]); }
Node getNode(Entry entry) { checkInit(); try { Children.PR.enterReadAccess(); EntrySupportLazyState state = internal.get(); EntryInfo info = state.getEntryToInfo().get(entry); if (info == null) { if (LOGGER.isLoggable(Level.FINER)) { LOGGER.finer("getNode() " + this); LOGGER.finer(" no such entry: " + entry); // NOI18N } return null; } Node node = info.getNode(); return isDummyNode(node) ? null : node; } finally { Children.PR.exitReadAccess(); } }
final EntryInfo changeIndex(int index) { return new EntryInfo(lazy, entry, index, refNode); }
@Override public Node get(Entry entry) { EntryInfo info = entryToInfo.get(entry); Node node = info.currentNode(); if (node == null) { node = info.getNode(false, origSnapshot); } if (isDummyNode(node)) { // force new snapshot hideEmpty(null, entry); } return node; } }
Node get(Entry entry) { EntryInfo info = entryToInfo.get(entry); Node node = info.getNode(); if (isDummyNode(node)) { // force new snapshot hideEmpty(null, entry); } return node; }
@Override public void run() { info.lazy().registerNode(-1, info); } }
public NodeRef(Node node, EntryInfo info) { super(node, Utilities.activeReferenceQueue()); info.lazy().registerNode(1, info); this.info = info; }
Entry entryForNode(Node key) { EntrySupportLazyState state = internal.get(); for (Map.Entry<Entry, EntryInfo> entry : state.getEntryToInfo().entrySet()) { if (entry.getValue().currentNode() == key) { return entry.getKey(); } } return null; }
/** * Gets or computes the nodes. It holds them using weak reference so * they can get garbage collected. */ public final Node getNode() { return getNode(false, null); }
/** * extract current node (if was already created) */ Node currentNode() { synchronized (lock()) { return refNode == null ? null : refNode.get(); } }