RefNotFoundException, InvalidRefNameException {
checkCallable();
processOptions();
- RevWalk revWalk = new RevWalk(repo);
- try {
+ try (RevWalk revWalk = new RevWalk(repo)) {
Ref refToCheck = repo.getRef(name);
boolean exists = refToCheck != null
&& refToCheck.getName().startsWith(Constants.R_HEADS);
return result;
} catch (IOException ioe) {
throw new JGitInternalException(ioe.getMessage(), ioe);
- } finally {
- revWalk.release();
}
}
if (!force) {
// check if the branches to be deleted
// are all merged into the current branch
- RevWalk walk = new RevWalk(repo);
- RevCommit tip = walk.parseCommit(repo.resolve(Constants.HEAD));
- for (String branchName : branchNames) {
- if (branchName == null)
- continue;
- Ref currentRef = repo.getRef(branchName);
- if (currentRef == null)
- continue;
+ try (RevWalk walk = new RevWalk(repo)) {
+ RevCommit tip = walk
+ .parseCommit(repo.resolve(Constants.HEAD));
+ for (String branchName : branchNames) {
+ if (branchName == null)
+ continue;
+ Ref currentRef = repo.getRef(branchName);
+ if (currentRef == null)
+ continue;
- RevCommit base = walk.parseCommit(repo.resolve(branchName));
- if (!walk.isMergedInto(base, tip)) {
- throw new NotMergedException();
+ RevCommit base = walk
+ .parseCommit(repo.resolve(branchName));
+ if (!walk.isMergedInto(base, tip)) {
+ throw new NotMergedException();
+ }
}
}
}
if (containsCommitish == null)
return refs;
- RevWalk walk = new RevWalk(repo);
- try {
+ try (RevWalk walk = new RevWalk(repo)) {
ObjectId resolved = repo.resolve(containsCommitish);
if (resolved == null)
throw new RefNotFoundException(MessageFormat.format(
RevCommit containsCommit = walk.parseCommit(resolved);
return RevWalkUtils.findBranchesReachableFrom(containsCommit, walk,
refs);
- } finally {
- walk.release();
}
}
public List<Note> call() throws GitAPIException {
checkCallable();
List<Note> notes = new ArrayList<Note>();
- RevWalk walk = new RevWalk(repo);
NoteMap map = NoteMap.newEmptyMap();
- try {
+ try (RevWalk walk = new RevWalk(repo)) {
Ref ref = repo.getRef(notesRef);
// if we have a notes ref, use it
if (ref != null) {
notes.add(i.next());
} catch (IOException e) {
throw new JGitInternalException(e.getMessage(), e);
- } finally {
- walk.release();
}
return notes;
checkCallable();
Map<String, Ref> refList;
List<Ref> tags = new ArrayList<Ref>();
- RevWalk revWalk = new RevWalk(repo);
- try {
+ try (RevWalk revWalk = new RevWalk(repo)) {
refList = repo.getRefDatabase().getRefs(Constants.R_TAGS);
for (Ref ref : refList.values()) {
tags.add(ref);
}
} catch (IOException e) {
throw new JGitInternalException(e.getMessage(), e);
- } finally {
- revWalk.release();
}
Collections.sort(tags, new Comparator<Ref>() {
public int compare(Ref o1, Ref o2) {
mergeStatus = MergeStatus.MERGED_NOT_COMMITTED;
}
if (commit && !squash) {
- newHeadId = new Git(getRepository()).commit()
- .setReflogComment(refLogMessage.toString())
- .call().getId();
+ try (Git git = new Git(getRepository())) {
+ newHeadId = git.commit()
+ .setReflogComment(refLogMessage.toString())
+ .call().getId();
+ }
mergeStatus = MergeStatus.MERGED;
}
if (commit && squash) {
e), e);
} finally {
if (revWalk != null)
- revWalk.release();
+ revWalk.close();
}
}
.call();
} catch (StashApplyFailureException e) {
conflicts = true;
- RevWalk rw = new RevWalk(repo);
- ObjectId stashId = repo.resolve(stash);
- RevCommit commit = rw.parseCommit(stashId);
- updateStashRef(commit, commit.getAuthorIdent(),
- commit.getShortMessage());
+ try (RevWalk rw = new RevWalk(repo)) {
+ ObjectId stashId = repo.resolve(stash);
+ RevCommit commit = rw.parseCommit(stashId);
+ updateStashRef(commit, commit.getAuthorIdent(),
+ commit.getShortMessage());
+ }
}
}
return conflicts;
// here we should skip this step in order to avoid
// confusing pseudo-changed
String ourCommitName = getOurCommitName();
- CherryPickResult cherryPickResult = new Git(repo).cherryPick()
+ try (Git git = new Git(repo)) {
+ CherryPickResult cherryPickResult = git.cherryPick()
.include(commitToPick).setOurCommitName(ourCommitName)
.setReflogPrefix(REFLOG_PREFIX).setStrategy(strategy)
.call();
- switch (cherryPickResult.getStatus()) {
- case FAILED:
- if (operation == Operation.BEGIN)
- return abort(RebaseResult.failed(cherryPickResult
- .getFailingPaths()));
- else
+ switch (cherryPickResult.getStatus()) {
+ case FAILED:
+ if (operation == Operation.BEGIN)
+ return abort(RebaseResult
+ .failed(cherryPickResult.getFailingPaths()));
+ else
+ return stop(commitToPick, Status.STOPPED);
+ case CONFLICTING:
return stop(commitToPick, Status.STOPPED);
- case CONFLICTING:
- return stop(commitToPick, Status.STOPPED);
- case OK:
- newHead = cherryPickResult.getNewHead();
+ case OK:
+ newHead = cherryPickResult.getNewHead();
+ }
}
}
return null;
// Use the cherry-pick strategy if all non-first parents did not
// change. This is different from C Git, which always uses the merge
// strategy (see below).
- if (otherParentsUnchanged) {
- boolean isMerge = commitToPick.getParentCount() > 1;
- String ourCommitName = getOurCommitName();
- CherryPickCommand pickCommand = new Git(repo).cherryPick()
- .include(commitToPick).setOurCommitName(ourCommitName)
- .setReflogPrefix(REFLOG_PREFIX).setStrategy(strategy);
- if (isMerge) {
- pickCommand.setMainlineParentNumber(1);
- // We write a MERGE_HEAD and later commit explicitly
- pickCommand.setNoCommit(true);
- writeMergeInfo(commitToPick, newParents);
- }
- CherryPickResult cherryPickResult = pickCommand.call();
- switch (cherryPickResult.getStatus()) {
- case FAILED:
- if (operation == Operation.BEGIN)
- return abort(RebaseResult.failed(cherryPickResult
- .getFailingPaths()));
- else
- return stop(commitToPick, Status.STOPPED);
- case CONFLICTING:
- return stop(commitToPick, Status.STOPPED);
- case OK:
+ try (Git git = new Git(repo)) {
+ if (otherParentsUnchanged) {
+ boolean isMerge = commitToPick.getParentCount() > 1;
+ String ourCommitName = getOurCommitName();
+ CherryPickCommand pickCommand = git.cherryPick()
+ .include(commitToPick)
+ .setOurCommitName(ourCommitName)
+ .setReflogPrefix(REFLOG_PREFIX)
+ .setStrategy(strategy);
if (isMerge) {
- // Commit the merge (setup above using writeMergeInfo())
- CommitCommand commit = new Git(repo).commit();
+ pickCommand.setMainlineParentNumber(1);
+ // We write a MERGE_HEAD and later commit explicitly
+ pickCommand.setNoCommit(true);
+ writeMergeInfo(commitToPick, newParents);
+ }
+ CherryPickResult cherryPickResult = pickCommand.call();
+ switch (cherryPickResult.getStatus()) {
+ case FAILED:
+ if (operation == Operation.BEGIN)
+ return abort(RebaseResult.failed(
+ cherryPickResult.getFailingPaths()));
+ else
+ return stop(commitToPick, Status.STOPPED);
+ case CONFLICTING:
+ return stop(commitToPick, Status.STOPPED);
+ case OK:
+ if (isMerge) {
+ // Commit the merge (setup above using
+ // writeMergeInfo())
+ CommitCommand commit = git.commit();
+ commit.setAuthor(commitToPick.getAuthorIdent());
+ commit.setReflogComment(REFLOG_PREFIX + " " //$NON-NLS-1$
+ + commitToPick.getShortMessage());
+ newHead = commit.call();
+ } else
+ newHead = cherryPickResult.getNewHead();
+ break;
+ }
+ } else {
+ // Use the merge strategy to redo merges, which had some of
+ // their non-first parents rewritten
+ MergeCommand merge = git.merge()
+ .setFastForward(MergeCommand.FastForwardMode.NO_FF)
+ .setCommit(false);
+ for (int i = 1; i < commitToPick.getParentCount(); i++)
+ merge.include(newParents.get(i));
+ MergeResult mergeResult = merge.call();
+ if (mergeResult.getMergeStatus().isSuccessful()) {
+ CommitCommand commit = git.commit();
commit.setAuthor(commitToPick.getAuthorIdent());
+ commit.setMessage(commitToPick.getFullMessage());
commit.setReflogComment(REFLOG_PREFIX + " " //$NON-NLS-1$
+ commitToPick.getShortMessage());
newHead = commit.call();
- } else
- newHead = cherryPickResult.getNewHead();
- break;
- }
- } else {
- // Use the merge strategy to redo merges, which had some of
- // their non-first parents rewritten
- MergeCommand merge = new Git(repo).merge()
- .setFastForward(MergeCommand.FastForwardMode.NO_FF)
- .setCommit(false);
- for (int i = 1; i < commitToPick.getParentCount(); i++)
- merge.include(newParents.get(i));
- MergeResult mergeResult = merge.call();
- if (mergeResult.getMergeStatus().isSuccessful()) {
- CommitCommand commit = new Git(repo).commit();
- commit.setAuthor(commitToPick.getAuthorIdent());
- commit.setMessage(commitToPick.getFullMessage());
- commit.setReflogComment(REFLOG_PREFIX + " " //$NON-NLS-1$
- + commitToPick.getShortMessage());
- newHead = commit.call();
- } else {
- if (operation == Operation.BEGIN
- && mergeResult.getMergeStatus() == MergeResult.MergeStatus.FAILED)
- return abort(RebaseResult.failed(mergeResult
- .getFailingPaths()));
- return stop(commitToPick, Status.STOPPED);
+ } else {
+ if (operation == Operation.BEGIN && mergeResult
+ .getMergeStatus() == MergeResult.MergeStatus.FAILED)
+ return abort(RebaseResult
+ .failed(mergeResult.getFailingPaths()));
+ return stop(commitToPick, Status.STOPPED);
+ }
}
}
}
String commitMessage = rebaseState
.readFile(MESSAGE_SQUASH);
- if (nextStep == null
- || ((nextStep.getAction() != Action.FIXUP) && (nextStep
- .getAction() != Action.SQUASH))) {
- // this is the last step in this sequence
- if (sequenceContainsSquash) {
- commitMessage = interactiveHandler
- .modifyCommitMessage(commitMessage);
- }
- retNewHead = new Git(repo).commit()
- .setMessage(stripCommentLines(commitMessage))
- .setAmend(true).setNoVerify(true).call();
- rebaseState.getFile(MESSAGE_SQUASH).delete();
- rebaseState.getFile(MESSAGE_FIXUP).delete();
+ try (Git git = new Git(repo)) {
+ if (nextStep == null || ((nextStep.getAction() != Action.FIXUP)
+ && (nextStep.getAction() != Action.SQUASH))) {
+ // this is the last step in this sequence
+ if (sequenceContainsSquash) {
+ commitMessage = interactiveHandler
+ .modifyCommitMessage(commitMessage);
+ }
+ retNewHead = git.commit()
+ .setMessage(stripCommentLines(commitMessage))
+ .setAmend(true).setNoVerify(true).call();
+ rebaseState.getFile(MESSAGE_SQUASH).delete();
+ rebaseState.getFile(MESSAGE_FIXUP).delete();
- } else {
- // Next step is either Squash or Fixup
- retNewHead = new Git(repo).commit().setMessage(commitMessage)
- .setAmend(true).setNoVerify(true).call();
+ } else {
+ // Next step is either Squash or Fixup
+ retNewHead = git.commit().setMessage(commitMessage)
+ .setAmend(true).setNoVerify(true).call();
+ }
}
return retNewHead;
}
} finally {
dc.unlock();
}
- RevWalk rw = new RevWalk(repo);
- RevCommit commit = rw.parseCommit(repo.resolve(Constants.HEAD));
- rw.release();
- return commit;
+ try (RevWalk rw = new RevWalk(repo)) {
+ RevCommit commit = rw.parseCommit(repo.resolve(Constants.HEAD));
+ return commit;
+ }
}
/**
throw new UnmergedPathsException();
// determine whether we need to commit
- TreeWalk treeWalk = new TreeWalk(repo);
- treeWalk.reset();
- treeWalk.setRecursive(true);
- treeWalk.addTree(new DirCacheIterator(dc));
- ObjectId id = repo.resolve(Constants.HEAD + "^{tree}"); //$NON-NLS-1$
- if (id == null)
- throw new NoHeadException(
- JGitText.get().cannotRebaseWithoutCurrentHead);
+ boolean needsCommit;
+ try (TreeWalk treeWalk = new TreeWalk(repo)) {
+ treeWalk.reset();
+ treeWalk.setRecursive(true);
+ treeWalk.addTree(new DirCacheIterator(dc));
+ ObjectId id = repo.resolve(Constants.HEAD + "^{tree}"); //$NON-NLS-1$
+ if (id == null)
+ throw new NoHeadException(
+ JGitText.get().cannotRebaseWithoutCurrentHead);
- treeWalk.addTree(id);
+ treeWalk.addTree(id);
- treeWalk.setFilter(TreeFilter.ANY_DIFF);
-
- boolean needsCommit = treeWalk.next();
- treeWalk.release();
+ treeWalk.setFilter(TreeFilter.ANY_DIFF);
+ needsCommit = treeWalk.next();
+ }
if (needsCommit) {
- CommitCommand commit = new Git(repo).commit();
- commit.setMessage(rebaseState.readFile(MESSAGE));
- commit.setAuthor(parseAuthor());
- return commit.call();
+ try (Git git = new Git(repo)) {
+ CommitCommand commit = git.commit();
+ commit.setMessage(rebaseState.readFile(MESSAGE));
+ commit.setAuthor(parseAuthor());
+ return commit.call();
+ }
}
return null;
}
rebaseState.createFile(AUTHOR_SCRIPT, authorScript);
rebaseState.createFile(MESSAGE, commitToPick.getFullMessage());
ByteArrayOutputStream bos = new ByteArrayOutputStream();
- DiffFormatter df = new DiffFormatter(bos);
- df.setRepository(repo);
- df.format(commitToPick.getParent(0), commitToPick);
+ try (DiffFormatter df = new DiffFormatter(bos)) {
+ df.setRepository(repo);
+ df.format(commitToPick.getParent(0), commitToPick);
+ }
rebaseState.createFile(PATCH, new String(bos.toByteArray(),
Constants.CHARACTER_ENCODING));
rebaseState.createFile(STOPPED_SHA,
private List<RevCommit> calculatePickList(RevCommit headCommit)
throws GitAPIException, NoHeadException, IOException {
- LogCommand cmd = new Git(repo).log().addRange(upstreamCommit,
- headCommit);
- Iterable<RevCommit> commitsToUse = cmd.call();
+ Iterable<RevCommit> commitsToUse;
+ try (Git git = new Git(repo)) {
+ LogCommand cmd = git.log().addRange(upstreamCommit, headCommit);
+ commitsToUse = cmd.call();
+ }
List<RevCommit> cherryPickList = new ArrayList<RevCommit>();
for (RevCommit commit : commitsToUse) {
if (preserveMerges || commit.getParentCount() == 1)
}
dco.setFailOnConflict(false);
dco.checkout();
- walk.release();
+ walk.close();
} finally {
monitor.endTask();
}
throw new IOException("Could not rewind to upstream commit");
}
} finally {
- walk.release();
+ walk.close();
monitor.endTask();
}
return true;
public Note call() throws GitAPIException {
checkCallable();
- RevWalk walk = new RevWalk(repo);
- ObjectInserter inserter = repo.newObjectInserter();
- NoteMap map = NoteMap.newEmptyMap();
- RevCommit notesCommit = null;
- try {
+ try (RevWalk walk = new RevWalk(repo);
+ ObjectInserter inserter = repo.newObjectInserter()) {
+ NoteMap map = NoteMap.newEmptyMap();
+ RevCommit notesCommit = null;
Ref ref = repo.getRef(notesRef);
// if we have a notes ref, use it
if (ref != null) {
return map.getNote(id);
} catch (IOException e) {
throw new JGitInternalException(e.getMessage(), e);
- } finally {
- inserter.release();
- walk.release();
}
}
}
private RevCommit parseCommit(final ObjectId commitId) {
- RevCommit commit;
- RevWalk rw = new RevWalk(repo);
- try {
- commit = rw.parseCommit(commitId);
+ try (RevWalk rw = new RevWalk(repo)) {
+ return rw.parseCommit(commitId);
} catch (IOException e) {
throw new JGitInternalException(MessageFormat.format(
JGitText.get().cannotReadCommit, commitId.toString()), e);
- } finally {
- rw.release();
}
- return commit;
}
private ObjectId resolveRefToCommitId() {
private void resetIndexForPaths(ObjectId commitTree) {
DirCache dc = null;
- try {
+ try (final TreeWalk tw = new TreeWalk(repo)) {
dc = repo.lockDirCache();
DirCacheBuilder builder = dc.builder();
- final TreeWalk tw = new TreeWalk(repo);
tw.addTree(new DirCacheBuildIterator(builder));
if (commitTree != null)
tw.addTree(commitTree);
private void resetIndex(ObjectId commitTree) throws IOException {
DirCache dc = repo.lockDirCache();
- TreeWalk walk = null;
- try {
+ try (TreeWalk walk = new TreeWalk(repo)) {
DirCacheBuilder builder = dc.builder();
- walk = new TreeWalk(repo);
if (commitTree != null)
walk.addTree(commitTree);
else
builder.commit();
} finally {
dc.unlock();
- if (walk != null)
- walk.release();
}
}
RevCommit newHead = null;
checkCallable();
- RevWalk revWalk = new RevWalk(repo);
- try {
+ try (RevWalk revWalk = new RevWalk(repo)) {
// get the head commit
Ref headRef = repo.getRef(Constants.HEAD);
merger.getResultTreeId());
dco.setFailOnConflict(true);
dco.checkout();
- newHead = new Git(getRepository()).commit()
- .setMessage(newMessage)
- .setReflogComment("revert: " + shortMessage).call(); //$NON-NLS-1$
+ try (Git git = new Git(getRepository())) {
+ newHead = git.commit().setMessage(newMessage)
+ .setReflogComment("revert: " + shortMessage) //$NON-NLS-1$
+ .call();
+ }
revertedRefs.add(src);
headCommit = newHead;
} else {
MessageFormat.format(
JGitText.get().exceptionCaughtDuringExecutionOfRevertCommand,
e), e);
- } finally {
- revWalk.release();
}
return newHead;
}
checkCallable();
DirCache dc = null;
- try {
+ try (final TreeWalk tw = new TreeWalk(repo)) {
dc = repo.lockDirCache();
DirCacheBuilder builder = dc.builder();
- final TreeWalk tw = new TreeWalk(repo);
tw.reset(); // drop the first empty tree, which we do not need here
tw.setRecursive(true);
tw.setFilter(PathFilterGroup.createFromStrings(filepatterns));
public Note call() throws GitAPIException {
checkCallable();
- RevWalk walk = new RevWalk(repo);
NoteMap map = NoteMap.newEmptyMap();
RevCommit notesCommit = null;
- try {
+ try (RevWalk walk = new RevWalk(repo)) {
Ref ref = repo.getRef(notesRef);
// if we have a notes ref, use it
if (ref != null) {
return map.getNote(id);
} catch (IOException e) {
throw new JGitInternalException(e.getMessage(), e);
- } finally {
- walk.release();
}
}
JGitText.get().stashApplyOnUnsafeRepository,
repo.getRepositoryState()));
- ObjectReader reader = repo.newObjectReader();
- try {
- RevWalk revWalk = new RevWalk(reader);
+ try (ObjectReader reader = repo.newObjectReader();
+ RevWalk revWalk = new RevWalk(reader)) {
ObjectId headCommit = repo.resolve(Constants.HEAD);
if (headCommit == null)
throw e;
} catch (IOException e) {
throw new JGitInternalException(JGitText.get().stashApplyFailed, e);
- } finally {
- reader.release();
}
}
private void resetIndex(RevTree tree) throws IOException {
DirCache dc = repo.lockDirCache();
- TreeWalk walk = null;
- try {
+ try (TreeWalk walk = new TreeWalk(repo)) {
DirCacheBuilder builder = dc.builder();
- walk = new TreeWalk(repo);
walk.addTree(tree);
walk.addTree(new DirCacheIterator(dc));
walk.setRecursive(true);
builder.commit();
} finally {
dc.unlock();
- if (walk != null)
- walk.release();
}
}
private void resetUntracked(RevTree tree) throws CheckoutConflictException,
IOException {
- TreeWalk walk = new TreeWalk(repo); // maybe NameConflictTreeWalk;
- try {
+ // TODO maybe NameConflictTreeWalk ?
+ try (TreeWalk walk = new TreeWalk(repo)) {
walk.addTree(tree);
walk.addTree(new FileTreeIterator(repo));
walk.setRecursive(true);
checkoutPath(entry, reader);
}
- } finally {
- walk.release();
}
}
private RevCommit parseCommit(final ObjectReader reader,
final ObjectId headId) throws IOException {
- final RevWalk walk = new RevWalk(reader);
- return walk.parseCommit(headId);
+ try (final RevWalk walk = new RevWalk(reader)) {
+ return walk.parseCommit(headId);
+ }
}
private CommitBuilder createBuilder() {
checkCallable();
Ref head = getHead();
- ObjectReader reader = repo.newObjectReader();
- try {
+ try (ObjectReader reader = repo.newObjectReader()) {
RevCommit headCommit = parseCommit(reader, head.getObjectId());
DirCache cache = repo.lockDirCache();
- ObjectInserter inserter = repo.newObjectInserter();
ObjectId commitId;
- try {
- TreeWalk treeWalk = new TreeWalk(reader);
+ try (ObjectInserter inserter = repo.newObjectInserter();
+ TreeWalk treeWalk = new TreeWalk(reader)) {
+
treeWalk.setRecursive(true);
treeWalk.addTree(headCommit.getTree());
treeWalk.addTree(new DirCacheIterator(cache));
}
} finally {
- inserter.release();
cache.unlock();
}
return parseCommit(reader, commitId);
} catch (IOException e) {
throw new JGitInternalException(JGitText.get().stashFailed, e);
- } finally {
- reader.release();
}
}
}
RefNotFoundException, GitAPIException {
checkCallable();
- try {
- SubmoduleWalk generator = SubmoduleWalk.forIndex(repo);
+ try (SubmoduleWalk generator = SubmoduleWalk.forIndex(repo)) {
if (!paths.isEmpty())
generator.setFilter(PathFilterGroup.createFromStrings(paths));
List<String> updated = new ArrayList<String>();
submoduleRepo = clone.call().getRepository();
}
- try {
- RevWalk walk = new RevWalk(submoduleRepo);
+ try (RevWalk walk = new RevWalk(submoduleRepo)) {
RevCommit commit = walk
.parseCommit(generator.getObjectId());
RepositoryState state = repo.getRepositoryState();
processOptions(state);
- RevWalk revWalk = new RevWalk(repo);
- try {
+ try (RevWalk revWalk = new RevWalk(repo)) {
// if no id is set, we should attempt to use HEAD
if (id == null) {
ObjectId objectId = repo.resolve(Constants.HEAD + "^{commit}"); //$NON-NLS-1$
newTag.setObjectId(id);
// write the tag object
- ObjectInserter inserter = repo.newObjectInserter();
- try {
+ try (ObjectInserter inserter = repo.newObjectInserter()) {
ObjectId tagId = inserter.insert(newTag);
inserter.flush();
String tag = newTag.getTag();
return updateTagRef(tagId, revWalk, tag, newTag.toString());
- } finally {
- inserter.release();
}
} catch (IOException e) {
throw new JGitInternalException(
JGitText.get().exceptionCaughtDuringExecutionOfTagCommand,
e);
- } finally {
- revWalk.release();
}
}
throw new IllegalStateException();
if (revPool != null)
- revPool.release();
+ revPool.close();
if (reverse)
revPool = new ReverseWalk(getRepository());
r.computeAll();
return r;
} finally {
- release();
+ close();
}
}
}
private boolean done() {
- release();
+ close();
return false;
}
try {
return compute(objectReader, pm);
} finally {
- objectReader.release();
+ objectReader.close();
}
}
return Collections.unmodifiableList(entries);
MissingObjectException, IncorrectObjectTypeException,
CheckoutConflictException, IndexWriteException {
toBeDeleted.clear();
- ObjectReader objectReader = repo.getObjectDatabase().newReader();
- try {
+ try (ObjectReader objectReader = repo.getObjectDatabase().newReader()) {
if (headCommitTree != null)
preScanTwoTrees();
else
// commit the index builder - a new index is persisted
if (!builder.commit())
throw new IndexWriteException();
- } finally {
- objectReader.release();
}
return toBeDeleted.size() == 0;
}
*/
private boolean isModifiedSubtree_IndexWorkingtree(String path)
throws CorruptObjectException, IOException {
- NameConflictTreeWalk tw = new NameConflictTreeWalk(repo);
- try {
+ try (NameConflictTreeWalk tw = new NameConflictTreeWalk(repo)) {
tw.addTree(new DirCacheIterator(dc));
tw.addTree(new FileTreeIterator(repo));
tw.setRecursive(true);
}
}
return false;
- } finally {
- tw.release();
}
}
*/
private boolean isModifiedSubtree_IndexTree(String path, ObjectId tree)
throws CorruptObjectException, IOException {
- NameConflictTreeWalk tw = new NameConflictTreeWalk(repo);
- try {
+ try (NameConflictTreeWalk tw = new NameConflictTreeWalk(repo)) {
tw.addTree(new DirCacheIterator(dc));
tw.addTree(tree);
tw.setRecursive(true);
return true;
}
return false;
- } finally {
- tw.release();
}
}
*/
protected byte[] readFileFromRepo(Repository repo,
String ref, String path) throws GitAPIException, IOException {
- ObjectReader reader = repo.newObjectReader();
- byte[] result;
- try {
+ try (ObjectReader reader = repo.newObjectReader()) {
ObjectId oid = repo.resolve(ref + ":" + path); //$NON-NLS-1$
- result = reader.open(oid).getBytes(Integer.MAX_VALUE);
- } finally {
- reader.release();
+ return reader.open(oid).getBytes(Integer.MAX_VALUE);
}
- return result;
}
}
DirCache index = DirCache.newInCore();
DirCacheBuilder builder = index.builder();
ObjectInserter inserter = repo.newObjectInserter();
- RevWalk rw = new RevWalk(repo);
- try {
+ try (RevWalk rw = new RevWalk(repo)) {
Config cfg = new Config();
for (Project proj : bareProjects) {
String name = proj.path;
return rw.parseCommit(commitId);
} catch (IOException e) {
throw new ManifestErrorException(e);
- } finally {
- rw.release();
}
} else {
return git
try {
Repository subRepo = add.call();
if (revision != null) {
- Git sub = new Git(subRepo);
- sub.checkout().setName(findRef(revision, subRepo)).call();
+ try (Git sub = new Git(subRepo)) {
+ sub.checkout().setName(findRef(revision, subRepo))
+ .call();
+ }
subRepo.close();
git.add().addFilepattern(name).call();
}
objdb.rollbackPack(newPackDesc);
}
} finally {
- ctx.release();
+ ctx.close();
}
}
@Override
public void release() {
- ctx.release();
+ ctx.close();
}
}
// The newly created pack is registered in the cache.
return ctx.open(id, type).openStream();
} finally {
- ctx.release();
+ ctx.close();
}
}
new ReadBackStream(pos), inf, bufsz), bufsz)) {
@Override
public void close() throws IOException {
- ctx.release();
+ ctx.close();
super.close();
}
};
*/
public DfsPackCompactor exclude(DfsPackFile pack) throws IOException {
final PackIndex idx;
- DfsReader ctx = (DfsReader) repo.newObjectReader();
- try {
+ try (DfsReader ctx = (DfsReader) repo.newObjectReader()) {
idx = pack.getPackIndex(ctx);
- } finally {
- ctx.release();
}
return exclude(new PackWriter.ObjectIdSet() {
public boolean contains(AnyObjectId id) {
pm = NullProgressMonitor.INSTANCE;
DfsObjDatabase objdb = repo.getObjectDatabase();
- DfsReader ctx = (DfsReader) objdb.newReader();
- try {
+ try (DfsReader ctx = (DfsReader) objdb.newReader()) {
PackConfig pc = new PackConfig(repo);
pc.setIndexVersion(2);
pc.setDeltaCompress(false);
writeIndex(objdb, pack, pw);
PackWriter.Statistics stats = pw.getStatistics();
- pw.release();
+ pw.close();
pw = null;
pack.setPackStats(stats);
}
} finally {
if (pw != null)
- pw.release();
+ pw.close();
}
} finally {
rw = null;
- ctx.release();
}
}
private Ref doPeel(final Ref leaf) throws MissingObjectException,
IOException {
- RevWalk rw = new RevWalk(repository);
- try {
+ try (RevWalk rw = new RevWalk(repository)) {
RevObject obj = rw.parseAny(leaf.getObjectId());
if (obj instanceof RevTag) {
return new ObjectIdRef.PeeledTag(
leaf.getName(),
leaf.getObjectId());
}
- } finally {
- rw.release();
}
}
ObjectId obj = pack.getReverseIdx(ctx).findObject(objectOffset);
return ctx.open(obj, type).openStream();
} finally {
- ctx.release();
+ ctx.close();
}
+ } finally {
+ ctx.close();
}
// Align buffer to inflater size, at a larger than default block.
@Override
public void close() {
- ctx.release();
+ ctx.close();
}
}
private ObjectIdRef doPeel(final Ref leaf) throws MissingObjectException,
IOException {
- RevWalk rw = new RevWalk(getRepository());
- try {
+ try (RevWalk rw = new RevWalk(getRepository())) {
RevObject obj = rw.parseAny(leaf.getObjectId());
if (obj instanceof RevTag) {
return new ObjectIdRef.PeeledTag(leaf.getStorage(), leaf
return new ObjectIdRef.PeeledNonTag(leaf.getStorage(), leaf
.getName(), leaf.getObjectId());
}
- } finally {
- rw.release();
}
}
objId = source.getOldObjectId();
updateHEAD = needToUpdateHEAD();
tmp = refdb.newTemporaryUpdate();
- final RevWalk rw = new RevWalk(refdb.getRepository());
- try {
+ try (final RevWalk rw = new RevWalk(refdb.getRepository())) {
// First backup the source so its never unreachable.
tmp.setNewObjectId(objId);
tmp.setForceUpdate(true);
} catch (IOException err) {
FileUtils.delete(refdb.fileFor(tmp.getName()));
}
- rw.release();
}
}
runWindow(w);
} finally {
block.pm.endWorker();
- or.release();
+ or.close();
or = null;
}
return null;
}
stats.totalBytes = out.length();
- reader.release();
+ reader.close();
endPhase(writeMonitor);
}
throws IOException {
dirCache = repository.readDirCache();
- TreeWalk treeWalk = new TreeWalk(repository);
- treeWalk.setRecursive(true);
- // 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));
- }
+ try (TreeWalk treeWalk = new TreeWalk(repository)) {
+ treeWalk.setRecursive(true);
+ // 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));
- fileModes.clear();
- 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) {
- int stage = dirCacheEntry.getStage();
- if (stage > 0) {
- String path = treeWalk.getPathString();
- addConflict(path, stage);
- continue;
+ if (filter != null)
+ filters.add(filter);
+ filters.add(new SkipWorkTreeFilter(INDEX));
+ indexDiffFilter = new IndexDiffFilter(INDEX, WORKDIR);
+ filters.add(indexDiffFilter);
+ treeWalk.setFilter(AndTreeFilter.create(filters));
+ fileModes.clear();
+ 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) {
+ int stage = dirCacheEntry.getStage();
+ if (stage > 0) {
+ String path = treeWalk.getPathString();
+ addConflict(path, stage);
+ continue;
+ }
}
}
- }
- if (treeIterator != null) {
- if (dirCacheIterator != null) {
- if (!treeIterator.idEqual(dirCacheIterator)
- || treeIterator.getEntryRawMode()
- != dirCacheIterator.getEntryRawMode()) {
- // in repo, in index, content diff => changed
+ if (treeIterator != null) {
+ if (dirCacheIterator != null) {
+ if (!treeIterator.idEqual(dirCacheIterator)
+ || treeIterator
+ .getEntryRawMode() != dirCacheIterator
+ .getEntryRawMode()) {
+ // in repo, in index, content diff => changed
+ if (!isEntryGitLink(treeIterator)
+ || !isEntryGitLink(dirCacheIterator)
+ || ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL)
+ changed.add(treeWalk.getPathString());
+ }
+ } else {
+ // in repo, not in index => removed
if (!isEntryGitLink(treeIterator)
- || !isEntryGitLink(dirCacheIterator)
|| ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL)
- changed.add(treeWalk.getPathString());
+ removed.add(treeWalk.getPathString());
+ if (workingTreeIterator != null)
+ untracked.add(treeWalk.getPathString());
}
} else {
- // in repo, not in index => removed
- if (!isEntryGitLink(treeIterator)
- || ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL)
- removed.add(treeWalk.getPathString());
- if (workingTreeIterator != null)
- untracked.add(treeWalk.getPathString());
- }
- } else {
- if (dirCacheIterator != null) {
- // not in repo, in index => added
- if (!isEntryGitLink(dirCacheIterator)
- || ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL)
- added.add(treeWalk.getPathString());
- } else {
- // not in repo, not in index => untracked
- if (workingTreeIterator != null
- && !workingTreeIterator.isEntryIgnored()) {
- untracked.add(treeWalk.getPathString());
+ if (dirCacheIterator != null) {
+ // not in repo, in index => added
+ if (!isEntryGitLink(dirCacheIterator)
+ || ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL)
+ 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
- if (!isEntryGitLink(dirCacheIterator)
- || ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL)
- missing.add(treeWalk.getPathString());
- } else {
- if (workingTreeIterator.isModified(
- dirCacheIterator.getDirCacheEntry(), true,
- treeWalk.getObjectReader())) {
- // in index, in workdir, content differs => modified
- if (!isEntryGitLink(dirCacheIterator) || !isEntryGitLink(workingTreeIterator)
- || (ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL && ignoreSubmoduleMode != IgnoreSubmoduleMode.DIRTY))
- modified.add(treeWalk.getPathString());
+ if (dirCacheIterator != null) {
+ if (workingTreeIterator == null) {
+ // in index, not in workdir => missing
+ if (!isEntryGitLink(dirCacheIterator)
+ || ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL)
+ missing.add(treeWalk.getPathString());
+ } else {
+ if (workingTreeIterator.isModified(
+ dirCacheIterator.getDirCacheEntry(), true,
+ treeWalk.getObjectReader())) {
+ // in index, in workdir, content differs => modified
+ if (!isEntryGitLink(dirCacheIterator)
+ || !isEntryGitLink(workingTreeIterator)
+ || (ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL
+ && ignoreSubmoduleMode != IgnoreSubmoduleMode.DIRTY))
+ modified.add(treeWalk.getPathString());
+ }
}
}
- }
- for (int i = 0; i < treeWalk.getTreeCount(); i++) {
- Set<String> values = fileModes.get(treeWalk.getFileMode(i));
- String path = treeWalk.getPathString();
- if (path != null) {
- if (values == null)
- values = new HashSet<String>();
- values.add(path);
- fileModes.put(treeWalk.getFileMode(i), values);
+ for (int i = 0; i < treeWalk.getTreeCount(); i++) {
+ Set<String> values = fileModes.get(treeWalk.getFileMode(i));
+ String path = treeWalk.getPathString();
+ if (path != null) {
+ if (values == null)
+ values = new HashSet<String>();
+ values.add(path);
+ fileModes.put(treeWalk.getFileMode(i), values);
+ }
}
}
}
* an unexpected IO error occurred while writing changes.
*/
public Result update() throws IOException {
- RevWalk rw = new RevWalk(getRepository());
- try {
+ try (RevWalk rw = new RevWalk(getRepository())) {
return update(rw);
- } finally {
- rw.release();
}
}
* @throws IOException
*/
public Result delete() throws IOException {
- RevWalk rw = new RevWalk(getRepository());
- try {
+ try (RevWalk rw = new RevWalk(getRepository())) {
return delete(rw);
- } finally {
- rw.release();
}
}
public ObjectId resolve(final String revstr)
throws AmbiguousObjectException, IncorrectObjectTypeException,
RevisionSyntaxException, IOException {
- RevWalk rw = new RevWalk(this);
- try {
+ try (RevWalk rw = new RevWalk(this)) {
Object resolved = resolve(rw, revstr);
if (resolved instanceof String) {
final Ref ref = getRef((String)resolved);
} else {
return (ObjectId) resolved;
}
- } finally {
- rw.release();
}
}
*/
public String simplify(final String revstr)
throws AmbiguousObjectException, IOException {
- RevWalk rw = new RevWalk(this);
- try {
+ try (RevWalk rw = new RevWalk(this)) {
Object resolved = resolve(rw, revstr);
if (resolved != null)
if (resolved instanceof String)
else
return ((AnyObjectId) resolved).getName();
return null;
- } finally {
- rw.release();
}
}
private ObjectId resolveAbbreviation(final String revstr) throws IOException,
AmbiguousObjectException {
AbbreviatedObjectId id = AbbreviatedObjectId.fromString(revstr);
- ObjectReader reader = newObjectReader();
- try {
+ try (ObjectReader reader = newObjectReader()) {
Collection<ObjectId> matches = reader.resolve(id);
if (matches.size() == 0)
return null;
return matches.iterator().next();
else
throw new AmbiguousObjectException(id, matches);
- } finally {
- reader.release();
}
}
private DirCache dircacheFromTree(ObjectId treeId) throws IOException {
DirCache ret = DirCache.newInCore();
DirCacheBuilder aBuilder = ret.builder();
- TreeWalk atw = new TreeWalk(reader);
- atw.addTree(treeId);
- atw.setRecursive(true);
- while (atw.next()) {
- DirCacheEntry e = new DirCacheEntry(atw.getRawPath());
- e.setFileMode(atw.getFileMode(0));
- e.setObjectId(atw.getObjectId(0));
- aBuilder.add(e);
+ try (TreeWalk atw = new TreeWalk(reader)) {
+ atw.addTree(treeId);
+ atw.setRecursive(true);
+ while (atw.next()) {
+ DirCacheEntry e = new DirCacheEntry(atw.getRawPath());
+ e.setFileMode(atw.getFileMode(0));
+ e.setObjectId(atw.getObjectId(0));
+ aBuilder.add(e);
+ }
}
aBuilder.finish();
return ret;
import org.eclipse.jgit.lib.AnyObjectId;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.ObjectInserter;
+import org.eclipse.jgit.lib.ObjectInserter.Formatter;
import org.eclipse.jgit.lib.ObjectReader;
import org.eclipse.jgit.lib.TreeFormatter;
@Override
ObjectId getTreeId() {
- return new ObjectInserter.Formatter().idFor(build());
+ try (Formatter f = new ObjectInserter.Formatter()) {
+ return f.idFor(build());
+ }
}
private TreeFormatter build() {
DirCache index = repository.readDirCache();
generator.setTree(new DirCacheIterator(index));
} catch (IOException e) {
- generator.release();
+ generator.close();
throw e;
}
return generator;
if (filter.isDone(generator.walk))
return generator;
} catch (IOException e) {
- generator.release();
+ generator.close();
throw e;
}
- generator.release();
+ generator.close();
return null;
}
if (filter.isDone(generator.walk))
return generator;
} catch (IOException e) {
- generator.release();
+ generator.close();
throw e;
}
- generator.release();
+ generator.close();
return null;
}
config.load();
modulesConfig = config;
} else {
- TreeWalk configWalk = new TreeWalk(repository);
- try {
+ try (TreeWalk configWalk = new TreeWalk(repository)) {
configWalk.addTree(rootTree);
// The root tree may be part of the submodule walk, so we need to revert
if (idx > 0)
rootTree.next(idx);
}
- } finally {
- configWalk.release();
}
}
return this;
/**
* Create process for specified transport and refs updates specification.
- *
+ *
* @param transport
* transport between remote and local repository, used to create
* connection.
}
return res;
} finally {
- walker.release();
+ walker.close();
}
}
service();
} finally {
msgOut = NullOutputStream.INSTANCE;
- walk.release();
+ walk.close();
if (timer != null) {
try {
timer.terminate();
}
private void processShallow() throws IOException {
- DepthWalk.RevWalk depthWalk =
- new DepthWalk.RevWalk(walk.getObjectReader(), depth);
+ try (DepthWalk.RevWalk depthWalk = new DepthWalk.RevWalk(
+ walk.getObjectReader(), depth)) {
- // Find all the commits which will be shallow
- for (ObjectId o : wantIds) {
- try {
- depthWalk.markRoot(depthWalk.parseCommit(o));
- } catch (IncorrectObjectTypeException notCommit) {
- // Ignore non-commits in this loop.
+ // Find all the commits which will be shallow
+ for (ObjectId o : wantIds) {
+ try {
+ depthWalk.markRoot(depthWalk.parseCommit(o));
+ } catch (IncorrectObjectTypeException notCommit) {
+ // Ignore non-commits in this loop.
+ }
}
- }
- RevCommit o;
- while ((o = depthWalk.next()) != null) {
- DepthWalk.Commit c = (DepthWalk.Commit) o;
+ RevCommit o;
+ while ((o = depthWalk.next()) != null) {
+ DepthWalk.Commit c = (DepthWalk.Commit) o;
- // Commits at the boundary which aren't already shallow in
- // the client need to be marked as such
- if (c.getDepth() == depth && !clientShallowCommits.contains(c))
- pckOut.writeString("shallow " + o.name()); //$NON-NLS-1$
+ // Commits at the boundary which aren't already shallow in
+ // the client need to be marked as such
+ if (c.getDepth() == depth && !clientShallowCommits.contains(c))
+ pckOut.writeString("shallow " + o.name()); //$NON-NLS-1$
- // Commits not on the boundary which are shallow in the client
- // need to become unshallowed
- if (c.getDepth() < depth && clientShallowCommits.remove(c)) {
- unshallowCommits.add(c.copy());
- pckOut.writeString("unshallow " + c.name()); //$NON-NLS-1$
+ // Commits not on the boundary which are shallow in the client
+ // need to become unshallowed
+ if (c.getDepth() < depth && clientShallowCommits.remove(c)) {
+ unshallowCommits.add(c.copy());
+ pckOut.writeString("unshallow " + c.name()); //$NON-NLS-1$
+ }
}
}
-
pckOut.end();
}
statistics = pw.getStatistics();
if (statistics != null)
logger.onPackStatistics(statistics);
- pw.release();
+ pw.close();
}
if (sideband)
@Override
public void close() {
- inserter.release();
- reader.release();
+ inserter.close();
+ reader.close();
for (final RemotePack p : unfetchedPacks) {
if (p.tmpIdx != null)
p.tmpIdx.delete();
String pathPack = null;
String pathIdx = null;
- final PackWriter writer = new PackWriter(transport.getPackConfig(),
- local.newObjectReader());
- try {
+ try (final PackWriter writer = new PackWriter(transport.getPackConfig(),
+ local.newObjectReader())) {
+
final Set<ObjectId> need = new HashSet<ObjectId>();
final Set<ObjectId> have = new HashSet<ObjectId>();
for (final RemoteRefUpdate r : updates)
safeDelete(pathPack);
throw new TransportException(uri, JGitText.get().cannotStoreObjects, err);
- } finally {
- writer.release();
}
}
projects / jgit.git / commitdiff