/** * @return the number of buckets in the {@link #buckets} property */ public default int bucketsSize() { return Iterables.size(getBuckets()); }
public default void forEachBucket(Consumer<Bucket> consumer) { getBuckets().forEach(consumer); }
/** * Performs the given action for each element of the {@link #buckets} collection respecting its * iteration order, which is the order of the bucket index. * * @deprecated * @param consumer a consumer that accepts a tuple given by the bucket index and the bucket * itself */ public default void forEachBucket(BiConsumer<Integer, Bucket> consumer) { getBuckets().forEach(b -> consumer.accept(Integer.valueOf(b.getIndex()), b)); }
public default Optional<Bucket> getBucket(int bucketIndex) { for (Bucket b : getBuckets()) { if (bucketIndex == b.getIndex()) { return Optional.of(b); } } return Optional.empty(); } }
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); }
public AllTrees(ObjectId id, ObjectStore from) { this.from = from; this.tree = from.getTree(id); this.trees = tree.trees().iterator(); buckets = tree.getBuckets().iterator(); bucketTrees = Collections.emptyIterator(); }
private @Nullable int[] writeBuckets(RevTree tree, FlatBufferBuilder builder) { return writeBuckets(tree.bucketsSize(), tree.getBuckets(), builder); }
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; }
@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.getBuckets()); }
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; }
public static Set<Node> getTreeNodes(RevTree tree, ObjectStore source) { Set<Node> nodes = new HashSet<>(); if (tree.bucketsSize() == 0) { nodes.addAll(tree.features()); nodes.addAll(tree.trees()); } else { Iterable<ObjectId> ids = Iterables.transform(tree.getBuckets(), Bucket::getObjectId); Iterator<RevTree> buckets = source.getAll(ids, BulkOpListener.NOOP_LISTENER, RevTree.class); while (buckets.hasNext()) { nodes.addAll(getTreeNodes(buckets.next(), source)); } } return nodes; }
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; }
public static int depth(ObjectStore store, RevTree tree) { int depth = 0; for (Bucket b : tree.getBuckets()) { RevTree btree = store.getTree(b.getObjectId()); depth = Math.max(depth, 1 + depth(store, btree)); } return depth; }
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; }
public static Set<ObjectId> verifyAllReachableTrees(ObjectStore store, ObjectId treeId) { Set<ObjectId> allIds = new HashSet<>(); RevTree tree = store.getTree(treeId); allIds.add(tree.getId()); tree.trees() .forEach(node -> allIds.addAll(verifyAllReachableTrees(store, node.getObjectId()))); tree.getBuckets() .forEach(b -> allIds.addAll(verifyAllReachableTrees(store, b.getObjectId()))); return allIds; } }
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; }
/** * @return the new tree, not saved to the object database. Any bucket tree though is saved when * this method returns. */ public RevTree build() { RevTree tree = normalize(); checkState(bucketTreesByBucket.isEmpty() || (featureChanges.isEmpty() && treeChanges.isEmpty())); if (obStore != null) { obStore.put(tree); } ObjectId oldid = HashObject.hashTree(original.trees(), original.features(), original.getBuckets()); ObjectId newid = HashObject.hashTree(tree.trees(), tree.features(), tree.getBuckets()); return oldid.equals(newid) ? original : tree; }
private void assertEqualsFully(RevTree o1, RevTree o2) { assertEquals(o1.size(), o2.size()); assertEquals(o1.numTrees(), o2.numTrees()); assertNodesEqual(o1.features(), o2.features()); assertNodesEqual(o1.trees(), o2.trees()); assertEquals(Lists.newArrayList(o1.getBuckets()), Lists.newArrayList(o2.getBuckets())); }
public static void assertEqualsFully(RevTree o1, RevTree o2) { assertEquals(o1.size(), o2.size()); assertEquals(o1.numTrees(), o2.numTrees()); assertEqualsFully(o1.features(), o2.features()); assertEqualsFully(o1.trees(), o2.trees()); assertEquals(Lists.newArrayList(o1.getBuckets()), Lists.newArrayList(o2.getBuckets())); }
private void walkTree(ObjectId treeId, ObjectDatabase source) { assertTrue(source.exists(treeId)); RevTree tree = source.getTree(treeId); for (Bucket b : tree.getBuckets()) { walkTree(b.getObjectId(), source); } } }