public final void walk(final Predicate<Bounded> filter, final Consumer consumer) { DepthFirstConsumer depthFirstConsumer = new DepthFirstConsumer(filter, consumer); inOrder.walk(depthFirstConsumer); }
public final void walk(final Predicate<Bounded> filter, final Consumer consumer) { DepthFirstConsumer depthFirstConsumer = new DepthFirstConsumer(filter, consumer); inOrder.walk(depthFirstConsumer); }
@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); }
@Test public void testSameRootTree() { RevTree left = RevObjectTestSupport.INSTANCE.createFeaturesTree(leftSource, "f", 10); RevTree right = left; PreOrderDiffWalk visitor = newVisitor(left, right); visitor.walk(consumer); verifyNoMoreInteractions(consumer); }
@Test public void testSameRootTree() { RevTree left = createFeaturesTree(leftSource, "f", 10); RevTree right = left; PreOrderDiffWalk visitor = newVisitor(left, right); visitor.walk(consumer); verifyNoMoreInteractions(consumer); }
@Test public void testSameRootTree() { RevTree left = testSupport.createFeaturesTree(leftSource, "f", 10); RevTree right = left; PreOrderDiffWalk visitor = newVisitor(left, right); visitor.walk(consumer); verifyNoMoreInteractions(consumer); }
@Test public void testSameChildTree() { RevTree left = testSupport.createFeaturesTree(leftSource, "f", 10); RevTree right = left; PreOrderDiffWalk visitor = newVisitor(left, right); visitor.walk(consumer); verifyNoMoreInteractions(consumer); }
@Test public void testSameChildTree() { RevTree left = RevObjectTestSupport.INSTANCE.createFeaturesTree(leftSource, "f", 10); RevTree right = left; PreOrderDiffWalk visitor = newVisitor(left, right); visitor.walk(consumer); verifyNoMoreInteractions(consumer); }
@Test public void testSameChildTree() { RevTree left = createFeaturesTree(leftSource, "f", 10); RevTree right = left; PreOrderDiffWalk visitor = newVisitor(left, right); visitor.walk(consumer); verifyNoMoreInteractions(consumer); }
@Test public void testCallsRootNode() { RevTree left = testSupport.createFeaturesTree(leftSource, "f", 1); RevTree right = testSupport.createFeaturesTree(rightSource, "f", 2); PreOrderDiffWalk visitor = newVisitor(left, right); visitor.walk(consumer); when(consumer.tree(any(NodeRef.class), any(NodeRef.class))).thenReturn(false); final NodeRef lNode = nodeFor(left); final NodeRef rNode = nodeFor(right); ArgumentCaptor<NodeRef> leftNode = ArgumentCaptor.forClass(NodeRef.class); ArgumentCaptor<NodeRef> rightNode = ArgumentCaptor.forClass(NodeRef.class); verify(consumer, times(1)).tree(leftNode.capture(), rightNode.capture()); assertEquals(lNode, leftNode.getValue()); assertEquals(rNode, rightNode.getValue()); verify(consumer, times(1)).endTree(leftNode.capture(), rightNode.capture()); verifyNoMoreInteractions(consumer); }
@Test public void testCallsRootNode() { RevTree left = RevObjectTestSupport.INSTANCE.createFeaturesTree(leftSource, "f", 1); RevTree right = RevObjectTestSupport.INSTANCE.createFeaturesTree(rightSource, "f", 2); PreOrderDiffWalk visitor = newVisitor(left, right); visitor.walk(consumer); when(consumer.tree(any(NodeRef.class), any(NodeRef.class))).thenReturn(false); final NodeRef lNode = nodeFor(left); final NodeRef rNode = nodeFor(right); ArgumentCaptor<NodeRef> leftNode = ArgumentCaptor.forClass(NodeRef.class); ArgumentCaptor<NodeRef> rightNode = ArgumentCaptor.forClass(NodeRef.class); verify(consumer, times(1)).tree(leftNode.capture(), rightNode.capture()); assertEquals(lNode, leftNode.getValue()); assertEquals(rNode, rightNode.getValue()); verify(consumer, times(1)).endTree(leftNode.capture(), rightNode.capture()); verifyNoMoreInteractions(consumer); }
@Test public void testCallsRootNode() { RevTree left = createFeaturesTree(leftSource, "f", 1); RevTree right = createFeaturesTree(rightSource, "f", 2); PreOrderDiffWalk visitor = newVisitor(left, right); visitor.walk(consumer); when(consumer.tree(any(NodeRef.class), any(NodeRef.class))).thenReturn(false); final NodeRef lNode = nodeFor(left); final NodeRef rNode = nodeFor(right); ArgumentCaptor<NodeRef> leftNode = ArgumentCaptor.forClass(NodeRef.class); ArgumentCaptor<NodeRef> rightNode = ArgumentCaptor.forClass(NodeRef.class); verify(consumer, times(1)).tree(leftNode.capture(), rightNode.capture()); assertEquals(lNode, leftNode.getValue()); assertEquals(rNode, rightNode.getValue()); verify(consumer, times(1)).endTree(leftNode.capture(), rightNode.capture()); verifyNoMoreInteractions(consumer); }
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()); }