import org.eclipse.jgit.dircache.DirCacheEditor; //导入依赖的package包/类
/**
 * Apply the changes that this {@link TreeUpdate} represents to the given
 * {@link DirCache}. The {@link DirCache} will be unlocked if was modified.
 *
 * @param dirCache
 * @return true if updates are applied to the {@link DirCache}, false if the
 *         {@link DirCache} has not been modified.
 */
public ObjectId apply(ObjectInserter objectInserter) {
	ObjectId newTreeId = null;
	if (hasUpdates()) {
		DirCacheEditor editor = index.editor();

		for (PathEdit pathEdit : pathEdits) {
			editor.add(pathEdit);
		}

		editor.finish();

		try {
			// Write the index as tree to the object database. This may
			// fail for example when the index contains unmerged paths
			// (unresolved conflicts)
			newTreeId = index.writeTree(objectInserter);
		} catch (IOException e) {
			throw new GitRepositoryException(e);
		}
	}
	return newTreeId;
}
 

import org.eclipse.jgit.dircache.DirCacheEditor; //导入依赖的package包/类
@Test
public void deleteFilesWithDirCacheEditorTest() {
  DirCache cache = setupCache("a/b/c1.txt",
                               "a/b/c2.txt",
                               "a/c3.txt",
                               "a/c4.txt",
                               "a/c5.txt",
                               "a/c6.txt");

  DirCacheEditor editor = cache.editor();
  CacheUtils.deleteFile("a/b/c1.txt", editor);
  CacheUtils.deleteFile("a/c3.txt", editor);
  CacheUtils.deleteFile("a/c4.txt", editor);
  CacheUtils.deleteFile("a/c6.txt", editor);
  editor.finish();

  assertEquals(2, cache.getEntryCount());
  assertNull(cache.getEntry("a/b/c1.txt"));
  assertNotNull(cache.getEntry("a/b/c2.txt"));
  assertNotNull(cache.getEntry("a/c5.txt"));
}
 

import org.eclipse.jgit.dircache.DirCacheEditor; //导入依赖的package包/类
@Test
public void deleteMultipleTreesTest() {
  DirCache cache = setupCache("a/b/c1.txt",
                               "a/b/c2.txt",
                               "a/d/c3.txt",
                               "a/d/c4.txt",
                               "a/c5.txt",
                               "a/c6.txt");

  DirCacheEditor editor = cache.editor();
  CacheUtils.deleteDirectory("a/b", editor);
  CacheUtils.deleteDirectory("a/d", editor);
  editor.finish();

  assertEquals(2, cache.getEntryCount());
  assertNotNull(cache.getEntry("a/c5.txt"));
  assertNotNull(cache.getEntry("a/c6.txt"));
}
 

import org.eclipse.jgit.dircache.DirCacheEditor; //导入依赖的package包/类
@Override
public List<DirCacheEditor.PathEdit> getPathEdits(Repository repository, RevCommit baseCommit)
    throws IOException {
  try (RevWalk revWalk = new RevWalk(repository)) {
    revWalk.parseHeaders(baseCommit);
    try (TreeWalk treeWalk =
        TreeWalk.forPath(revWalk.getObjectReader(), currentFilePath, baseCommit.getTree())) {
      if (treeWalk == null) {
        return Collections.emptyList();
      }
      DirCacheEditor.DeletePath deletePathEdit = new DirCacheEditor.DeletePath(currentFilePath);
      AddPath addPathEdit =
          new AddPath(newFilePath, treeWalk.getFileMode(0), treeWalk.getObjectId(0));
      return Arrays.asList(deletePathEdit, addPathEdit);
    }
  }
}
 

import org.eclipse.jgit.dircache.DirCacheEditor; //导入依赖的package包/类
protected void saveFile(String fileName, byte[] raw) throws IOException {
  DirCacheEditor editor = newTree.editor();
  if (raw != null && 0 < raw.length) {
    final ObjectId blobId = inserter.insert(Constants.OBJ_BLOB, raw);
    editor.add(
        new PathEdit(fileName) {
          @Override
          public void apply(DirCacheEntry ent) {
            ent.setFileMode(FileMode.REGULAR_FILE);
            ent.setObjectId(blobId);
          }
        });
  } else {
    editor.add(new DeletePath(fileName));
  }
  editor.finish();
}
 

