How to use

setReportTrees

method

in

org.locationtech.geogig.plumbing.DiffTree

    .setReportTrees(true).setOldTree(ancestor.get()).setNewTree(commit.getId())
    .setPreserveIterationOrder(true).call();
commitDiffs.add(toMergeDiffs);

    .setReportTrees(true).setOldTree(ancestor.get()).setNewTree(commit.getId())
    .setPreserveIterationOrder(true).call();
commitDiffs.add(toMergeDiffs);

/**
 * Finds differences between the tree pointed to by the given ref and the index.
 * 
 * @return an iterator to a set of differences between the two trees
 * @see DiffEntry
 */
@Override
protected AutoCloseableIterator<DiffEntry> _call() {
  final String oldVersion = Optional.fromNullable(refSpec).or(Ref.HEAD);
  final Optional<ObjectId> rootTreeId;
  rootTreeId = command(ResolveTreeish.class).setTreeish(oldVersion).call();
  Preconditions.checkArgument(rootTreeId.isPresent(), "refSpec %s did not resolve to a tree",
      oldVersion);
  final RevTree rootTree;
  rootTree = command(RevObjectParse.class).setObjectId(rootTreeId.get()).call(RevTree.class)
      .get();
  final RevTree newTree = stagingArea().getTree();
  DiffTree diff = command(DiffTree.class).setPathFilter(this.pathFilters)
      .setReportTrees(this.reportTrees).setOldTree(rootTree.getId())
      .setNewTree(newTree.getId()).setPreserveIterationOrder(preserveIterationOrder)
      .setMaxDiffs(limit);
  return diff.call();
}

/**
 * Finds differences between the tree pointed to by the given ref and the index.
 * 
 * @return an iterator to a set of differences between the two trees
 * @see DiffEntry
 */
@Override
protected AutoCloseableIterator<DiffEntry> _call() {
  final String oldVersion = Optional.fromNullable(refSpec).or(Ref.HEAD);
  final Optional<ObjectId> rootTreeId;
  rootTreeId = command(ResolveTreeish.class).setTreeish(oldVersion).call();
  Preconditions.checkArgument(rootTreeId.isPresent(), "refSpec %s did not resolve to a tree",
      oldVersion);
  final RevTree rootTree;
  rootTree = command(RevObjectParse.class).setObjectId(rootTreeId.get()).call(RevTree.class)
      .get();
  final RevTree newTree = stagingArea().getTree();
  DiffTree diff = command(DiffTree.class).setPathFilter(this.pathFilters)
      .setReportTrees(this.reportTrees).setOldTree(rootTree.getId())
      .setNewTree(newTree.getId()).setPreserveIterationOrder(preserveIterationOrder)
      .setMaxDiffs(limit);
  return diff.call();
}

/**
 * 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();
}

/**
 * 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();
}

DiffTree diffs = command(DiffTree.class).setRecursive(false).setReportTrees(false)
    .setOldTree(leftTreeId).setNewTree(rightTreeId)
    .setPathFilter(new ArrayList<>(strippedPathFilters)).setCustomFilter(null);

DiffTree diffs = command(DiffTree.class).setRecursive(false).setReportTrees(false)
    .setOldTree(leftTreeId).setNewTree(rightTreeId)
    .setPathFilter(new ArrayList<>(strippedPathFilters)).setCustomFilter(null);

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

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

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

.setPathFilter(pathFilter).setReportTrees(reportTrees)
.setPreserveIterationOrder(preserveIterationOrder).call();

.setPathFilter(pathFilter).setReportTrees(reportTrees)
.setPreserveIterationOrder(preserveIterationOrder).call();

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

.setNewTree(parentTreeId).setOldTree(commit.getTreeId()).setReportTrees(false)
.call()) {

.setNewTree(commit.getTreeId()).setReportTrees(true);

try (AutoCloseableIterator<DiffEntry> diff = command(DiffTree.class)
    .setOldTree(ancestorCommit.get()).setNewTree(targetCommit.getId())
    .setReportTrees(true).call()) {

try (AutoCloseableIterator<DiffEntry> diff = command(DiffTree.class)
    .setOldTree(ancestorCommit.get()).setNewTree(targetCommit.getId())
    .setReportTrees(true).call()) {

  .setOldTree(parentTreeId).setNewTree(commit.getTreeId()).setReportTrees(true)
  .call()) {
while (diffs.hasNext()) {