Node<E> node = root.getLeftMostNode(); while (node != null) { if (node.prev != null && !node.prev.isFull()) { Node<E> prev = node.prev; int count = Math.min(Node.NODE_SIZE - prev.size, node.size); prev.size += count; if (node.isEmpty()) { Node<E> temp = node.next; deleteNode(node); node = temp; continue; } else if (!node.isFull()) { if (node.leftIndex != 0) { System.arraycopy(node.entries, node.leftIndex,
size++; modCount++; if (!prevNode.isFull()) { prevNode.addEntryLeft(entry); } else { prevNode.addEntryRight(entry); if (prevNode.prev != null && !prevNode.prev.isFull()) { prevNode.prev.addEntryRight(entry); } else { attachNodeLeft(prevNode, cachedOrNewNode(entry)); } else if (prevNode.next != null && !prevNode.next.isFull()) { prevNode.next.addEntryLeft(entry); } else { attachNodeRight(prevNode, cachedOrNewNode(entry));
if (!node.isFull()) { node.addEntryAt(entry, index); } else { if (next != null && !next.isFull()) { E movedEntry = node.insertEntrySlideRight(entry, index); next.addEntryLeft(movedEntry); } else { E movedEntry = node.insertEntrySlideLeft(entry, index); Node<E> newNode = cachedOrNewNode(movedEntry); attachNodeLeft(node, newNode); } else if (!prev.isFull()) { E movedEntry = node.insertEntrySlideLeft(entry, index); prev.addEntryRight(movedEntry); } else if (next == null) { E movedEntry = node.insertEntrySlideRight(entry, index); Node<E> newNode = cachedOrNewNode(movedEntry); attachNodeRight(node, newNode); } else if (!next.isFull()) { E movedEntry = node.insertEntrySlideRight(entry, index); next.addEntryLeft(movedEntry); } else { E movedEntry = node.insertEntrySlideRight(entry, index);
return true; } else { Node<E> node = root.getRightMostNode(); if (compare(node.entries[node.rightIndex], entry, comparator) < 0) { size++; modCount++; if (!node.isFull()) { node.addEntryRight(entry); } else { attachNodeRight(node, cachedOrNewNode(entry));
private E removeElementRight(Node<E> node) { modCount++; size--; E entry = node.removeEntryRight(); if (node.isEmpty()) { deleteNode(node); } else if (node.prev != null && (Node.NODE_SIZE - 1 - node.prev.rightIndex) >= node.size) { // Remaining entries fit in the prev node, move them and delete this node node.prev.addEntriesRight(node); deleteNode(node); } else if (node.next != null && node.next.leftIndex >= node.size) { // Remaining entries fit in the next node, move them and delete this node node.next.addEntriesLeft(node); deleteNode(node); } else if (node.next != null && node.next.size < (Node.NODE_SIZE - 1 - node.rightIndex)) { // Entries in next node will fit in this node, move them and delete next node.addEntriesRight(node.next); deleteNode(node.next); } return entry; }
private E removeElementAt(Node<E> node, int index) { modCount++; size--; E entry = node.removeEntryAt(index); if (node.prev != null && (Node.NODE_SIZE - 1 - node.prev.rightIndex) >= node.size) { // Remaining entries fit in the prev node, move them and delete this node node.prev.addEntriesRight(node); deleteNode(node); } else if (node.next != null && (node.next.leftIndex) >= node.size) { // Remaining entries fit in the next node, move them and delete this node node.next.addEntriesLeft(node); deleteNode(node); } else if (node.prev != null && node.prev.size < node.leftIndex) { // Entries in prev node will fit in this node, move them and delete prev node.addEntriesLeft(node.prev); deleteNode(node.prev); } else if (node.next != null && node.next.size < (Node.NODE_SIZE - 1 - node.rightIndex)) { // Entries in next node will fit in this node, move them and delete next node.addEntriesRight(node.next); deleteNode(node.next); } return entry; }
private E removeElementLeft(Node<E> node) { modCount++; size--; E entry = node.removeEntryLeft(); if (node.isEmpty()) { deleteNode(node); } else if (node.prev != null && (Node.NODE_SIZE - 1 - node.prev.rightIndex) >= node.size) { // Remaining entries fit in the prev node, move them and delete this node node.prev.addEntriesRight(node); deleteNode(node); } else if (node.next != null && node.next.leftIndex >= node.size) { // Remaining entries fit in the next node, move them and delete this node node.next.addEntriesLeft(node); deleteNode(node); } else if (node.prev != null && node.prev.size < node.leftIndex) { // Entries in prev node will fit in this node, move them and delete prev node.addEntriesLeft(node.prev); deleteNode(node.prev); } return entry; }
@Override @SuppressWarnings("unchecked") public <T> T[] toArray(T[] a) { T[] r = a.length >= size ? a : (T[]) java.lang.reflect.Array .newInstance(a.getClass().getComponentType(), size); if (!isEmpty()) { Node<E> node = root.getLeftMostNode(); int pos = 0; while (node != null) { System.arraycopy(node.entries, node.leftIndex, r, pos, node.size); pos += node.size; node = node.next; } if (r.length > pos) { r[pos] = null; } } else if (a.length > 0) { a[0] = null; } return r; }
/** * Returns the current size divided by the capacity of the tree. A value * between 0.0 and 1.0, where 1.0 means that every allocated node in the tree * is completely full. * * An empty set will return 1.0 * * @return the fill ratio of the tree */ public double fillRatio() { if (nodeCount > 1) { // Count the last node as completely full since it can't be compacted return (size + (Node.NODE_SIZE - root.getRightMostNode().size)) / (double) (nodeCount * Node.NODE_SIZE); } return 1.0; }
private void cacheAndClear(Node<E> node) { if (cachedNode == null) { node.clear(); cachedNode = node; } }
private TreeSetIterator(FoldedTreeSet<E> tree) { this.tree = tree; this.iteratorModCount = tree.modCount; if (!tree.isEmpty()) { this.node = tree.root.getLeftMostNode(); this.index = this.node.leftIndex; } }
@Override public Object[] toArray() { Object[] objects = new Object[size]; if (!isEmpty()) { int pos = 0; for (Node<E> node = root.getLeftMostNode(); node != null; pos += node.size, node = node.next) { System.arraycopy(node.entries, node.leftIndex, objects, pos, node.size); } } return objects; }
@Override public E first() { if (!isEmpty()) { Node<E> node = root.getLeftMostNode(); return node.entries[node.leftIndex]; } return null; }
@Override public E last() { if (!isEmpty()) { Node<E> node = root.getRightMostNode(); return node.entries[node.rightIndex]; } return null; }
private Node<E> cachedOrNewNode(E entry) { Node<E> node = (cachedNode != null) ? cachedNode : new Node<E>(); cachedNode = null; nodeCount++; // Since BlockIDs are always increasing for new blocks it is best to // add values on the left side to enable quicker inserts on the right node.addEntryLeft(entry); return node; }