public PostOrderDiffWalk(RevTree left, RevTree right, ObjectStore leftSource, ObjectStore rightSource) { this.inOrder = new PreOrderDiffWalk(left, right, leftSource, rightSource); }
public PostOrderDiffWalk(RevTree left, RevTree right, ObjectStore leftSource, ObjectStore rightSource) { this.inOrder = new PreOrderDiffWalk(left, right, leftSource, rightSource); }
private PreOrderDiffWalk newVisitor(RevTree left, RevTree right) { PreOrderDiffWalk visitor = new PreOrderDiffWalk(left, right, leftSource, rightSource); return visitor; }
private PreOrderDiffWalk newVisitor(RevTree left, RevTree right) { PreOrderDiffWalk visitor = new PreOrderDiffWalk(left, right, leftSource, rightSource); return visitor; }
private PreOrderDiffWalk newVisitor(RevTree left, RevTree right) { PreOrderDiffWalk visitor = new PreOrderDiffWalk(left, right, leftSource, rightSource); return visitor; }
/** * */ private int getTreeDepth(RevTree tree, ObjectDatabase source, final int depth) { PreOrderDiffWalk visitor = new PreOrderDiffWalk(tree, RevTree.EMPTY, source, source); final AtomicInteger maxDepth = new AtomicInteger(); visitor.walk(new PreOrderDiffWalk.AbstractConsumer() { @Override public boolean bucket(NodeRef lparent, NodeRef rparent, BucketIndex bucketIndex, Bucket left, Bucket right) { int bucketDepth = bucketIndex.depthIndex(); maxDepth.set(Math.max(maxDepth.get(), bucketDepth + 1));// use +1 cause we want the // number of levels, not the // zero-based level index return true; } }); return maxDepth.get(); }
/** * */ private int getTreeDepth(RevTree tree, ObjectDatabase source, final int depth) { PreOrderDiffWalk visitor = new PreOrderDiffWalk(tree, RevTree.EMPTY, source, source); final AtomicInteger maxDepth = new AtomicInteger(); visitor.walk(new PreOrderDiffWalk.AbstractConsumer() { @Override public boolean bucket(NodeRef lparent, NodeRef rparent, BucketIndex bucketIndex, Bucket left, Bucket right) { int bucketDepth = bucketIndex.depthIndex(); maxDepth.set(Math.max(maxDepth.get(), bucketDepth + 1));// use +1 cause we want the // number of levels, not the // zero-based level index return true; } }); return maxDepth.get(); }
/** * */ private int getTreeDepth(RevTree tree, ObjectDatabase source, final int depth) { PreOrderDiffWalk visitor = new PreOrderDiffWalk(tree, RevTree.EMPTY, source, source); final AtomicInteger maxDepth = new AtomicInteger(); visitor.walk(new PreOrderDiffWalk.AbstractConsumer() { @Override public boolean bucket(NodeRef lparent, NodeRef rparent, BucketIndex bucketIndex, Bucket left, Bucket right) { int bucketDepth = bucketIndex.depthIndex(); maxDepth.set(Math.max(maxDepth.get(), bucketDepth + 1));// use +1 cause we want the // number of levels, not the // zero-based level index return true; } }); return maxDepth.get(); }
@Override protected Geometry _call() { final String leftRefSpec = fromNullable(oldVersion).or(Ref.HEAD); final String rightRefSpec = fromNullable(newVersion).or(Ref.WORK_HEAD); RevTree left = resolveTree(leftRefSpec); RevTree right = resolveTree(rightRefSpec); ObjectDatabase leftSource = objectDatabase(); ObjectDatabase rightSource = objectDatabase(); PreOrderDiffWalk visitor = new PreOrderDiffWalk(left, right, leftSource, rightSource); MinimalDiffBoundsConsumer boundsBuilder = new MinimalDiffBoundsConsumer(); Consumer consumer = boundsBuilder; if (treeName != null) { consumer = new PathFilteringDiffConsumer(ImmutableList.of(treeName), boundsBuilder); } visitor.walk(consumer); Geometry minimalBounds = boundsBuilder.buildGeometry(); return minimalBounds; }
public void call(PreOrderDiffWalk.Consumer consumer) { checkArgument(oldRefSpec != null || oldTreeId != null || oldTree != null, "old version not specified"); checkArgument(newRefSpec != null || oldTreeId != null || newTree != null, "new version not specified"); final ObjectStore leftSource; final ObjectStore rightSource; leftSource = this.leftSource == null ? objectDatabase() : this.leftSource; rightSource = this.rightSource == null ? objectDatabase() : this.rightSource; final RevTree oldTree = resolveTree(oldRefSpec, this.oldTreeId, this.oldTree, leftSource); final RevTree newTree = resolveTree(newRefSpec, this.newTreeId, this.newTree, rightSource); final PreOrderDiffWalk visitor = new PreOrderDiffWalk(oldTree, newTree, leftSource, rightSource, preserveIterationOrder); visitor.setDefaultMetadataId(this.metadataId); visitor.walk(consumer); }
@Override protected DiffObjectCount _call() { checkState(oldRefSpec != null || oldTreeId != null, "old ref spec not provided"); checkState(newRefSpec != null || newTreeId != null, "new ref spec not provided"); final RevTree oldTree = getTree(oldRefSpec, oldTreeId); final RevTree newTree = getTree(newRefSpec, newTreeId); DiffObjectCount diffCount; ObjectDatabase index = objectDatabase(); PreOrderDiffWalk visitor = new PreOrderDiffWalk(oldTree, newTree, index, index); DiffCountConsumer counter = new DiffCountConsumer(index); PreOrderDiffWalk.Consumer filter = counter; if (!pathFilters.isEmpty()) { filter = new PathFilteringDiffConsumer(pathFilters, counter); } visitor.walk(filter); diffCount = counter.get(); return diffCount; }
@Override protected DiffObjectCount _call() { checkState(oldRefSpec != null || oldTreeId != null || oldTree != null, "old ref spec not provided"); checkState(newRefSpec != null || newTreeId != null || newTree != null, "new ref spec not provided"); final ObjectStore leftSource = this.leftSource == null ? objectDatabase() : this.leftSource; final ObjectStore rightSource = this.rightSource == null ? objectDatabase() : this.rightSource; final RevTree oldTree = getTree(oldRefSpec, oldTreeId, this.oldTree, leftSource); final RevTree newTree = getTree(newRefSpec, newTreeId, this.newTree, rightSource); DiffObjectCount diffCount; PreOrderDiffWalk visitor = new PreOrderDiffWalk(oldTree, newTree, leftSource, rightSource); DiffCountConsumer counter = new DiffCountConsumer(leftSource, rightSource); PreOrderDiffWalk.Consumer filter = counter; if (!pathFilters.isEmpty()) { filter = new PathFilteringDiffConsumer(pathFilters, counter); } visitor.walk(filter); diffCount = counter.get(); return diffCount; }
private DiffObjectCount count(RevTree left, RevTree right) { PreOrderDiffWalk visitor = new PreOrderDiffWalk(left, right, odb, odb); DiffCountConsumer consumer = new DiffCountConsumer(odb); visitor.walk(consumer); DiffObjectCount count = consumer.get(); return count; }
private DiffObjectCount count(RevTree left, RevTree right) { PreOrderDiffWalk visitor = new PreOrderDiffWalk(left, right, odb, odb); DiffCountConsumer consumer = new DiffCountConsumer(odb); visitor.walk(consumer); DiffObjectCount count = consumer.get(); return count; }
public void checkFalseReturnValueOnConsumerFeatureAbortsTraversal(RevTree left, RevTree right) { final long leftsize = left.size(); final long rightsize = right.size(); // sanity check { FeatureCountingConsumer counter = new FeatureCountingConsumer(); PreOrderDiffWalk walk = new PreOrderDiffWalk(left, right, leftSource, rightSource); walk.walk(counter); final long totalDiffCount = Math.abs(rightsize - leftsize); assertEquals(totalDiffCount, counter.count.intValue()); } FeatureCountingConsumer counter = new FeatureCountingConsumer(); consumer = new PreOrderDiffWalk.MaxFeatureDiffsLimiter(counter, 3); PreOrderDiffWalk walk = new PreOrderDiffWalk(left, right, leftSource, rightSource); walk.walk(consumer); final int abortedAtCount = counter.count.intValue(); assertEquals(3, abortedAtCount); }
public void checkFalseReturnValueOnConsumerFeatureAbortsTraversal(RevTree left, RevTree right) { final long leftsize = left.size(); final long rightsize = right.size(); // sanity check { FeatureCountingConsumer counter = new FeatureCountingConsumer(); PreOrderDiffWalk walk = new PreOrderDiffWalk(left, right, leftSource, rightSource); walk.walk(counter); final long totalDiffCount = Math.abs(rightsize - leftsize); assertEquals(totalDiffCount, counter.count.intValue()); } FeatureCountingConsumer counter = new FeatureCountingConsumer(); consumer = new PreOrderDiffWalk.MaxFeatureDiffsLimiter(counter, 3); PreOrderDiffWalk walk = new PreOrderDiffWalk(left, right, leftSource, rightSource); walk.walk(consumer); final int abortedAtCount = counter.count.intValue(); assertEquals(3, abortedAtCount); }
public void checkFalseReturnValueOnConsumerFeatureAbortsTraversal(RevTree left, RevTree right) { final long leftsize = left.size(); final long rightsize = right.size(); // sanity check { FeatureCountingConsumer counter = new FeatureCountingConsumer(); PreOrderDiffWalk walk = new PreOrderDiffWalk(left, right, leftSource, rightSource); walk.walk(counter); final long totalDiffCount = Math.abs(rightsize - leftsize); assertEquals(totalDiffCount, counter.count.intValue()); } FeatureCountingConsumer counter = new FeatureCountingConsumer(); consumer = new PreOrderDiffWalk.MaxFeatureDiffsLimiter(counter, 3); PreOrderDiffWalk walk = new PreOrderDiffWalk(left, right, leftSource, rightSource); walk.walk(consumer); final int abortedAtCount = counter.count.intValue(); assertEquals(3, abortedAtCount); }
@Test public void testMaxFeatureDiffsFilter() { final int leftsize = 2 * CanonicalNodeNameOrder.normalizedSizeLimit(0); final int rightsize = CanonicalNodeNameOrder.normalizedSizeLimit(0); final RevTree left = testSupport.createFeaturesTree(leftSource, "f", leftsize); final RevTree right = testSupport.createFeaturesTree(rightSource, "f", rightsize); FeatureCountingConsumer counter = new FeatureCountingConsumer(); PreOrderDiffWalk walk = new PreOrderDiffWalk(left, right, leftSource, rightSource); walk.walk(counter); final int totalDiffCount = leftsize - rightsize; assertEquals(totalDiffCount, counter.count.intValue()); counter = new FeatureCountingConsumer(); MaxFeatureDiffsLimiter limiter = new PreOrderDiffWalk.MaxFeatureDiffsLimiter(counter, 10); new PreOrderDiffWalk(left, right, leftSource, rightSource).walk(limiter); assertEquals(10, counter.count.intValue()); }
@Test public void testMaxFeatureDiffsFilter() { final int leftsize = 2 * CanonicalNodeNameOrder.normalizedSizeLimit(0); final int rightsize = CanonicalNodeNameOrder.normalizedSizeLimit(0); final RevTree left = createFeaturesTree(leftSource, "f", leftsize); final RevTree right = createFeaturesTree(rightSource, "f", rightsize); FeatureCountingConsumer counter = new FeatureCountingConsumer(); PreOrderDiffWalk walk = new PreOrderDiffWalk(left, right, leftSource, rightSource); walk.walk(counter); final int totalDiffCount = leftsize - rightsize; assertEquals(totalDiffCount, counter.count.intValue()); counter = new FeatureCountingConsumer(); MaxFeatureDiffsLimiter limiter = new PreOrderDiffWalk.MaxFeatureDiffsLimiter(counter, 10); new PreOrderDiffWalk(left, right, leftSource, rightSource).walk(limiter); assertEquals(10, counter.count.intValue()); }
@Test public void testMaxFeatureDiffsFilter() { final int leftsize = 2 * CanonicalNodeNameOrder.normalizedSizeLimit(0); final int rightsize = CanonicalNodeNameOrder.normalizedSizeLimit(0); final RevTree left = RevObjectTestSupport.INSTANCE.createFeaturesTree(leftSource, "f", leftsize); final RevTree right = RevObjectTestSupport.INSTANCE.createFeaturesTree(rightSource, "f", rightsize); FeatureCountingConsumer counter = new FeatureCountingConsumer(); PreOrderDiffWalk walk = new PreOrderDiffWalk(left, right, leftSource, rightSource); walk.walk(counter); final int totalDiffCount = leftsize - rightsize; assertEquals(totalDiffCount, counter.count.intValue()); counter = new FeatureCountingConsumer(); MaxFeatureDiffsLimiter limiter = new PreOrderDiffWalk.MaxFeatureDiffsLimiter(counter, 10); new PreOrderDiffWalk(left, right, leftSource, rightSource).walk(limiter); assertEquals(10, counter.count.intValue()); }