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); } }
boolean removed = builder.remove(left); checkState(removed, "Node was not removed from index: %s", left); } else {
@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; }
public void remove(FeatureToDelete feature) { final RevTreeBuilder treeBuilder = getTreeBuilder(feature); String fid = feature.getIdentifier().getID(); Node featureNode = RevObjectFactory.defaultInstance().createNode(fid, ObjectId.NULL, ObjectId.NULL, TYPE.FEATURE, null, null); treeBuilder.remove(featureNode); }
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()); }
parentBuilder.remove(RevObjectFactory.defaultInstance().createNode(fid, ObjectId.NULL, ObjectId.NULL, TYPE.FEATURE, null, null));
final DiffEntry diff = updatedIterator.next(); if (diff.isDelete()) { builder.remove(diff.oldNode()); } else { NodeRef newObject = diff.getNewObject();
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; }
public @Test void testRemoveWorldPointsWholeQuadrant() { 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()); final Envelope NEBounds = new Envelope(0, 180, 0, 90); List<Node> removes = new ArrayList<>(); for (Node n : nodes) { if (NEBounds.contains(n.bounds().orNull())) { removes.add(n); } } final RevTreeBuilder builder2 = createBuiler(tree); removes.forEach((n) -> assertTrue(builder2.remove(n))); RevTree tree2 = builder2.build(); assertEquals(nodes.size() - removes.size(), tree2.size()); } }
} else { getTreeBuilder(currentWorkHead, foundChild, featureTypeTrees, currentFeatureTypeRefs).remove(foundChild.getNode());
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); }
parentTree.remove(oldNode); if (TYPE.TREE.equals(type)) { deletedTrees.add(ref.path());
final RevTree currentParent = indexDatabase.getTree(typeTreeRef.getObjectId()); RevTreeBuilder parentBuilder = RevTreeBuilder.builder(indexDatabase, currentParent); parentBuilder.remove(childRef.getNode());
builder.remove(node(String.valueOf(i))); } else { builder.put(feature(i, RevObjectTestSupport.hashString("changed" + i)));
@Test public void testChangeTypeFilter() { ObjectDatabase db = geogig.getContext().objectDatabase(); final RevTree tree1 = tree(1000, db); final RevTree tree2 = tree(50, db); final RevTree tree2Changed; { RevTreeBuilder builder = RevTreeBuilder.builder(db, tree2); // add 10 changed features, and delete 10 more for (int i = 0; i < 20; i++) { if (i % 2 == 0) { builder.remove(node(String.valueOf(i))); } else { builder.put(feature(i, RevObjectTestSupport.hashString("changed" + i))); } } tree2Changed = builder.build(); db.put(tree2Changed); assertEquals(tree2.size() - 10, tree2Changed.size()); } final RevTree root1 = createRoot(db, tree1, tree2); final RevTree root2 = createRoot(db, tree1, tree2Changed); assertChangeTypeFilter(ObjectId.NULL, root1.getId(), (int) (tree1.size() + tree2.size()), 0, 0); assertChangeTypeFilter(root1.getId(), ObjectId.NULL, 0, (int) (tree1.size() + tree2.size()), 0); assertChangeTypeFilter(tree2.getId(), tree2Changed.getId(), 0, 10, 10); assertChangeTypeFilter(root1.getId(), root2.getId(), 0, 10, 10); assertChangeTypeFilter(root2.getId(), root1.getId(), 10, 0, 10); }
childTree2.remove(featureRef("tree2", 2)); rootBuilder = CanonicalTreeBuilder.create(odb, newRoot); RevTree child2 = childTree2.build();