public Buckets(RevTree tree) { Preconditions.checkArgument(!tree.buckets().isEmpty()); buckets = Iterators.filter(tree.buckets().values().iterator(), boundsFilter); bucketEntries = Collections.emptyIterator(); // may it be a mixed tree (having both direct children and buckets) bucketEntries = RevObjects.children(tree, CanonicalNodeOrder.INSTANCE); }
public @Override void findSuccessors(final Object object, final List<Object> successors, ObjectStore database) { if (object instanceof RevTree) { final RevTree tree = (RevTree) object; if (!tree.buckets().isEmpty()) { Iterable<ObjectId> bucketIds = Iterables.transform(tree.buckets().values(), (b) -> b.getObjectId()); Iterator<RevTree> buckets = database.getAll(bucketIds, NOOP_LISTENER, RevTree.class); buckets.forEachRemaining((b) -> successors.add(b)); } } }
public Features(RevTree tree) { if (!tree.features().isEmpty()) { this.features = Iterators.filter(tree.features().iterator(), boundsFilter); } else if (!tree.buckets().isEmpty()) { this.features = new FeatureBuckets(tree); } else { this.features = Collections.emptyIterator(); } }
public Trees(RevTree tree) { if (tree.numTrees() == 0) { this.trees = Collections.emptyIterator(); } else if (!tree.trees().isEmpty()) { this.trees = Iterators.filter(tree.trees().iterator(), boundsFilter); } else if (!tree.buckets().isEmpty()) { this.trees = new TreeBuckets(tree); } else { this.trees = Collections.emptyIterator(); } }
public Children(RevTree tree) { if (!tree.buckets().isEmpty()) { this.children = new Buckets(tree); } else { this.children = Iterators.filter( RevObjects.children(tree, CanonicalNodeOrder.INSTANCE), boundsFilter); } }
public AllTrees(ObjectId id, ObjectStore from) { this.from = from; this.tree = from.getTree(id); this.trees = tree.trees().iterator(); buckets = tree.buckets().values().iterator(); bucketTrees = Collections.emptyIterator(); }
@Override protected Iterator<Node> resolveBucketEntries(ObjectId bucketId) { RevTree bucketTree = source.getTree(bucketId); if (!bucketTree.buckets().isEmpty()) { return new FeatureBuckets(bucketTree); } if (!bucketTree.features().isEmpty()) { return new Features(bucketTree); } return Collections.emptyIterator(); } }
@Override public void funnel(RevTree from, PrimitiveSink into) { ImmutableList<Node> trees = from.trees(); ImmutableList<Node> features = from.features(); ImmutableSortedMap<Integer, Bucket> buckets = from.buckets(); funnel(into, trees, features, buckets); }
/** * @param bucketId * @return */ protected Iterator<Node> resolveBucketEntries(ObjectId bucketId) { RevTree bucketTree = source.getTree(bucketId); if (!bucketTree.buckets().isEmpty()) { return new Buckets(bucketTree); } return new Children(bucketTree); } }
@Override protected void print(RevTree revTree, Writer w) throws IOException { println(w, "size\t", Long.toString(revTree.size())); println(w, "numtrees\t", Integer.toString(revTree.numTrees())); writeChildren(w, revTree.trees()); writeChildren(w, revTree.features()); writeBuckets(w, revTree.buckets()); }
private int depth(RevTree deepTree, int currDepth) { if (deepTree.buckets().isEmpty()) { return currDepth; } int depth = currDepth; for (Bucket bucket : deepTree.buckets().values()) { RevTree bucketTree = odb.get(bucket.getObjectId(), RevTree.class); int d = depth(bucketTree, currDepth + 1); depth = Math.max(depth, d); } return depth; }
private List<Bounded> preorder(ObjectStore source, RevTree tree) { List<Bounded> res = new ArrayList<>(); if (tree.buckets().isEmpty()) { res.addAll(tree.features()); } else { tree.buckets().values().forEach((b) -> { res.add(b); RevTree bucketTree = source.getTree(b.getObjectId()); res.addAll(preorder(source, bucketTree)); res.add(b); }); } return res; }
public static int depth(ObjectStore store, RevTree tree) { int depth = 0; for (Bucket b : tree.buckets().values()) { RevTree btree = store.getTree(b.getObjectId()); depth = Math.max(depth, 1 + depth(store, btree)); } 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.buckets().size() + 4, lines.length); for (int i = 4; i < lines.length; i++) { String[] tokens = lines[i].split("\t"); assertEquals(tokens[0].trim(), "BUCKET"); } }
public static Envelope boundsOf(RevTree tree) { Envelope env = new Envelope(); tree.buckets().values().forEach((b) -> b.expand(env)); tree.trees().forEach((t) -> t.expand(env)); tree.features().forEach((f) -> f.expand(env)); return env; }
private RevTree forceTreeId(RevTreeBuilder b, ObjectId treeId) { RevTree tree = b.build(); long size = tree.size(); int childTreeCount = tree.numTrees(); ImmutableList<Node> trees = tree.trees(); ImmutableList<Node> features = tree.features(); SortedMap<Integer, Bucket> buckets = tree.buckets(); RevTree fakenId = RevTreeBuilder.create(treeId, size, childTreeCount, trees, features, buckets); return fakenId; }
private void walkTree(ObjectId treeId, ObjectDatabase source) { assertTrue(source.exists(treeId)); RevTree tree = source.getTree(treeId); for (Bucket b : tree.buckets().values()) { walkTree(b.getObjectId(), source); } } }