import org.eclipse.jgit.dircache.DirCacheEditor; //导入依赖的package包/类
public Optional<ObjectId> execute() {
    final Map<String, String> content = commitContent.getContent();
    final DirCacheEditor editor = DirCache.newInCore().editor();
    final List<String> pathsAdded = new ArrayList<>();

    try {
        iterateOverTreeWalk(git,
                            headId,
                            (walkPath, hTree) -> {
                                final String toPath = content.get(walkPath);
                                final DirCacheEntry dcEntry = new DirCacheEntry((toPath == null) ? walkPath : toPath);
                                if (!pathsAdded.contains(dcEntry.getPathString())) {
                                    addToTemporaryInCoreIndex(editor,
                                                              dcEntry,
                                                              hTree.getEntryObjectId(),
                                                              hTree.getEntryFileMode());
                                    pathsAdded.add(dcEntry.getPathString());
                                }
                            });
        editor.finish();
    } catch (final Exception e) {
        throw new RuntimeException(e);
    }

    return buildTree(editor);
}
 

import org.eclipse.jgit.dircache.DirCacheEditor; //导入依赖的package包/类
public Optional<ObjectId> execute() {
    final DirCacheEditor editor = DirCache.newInCore().editor();

    try {
        iterateOverTreeWalk(git,
                            headId,
                            (walkPath, hTree) -> {
                                addToTemporaryInCoreIndex(editor,
                                                          new DirCacheEntry(walkPath),
                                                          hTree.getEntryObjectId(),
                                                          hTree.getEntryFileMode());
                            });

        editor.finish();
    } catch (final Exception e) {
        throw new RuntimeException(e);
    }

    return buildTree(editor);
}
 

import org.eclipse.jgit.dircache.DirCacheEditor; //导入依赖的package包/类
private List<DirCacheEditor.PathEdit> getPathEdits(Repository repository) throws IOException {
  List<DirCacheEditor.PathEdit> pathEdits = new ArrayList<>();
  for (TreeModification treeModification : treeModifications) {
    pathEdits.addAll(treeModification.getPathEdits(repository, baseCommit));
  }
  return pathEdits;
}
 

import org.eclipse.jgit.dircache.DirCacheEditor; //导入依赖的package包/类
Optional<ObjectId> buildTree(final DirCacheEditor editor) {
    try {
        return Optional.ofNullable(editor.getDirCache().writeTree(odi));
    } catch (Exception ex) {
        throw new RuntimeException(ex);
    }
}
 

import org.eclipse.jgit.dircache.DirCacheEditor; //导入依赖的package包/类
void addToTemporaryInCoreIndex(final DirCacheEditor editor,
                               final DirCacheEntry dcEntry,
                               final ObjectId objectId,
                               final FileMode fileMode) {
    editor.add(new DirCacheEditor.PathEdit(dcEntry) {
        @Override
        public void apply(final DirCacheEntry ent) {
            ent.setObjectId(objectId);
            ent.setFileMode(fileMode);
        }
    });
}
 

import org.eclipse.jgit.dircache.DirCacheEditor; //导入依赖的package包/类
public Optional<ObjectId> execute() {
    final Map<String, String> content = commitContent.getContent();

    final DirCacheEditor editor = DirCache.newInCore().editor();

    try {
        iterateOverTreeWalk(git,
                            headId,
                            (walkPath, hTree) -> {
                                final String toPath = content.get(walkPath);
                                addToTemporaryInCoreIndex(editor,
                                                          new DirCacheEntry(walkPath),
                                                          hTree.getEntryObjectId(),
                                                          hTree.getEntryFileMode());
                                if (toPath != null) {
                                    addToTemporaryInCoreIndex(editor,
                                                              new DirCacheEntry(toPath),
                                                              hTree.getEntryObjectId(),
                                                              hTree.getEntryFileMode());
                                }
                            });

        editor.finish();
    } catch (final Exception e) {
        throw new RuntimeException(e);
    }

    return buildTree(editor);
}
 

