private RevTreeBuilder createBuilder(final RevTree origTree) { return RevTreeBuilder.builder(db, origTree); }
private RevTreeBuilder resolveTargetTree(final RevTree root, String treePath, Map<String, RevTreeBuilder> treeCache, Map<String, ObjectId> metadataCache, ObjectId fallbackMetadataId, ObjectDatabase repositoryDatabase) { RevTreeBuilder treeBuilder = treeCache.get(treePath); if (treeBuilder == null) { if (NodeRef.ROOT.equals(treePath)) { treeBuilder = RevTreeBuilder.builder(repositoryDatabase, root); } else { Optional<NodeRef> treeRef = command(FindTreeChild.class).setParent(root) .setChildPath(treePath).call(); if (treeRef.isPresent()) { metadataCache.put(treePath, treeRef.get().getMetadataId()); treeBuilder = RevTreeBuilder.builder(repositoryDatabase, command(RevObjectParse.class).setObjectId(treeRef.get().getObjectId()) .call(RevTree.class).get()); } else { metadataCache.put(treePath, fallbackMetadataId); treeBuilder = RevTreeBuilder.builder(repositoryDatabase); } } treeCache.put(treePath, treeBuilder); } return treeBuilder; }
@Nullable private RevTreeBuilder getTreeBuilder(final Map<String, NodeRef> currentTrees, final Map<String, RevTreeBuilder> treeBuilders, final String treePath, final @Nullable ObjectId featureMetadataId) { checkNotNull(treePath); RevTreeBuilder builder = treeBuilders.get(treePath); if (builder == null) { NodeRef treeRef = currentTrees.get(treePath); if (treeRef == null) { if (featureMetadataId == null) { return null; } String parentPath = NodeRef.parentPath(treePath); String name = NodeRef.nodeFromPath(treePath); Node treeNode = RevObjectFactory.defaultInstance().createNode(name, EMPTY_TREE_ID, featureMetadataId, TYPE.TREE, null, null); treeRef = new NodeRef(treeNode, parentPath, featureMetadataId); currentTrees.put(treePath, treeRef); } builder = RevTreeBuilder.builder(indexDatabase, context.command(FindOrCreateSubtree.class).setParent(getTree()) .setChildPath(treePath).call()); treeBuilders.put(treePath, builder); } return builder; }
private RevTreeBuilder createFeaturesTree(final String parentPath, final int numEntries) { RevTreeBuilder tree = RevTreeBuilder.builder(odb); for (int i = 0; i < numEntries; i++) { tree.put(featureRef(parentPath, i)); } return tree; }
private RevTree createTree(String... blobs) { RevTreeBuilder builder = RevTreeBuilder.builder(odb); for (String blob : blobs) { builder.put(blob(blob)); } RevTree tree = builder.build(); return tree; }
private RevTreeBuilder getTreeBuilder(RevTree currentIndexHead, NodeRef featureRef, Map<String, RevTreeBuilder> featureTypeTrees, Map<String, NodeRef> currentFeatureTypeRefs) { checkArgument(TYPE.FEATURE.equals(featureRef.getType())); final String typeTreePath = featureRef.getParentPath(); RevTreeBuilder typeTreeBuilder = featureTypeTrees.get(typeTreePath); if (typeTreeBuilder == null) { NodeRef typeTreeRef = context.command(FindTreeChild.class).setParent(currentIndexHead) .setChildPath(typeTreePath).call().orNull(); final RevTree currentTypeTree; if (typeTreeRef == null) { ObjectId metadataId = featureRef.getMetadataId(); Node parentNode = RevObjectFactory.defaultInstance().createNode( NodeRef.nodeFromPath(typeTreePath), EMPTY_TREE_ID, metadataId, TYPE.TREE, null, null); typeTreeRef = NodeRef.create(NodeRef.parentPath(typeTreePath), parentNode); currentTypeTree = EMPTY; } else { currentTypeTree = context.objectDatabase().getTree(typeTreeRef.getObjectId()); } typeTreeBuilder = RevTreeBuilder.builder(context.objectDatabase(), currentTypeTree); currentFeatureTypeRefs.put(typeTreePath, typeTreeRef); featureTypeTrees.put(typeTreePath, typeTreeBuilder); } return typeTreeBuilder; }
private RevTree createTree(int numChildren) { RevTreeBuilder rtb = RevTreeBuilder.builder(odb); for (int i = 0; i < numChildren; i++) { String key = FEATURE_PREFIX + i; Node ref = RevObjectFactory.defaultInstance().createNode(key, FAKE_ID, FAKE_ID, TYPE.FEATURE, null, null); rtb.put(ref); } return rtb.build(); }
private RevTree tree(int nFeatures, ObjectDatabase db) { RevTreeBuilder b = RevTreeBuilder.builder(db); for (int i = 0; i < nFeatures; i++) { b.put(feature(i)); } RevTree tree = b.build(); db.put(tree); return tree; }
public RevTree build(ObjectStore store) { final ObjectId treeId = this.node.getObjectId(); final RevTree original = EMPTY_TREE_ID.equals(treeId) ? EMPTY : store.getTree(treeId); RevTreeBuilder builder = RevTreeBuilder.builder(store, original); ImmutableList<Node> currentTrees = original.trees(); currentTrees.forEach(builder::remove); for (MutableTree childTree : this.childTrees.values()) { childTree.build(store); Node newNode = childTree.node; builder.put(newNode); } final Node oldNode = this.node; RevTree newTree = builder.build(); Envelope newBounds = SpatialOps.boundsOf(newTree); Node newNode = oldNode.update(newTree.getId(), newBounds); this.node = newNode; return newTree; }
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; }
public RevTreeBuilder createLargeFeaturesTreeBuilder(ObjectDatabase 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; }
private RevTreeBuilder newTreeBuilder(final NodeRef featureRef) { final String typeTreePath = featureRef.getParentPath(); NodeRef typeTreeRef = context.command(FindTreeChild.class).setParent(currentIndexHead) .setChildPath(typeTreePath).call().orNull(); final RevTree currentTypeTree; if (typeTreeRef == null) { ObjectId metadataId = featureRef.getMetadataId(); Node parentNode = RevObjectFactory.defaultInstance().createNode( NodeRef.nodeFromPath(typeTreePath), EMPTY_TREE_ID, metadataId, TYPE.TREE, null, null); typeTreeRef = NodeRef.create(NodeRef.parentPath(typeTreePath), parentNode); currentTypeTree = EMPTY; } else { currentTypeTree = context.objectDatabase().getTree(typeTreeRef.getObjectId()); } RevTreeBuilder typeTreeBuilder = RevTreeBuilder.builder(context.objectDatabase(), currentTypeTree); currentFeatureTypeRefs.put(typeTreePath, typeTreeRef); return typeTreeBuilder; }
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 List<NodeRef> createLayers(Map<String, SimpleFeatureType> types) { List<NodeRef> layers = new ArrayList<>(); WorkingTree workingTree = repo.workingTree(); repo.objectDatabase().putAll(Iterators.transform(types.values().iterator(), (t) -> RevFeatureType.builder().type(t).build())); RevTree wt = workingTree.getTree(); RevTreeBuilder newWorkHeadBuilder = RevTreeBuilder.builder(repo.objectDatabase(), wt); types.forEach((treePath, featureType) -> { ObjectId mdId = RevFeatureType.builder().type(featureType).build().getId(); Node node = RevObjectFactory.defaultInstance().createNode(treePath, RevTree.EMPTY_TREE_ID, mdId, TYPE.TREE, null, null); newWorkHeadBuilder.put(node); NodeRef nodeRef = NodeRef.create(NodeRef.ROOT, node); layers.add(nodeRef); }); RevTree newWorkHead = newWorkHeadBuilder.build(); workingTree.updateWorkHead(newWorkHead.getId()); return layers; } }
public RevTreeBuilder createTreesTreeBuilder(ObjectStore source, int numSubTrees, int featuresPerSubtre, ObjectId metadataId) { RevTreeBuilder builder = RevTreeBuilder.builder(source); for (int treeN = 0; treeN < numSubTrees; treeN++) { RevTree subtree = createFeaturesTreeBuilder(source, "subtree" + treeN, featuresPerSubtre).build(); source.put(subtree); builder.put(RevObjectFactory.defaultInstance().createNode("subtree" + treeN, subtree.getId(), metadataId, TYPE.TREE, null, null)); } return builder; }
.setChildPath(parentTreePath).call().get(); final RevTree currentParent = indexDatabase.getTree(typeTreeRef.getObjectId()); RevTreeBuilder parentBuilder = RevTreeBuilder.builder(indexDatabase, currentParent); parentBuilder.remove(childRef.getNode());
private RevTree createRoot(ObjectDatabase db, final RevTree tree1, final RevTree tree2) { RevTreeBuilder rootBuilder = RevTreeBuilder.builder(db); rootBuilder.put(RevObjectFactory.defaultInstance().createNode("tree1", tree1.getId(), metadataId, TYPE.TREE, SpatialOps.boundsOf(tree1), null)); rootBuilder.put(RevObjectFactory.defaultInstance().createNode("tree2", tree2.getId(), metadataId, TYPE.TREE, SpatialOps.boundsOf(tree2), null)); RevTree root = rootBuilder.build(); db.put(root); return root; }
final ObjectId metadataId = id(mdId); final String feturePrefix = NodeRef.nodeFromPath(path); RevTreeBuilder b = RevTreeBuilder.builder(db); if (numFeatures > 0) { for (int i = 0; i < numFeatures; 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); }
RevTreeBuilder rootBuilder = RevTreeBuilder.builder(odb); childTree1 = createFeaturesTree("tree1", 10); RevTree child = childTree1.build();