public static RevTreeBuilder quadBuilder(@NonNull ObjectStore source, @NonNull ObjectStore target, @NonNull Envelope maxBounds) { return QuadTreeBuilder.create(source, target, RevTree.EMPTY, maxBounds); }
public static QuadTreeBuilder create(final @NonNull ObjectStore source, final @NonNull ObjectStore target, final @NonNull RevTree original, final @NonNull Envelope maxBounds) { ClusteringStrategy strategy = ClusteringStrategyBuilder// .quadTree(source)// .original(original)// .maxBounds(maxBounds)// .build(); return new QuadTreeBuilder(target, RevTree.EMPTY, strategy); }
public static ContentIdsProducer forIndex(IndexInfo indexInfo, IndexDatabase sourceStore, List<ObjectId[]> treeIds, Deduplicator deduplicator, ObjectReporter objectReport) { Envelope maxBounds = IndexInfo.getMaxBounds(indexInfo); Preconditions.checkNotNull(maxBounds); NodeOrdering diffNodeOrdering = QuadTreeBuilder.nodeOrdering(maxBounds); boolean reportFeatures = false; ContentIdsProducer producer = new ContentIdsProducer(sourceStore, treeIds, deduplicator, objectReport, reportFeatures); producer.diffOrder = diffNodeOrdering; return producer; }
private void testRemove(final int ncount) { final Set<Node> nodes = new HashSet<>(createPointNodes(nodeRange(ncount))); QuadTreeBuilder initialTreeBuilder = createQuadTree(maxBounds, nodes); initialTreeBuilder.clusteringStrategy(); final RevTree tree = initialTreeBuilder.build(); final Set<Node> removedNodes; QuadTreeBuilder builder = QuadTreeBuilder.create(objectStore, objectStore, tree, maxBounds); // collect some keys to remove { Set<Node> treeNodes = RevObjectTestSupport.getTreeNodes(tree, objectStore); assertEquals(nodes, treeNodes); List<Node> list = new ArrayList<>(treeNodes); Collections.shuffle(list); int removeCount = ncount / 10; removedNodes = ImmutableSet.copyOf(list.subList(0, removeCount)); for (Node node : removedNodes) { boolean removed = builder.remove(node); assertTrue("Not removed: " + node, removed); } assertFalse(removedNodes.isEmpty()); } final RevTree result = builder.build(); Set<Node> resultNodes = getNodes(result); SetView<Node> difference = Sets.difference(nodes, resultNodes); assertEquals(removedNodes.size(), difference.size()); assertEquals(removedNodes, difference); }
final Set<Node> origNodes = new HashSet<>(createPointNodes(nodeRange(ncount))); final RevTree tree = createQuadTree(maxBounds, origNodes).build(); QuadTreeBuilder builder = QuadTreeBuilder.create(objectStore, objectStore, tree, maxBounds); builder.update(oldNode, newNode); removedNodes.add(oldNode); addedNodes.add(newNode); final RevTree result = builder.build();
public static RevTreeBuilder quadBuilder(@NonNull ObjectStore source, @NonNull ObjectStore target, @NonNull RevTree original, @NonNull Envelope maxBounds) { return QuadTreeBuilder.create(source, target, original, maxBounds); }
diffNodeOrdering = QuadTreeBuilder.nodeOrdering(maxBounds); info.diffUsesIndex = true; info.materializedIndexProperties = resolveMaterializedProperties(indexInfo);
public static QuadTreeBuilder create(final ObjectStore source, final ObjectStore target, final RevTree original, final Envelope maxBounds) { Preconditions.checkNotNull(source); Preconditions.checkNotNull(target); Preconditions.checkNotNull(original); Preconditions.checkNotNull(maxBounds); ClusteringStrategy strategy = ClusteringStrategyBuilder// .quadTree(source)// .original(original)// .maxBounds(maxBounds)// .build(); QuadTreeBuilder builder = new QuadTreeBuilder(target, RevTree.EMPTY, strategy); return builder; } }
public QuadTreeBuilder newTreeBuilder(RevTree original) { QuadTreeBuilder builder = QuadTreeBuilder.create(store, store, original, maxBoundsFloat64); return builder; }
@Override protected RevTreeBuilder createBuiler(RevTree original) { return QuadTreeBuilder.create(objectStore, objectStore, original, maxBounds); }
builder = QuadTreeBuilder.create(source, target, oldIndexTree, maxBounds); break; default: