@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()); }
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 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(); } }
public static void deepEquals(@NonNull RevTree expected, @NonNull RevTree actual) { assertEquals(TYPE.TREE, actual.getType()); assertEquals(expected.getId(), expected.getId()); assertEquals(expected.size(), expected.size()); assertEquals(expected.numTrees(), expected.numTrees()); assertEquals(expected.treesSize(), expected.treesSize()); assertEquals(expected.featuresSize(), expected.featuresSize()); assertEquals(expected.bucketsSize(), expected.bucketsSize()); deepEquals(expected.trees(), actual.trees()); deepEquals(expected.features(), actual.features()); deepEquals(expected.getBuckets(), actual.getBuckets()); for (Bucket b : expected.getBuckets()) { deepEquals(b, actual.getBucket(b.getIndex()).orElse(null)); } }
@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()); }
@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 encodeDecode(RevTree orig) throws IOException { final byte[] encoded = RevTreeFormat.encode(orig); assertNotNull(encoded); RevTree decoded = RevTreeFormat.decode(orig.getId(), encoded); assertEquals(orig, decoded); // equals only checks for objectId assertEquals(TYPE.TREE, decoded.getType()); assertEquals(orig.size(), decoded.size()); assertEquals(orig.numTrees(), decoded.numTrees()); assertEqualsFully(orig.trees(), decoded.trees()); assertEqualsFully(orig.features(), decoded.features()); assertEquals(orig.buckets(), decoded.buckets()); return decoded; }
public static void encode(DataOutput out, RevTree tree) throws IOException { // object type out.write(RevObject.TYPE.TREE.ordinal()); final long totalSize = tree.size(); final int totalSubtrees = tree.numTrees(); Varint.writeUnsignedVarLong(totalSize, out); Varint.writeUnsignedVarInt(totalSubtrees, out); }
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); }
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; } }
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; }
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(); } }
@Override public SimpleFeature apply(SimpleFeature input) { progressListener .setProgress((count.incrementAndGet() * 100.f) / typeTree.size()); return input; } });
private Map<NodeId, DAGNode> lazyNodes(final RevTree tree) { if (tree.isEmpty()) { return ImmutableMap.of(); } final TreeCache treeCache = storageProvider.getTreeCache(); final int cacheTreeId = treeCache.getTreeId(tree).intValue(); Map<NodeId, DAGNode> dagNodes = new HashMap<>(); List<Node> treeNodes = tree.trees(); for (int i = 0; i < treeNodes.size(); i++) { NodeId nodeId = computeId(treeNodes.get(i)); DAGNode dagNode = DAGNode.treeNode(cacheTreeId, i); dagNodes.put(nodeId, dagNode); } ImmutableList<Node> featureNodes = tree.features(); for (int i = 0; i < featureNodes.size(); i++) { NodeId nodeId = computeId(featureNodes.get(i)); DAGNode dagNode = DAGNode.featureNode(cacheTreeId, i); dagNodes.put(nodeId, dagNode); } return dagNodes; }