public NonConcurrentTree singleThreadedTree() throws Exception { pageFactory = nonConcurrentPageFactory; return new NonConcurrentTree(root, maxCache, maxPageSize, pageFactory); }
@Override public void close() throws IOException { close(false, CloseOperation.NONE); }
@Override public boolean deleteNode(String name) { return tree.deleteNode(this, name); }
try { NonConcurrentTree tree = new TreeBuilder(dir).maxPageSize(5).singleThreadedTree(); NonConcurrentTreeNode root = tree.getRootNode(); NonConcurrentTreeNode node = tree.getOrCreateNode(root, Integer.toString(i), null); assertNotNull(node); assertEquals(Integer.toString(i), node.getName()); NonConcurrentTreeNode child = tree.getOrCreateNode(node, Integer.toString(i), null); assertNotNull(child); ClosableIterator<DataTreeNode> iterator = tree.getIterator(); try { int counter = 0; if (rng.nextFloat() < 0.8) { String name = node.getName(); tree.deleteNode(root, name); counter++; tree.close(false, close);
@Test public void getOrCreateOneThread() throws Exception { log.info("getOrCreateOneThread"); File dir = makeTemporaryDirectory(); try { NonConcurrentTree tree = new NonConcurrentTree(dir, 100, 100, NonConcurrentPage.NonConcurrentPageFactory.singleton); NonConcurrentTreeNode root = tree.getRootNode(); for (int i = 0; i < 1000; i++) { NonConcurrentTreeNode node = tree.getOrCreateNode(root, Integer.toString(i), null); assertNotNull(node); assertEquals(Integer.toString(i), node.getName()); } for (int i = 0; i < 1000; i++) { NonConcurrentTreeNode node = tree.getNode(root, Integer.toString(i), true); assertNotNull(node); assertEquals(Integer.toString(i), node.getName()); } tree.close(false, close); } finally { if (dir != null) { LessFiles.deleteDir(dir); } } }
@Override public ClosableIterator<DataTreeNode> getIterator() { NonConcurrentTreeNode rootNode = getRootNode(); if (rootNode != null) { return getRootNode().getIterator(); } return null; }
@Test public void maximumNodeIdentifier() throws Exception { File dir = makeTemporaryDirectory(); try { NonConcurrentTree tree = new TreeBuilder(dir).singleThreadedTree(); NonConcurrentTreeNode root = tree.getRootNode(); for (int i = 0; i < 1000; i++) { NonConcurrentTreeNode node = tree.getOrCreateNode(root, Integer.toString(i), null); assertNotNull(node); assertEquals(Integer.toString(i), node.getName()); NonConcurrentTreeNode child = tree.getOrCreateNode(node, Integer.toString(i), null); child.release(); node.release(); } assertTrue(tree.setNextNodeDB(Integer.MAX_VALUE)); for (int i = 1000; i < 2000; i++) { NonConcurrentTreeNode node = tree.getOrCreateNode(root, Integer.toString(i), null); assertNotNull(node); assertEquals(Integer.toString(i), node.getName()); NonConcurrentTreeNode child = tree.getOrCreateNode(node, Integer.toString(i), null); child.release(); node.release(); } tree.close(false, close); } finally { if (dir != null) { LessFiles.deleteDir(dir); } } }
@Override public NonConcurrentTreeNode getNode(String name) { return tree.getNode(this, name, false); }
BooleanSupplier terminationCondition) { long nodeDB = rootNode.nodeDB(); IPageDB.Range<DBKey, NonConcurrentTreeNode> range = fetchNodeRange(nodeDB); DBKey endRange; boolean reschedule; NonConcurrentTreeNode next = entry.getValue(); if (next.hasNodes() && !next.isAlias()) { deleteSubTree(next, totalCount, nodeCount, terminationCondition); markForChildDeletion(rootNode);
public NonConcurrentTreeNode getOrCreateEditableNode(String name, DataTreeNodeInitializer creator) { return tree.getOrCreateNode(this, name, creator); }
@Override public void foregroundNodeDeletion(BooleanSupplier terminationCondition) { IPageDB.Range<DBKey, NonConcurrentTreeNode> range = fetchNodeRange(treeTrashNode.nodeDB()); Map.Entry<DBKey, NonConcurrentTreeNode> entry; MutableLong totalCount = new MutableLong(); MutableLong nodeCount = new MutableLong(); try { while (range.hasNext() && !terminationCondition.getAsBoolean()) { entry = range.next(); if (entry != null) { NonConcurrentTreeNode node = entry.getValue(); NonConcurrentTreeNode prev = source.remove(entry.getKey()); if (prev != null) { deleteSubTree(node, totalCount, nodeCount, terminationCondition); nodeCount.increment(); treeTrashNode.incrementCounter(); } } } } finally { range.close(); } }
/** * returns an iterator of read-only nodes */ public ClosableIterator<DataTreeNode> getNodeIterator() { return !hasNodes() ? new Iter(null) : new Iter(tree.fetchNodeRange(nodedb)); }
protected void requireNodeDB() { if (!hasNodes()) { nodedb = tree.getNextNodeDB(); } }
@Test public void recursiveDelete() throws Exception { log.info("recursiveDelete"); File dir = makeTemporaryDirectory(); try { NonConcurrentTree tree = new TreeBuilder(dir).singleThreadedTree(); NonConcurrentTreeNode root = tree.getRootNode(); NonConcurrentTreeNode parent = tree.getOrCreateNode(root, "0", null); for (int j = 0; j < TreeCommonParameters.cleanQMax; j++) { NonConcurrentTreeNode child = tree.getOrCreateNode(parent, Integer.toString(j), null); assertNotNull(child); assertEquals(Integer.toString(j), child.getName()); parent.release(); parent = child; } parent.release(); tree.deleteNode(root, "0"); assertEquals(0, root.getNodeCount()); tree.close(false, close); } finally { if (dir != null) { LessFiles.deleteDir(dir); } } }
@Override public DataTreeNode getOrCreateNode(String name, DataTreeNodeInitializer init) { return getRootNode().getOrCreateNode(name, init); }
@Override public NonConcurrentTreeNode getLeasedNode(String name) { return tree.getNode(this, name, true); }
/** * returns an iterator of read-only nodes */ public ClosableIterator<DataTreeNode> getNodeIterator(String from, String to) { if (!hasNodes()) { return new Iter(null); } return new Iter(tree.fetchNodeRange(nodedb, from, to)); }
@Override public String getName() { return getRootNode().getName(); }
void fetchNext() { if (range != null) { next = null; while (range.hasNext()) { Entry<DBKey, NonConcurrentTreeNode> tne = range.next(); next = tree.getNode(NonConcurrentTreeNode.this, tne.getKey().rawKey().toString(), false); if (next != null) { break; } } } }
tree = new ConcurrentTree(LessFiles.initDirectory(treePath.toFile())); } else { tree = new NonConcurrentTree(LessFiles.initDirectory(treePath.toFile()));