/** * Constructs a new, empty instance of SkipList. */ public DiffListBySkipList(int capacity) { skipNodeList = new ArrayList<>(capacity); head = new SkipListNode(null, 0); }
StringBuilder appendTo(StringBuilder b) { b.append(this).append(": ").append(skip2String(next, getChildrenDiff(0))); for(int i = 0; i < skips.length; i++) { b.append(", ").append(skips[i]); } return b; } }
int headLevel = head.level(); int nodeLevel = node.level(); final SkipListNode[] nodePath = findPreviousNodes(node, nodeLevel); final SkipListNode next = node.getSkipNode(level); if (level == 0) { if (next != null) { previous.setSkipDiff4Target(next, 1, previous.getChildrenDiff(0)); previous.setSkipDiff(null, level); } else { if (node.getChildrenDiff(level) != null) { final ChildrenDiff combined; if (previous == nodePath[level - 1] && next == node.getSkipNode(level - 1)) { combined = nodePath[level - 1].getChildrenDiff(level - 1); previous.setSkipDiff4Target(next, level + 1, combined); } else if (next == previous.getSkipNode(level + 1)) { combined = previous.getChildrenDiff(level + 1); } else { combined = new ChildrenDiff(); combined.combinePosterior(previous.getChildrenDiff(level), null); combined.combinePosterior(node.getChildrenDiff(level), null); previous.setSkipDiff(combined, level); previous.setSkipTo(next, level);
SkipListNode next = null; ChildrenDiff childrenDiff = null; for (int level = current.level(); level >= 0; level--) { next = current.getSkipNode(level); if (next != null && next.getDiff().compareTo(toSnapshotId) <= 0) { childrenDiff = current.getChildrenDiff(level); break; final DirectoryDiff curDiff = current.getDiff(); subList.add(childrenDiff == null ? curDiff : new DirectoryDiff(curDiff.getSnapshotId(), dir, childrenDiff)); if (current.getDiff().compareTo(toSnapshotId) == 0) { break;
Arrays.fill(nodePath, head); final SkipListNode newNode = new SkipListNode(diff, nodeLevel); for (int level = 0; level <= nodeLevel; level++) { if (level > 0) { final SkipListNode nextNode = head.getSkipNode(level); if (nextNode != null) { ChildrenDiff combined = combineDiff(newNode, nextNode, level); if (combined != null) { newNode.setSkipDiff(combined, level); newNode.setSkipTo(nodePath[level].getSkipNode(level), level); nodePath[level].setSkipTo(newNode, level);
final SkipListNode[] nodePath = findPreviousNodes(null, nodeLevel); final SkipListNode newNode = new SkipListNode(diff, nodeLevel); for (int level = 0; level <= nodeLevel; level++) { if (level > 0 && nodePath[level] != head) { nodePath[level].setSkipDiff(combined, level); nodePath[level].setSkipTo(newNode, level); newNode.setSkipTo(null, level);
private static ChildrenDiff combineDiff(SkipListNode from, SkipListNode to, int level) { ChildrenDiff combined = null; ChildrenDiff first = null; SkipListNode cur = from; for (int i = level - 1; i >= 0; i--) { while (cur != to) { final SkipListNode next = cur.getSkipNode(i); if (next == null) { break; } if (first == null) { first = cur.getChildrenDiff(i); } else { if (combined == null) { combined = new ChildrenDiff(); combined.combinePosterior(first, null); } combined.combinePosterior(cur.getChildrenDiff(i), null); } cur = next; } } return combined != null? combined: first; }
private SkipListNode[] findPreviousNodes(SkipListNode node, int nodeLevel) { final SkipListNode[] nodePath = new SkipListNode[nodeLevel + 1]; SkipListNode cur = head; final int headLevel = head.level(); for (int level = headLevel < nodeLevel ? headLevel : nodeLevel; level >= 0; level--) { while (cur.getSkipNode(level) != node) { cur = cur.getSkipNode(level); } nodePath[level] = cur; } for (int level = headLevel + 1; level <= nodeLevel; level++) { nodePath[level] = head; } return nodePath; }
public void setSkipTo(SkipListNode node, int level) { if (level == 0) { next = node; } else { resize(level); skips[level - 1].setSkipTo(node); } }
/** * Returns the data element at the specified index in this SkipList. * * @param index The index of the element to be returned. * @return The element at the specified index in this SkipList. */ @Override public DirectoryDiff get(int index) { return skipNodeList.get(index).getDiff(); }
public void setSkipDiff(ChildrenDiff cDiff, int level) { Preconditions.checkArgument(level > 0); resize(level); skips[level - 1].setDiff(cDiff); }
void setSkipDiff4Target( SkipListNode target, int startLevel, ChildrenDiff childrenDiff) { for(int i = startLevel; i <= level(); i++) { if (getSkipNode(i) != target) { return; } setSkipDiff(childrenDiff, i); } }
@Override public DirectoryDiff next() { return i.next().getDiff(); } };