protected @Override List<DiffEntry> _call() { TreeChangesCollector collector = new TreeChangesCollector(); DiffTree diffTree = command(DiffTree.class)// .setPreserveIterationOrder(false)// .setReportFeatures(false)// .setReportTrees(true)// .setPathFilter(this.pathFilters)// .setLeftSource(leftSource)// .setRightSource(rightSource); if (oldTree != null) { diffTree.setOldTree(oldTree); } else if (oldTreeId != null) { diffTree.setOldTree(oldTreeId); } else { diffTree.setOldVersion(oldRefSpec); } if (newTree != null) { diffTree.setNewTree(newTree); } else if (newTreeId != null) { diffTree.setNewTree(newTreeId); } else { diffTree.setNewVersion(newRefSpec); } diffTree.call(collector); List<DiffEntry> res = new ArrayList<>(collector.queue); return res; }
private List<DiffEntry> findWithDiffTreeCommandReportingOnlyTrees(RevTree left, RevTree right) { try (AutoCloseableIterator<DiffEntry> it = repo.command(DiffTree.class)// .setPreserveIterationOrder(false)// .setReportFeatures(false)// .setReportTrees(true)// .setOldTree(left)// .setNewTree(right)// .call()) { return Lists.newArrayList(it); } }
private List<DiffEntry> getExpectedEntries(String layerName, String oldHead, String newHead) { AutoCloseableIterator<DiffEntry> diffs = repo.command(DiffTree.class) .setPathFilter(layerName).setOldVersion(oldHead).setNewVersion(newHead).call(); return Lists.newArrayList(diffs); }
@Test public void testTreePathFiltering() { ObjectDatabase db = geogig.getContext().objectDatabase(); RevTree tree1 = tree(100, db); RevTree tree2 = tree(50, db); RevTree root = createRoot(db, tree1, tree2); List<String> pathFilters = ImmutableList.of("tree1"); diffTree.setOldTree(ObjectId.NULL).setNewTree(root.getId()).setPathFilter(pathFilters); List<DiffEntry> diffs = ImmutableList.copyOf(diffTree.call()); assertEquals(tree1.size(), diffs.size()); pathFilters = ImmutableList.of("tree2"); diffTree.setOldTree(ObjectId.NULL).setNewTree(root.getId()).setPathFilter(pathFilters); diffs = ImmutableList.copyOf(diffTree.call()); assertEquals(tree2.size(), diffs.size()); pathFilters = ImmutableList.of("tree1/1", "tree1/2", "tree1/3", "tree1/4", "tree2/2", "tree2/3", "tree2/10"); diffTree.setOldTree(ObjectId.NULL).setNewTree(root.getId()).setPathFilter(pathFilters); diffs = ImmutableList.copyOf(diffTree.call()); assertEquals(pathFilters.size(), diffs.size()); }
/** * If no {@link #setOldVersion(String) old version} was set, returns the differences between the * working tree and the index, otherwise the differences between the working tree and the * specified revision. * * @return an iterator to a set of differences between the two trees * @see DiffEntry */ @Override protected AutoCloseableIterator<DiffEntry> _call() { final Optional<String> ref = Optional.fromNullable(refSpec); final RevTree oldTree = ref.isPresent() ? getOldTree() : stagingArea().getTree(); final RevTree newTree = workingTree().getTree(); DiffTree diff = command(DiffTree.class).setReportTrees(this.reportTrees) .setOldTree(oldTree.getId()).setNewTree(newTree.getId()).setMaxDiffs(limit) .setPreserveIterationOrder(preserveIterationOrder); if (this.pathFilter != null) { diff.setPathFilter(ImmutableList.of(pathFilter)); } return diff.call(); }
} else { iterator = command(DiffTree.class).setOldVersion(oldRefSpec).setNewVersion(newRefSpec) .setPathFilter(pathFilter).setReportTrees(reportTrees) .setPreserveIterationOrder(preserveIterationOrder).call();
@Test public void testInvalidOldVersion() { exception.expect(IllegalArgumentException.class); diffTree.setOldVersion("abcdef0123").setNewVersion(Ref.HEAD).call(); }
info.diffOp.setDefaultMetadataId(featureTypeId) // .setPreserveIterationOrder(preserveIterationOrder)// .setPathFilter(createFidFilter(info.nativeFilter)) // .setCustomFilter(indexPreFilter) // .setBoundsFilter(boundsPreFilter) // .setChangeTypeFilter(resolveChangeType()) // .setOldTree(oldFeatureTypeTree) // .setNewTree(newFeatureTypeTree) // .setLeftSource(leftSource) // .setRightSource(rightSource) // .setNodeOrdering(diffNodeOrdering)// .recordStats();
private AutoCloseableIterator<DiffEntry> buildDiffEntries(GeogigCLI cli) { org.locationtech.geogig.plumbing.DiffTree diff = cli.getGeogig() .command(org.locationtech.geogig.plumbing.DiffTree.class); String oldVersion = resolveOldVersion(); String newVersion = resolveNewVersion(); diff.setOldVersion(oldVersion).setNewVersion(newVersion); AutoCloseableIterator<DiffEntry> diffEntries; if (paths.isEmpty()) { diffEntries = diff.setProgressListener(cli.getProgressListener()).call(); } else { diffEntries = AutoCloseableIterator.emptyIterator(); for (String path : paths) { AutoCloseableIterator<DiffEntry> moreEntries = diff.setPathFilter(path) .setProgressListener(cli.getProgressListener()).call(); diffEntries = AutoCloseableIterator.concat(diffEntries, moreEntries); } } return diffEntries; }
DiffTree diffs = command(DiffTree.class).setRecursive(false).setReportTrees(false) .setOldTree(leftTreeId).setNewTree(rightTreeId) .setPathFilter(new ArrayList<>(strippedPathFilters)).setCustomFilter(null); try (AutoCloseableIterator<DiffEntry> sourceIterator = diffs.get()) { Iterator<DiffEntry> updatedIterator = sourceIterator; if (!strippedPathFilters.isEmpty()) {
private void assertChangeTypeFilter(final ObjectId leftTree, final ObjectId rightTree, final int expectedAdds, final int expectedRemoves, final int expectedChanges) { List<DiffEntry> list; diffTree.setOldTree(leftTree).setNewTree(rightTree); diffTree.setChangeTypeFilter(ChangeType.ADDED); list = newArrayList(diffTree.call()); assertEquals(list.toString(), expectedAdds, list.size()); diffTree.setChangeTypeFilter(ChangeType.REMOVED); list = newArrayList(diffTree.call()); assertEquals(list.toString(), expectedRemoves, list.size()); diffTree.setChangeTypeFilter(ChangeType.MODIFIED); list = newArrayList(diffTree.call()); assertEquals(list.toString(), expectedChanges, list.size()); }
@Test public void testNullTrees() { try (AutoCloseableIterator<DiffEntry> diffs = diffTree.setOldTree(ObjectId.NULL) .setNewTree(ObjectId.NULL).call()) { assertFalse(diffs.hasNext()); } }
/** * Implements {@link Supplier#get()} by delegating to {@link #call()}. */ @Override public AutoCloseableIterator<DiffEntry> get() { return call(); }
@Test public void testNoNewVersionSet() { exception.expect(IllegalArgumentException.class); exception.expectMessage("new version"); diffTree.setOldVersion(Ref.HEAD).call(); }
/** * Verifies the index was using by inspecting {@link DiffTree#setNewTree} was given the index * objectId */ private void verifyUsesIndex(Index index) { ObjectId indexTreeId = index.indexTreeId(); verify(difftree).setNewTree(eq(indexTreeId)); }
/** * @param path the path filter to use during the diff operation, replaces any other filter * previously set * @return {@code this} */ public DiffTree setPathFilter(@Nullable String path) { if (path == null) { setPathFilter((List<String>) null); } else { setPathFilter(ImmutableList.of(path)); } return this; }
diff.setPreserveIterationOrder(false); diff.call(consumer); } else { final int attributeIndex = findAttributeIndex(propertyName, nativeType); ObjectStore store = source.getRepository().objectDatabase(); try (AutoCloseableIterator<NodeRef> refs = FeatureReaderBuilder .toFeatureRefs(diff.call(), ChangeType.ADDED)) { try (AutoCloseableIterator<ObjectInfo<RevFeature>> features = new BulkFeatureRetriever( store, store).getGeoGIGFeatures(refs)) {
diffWalkInfo.diffOp.setConsumerWrapper(diffMerger); AutoCloseableIterator<DiffEntry> entries = diffWalkInfo.diffOp.call(); try { BulkFeatureRetriever retriever = new BulkFeatureRetriever(leftContext.objectDatabase(),
@Test public void testTreePathFiltering() { ObjectDatabase db = geogig.getContext().objectDatabase(); RevTree tree1 = tree(100, db); RevTree tree2 = tree(50, db); RevTree root = createRoot(db, tree1, tree2); List<String> pathFilters = ImmutableList.of("tree1"); diffTree.setOldTree(ObjectId.NULL).setNewTree(root.getId()).setPathFilter(pathFilters); List<DiffEntry> diffs = ImmutableList.copyOf(diffTree.call()); assertEquals(tree1.size(), diffs.size()); pathFilters = ImmutableList.of("tree2"); diffTree.setOldTree(ObjectId.NULL).setNewTree(root.getId()).setPathFilter(pathFilters); diffs = ImmutableList.copyOf(diffTree.call()); assertEquals(tree2.size(), diffs.size()); pathFilters = ImmutableList.of("tree1/1", "tree1/2", "tree1/3", "tree1/4", "tree2/2", "tree2/3", "tree2/10"); diffTree.setOldTree(ObjectId.NULL).setNewTree(root.getId()).setPathFilter(pathFilters); diffs = ImmutableList.copyOf(diffTree.call()); assertEquals(pathFilters.size(), diffs.size()); }
@Override protected MergeScenarioReport _call() { if (consumer == null) { consumer = new MergeScenarioConsumer(); } final Optional<ObjectId> ancestorOpt = command(FindCommonAncestor.class).setLeft(toMerge) .setRight(mergeInto).call(); Preconditions.checkState(ancestorOpt.isPresent(), "No ancestor commit could be found."); final ObjectId ancestor = ancestorOpt.get(); MergeScenarioReport report = null; try (AutoCloseableIterator<DiffEntry> mergeIntoDiffs = command(DiffTree.class) .setOldTree(ancestor).setReportTrees(true).setNewTree(mergeInto.getId()) .setPreserveIterationOrder(true).call(); AutoCloseableIterator<DiffEntry> toMergeDiffs = command(DiffTree.class) .setOldTree(ancestor).setReportTrees(true).setNewTree(toMerge.getId()) .setPreserveIterationOrder(true).call();) { Iterator<MergeDiffRef> tupleIterator = new MergeDiffIterator(mergeIntoDiffs, toMergeDiffs); final RevCommit ancestorCommit = objectDatabase().getCommit(ancestor); final RevTree ancestorTree = objectDatabase().getTree(ancestorCommit.getTreeId()); report = process(tupleIterator, ancestorTree); } return report; }