public Buckets(RevTree tree) { Preconditions.checkArgument(tree.bucketsSize() > 0); buckets = Iterators.filter(tree.getBuckets().iterator(), boundsFilter); bucketEntries = Collections.emptyIterator(); // may it be a mixed tree (having both direct children and buckets) bucketEntries = RevObjects.children(tree, CanonicalNodeOrder.INSTANCE); }
private void preloadBuckets(RevTree tree) { if (tree.bucketsSize() > 0) { List<ObjectId> ids = new ArrayList<>(tree.bucketsSize()); tree.forEachBucket(bucket -> ids.add(bucket.getObjectId())); this.storageProvider.getTreeCache().preload(ids); } }
public Children(RevTree tree) { if (tree.bucketsSize() > 0) { this.children = new Buckets(tree); } else { this.children = Iterators.filter( RevObjects.children(tree, CanonicalNodeOrder.INSTANCE), boundsFilter); } }
public Features(RevTree tree) { if (tree.featuresSize() > 0) { this.features = Iterators.filter(tree.features().iterator(), boundsFilter); } else if (tree.bucketsSize() > 0) { this.features = new FeatureBuckets(tree); } else { this.features = Collections.emptyIterator(); } }
private @Nullable int[] writeBuckets(RevTree tree, FlatBufferBuilder builder) { return writeBuckets(tree.bucketsSize(), tree.getBuckets(), builder); }
public int write(RevTree tree, FlatBufferBuilder builder) { if (tree.bucketsSize() == 0) { return writeLeafTree(tree, builder); } return writeNodeTree(tree, builder); }
public Trees(RevTree tree) { if (tree.numTrees() == 0) { this.trees = Collections.emptyIterator(); } else if (tree.treesSize() > 0) { this.trees = Iterators.filter(tree.trees().iterator(), boundsFilter); } else if (tree.bucketsSize() > 0) { this.trees = new TreeBuckets(tree); } else { this.trees = Collections.emptyIterator(); } }
public RevTree getTree(final ObjectId treeId) { Integer internalId = oidMapping.inverse().get(treeId); final RevTree tree; if (internalId == null) { tree = store.getTree(treeId); getTreeId(tree); if (tree.bucketsSize() > 0) { List<ObjectId> bucketIds = new ArrayList<>(tree.bucketsSize()); tree.forEachBucket(bucket -> bucketIds.add(bucket.getObjectId())); preload(bucketIds); } } else { tree = resolve(internalId.intValue()); } return tree; }
/** * @param bucketId * @return */ protected Iterator<Node> resolveBucketEntries(ObjectId bucketId) { RevTree bucketTree = source.getTree(bucketId); if (bucketTree.bucketsSize() > 0) { return new Buckets(bucketTree); } return new Children(bucketTree); } }
@Override protected Iterator<Node> resolveBucketEntries(ObjectId bucketId) { RevTree bucketTree = source.getTree(bucketId); if (bucketTree.bucketsSize() > 0) { return new FeatureBuckets(bucketTree); } if (bucketTree.featuresSize() > 0) { return new Features(bucketTree); } return Collections.emptyIterator(); } }
public static Set<RevTree> getAllTrees(ObjectStore source, RevTree tree) { Set<RevTree> trees = new HashSet<>(); trees.add(tree); if (tree.bucketsSize() > 0) { Iterable<ObjectId> ids = Iterables.transform(tree.getBuckets(), Bucket::getObjectId); List<RevTree> buckets = Lists .newArrayList(source.getAll(ids, BulkOpListener.NOOP_LISTENER, RevTree.class)); trees.addAll(buckets); for (RevTree bucket : buckets) { trees.addAll(getAllTrees(source, bucket)); } } return trees; }
private List<Bounded> preorder(ObjectStore source, RevTree tree) { List<Bounded> res = new ArrayList<>(); if (tree.bucketsSize() == 0) { res.addAll(tree.features()); } else { tree.getBuckets().forEach((b) -> { res.add(b); RevTree bucketTree = source.getTree(b.getObjectId()); res.addAll(preorder(source, bucketTree)); res.add(b); }); } return res; }
private List<Bounded> preorder(ObjectStore source, RevTree tree) { List<Bounded> res = new ArrayList<>(); if (tree.bucketsSize() == 0) { res.addAll(tree.features()); } else { tree.getBuckets().forEach((b) -> { res.add(b); RevTree bucketTree = source.getTree(b.getObjectId()); res.addAll(preorder(source, bucketTree)); res.add(b); }); } return res; }
private Set<Node> getNodes(RevTree t) { Set<Node> nodes = new TreeSet<>(); if (t.bucketsSize() == 0) { nodes.addAll(t.features()); } else { for (Bucket b : t.getBuckets()) { RevTree subtree = objectStore.getTree(b.getObjectId()); nodes.addAll(getNodes(subtree)); } } return nodes; }
private int depth(RevTree deepTree, int currDepth) { if (deepTree.bucketsSize() == 0) { return currDepth; } int depth = currDepth; for (Bucket bucket : deepTree.getBuckets()) { RevTree bucketTree = odb.get(bucket.getObjectId(), RevTree.class); int d = depth(bucketTree, currDepth + 1); depth = Math.max(depth, d); } return depth; }
@Test public void TestCatTreeWithBucketsObject() throws Exception { int numChildren = CanonicalNodeNameOrder.normalizedSizeLimit(0) * 2; RevTree tree = createTree(numChildren); CharSequence desc = geogig.command(CatObject.class).setObject(Suppliers.ofInstance(tree)) .call(); String[] lines = desc.toString().split("\n"); assertEquals(tree.bucketsSize() + 4, lines.length); for (int i = 4; i < lines.length; i++) { String[] tokens = lines[i].split("\t"); assertEquals(tokens[0].trim(), "BUCKET"); } }
private int writeNodeTree(RevTree tree, FlatBufferBuilder builder) { final int bucketsOffset = tree.bucketsSize() == 0 ? 0 : NodeTree.createBucketsVector(builder, writeBuckets(tree, builder)); NodeTree.startNodeTree(builder); NodeTree.addSize(builder, tree.size()); NodeTree.addNumTreesRecursive(builder, tree.numTrees()); if (bucketsOffset > 0) { NodeTree.addBuckets(builder, bucketsOffset); } return NodeTree.endNodeTree(builder); }
@Test public void testEmptyTree() { RevTree emptyTree = RevTree.EMPTY; assertEquals(TYPE.TREE, emptyTree.getType()); assertEquals(RevTree.EMPTY_TREE_ID, emptyTree.getId()); assertEquals(0, emptyTree.trees().size()); assertEquals(0, emptyTree.features().size()); assertEquals(0, emptyTree.bucketsSize()); assertEquals(0, emptyTree.size()); assertEquals(0, emptyTree.numTrees()); assertTrue(emptyTree.isEmpty()); assertTrue(emptyTree.toString().contains("EMPTY TREE")); assertEquals(emptyTree, emptyTree); assertFalse(emptyTree.equals(RevTree.EMPTY_TREE_ID)); }
private RevTree testCreateLeafTree(ObjectId id, long size, List<Node> trees, List<Node> features) { RevTree actual = factory.createTree(id, size, trees, features); assertNotNull(actual); RevTree expected = DEFAULT.createTree(id, size, trees, features); assertNotNull(expected); assertEquals(id, expected.getId()); assertEquals(size, expected.size()); assertEquals(trees.size(), expected.numTrees()); assertEquals(trees.size(), expected.treesSize()); assertEquals(features.size(), expected.featuresSize()); assertEquals(0, expected.bucketsSize()); RevObjectTestUtil.deepEquals(expected, actual); return actual; }
private RevTree testCreateTree(ObjectId id, @Nonnegative long size, int childTreeCount, SortedSet<Bucket> buckets) { RevTree actual = factory.createTree(id, size, childTreeCount, buckets); assertNotNull(actual); RevTree expected = DEFAULT.createTree(id, size, childTreeCount, buckets); assertNotNull(expected); assertEquals(id, expected.getId()); assertEquals(size, expected.size()); assertEquals(0, expected.treesSize()); assertEquals(0, expected.featuresSize()); assertEquals(childTreeCount, expected.numTrees()); assertEquals(buckets.size(), expected.bucketsSize()); RevObjectTestUtil.deepEquals(expected, actual); return actual; }