Examples of org.eclipse.jgit.treewalk.AbstractTreeIterator

org.eclipse.jgit.treewalk.AbstractTreeIterator
Walks a Git tree (directory) in Git sort order.
A new iterator instance should be positioned on the first entry, or at eof. Data for the first entry (if not at eof) should be available immediately.
Implementors must walk a tree in the Git sort order, which has the following odd sorting:
1. A.c
2. A/c
3. A0c
In the second item, A is the name of a subtree and c is a file within that subtree. The other two items are files in the root level tree. @see CanonicalTreeParser

    filters.add(new SkipWorkTreeFilter(INDEX));
    indexDiffFilter = new IndexDiffFilter(INDEX, WORKDIR);
    filters.add(indexDiffFilter);
    treeWalk.setFilter(AndTreeFilter.create(filters));
    while (treeWalk.next()) {
      AbstractTreeIterator treeIterator = treeWalk.getTree(TREE,
          AbstractTreeIterator.class);
      DirCacheIterator dirCacheIterator = treeWalk.getTree(INDEX,
          DirCacheIterator.class);
      WorkingTreeIterator workingTreeIterator = treeWalk.getTree(WORKDIR,
          WorkingTreeIterator.class);


      if (dirCacheIterator != null) {
        final DirCacheEntry dirCacheEntry = dirCacheIterator
            .getDirCacheEntry();
        if (dirCacheEntry != null && dirCacheEntry.getStage() > 0) {
          conflicts.add(treeWalk.getPathString());
          continue;
        }
      }


      if (treeIterator != null) {
        if (dirCacheIterator != null) {
          if (!treeIterator.idEqual(dirCacheIterator)
              || treeIterator.getEntryRawMode()
              != dirCacheIterator.getEntryRawMode()) {
            // in repo, in index, content diff => changed
            changed.add(treeWalk.getPathString());
          }
        } else {

View Full Code Here

    treeWalk.addTree(tree);
    treeWalk.addTree(new DirCacheIterator(dirCache));
    treeWalk.addTree(initialWorkingTreeIterator);
    treeWalk.setFilter(TreeFilter.ANY_DIFF);
    while (treeWalk.next()) {
      AbstractTreeIterator treeIterator = treeWalk.getTree(TREE,
          AbstractTreeIterator.class);
      DirCacheIterator dirCacheIterator = treeWalk.getTree(INDEX,
          DirCacheIterator.class);
      WorkingTreeIterator workingTreeIterator = treeWalk.getTree(WORKDIR,
          WorkingTreeIterator.class);
      FileMode fileModeTree = treeWalk.getFileMode(TREE);


      if (treeIterator != null) {
        if (dirCacheIterator != null) {
          if (!treeIterator.getEntryObjectId().equals(
              dirCacheIterator.getEntryObjectId())) {
            // in repo, in index, content diff => changed
            changed.add(dirCacheIterator.getEntryPathString());
            changesExist = true;
          }
        } else {
          // in repo, not in index => removed
          if (!fileModeTree.equals(FileMode.TYPE_TREE)) {
            removed.add(treeIterator.getEntryPathString());
            changesExist = true;
          }
        }
      } else {
        if (dirCacheIterator != null) {

View Full Code Here

    private static boolean nonTree(final int mode) {
      return mode != 0 && !FileMode.TREE.equals(mode);
    }


    private void add(final int tree, final int stage) throws IOException {
      final AbstractTreeIterator i = getTree(tree);
      if (i != null) {
        if (FileMode.TREE.equals(tw.getRawMode(tree))) {
          builder.addTree(tw.getRawPath(), stage, reader, tw
              .getObjectId(tree));
        } else {
          final DirCacheEntry e;


          e = new DirCacheEntry(tw.getRawPath(), stage);
          e.setObjectIdFromRaw(i.idBuffer(), i.idOffset());
          e.setFileMode(tw.getFileMode(tree));
          builder.add(e);
        }
      }
    }

View Full Code Here

    }
  }


  private DirCacheEntry toEntry(final int stage, final TreeWalk tw) {
    final DirCacheEntry e = new DirCacheEntry(tw.getRawPath(), stage);
    final AbstractTreeIterator i;


    i = tw.getTree(0, AbstractTreeIterator.class);
    e.setFileMode(tw.getFileMode(0));
    e.setObjectIdFromRaw(i.idBuffer(), i.idOffset());
    return e;
  }

View Full Code Here

    String purposedir = args[1];
    String olderBranch = args[2];
    
    Repository repo = openGitRepository();
    String importBranch = repo.getBranch();
    AbstractTreeIterator oldTreeParser = gitTreeParser(repo, "refs/heads/" + olderBranch);
    AbstractTreeIterator importTreeParser = gitTreeParser(repo, "refs/heads/" + importBranch);


    List<DiffEntry> diff = new Git(repo).diff().setOldTree(oldTreeParser).setNewTree(importTreeParser).call();


    System.out.println("Creating ../git-modified-list.txt file");
    PrintWriter writer = new PrintWriter("git-modified-list.txt", "UTF-8");

View Full Code Here


        DiffFormatter formatter = new DiffFormatter(NullOutputStream.INSTANCE);
        formatter.setRepository(fakeRepo);
        formatter.setDetectRenames(true);


        AbstractTreeIterator treeParserA, treeParserB;
        RevTree treeA = null, treeB = null;


        if (commitA != null) {
            treeA = new RevWalk(repositoryA).parseTree(commitA);
            treeParserA = new CanonicalTreeParser();

View Full Code Here


  private void scanForConflicts(TreeWalk treeWalk) throws IOException {
    File workingTree = repo.getWorkTree();
    while (treeWalk.next()) {
      // State of the stashed index and working directory
      AbstractTreeIterator stashIndexIter = treeWalk.getTree(1,
          AbstractTreeIterator.class);
      AbstractTreeIterator stashWorkingIter = treeWalk.getTree(2,
          AbstractTreeIterator.class);


      // State of the current HEAD, index, and working directory
      AbstractTreeIterator headIter = treeWalk.getTree(3,
          AbstractTreeIterator.class);
      AbstractTreeIterator indexIter = treeWalk.getTree(4,
          AbstractTreeIterator.class);
      AbstractTreeIterator workingIter = treeWalk.getTree(5,
          AbstractTreeIterator.class);


      if (isConflict(stashIndexIter, stashWorkingIter, headIter,
          indexIter, workingIter)) {
        String path = treeWalk.getPathString();

View Full Code Here

    while (treeWalk.next()) {
      String path = treeWalk.getPathString();
      File file = new File(workingTree, path);


      // State of the stashed HEAD, index, and working directory
      AbstractTreeIterator stashHeadIter = treeWalk.getTree(0,
          AbstractTreeIterator.class);
      AbstractTreeIterator stashIndexIter = treeWalk.getTree(1,
          AbstractTreeIterator.class);
      AbstractTreeIterator stashWorkingIter = treeWalk.getTree(2,
          AbstractTreeIterator.class);


      if (stashWorkingIter != null && stashIndexIter != null) {
        // Checkout index change
        DirCacheEntry entry = cache.getEntry(path);
        if (entry == null)
          entry = new DirCacheEntry(treeWalk.getRawPath());
        entry.setFileMode(stashIndexIter.getEntryFileMode());
        entry.setObjectId(stashIndexIter.getEntryObjectId());
        DirCacheCheckout.checkoutEntry(repo, file, entry,
            treeWalk.getObjectReader());
        final DirCacheEntry updatedEntry = entry;
        editor.add(new PathEdit(path) {


          public void apply(DirCacheEntry ent) {
            ent.copyMetaData(updatedEntry);
          }
        });


        // Checkout working directory change
        if (!stashWorkingIter.idEqual(stashIndexIter)) {
          entry = new DirCacheEntry(treeWalk.getRawPath());
          entry.setObjectId(stashWorkingIter.getEntryObjectId());
          DirCacheCheckout.checkoutEntry(repo, file, entry,
              treeWalk.getObjectReader());
        }
      } else {
        if (stashIndexIter == null

View Full Code Here

      walk.addTree(commit.getTree());
      walk.addTree(new DirCacheIterator(dc));
      walk.setRecursive(true);


      while (walk.next()) {
        AbstractTreeIterator cIter = walk.getTree(0,
            AbstractTreeIterator.class);
        if (cIter == null) {
          editor.add(new DeletePath(walk.getPathString()));
          continue;
        }


        final DirCacheEntry entry = new DirCacheEntry(walk.getRawPath());
        entry.setFileMode(cIter.getEntryFileMode());
        entry.setObjectIdFromRaw(cIter.idBuffer(), cIter.idOffset());


        DirCacheIterator dcIter = walk.getTree(1,
            DirCacheIterator.class);
        if (dcIter != null && dcIter.idEqual(cIter)) {
          DirCacheEntry indexEntry = dcIter.getDirCacheEntry();

View Full Code Here

    }
  }


  private DirCacheEntry toEntry(final int stage, final TreeWalk tw) {
    final DirCacheEntry e = new DirCacheEntry(tw.getRawPath(), stage);
    final AbstractTreeIterator i;


    i = tw.getTree(0, AbstractTreeIterator.class);
    e.setFileMode(tw.getFileMode(0));
    e.setObjectIdFromRaw(i.idBuffer(), i.idOffset());
    return e;
  }

View Full Code Here

0 1 2 3 4

TOP

Related Classes of org.eclipse.jgit.treewalk.AbstractTreeIterator

com.liferay.documentation.util.GitCompare

org.apache.maven.scm.provider.git.jgit.command.diff.JGitDiffCommand

org.dstadler.jgit.porcelain.ShowBranchDiff

org.dstadler.jgit.porcelain.ShowFileDiff

org.eclipse.egit.core.op.BranchOperation

org.eclipse.egit.core.test.ContainerTreeIteratorResourceFilterTest

org.eclipse.egit.ui.internal.dialogs.CompareTreeView

org.eclipse.egit.ui.internal.merge.GitCompareEditorInput

org.eclipse.egit.ui.internal.merge.GitMergeEditorInput

org.eclipse.jgit.api.ResetCommand

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.