static RevTree build(final long size, final int childTreeCount, @Nullable List<Node> trees, @Nullable List<Node> features, @Nullable SortedSet<Bucket> buckets) { trees = trees == null ? Collections.emptyList() : trees; features = features == null ? Collections.emptyList() : features; buckets = buckets == null ? Collections.emptySortedSet() : buckets; ObjectId id = HashObjectFunnels.hashTree(trees, features, buckets); if (buckets.isEmpty()) { return RevObjectFactory.defaultInstance().createTree(id, size, trees, features); } return RevObjectFactory.defaultInstance().createTree(id, size, childTreeCount, buckets); }
return RevObjectFactory.defaultInstance().createTree(id, size, trees, features); return RevObjectFactory.defaultInstance().createTree(id, size, treeCount, buckets);
private RevTree createLeafTree(int i) { final int numNodes = 512; List<Node> nodes = IntStream.range(0, numNodes).mapToObj(this::createNode) .collect(Collectors.toList()); ObjectId id = ObjectId.create(i, i * i, i * i * i); RevTree tree = objectFactory.createTree(id, numNodes, Collections.emptyList(), ImmutableList.copyOf(nodes)); return tree; }
return RevObjectFactory.defaultInstance().createTree(id, size, trees.build(), features.build()); return RevObjectFactory.defaultInstance().createTree(id, size, numTrees, subtrees);
private RevTree createNodeTree(long size, int numTrees, @NonNull SortedMap<Integer, Bucket> buckets) { final ObjectId id = HashObject.hashTree(null, null, buckets.values()); return RevObjectFactory.defaultInstance().createTree(id, size, numTrees, new TreeSet<>(buckets.values())); }
public static RevTree tree(int treeSize, List<Node> treeNodes, List<Node> featureNodes, SortedSet<Bucket> buckets) { ObjectId id = HashObject.hashTree(treeNodes, featureNodes, buckets); ImmutableList<Node> trees = treeNodes == null ? ImmutableList.of() : ImmutableList.copyOf(treeNodes); ImmutableList<Node> features = featureNodes == null ? ImmutableList.of() : ImmutableList.copyOf(featureNodes); buckets = buckets == null ? Collections.emptySortedSet() : buckets; int childTreeCount = treeNodes == null ? 0 : treeNodes.size(); if (buckets.isEmpty()) { return RevObjectFactory.defaultInstance().createTree(id, treeSize, trees, features); } return RevObjectFactory.defaultInstance().createTree(id, treeSize, childTreeCount, buckets); }
private RevTree createLeafTree(int i) { final int numNodes = 512; List<Node> nodes = new ArrayList<>(numNodes); for (int n = 0; n < numNodes; n++) { Node node = createNodeWithMetadata(n); nodes.add(node); } ObjectId id = RevObjectTestSupport.hashString("fake-tree-" + i); RevTree tree = RevObjectFactory.defaultInstance().createTree(id, numNodes, Collections.emptyList(), ImmutableList.copyOf(nodes)); return tree; }
return RevObjectFactory.defaultInstance().createTree(id, size, trees, features); return RevObjectFactory.defaultInstance().createTree(id, size, treeCount, buckets);
public static RevTree createLeafTree(long size, Collection<Node> features, Collection<Node> trees) { Preconditions.checkNotNull(features); Preconditions.checkNotNull(trees); ImmutableList<Node> featuresList = ImmutableList.of(); ImmutableList<Node> treesList = ImmutableList.of(); if (!features.isEmpty()) { featuresList = NODE_STORAGE_ORDER.immutableSortedCopy(features); } if (!trees.isEmpty()) { treesList = NODE_STORAGE_ORDER.immutableSortedCopy(trees); } final ObjectId id = HashObject.hashTree(treesList, featuresList, (Iterable<Bucket>) null); return RevObjectFactory.defaultInstance().createTree(id, size, treesList, featuresList); }
private RevTree createBucketTree(int i) { final int bucketCount = 32; SortedSet<Bucket> buckets = new TreeSet<>(); for (int b = 0; b < bucketCount; b++) { ObjectId bucketTree = RevObjectTestSupport.hashString("b" + b); Envelope bounds = new Envelope(0, b, 0, b); Bucket bucket = objectFactory.createBucket(bucketTree, b, bounds); buckets.add(bucket); } final ObjectId fakeId = RevObjectTestSupport.hashString(String.valueOf(i)); RevTree tree = objectFactory.createTree(fakeId, 1024, 0, buckets); return tree; }
private RevTree createBucketTree(int i) { final int bucketCount = 32; SortedSet<Bucket> buckets = new TreeSet<>(); for (int b = 0; b < bucketCount; b++) { ObjectId bucketTree = RevObjectTestSupport.hashString("b" + b); Envelope bounds = new Envelope(0, b, 0, b); Bucket bucket = RevObjectFactory.defaultInstance().createBucket(bucketTree, 0, bounds); buckets.add(bucket); } final ObjectId fakeId = RevObjectTestSupport.hashString(String.valueOf(i)); RevTree tree = RevObjectFactory.defaultInstance().createTree(fakeId, 1024, 0, buckets); return tree; }
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(); SortedSet<Bucket> buckets = ImmutableSortedSet.copyOf(tree.getBuckets()); RevObjectFactory factory = RevObjectFactory.defaultInstance(); RevTree fakenId; if (buckets.isEmpty()) { fakenId = factory.createTree(treeId, size, trees, features); } else { fakenId = factory.createTree(treeId, size, childTreeCount, buckets); } return fakenId; }
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; }
@Test public void testRoundTripBucketsFull() throws IOException { ObjectId id = RevObjectTestSupport.hashString("fake"); long size = 100000000; int childTreeCount = 0; SortedSet<Bucket> bucketTrees = createBuckets(32); final RevTree tree = RevObjectFactory.defaultInstance().createTree(id, size, childTreeCount, bucketTrees); RevTree roundTripped = (RevTree) read(tree.getId(), write(tree)); assertTreesAreEqual(tree, roundTripped); }