Package org.eclipse.jgit.dircache

Examples of org.eclipse.jgit.dircache.DirCacheIterator


    this.treeIdx = treeIdx;
  }

  @Override
  public boolean include(TreeWalk walker) {
    DirCacheIterator i = walker.getTree(treeIdx, DirCacheIterator.class);
    if (i == null)
      return true;

    DirCacheEntry e = i.getDirCacheEntry();
    return e == null || !e.isSkipWorkTree();
  }
View Full Code Here


    if (state.walk != null) {
      // If there is a matching DirCacheIterator, we can reuse
      // its idBuffer, but only if we appear to be clean against
      // the cached index information for the path.
      //
      DirCacheIterator i = state.walk.getTree(state.dirCacheTree,
          DirCacheIterator.class);
      if (i != null) {
        DirCacheEntry ent = i.getDirCacheEntry();
        if (ent != null && compareMetadata(ent) == MetadataDiff.EQUAL) {
          contentIdOffset = i.idOffset();
          contentIdFromPtr = ptr;
          return contentId = i.idBuffer();
        }
        contentIdOffset = 0;
      } else {
        contentIdOffset = 0;
      }
View Full Code Here

    if (n == 1) // Assume they meant difference to empty tree.
      return true;

    final int m = walker.getRawMode(baseTree);
    for (int i = 1; i < n; i++) {
      DirCacheIterator baseDirCache = walker.getTree(baseTree,
          DirCacheIterator.class);
      DirCacheIterator newDirCache = walker.getTree(i,
          DirCacheIterator.class);
      if (baseDirCache != null && newDirCache != null) {
        DirCacheEntry baseDci = baseDirCache.getDirCacheEntry();
        DirCacheEntry newDci = newDirCache.getDirCacheEntry();
        if (baseDci != null && newDci != null) {
          if (baseDci.isAssumeValid() != newDci.isAssumeValid())
            return true;
          if (baseDci.isAssumeValid()) // && newDci.isAssumeValid()
            return false;
View Full Code Here

          } finally {
            reader.release();
          }
          oldTree = p;
        }
        newTree = new DirCacheIterator(repo.readDirCache());
      } else {
        if (oldTree == null)
          oldTree = new DirCacheIterator(repo.readDirCache());
        if (newTree == null)
          newTree = new FileTreeIterator(repo);
      }

      diffFmt.setPathFilter(pathFilter);
View Full Code Here

        p.reset(reader, head);
      } finally {
        reader.release();
      }
      oldTree = p;
      newTree = new DirCacheIterator(db.readDirCache());
    } else if (scope.equals(GitConstants.KEY_DIFF_DEFAULT)) {
      oldTree = new DirCacheIterator(db.readDirCache());
    } else {
      oldTree = getTreeIterator(db, scope);
    }

    String[] paths = request.getParameterValues(ProtocolConstants.KEY_PATH);
View Full Code Here

    try {
      DirCacheBuilder builder = dc.builder();

      walk = new TreeWalk(repo);
      walk.addTree(tree);
      walk.addTree(new DirCacheIterator(dc));
      walk.setRecursive(true);

      while (walk.next()) {
        AbstractTreeIterator cIter = walk.getTree(0, AbstractTreeIterator.class);
        if (cIter == null) {
          // Not in commit, don't add to new index
          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();
          entry.setLastModified(indexEntry.getLastModified());
          entry.setLength(indexEntry.getLength());
        }

        builder.add(entry);
View Full Code Here

    // add the trees (tree, dirchache, workdir)
    if (tree != null)
      treeWalk.addTree(tree);
    else
      treeWalk.addTree(new EmptyTreeIterator());
    treeWalk.addTree(new DirCacheIterator(dirCache));
    treeWalk.addTree(initialWorkingTreeIterator);
    Collection<TreeFilter> filters = new ArrayList<TreeFilter>(4);

    if (monitor != null) {
      // Get the maximum size of the work tree and index
      // and add some (quite arbitrary)
      if (estIndexSize == 0)
        estIndexSize = dirCache.getEntryCount();
      int total = Math.max(estIndexSize * 10 / 9,
          estWorkTreeSize * 10 / 9);
      monitor.beginTask(title, total);
      filters.add(new ProgressReportingFilter(monitor, total));
    }

    if (filter != null)
      filters.add(filter);
    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 {
          // in repo, not in index => removed
          removed.add(treeWalk.getPathString());
          if (workingTreeIterator != null)
            untracked.add(treeWalk.getPathString());
        }
      } else {
        if (dirCacheIterator != null) {
          // not in repo, in index => added
          added.add(treeWalk.getPathString());
        } else {
          // not in repo, not in index => untracked
          if (workingTreeIterator != null
              && !workingTreeIterator.isEntryIgnored()) {
            untracked.add(treeWalk.getPathString());
          }
        }
      }

      if (dirCacheIterator != null) {
        if (workingTreeIterator == null) {
          // in index, not in workdir => missing
          missing.add(treeWalk.getPathString());
        } else {
          if (workingTreeIterator.isModified(
              dirCacheIterator.getDirCacheEntry(), true)) {
            // in index, in workdir, content differs => modified
            modified.add(treeWalk.getPathString());
          }
        }
      }
View Full Code Here

    TreeWalk treeWalk = new TreeWalk(repository);
    treeWalk.reset();
    treeWalk.setRecursive(true);
    // add the trees (tree, dirchache, workdir)
    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) {
          // not in repo, in index => added
          added.add(dirCacheIterator.getEntryPathString());
          changesExist = true;
        } else {
          // not in repo, not in index => untracked
          if (workingTreeIterator != null
              && !workingTreeIterator.isEntryIgnored()) {
            untracked.add(workingTreeIterator.getEntryPathString());
            changesExist = true;
          }
        }
      }

      if (dirCacheIterator != null) {
        if (workingTreeIterator == null) {
          // in index, not in workdir => missing
          missing.add(dirCacheIterator.getEntryPathString());
          changesExist = true;
        } else {
          if (!dirCacheIterator.idEqual(workingTreeIterator)) {
            // in index, in workdir, content differs => modified
            modified.add(dirCacheIterator.getEntryPathString());
            changesExist = true;
          }
        }
      }
    }
View Full Code Here

    }

    final TreeWalk tw = new TreeWalk(db);
    tw.reset();
    tw.setPostOrderTraversal(false);
    tw.addTree(new DirCacheIterator(tree));

    assertModes("a", REGULAR_FILE, tw);
    assertModes("b", TREE, tw);
    assertTrue(tw.isSubtree());
    assertFalse(tw.isPostChildren());
View Full Code Here

    }

    final TreeWalk tw = new TreeWalk(db);
    tw.reset();
    tw.setPostOrderTraversal(true);
    tw.addTree(new DirCacheIterator(tree));

    assertModes("a", REGULAR_FILE, tw);

    assertModes("b", TREE, tw);
    assertTrue(tw.isSubtree());
View Full Code Here

TOP

Related Classes of org.eclipse.jgit.dircache.DirCacheIterator

Copyright © 2018 www.massapicom. All rights reserved.
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.