/* * stack contains all ancestors of the node, stack.peek() is its parent. */ private void mutateUp(@NotNull final Deque<ChildReferenceTransient> stack, MutableNode node) { while (!stack.isEmpty()) { final ChildReferenceTransient parent = stack.pop(); final MutableNode mutableParent = parent.mutate(this); mutableParent.setChild(parent.firstByte, node); node = mutableParent; } }
private boolean deleteImpl(@NotNull final ByteIterable key) { final ByteIterator it = key.iterator(); NodeBase node = root; final Deque<ChildReferenceTransient> stack = new ArrayDeque<>(); for (; ; ) { if (node == null || node.matchesKeySequence(it).matchingLength < 0) { return false; } if (!it.hasNext()) { break; } final byte nextByte = it.next(); stack.push(new ChildReferenceTransient(nextByte, node)); node = node.getChild(this, nextByte); } if (!node.hasValue()) { return false; } --size; MutableNode mutableNode = node.getMutableCopy(this); ChildReferenceTransient parent = stack.peek(); final boolean hasChildren = mutableNode.hasChildren(); if (!hasChildren && parent != null) { stack.pop(); mutableNode = parent.mutate(this); mutableNode.removeChild(parent.firstByte); if (!mutableNode.hasValue() && mutableNode.getChildrenCount() == 1) { mutableNode.mergeWithSingleChild(this); } } else { mutableNode.setValue(null); if (!hasChildren) { mutableNode.setKeySequence(ByteIterable.EMPTY); } else if (mutableNode.getChildrenCount() == 1) { mutableNode.mergeWithSingleChild(this); } } mutateUp(stack, mutableNode); return true; }
public void testIt() { MutableNode n = new MutableNode("".toCharArray(), 0, 0, MARKER_OBJECT); n.insert("xyz".toCharArray(), 0, MARKER_OBJECT2); assertEquals(1, n.getChildren().length); n.insert("xya".toCharArray(), 0, MARKER_OBJECT3); assertEquals(1, n.getChildren().length); assertEquals(null, n.get("xy".toCharArray(), 0)); assertEquals(MARKER_OBJECT2, n.get("xyz".toCharArray(), 0)); assertEquals(MARKER_OBJECT3, n.get("xya".toCharArray(), 0)); }
@Override public boolean put(@NotNull final ByteIterable key, @NotNull final ByteIterable value) { final ByteIterator it = key.iterator(); MutableNode node = root; MutableNode prev = null; byte prevFirstByte = (byte) 0; boolean result = false; while (true) { final NodeBase.MatchResult matchResult = node.matchesKeySequence(it); final int matchingLength = matchResult.matchingLength; if (matchingLength < 0) { final MutableNode prefix = node.splitKey(-matchingLength - 1, matchResult.keyByte); if (matchResult.hasNext) { prefix.hang(matchResult.nextByte, it).setValue(value); } else { prefix.setValue(value); } if (prev == null) { root = new MutableRoot(prefix, root.sourceAddress); } else { prev.setChild(prevFirstByte, prefix); } ++size; result = true; break; } if (!it.hasNext()) { final ByteIterable oldValue = node.getValue(); node.setValue(value); if (oldValue == null) { ++size; result = true; } break; } final byte nextByte = it.next(); final NodeBase child = node.getChild(this, nextByte); if (child == null) { if (node.hasChildren() || node.hasKey() || node.hasValue()) { node.hang(nextByte, it).setValue(value); } else { node.setKeySequence(new ArrayByteIterable(nextByte, it)); node.setValue(value); } ++size; result = true; break; } prev = node; prevFirstByte = nextByte; final MutableNode mutableChild = child.getMutableCopy(this); if (!child.isMutable()) { node.setChild(nextByte, mutableChild); } node = mutableChild; } TreeCursorMutable.notifyCursors(this); return result; }
@Override public boolean add(@NotNull final ByteIterable key, @NotNull final ByteIterable value) { final ByteIterator it = key.iterator(); NodeBase node = root; MutableNode mutableNode = null; final Deque<ChildReferenceTransient> stack = new ArrayDeque<>(); while (true) { final NodeBase.MatchResult matchResult = node.matchesKeySequence(it); final int matchingLength = matchResult.matchingLength; if (matchingLength < 0) { final MutableNode prefix = node.getMutableCopy(this).splitKey(-matchingLength - 1, matchResult.keyByte); if (matchResult.hasNext) { prefix.hang(matchResult.nextByte, it).setValue(value); } else { prefix.setValue(value); } if (stack.isEmpty()) { root = new MutableRoot(prefix, root.sourceAddress); } else { final ChildReferenceTransient parent = stack.pop(); mutableNode = parent.mutate(this); mutableNode.setChild(parent.firstByte, prefix); } break; } if (!it.hasNext()) { if (node.hasValue()) { return false; } mutableNode = node.getMutableCopy(this); mutableNode.setValue(value); break; } final byte nextByte = it.next(); final NodeBase child = node.getChild(this, nextByte); if (child == null) { mutableNode = node.getMutableCopy(this); if (mutableNode.hasChildren() || mutableNode.hasKey() || mutableNode.hasValue()) { mutableNode.hang(nextByte, it).setValue(value); } else { mutableNode.setKeySequence(new ArrayByteIterable(nextByte, it)); mutableNode.setValue(value); } break; } stack.push(new ChildReferenceTransient(nextByte, node)); node = child; } ++size; mutateUp(stack, mutableNode); TreeCursorMutable.notifyCursors(this); return true; }
public void testSplit() { MutableNode root = new MutableNode("".toCharArray(), 0, 0, null); root.insert("brittany".toCharArray(), 0, null); root.insert("brit".toCharArray(), 0, null); root.insert("bryan".toCharArray(), 0, null); // <null> // -> br // -> it // -> tany // -> yan assertEquals(1, root.getChildren().length); final MutableNode br = root.getChildren()[0]; assertEquals("br", new String(br.getPrefix())); assertEquals(2, br.getChildren().length); MutableNode it = br.getChildren()[0]; assertEquals("it", new String(it.getPrefix())); assertEquals(1, it.getChildren().length); MutableNode tany = it.getChildren()[0]; assertEquals("tany", new String(tany.getPrefix())); assertNull(tany.getChildren()); MutableNode yan = br.getChildren()[1]; assertEquals("yan", new String(yan.getPrefix())); assertNull(yan.getChildren()); }