How to use

DiffTree

in

org.locationtech.geogig.plumbing

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;
}