import org.eclipse.jgit.dircache.DirCacheEditor; //导入依赖的package包/类
private static void applyPathEdit(DirCache dirCache, PathEdit edit) {
    final DirCacheEditor e = dirCache.editor();
    e.add(edit);
    e.finish();
}
 

import org.eclipse.jgit.dircache.DirCacheEditor; //导入依赖的package包/类
@Override
public void delete() {
	DirCacheEditor.DeletePath deletePath = new DirCacheEditor.DeletePath(
			dirCacheEntry);
	cacheTreeUpdate.registerPathEdit(deletePath);
}
 

import org.eclipse.jgit.dircache.DirCacheEditor; //导入依赖的package包/类
public void insert(Account account) throws IOException {
  File path = getPath();
  if (path != null) {
    try (Repository repo = new FileRepository(path);
        ObjectInserter oi = repo.newObjectInserter()) {
      PersonIdent ident =
          new PersonIdent(
              new GerritPersonIdentProvider(flags.cfg).get(), account.getRegisteredOn());

      Config accountConfig = new Config();
      AccountConfig.writeToConfig(account, accountConfig);

      DirCache newTree = DirCache.newInCore();
      DirCacheEditor editor = newTree.editor();
      final ObjectId blobId =
          oi.insert(Constants.OBJ_BLOB, accountConfig.toText().getBytes(UTF_8));
      editor.add(
          new PathEdit(AccountConfig.ACCOUNT_CONFIG) {
            @Override
            public void apply(DirCacheEntry ent) {
              ent.setFileMode(FileMode.REGULAR_FILE);
              ent.setObjectId(blobId);
            }
          });
      editor.finish();

      ObjectId treeId = newTree.writeTree(oi);

      CommitBuilder cb = new CommitBuilder();
      cb.setTreeId(treeId);
      cb.setCommitter(ident);
      cb.setAuthor(ident);
      cb.setMessage("Create Account");
      ObjectId id = oi.insert(cb);
      oi.flush();

      String refName = RefNames.refsUsers(account.getId());
      RefUpdate ru = repo.updateRef(refName);
      ru.setExpectedOldObjectId(ObjectId.zeroId());
      ru.setNewObjectId(id);
      ru.setRefLogIdent(ident);
      ru.setRefLogMessage("Create Account", false);
      Result result = ru.update();
      if (result != Result.NEW) {
        throw new IOException(
            String.format("Failed to update ref %s: %s", refName, result.name()));
      }
      account.setMetaId(id.name());
    }
  }
}
 

import org.eclipse.jgit.dircache.DirCacheEditor; //导入依赖的package包/类
@Override
public List<DirCacheEditor.PathEdit> getPathEdits(Repository repository, RevCommit baseCommit) {
  DirCacheEditor.PathEdit changeContentEdit = new ChangeContent(filePath, newContent, repository);
  return Collections.singletonList(changeContentEdit);
}
 

import org.eclipse.jgit.dircache.DirCacheEditor; //导入依赖的package包/类
@Override
public List<DirCacheEditor.PathEdit> getPathEdits(Repository repository, RevCommit baseCommit) {
  DirCacheEditor.DeletePath deletePathEdit = new DirCacheEditor.DeletePath(filePath);
  return Collections.singletonList(deletePathEdit);
}
 

import org.eclipse.jgit.dircache.DirCacheEditor; //导入依赖的package包/类
private DirCache createNewTree(Repository repository) throws IOException {
  DirCache newTree = readBaseTree(repository);
  List<DirCacheEditor.PathEdit> pathEdits = getPathEdits(repository);
  applyPathEdits(newTree, pathEdits);
  return newTree;
}
 

import org.eclipse.jgit.dircache.DirCacheEditor; //导入依赖的package包/类
private static void applyPathEdits(DirCache tree, List<DirCacheEditor.PathEdit> pathEdits) {
  DirCacheEditor dirCacheEditor = tree.editor();
  pathEdits.forEach(dirCacheEditor::add);
  dirCacheEditor.finish();
}
 

