public RevTreeBuilder createFeaturesTreeBuilder(ObjectStore source, final String namePrefix, final int numEntries, final int startIndex, boolean randomIds) { RevTreeBuilder builder; if (spatialTrees) { Envelope maxBounds = getMaxBounds(); builder = RevTreeBuilder.quadBuilder(source, source, RevTree.EMPTY, maxBounds); } else { builder = RevTreeBuilder.builder(source); } for (int i = startIndex; i < startIndex + numEntries; i++) { builder.put(featureNode(namePrefix, i, randomIds)); } return builder; }
final RevTreeBuilder builder = RevTreeBuilder.builder(repositoryDatabase, currentLeftTree); final DiffEntry diff = updatedIterator.next(); if (diff.isDelete()) { builder.remove(diff.oldNode()); } else { NodeRef newObject = diff.getNewObject(); Node node = newObject.getNode(); builder.put(node); final RevTree newTree = builder.build(); repositoryDatabase.put(newTree); return newTree;
private RevTreeBuilder createQuadTree(Envelope maxBounds, final Iterable<Node> nodes, final ObjectStore objectStore) { RevTreeBuilder qtree = RevTreeBuilder.quadBuilder(objectStore, objectStore, RevTree.EMPTY, maxBounds); for (Node node : nodes) { assertTrue(qtree.put(node)); } return qtree; } }
protected ObjectId createAndSaveTree(final List<Node> nodes, final boolean insertInListOrder) throws Exception { List<Node> insert = nodes; if (!insertInListOrder) { insert = new ArrayList<>(nodes); Collections.shuffle(insert); } RevTreeBuilder treeBuilder = createBuiler(); nodes.forEach((n) -> treeBuilder.put(n)); RevTree tree = treeBuilder.build(); assertTrue(objectStore.exists(tree.getId())); assertEquals(nodes.size(), tree.size()); return tree.getId(); }
private RevTree createLeafTree(Collection<Node> featureNodes) { int childTreeCount = 0; ImmutableList<Node> trees = null; List<Node> sorted = new ArrayList<Node>(featureNodes); Collections.sort(sorted, CanonicalNodeOrder.INSTANCE); ImmutableList<Node> features = ImmutableList.copyOf(sorted); SortedSet<Bucket> buckets = null; int size = features.size(); RevTree tree = RevTreeBuilder.build(size, childTreeCount, trees, features, buckets); return tree; }
public @Test void testRemoveWorldPoints() { List<Node> nodes = IndexTestSupport.createWorldPointsNodes(5); final RevTreeBuilder builder = createBuiler(); nodes.forEach((n) -> assertTrue(builder.put(n))); RevTree tree = builder.build(); assertEquals(nodes.size(), tree.size()); List<Node> removes = nodes.subList(0, nodes.size() / 2); final RevTreeBuilder builder2 = createBuiler(tree); removes.forEach((n) -> assertTrue(builder2.remove(n))); RevTree tree2 = builder2.build(); assertEquals(nodes.size() - removes.size(), tree2.size()); }
private RevTree setUpMultipleChanges(int numlayers, int numAdded, int numChanged, int numDeleted) { final List<NodeRef> initialLayers = createLayers(numlayers); WorkingTree workingTree = repo.workingTree(); final RevTree initialRoot = workingTree.getTree(); final List<NodeRef> addedLayers = createLayers(numlayers, numlayers + numAdded); assertEquals(numAdded, addedLayers.size()); final List<NodeRef> deletedLayers = new ArrayList<>(initialLayers.subList(0, numDeleted)); final List<NodeRef> changedLayers = new ArrayList<>( initialLayers.subList(numlayers - numChanged, numlayers)); { RevTree newWorkhead = workingTree.getTree(); RevTreeBuilder tb = RevTreeBuilder.builder(repo.objectDatabase(), newWorkhead); deletedLayers.forEach(n -> tb.remove(n.getNode())); newWorkhead = tb.build(); workingTree.updateWorkHead(newWorkhead.getId()); changedLayers.forEach(ref -> putFeatures(ref, 10)); } return initialRoot; }
private IndexInfo createIndex(String treeName, IndexDatabase target) { IndexInfo index = target.createIndexInfo(treeName, "the_geom", IndexType.QUADTREE, null); Envelope maxBounds = new Envelope(-180, 180, -90, 90); Envelope bounds = new Envelope(); RevTree tree = RevTree.EMPTY; for (int y = -90; y <= 90; y += 5) { RevTreeBuilder builder = RevTreeBuilder.quadBuilder(target, target, tree, maxBounds); for (int x = -180; x <= 180; x += 5) { bounds.init(x, x, y, y); String name = String.format("%d_%d", x, y); ObjectId oid = RevObjectTestSupport.hashString(name); Node node = RevObjectFactory.defaultInstance().createNode(name, oid, ObjectId.NULL, TYPE.FEATURE, bounds, null); builder.put(node); } tree = builder.build(); ObjectId originalTree = RevObjectTestSupport.hashString("fake" + tree.getId()); target.addIndexedTree(index, originalTree, tree.getId()); } return index; }
@Override public boolean feature(final @Nullable NodeRef left, @Nullable final NodeRef right) { final boolean cancelled = progress.isCanceled(); if (!cancelled) { if (left == null) { Node node = right.getNode(); boolean put = builder.put(node); checkState(put, "Node was not added to index: %s", node); } else if (right == null) { Node node = left.getNode(); boolean removed = builder.remove(node); checkState(removed, "Node was not removed from index: %s", node); } else { Node lnode = left.getNode(); Node rnode = right.getNode(); boolean updated = builder.update(lnode, rnode); if (!lnode.equals(rnode)) { checkState(updated, "Node %s was not updated to %s", lnode, rnode); } } progress.setProgress(count.incrementAndGet()); } return !cancelled; }
private void testRemove(final int ncount) { final Set<Node> nodes = new HashSet<>(createPointNodes(nodeRange(ncount))); RevTreeBuilder initialTreeBuilder = createQuadTree(maxBounds, nodes); final RevTree tree = initialTreeBuilder.build(); final Set<Node> removedNodes; RevTreeBuilder builder = RevTreeBuilder.quadBuilder(objectStore, objectStore, tree, maxBounds); // collect some keys to remove { Set<Node> treeNodes = RevObjectTestSupport.getTreeNodes(tree, objectStore); assertEquals(nodes, treeNodes); List<Node> list = new ArrayList<>(treeNodes); Collections.shuffle(list); int removeCount = ncount / 10; removedNodes = ImmutableSet.copyOf(list.subList(0, removeCount)); for (Node node : removedNodes) { boolean removed = builder.remove(node); assertTrue("Not removed: " + node, removed); } assertFalse(removedNodes.isEmpty()); } final RevTree result = builder.build(); Set<Node> resultNodes = getNodes(result); SetView<Node> difference = Sets.difference(nodes, resultNodes); assertEquals(removedNodes.size(), difference.size()); assertEquals(removedNodes, difference); }
final Set<Node> origNodes = new HashSet<>(createPointNodes(nodeRange(ncount))); final RevTree tree = createQuadTree(maxBounds, origNodes).build(); RevTreeBuilder builder = RevTreeBuilder.quadBuilder(objectStore, objectStore, tree, maxBounds); builder.update(oldNode, newNode); removedNodes.add(oldNode); addedNodes.add(newNode); final RevTree result = builder.build();
private int putAll(final int size, final Stream<Node> nodes, final RevTreeBuilder b) { int count = 0, s = 0; final int step = size / 100; Node n = null; for (Iterator<Node> it = nodes.iterator(); it.hasNext();) { n = it.next(); count++; s++; b.put(n); if (s == step) { s = 0; System.err.print('#'); } } System.err.println(); return count; }
private RevTreeBuilder createBuilder(final RevTree origTree) { return RevTreeBuilder.builder(db, origTree); }
@Override protected RevTreeBuilder createBuiler(RevTree original) { return RevTreeBuilder.quadBuilder(objectStore, objectStore, original, maxBounds); }
public void remove(String featurePath) { final String treePath = NodeRef.parentPath(featurePath); final String featureId = NodeRef.nodeFromPath(featurePath); Optional<RevTreeBuilder> treeBuilder = getTreeBuilder(treePath); if (treeBuilder.isPresent()) { RevTreeBuilder builder = treeBuilder.get(); Node featureNode = RevObjectFactory.defaultInstance().createNode(featureId, ObjectId.NULL, ObjectId.NULL, TYPE.FEATURE, null, null); builder.remove(featureNode); } }
@Test public void testNodeOrderPassSplitThreshold() { final int splitThreshold = CanonicalNodeNameOrder.normalizedSizeLimit(0); List<Node> expectedOrder = createNodes(splitThreshold + 1); Collections.sort(expectedOrder, CanonicalNodeOrder.INSTANCE); final List<Node> flat = expectedOrder.subList(0, splitThreshold); RevTreeBuilder flatTreeBuilder = createBuiler(); RevTreeBuilder bucketTreeBuilder = createBuiler(); for (Node n : flat) { flatTreeBuilder.put(n); bucketTreeBuilder.put(n); } bucketTreeBuilder.put(expectedOrder.get(expectedOrder.size() - 1)); RevTree flatTree = flatTreeBuilder.build(); RevTree bucketTree = bucketTreeBuilder.build(); assertEquals(0, flatTree.bucketsSize()); assertNotEquals(0, bucketTree.bucketsSize()); objectStore.put(flatTree); objectStore.put(bucketTree); List<Node> flatNodes = lstree(flatTree); assertEquals(flat, flatNodes); List<Node> splitNodes = lstree(bucketTree); assertEquals(expectedOrder, splitNodes); }
private RevTree buildLeafTree(DAG root) { if (state.isCancelled()) { return null; } checkState(root.numBuckets() == 0); final List<Node> children; { Set<NodeId> childrenIds = new HashSet<>(); root.forEachChild(childrenIds::add); children = toNodes(childrenIds); } List<Node> treesList = children.stream() .filter(n -> n.getType().equals(TYPE.TREE) && !n.getObjectId().isNull()) .collect(Collectors.toList()); List<Node> featuresList = children.stream() .filter(n -> n.getType().equals(TYPE.FEATURE) && !n.getObjectId().isNull()) .collect(Collectors.toList()); final long size = sumTreeSizes(treesList) + featuresList.size(); final int childTreeCount = treesList.size(); SortedSet<Bucket> buckets = null; if (state.isCancelled()) { return null; } return RevTreeBuilder.build(size, childTreeCount, treesList, featuresList, buckets); }