import org.eclipse.jgit.dircache.DirCacheEditor; //导入依赖的package包/类
/** Create a separate gitlink commit */
public CodeReviewCommit composeGitlinksCommit(Branch.NameKey subscriber)
    throws IOException, SubmoduleException {
  OpenRepo or;
  try {
    or = orm.getRepo(subscriber.getParentKey());
  } catch (NoSuchProjectException | IOException e) {
    throw new SubmoduleException("Cannot access superproject", e);
  }

  CodeReviewCommit currentCommit;
  if (branchTips.containsKey(subscriber)) {
    currentCommit = branchTips.get(subscriber);
  } else {
    Ref r = or.repo.exactRef(subscriber.get());
    if (r == null) {
      throw new SubmoduleException(
          "The branch was probably deleted from the subscriber repository");
    }
    currentCommit = or.rw.parseCommit(r.getObjectId());
    addBranchTip(subscriber, currentCommit);
  }

  StringBuilder msgbuf = new StringBuilder("");
  PersonIdent author = null;
  DirCache dc = readTree(or.rw, currentCommit);
  DirCacheEditor ed = dc.editor();
  for (SubmoduleSubscription s : targets.get(subscriber)) {
    RevCommit newCommit = updateSubmodule(dc, ed, msgbuf, s);
    if (newCommit != null) {
      if (author == null) {
        author = newCommit.getAuthorIdent();
      } else if (!author.equals(newCommit.getAuthorIdent())) {
        author = myIdent;
      }
    }
  }
  ed.finish();
  ObjectId newTreeId = dc.writeTree(or.ins);

  // Gitlinks are already in the branch, return null
  if (newTreeId.equals(currentCommit.getTree())) {
    return null;
  }
  CommitBuilder commit = new CommitBuilder();
  commit.setTreeId(newTreeId);
  commit.setParentId(currentCommit);
  StringBuilder commitMsg = new StringBuilder("Update git submodules\n\n");
  if (verboseSuperProject != VerboseSuperprojectUpdate.FALSE) {
    commitMsg.append(msgbuf);
  }
  commit.setMessage(commitMsg.toString());
  commit.setAuthor(author);
  commit.setCommitter(myIdent);
  ObjectId id = or.ins.insert(commit);
  return or.rw.parseCommit(id);
}
 

import org.eclipse.jgit.dircache.DirCacheEditor; //导入依赖的package包/类
private RevCommit updateSubmodule(
    DirCache dc, DirCacheEditor ed, StringBuilder msgbuf, SubmoduleSubscription s)
    throws SubmoduleException, IOException {
  OpenRepo subOr;
  try {
    subOr = orm.getRepo(s.getSubmodule().getParentKey());
  } catch (NoSuchProjectException | IOException e) {
    throw new SubmoduleException("Cannot access submodule", e);
  }

  DirCacheEntry dce = dc.getEntry(s.getPath());
  RevCommit oldCommit = null;
  if (dce != null) {
    if (!dce.getFileMode().equals(FileMode.GITLINK)) {
      String errMsg =
          "Requested to update gitlink "
              + s.getPath()
              + " in "
              + s.getSubmodule().getParentKey().get()
              + " but entry "
              + "doesn't have gitlink file mode.";
      throw new SubmoduleException(errMsg);
    }
    oldCommit = subOr.rw.parseCommit(dce.getObjectId());
  }

  final CodeReviewCommit newCommit;
  if (branchTips.containsKey(s.getSubmodule())) {
    newCommit = branchTips.get(s.getSubmodule());
  } else {
    Ref ref = subOr.repo.getRefDatabase().exactRef(s.getSubmodule().get());
    if (ref == null) {
      ed.add(new DeletePath(s.getPath()));
      return null;
    }
    newCommit = subOr.rw.parseCommit(ref.getObjectId());
    addBranchTip(s.getSubmodule(), newCommit);
  }

  if (Objects.equals(newCommit, oldCommit)) {
    // gitlink have already been updated for this submodule
    return null;
  }
  ed.add(
      new PathEdit(s.getPath()) {
        @Override
        public void apply(DirCacheEntry ent) {
          ent.setFileMode(FileMode.GITLINK);
          ent.setObjectId(newCommit.getId());
        }
      });

  if (verboseSuperProject != VerboseSuperprojectUpdate.FALSE) {
    createSubmoduleCommitMsg(msgbuf, s, subOr, newCommit, oldCommit);
  }
  subOr.rw.parseBody(newCommit);
  return newCommit;
}