motiejus
/
jgit
1
Fork 0
Code Releases Activity

Use AutoClosable to close resources in bundle org.eclipse.jgit 

- use try-with-resource where possible
- replace use of deprecated release() by close()

Change-Id: I0f139c3535679087b7fa09649166bca514750b81
Signed-off-by: Matthias Sohn <matthias.sohn@sap.com>
This commit is contained in:
Matthias Sohn 2015-04-11 00:24:27 +02:00
parent 6424dcd694
commit 0e73d39506
40 changed files with 373 additions and 443 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
org.eclipse.jgit/src/org/eclipse/jgit/api/CreateBranchCommand.java
View File

@ -124,8 +124,7 @@ public Ref call() throws GitAPIException, RefAlreadyExistsException,
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);
@ -270,8 +269,6 @@ else if (upstreamMode == SetupUpstreamMode.NOTRACK)
return result;
} catch (IOException ioe) {
throw new JGitInternalException(ioe.getMessage(), ioe);
} finally {
revWalk.release();
}
}

25
org.eclipse.jgit/src/org/eclipse/jgit/api/DeleteBranchCommand.java
View File

@ -108,18 +108,21 @@ public List<String> call() throws GitAPIException,
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();
}
}
}
}

5
org.eclipse.jgit/src/org/eclipse/jgit/api/ListBranchCommand.java
View File

@ -139,8 +139,7 @@ private Collection<Ref> filterRefs(Collection<Ref> refs)
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(
@ -149,8 +148,6 @@ private Collection<Ref> filterRefs(Collection<Ref> refs)
RevCommit containsCommit = walk.parseCommit(resolved);
return RevWalkUtils.findBranchesReachableFrom(containsCommit, walk,
refs);
} finally {
walk.release();
}
}

5
org.eclipse.jgit/src/org/eclipse/jgit/api/ListNotesCommand.java
View File

@ -80,9 +80,8 @@ protected ListNotesCommand(Repository repo) {
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) {
@ -95,8 +94,6 @@ public List<Note> call() throws GitAPIException {
notes.add(i.next());
} catch (IOException e) {
throw new JGitInternalException(e.getMessage(), e);
} finally {
walk.release();
}
return notes;

5
org.eclipse.jgit/src/org/eclipse/jgit/api/ListTagCommand.java
View File

@ -78,16 +78,13 @@ public List<Ref> call() throws GitAPIException {
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) {

10
org.eclipse.jgit/src/org/eclipse/jgit/api/MergeCommand.java
View File

@ -369,9 +369,11 @@ public MergeResult call() throws GitAPIException, NoHeadException,
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) {
@ -416,7 +418,7 @@ public MergeResult call() throws GitAPIException, NoHeadException,
e), e);
} finally {
if (revWalk != null)
revWalk.release();
revWalk.close();
}
}

240
org.eclipse.jgit/src/org/eclipse/jgit/api/RebaseCommand.java
View File

@ -405,11 +405,12 @@ private boolean autoStashApply() throws IOException, GitAPIException {
.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;
@ -518,21 +519,23 @@ private RebaseResult cherryPickCommitFlattening(RevCommit commitToPick)
// 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;
@ -563,62 +566,67 @@ private RebaseResult cherryPickCommitPreservingMerges(RevCommit commitToPick)
// 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);
}
}
}
}
@ -758,24 +766,25 @@ private RevCommit squashIntoPrevious(boolean sequenceContainsSquash,
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;
}
@ -917,10 +926,10 @@ private RevCommit checkoutCurrentHead() throws IOException, NoHeadException {
} 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;
}
}
/**
@ -936,27 +945,29 @@ private RevCommit continueRebase() throws GitAPIException, IOException {
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;
}
@ -979,9 +990,10 @@ private RebaseResult stop(RevCommit commitToPick, RebaseResult.Status status)
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,
@ -1124,9 +1136,11 @@ else if (!isInteractive() && walk.isMergedInto(headCommit, upstream)) {
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)
@ -1312,7 +1326,7 @@ private RebaseResult abort(RebaseResult result) throws IOException,
}
dco.setFailOnConflict(false);
dco.checkout();
walk.release();
walk.close();
} finally {
monitor.endTask();
}
@ -1387,7 +1401,7 @@ private boolean checkoutCommit(String headName, RevCommit commit)
throw new IOException("Could not rewind to upstream commit");
}
} finally {
walk.release();
walk.close();
monitor.endTask();
}
return true;

12
org.eclipse.jgit/src/org/eclipse/jgit/api/RemoveNoteCommand.java
View File

@ -81,11 +81,10 @@ protected RemoveNoteCommand(Repository repo) {
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) {
@ -98,9 +97,6 @@ public Note call() throws GitAPIException {
return map.getNote(id);
} catch (IOException e) {
throw new JGitInternalException(e.getMessage(), e);
} finally {
inserter.release();
walk.release();
}
}

18
org.eclipse.jgit/src/org/eclipse/jgit/api/ResetCommand.java
View File

@ -234,17 +234,12 @@ else if (repo.readSquashCommitMsg() != null)
}
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() {
@ -305,11 +300,10 @@ private String getRefOrHEAD() {
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);
@ -342,11 +336,9 @@ private void resetIndexForPaths(ObjectId 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
@ -380,8 +372,6 @@ private void resetIndex(ObjectId commitTree) throws IOException {
builder.commit();
} finally {
dc.unlock();
if (walk != null)
walk.release();
}
}

13
org.eclipse.jgit/src/org/eclipse/jgit/api/RevertCommand.java
View File

@ -126,8 +126,7 @@ public RevCommit call() throws NoMessageException, UnmergedPathsException,
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);
@ -182,9 +181,11 @@ public RevCommit call() throws NoMessageException, UnmergedPathsException,
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 {
@ -220,8 +221,6 @@ public RevCommit call() throws NoMessageException, UnmergedPathsException,
MessageFormat.format(
JGitText.get().exceptionCaughtDuringExecutionOfRevertCommand,
e), e);
} finally {
revWalk.release();
}
return newHead;
}

3
org.eclipse.jgit/src/org/eclipse/jgit/api/RmCommand.java
View File

@ -144,10 +144,9 @@ public DirCache call() throws GitAPIException,
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));

5
org.eclipse.jgit/src/org/eclipse/jgit/api/ShowNoteCommand.java
View File

@ -76,10 +76,9 @@ protected ShowNoteCommand(Repository repo) {
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) {
@ -89,8 +88,6 @@ public Note call() throws GitAPIException {
return map.getNote(id);
} catch (IOException e) {
throw new JGitInternalException(e.getMessage(), e);
} finally {
walk.release();
}
}

19
org.eclipse.jgit/src/org/eclipse/jgit/api/StashApplyCommand.java
View File

@ -166,9 +166,8 @@ public ObjectId call() throws GitAPIException,
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)
@ -250,8 +249,6 @@ public ObjectId call() throws GitAPIException,
throw e;
} catch (IOException e) {
throw new JGitInternalException(JGitText.get().stashApplyFailed, e);
} finally {
reader.release();
}
}
@ -286,11 +283,9 @@ public void setApplyUntracked(boolean applyUntracked) {
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);
@ -321,15 +316,13 @@ private void resetIndex(RevTree tree) throws IOException {
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);
@ -359,8 +352,6 @@ private void resetUntracked(RevTree tree) throws CheckoutConflictException,
checkoutPath(entry, reader);
}
} finally {
walk.release();
}
}

17
org.eclipse.jgit/src/org/eclipse/jgit/api/StashCreateCommand.java
View File

@ -187,8 +187,9 @@ public StashCreateCommand setIncludeUntracked(boolean includeUntracked) {
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() {
@ -239,14 +240,13 @@ public RevCommit call() throws GitAPIException {
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));
@ -380,7 +380,6 @@ public void apply(DirCacheEntry ent) {
}
} finally {
inserter.release();
cache.unlock();
}
@ -391,8 +390,6 @@ public void apply(DirCacheEntry ent) {
return parseCommit(reader, commitId);
} catch (IOException e) {
throw new JGitInternalException(JGitText.get().stashFailed, e);
} finally {
reader.release();
}
}
}

6
org.eclipse.jgit/src/org/eclipse/jgit/api/SubmoduleUpdateCommand.java
View File

@ -143,8 +143,7 @@ public Collection<String> call() throws InvalidConfigurationException,
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>();
@ -171,8 +170,7 @@ public Collection<String> call() throws InvalidConfigurationException,
submoduleRepo = clone.call().getRepository();
}
try {
RevWalk walk = new RevWalk(submoduleRepo);
try (RevWalk walk = new RevWalk(submoduleRepo)) {
RevCommit commit = walk
.parseCommit(generator.getObjectId());

10
org.eclipse.jgit/src/org/eclipse/jgit/api/TagCommand.java
View File

@ -128,8 +128,7 @@ public Ref call() throws GitAPIException, ConcurrentRefUpdateException,
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$
@ -157,24 +156,19 @@ public Ref call() throws GitAPIException, ConcurrentRefUpdateException,
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();
}
}

6
org.eclipse.jgit/src/org/eclipse/jgit/blame/BlameGenerator.java
View File

@ -172,7 +172,7 @@ private void initRevPool(boolean reverse) {
throw new IllegalStateException();
if (revPool != null)
revPool.release();
revPool.close();
if (reverse)
revPool = new ReverseWalk(getRepository());
@ -450,7 +450,7 @@ public BlameResult computeBlameResult() throws IOException {
r.computeAll();
return r;
} finally {
release();
close();
}
}
@ -513,7 +513,7 @@ public boolean next() throws IOException {
}
private boolean done() {
release();
close();
return false;
}

2
org.eclipse.jgit/src/org/eclipse/jgit/diff/RenameDetector.java
View File

@ -323,7 +323,7 @@ public List<DiffEntry> compute(ProgressMonitor pm) throws IOException {
try {
return compute(objectReader, pm);
} finally {
objectReader.release();
objectReader.close();
}
}
return Collections.unmodifiableList(entries);

15
org.eclipse.jgit/src/org/eclipse/jgit/dircache/DirCacheCheckout.java
View File

@ -403,8 +403,7 @@ private boolean doCheckout() throws CorruptObjectException, IOException,
MissingObjectException, IncorrectObjectTypeException,
CheckoutConflictException, IndexWriteException {
toBeDeleted.clear();
ObjectReader objectReader = repo.getObjectDatabase().newReader();
try {
try (ObjectReader objectReader = repo.getObjectDatabase().newReader()) {
if (headCommitTree != null)
preScanTwoTrees();
else
@ -454,8 +453,6 @@ private boolean doCheckout() throws CorruptObjectException, IOException,
// commit the index builder - a new index is persisted
if (!builder.commit())
throw new IndexWriteException();
} finally {
objectReader.release();
}
return toBeDeleted.size() == 0;
}
@ -1056,8 +1053,7 @@ private void cleanUpConflicts() throws CheckoutConflictException {
*/
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);
@ -1075,8 +1071,6 @@ private boolean isModifiedSubtree_IndexWorkingtree(String path)
}
}
return false;
} finally {
tw.release();
}
}
@ -1105,8 +1099,7 @@ private boolean isModified_IndexTree(String path, ObjectId iId,
*/
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);
@ -1124,8 +1117,6 @@ private boolean isModifiedSubtree_IndexTree(String path, ObjectId tree)
return true;
}
return false;
} finally {
tw.release();
}
}

20
org.eclipse.jgit/src/org/eclipse/jgit/gitrepo/RepoCommand.java
View File

@ -214,15 +214,10 @@ public byte[] readFile(String uri, String ref, String path)
*/
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;
}
}
@ -748,8 +743,7 @@ public RevCommit call() throws GitAPIException {
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;
@ -831,8 +825,6 @@ public RevCommit call() throws GitAPIException {
return rw.parseCommit(commitId);
} catch (IOException e) {
throw new ManifestErrorException(e);
} finally {
rw.release();
}
} else {
return git
@ -859,8 +851,10 @@ private void addSubmodule(String url, String name, String revision,
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();
}

2
org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/dfs/DfsGarbageCollector.java
View File

@ -230,7 +230,7 @@ public boolean pack(ProgressMonitor pm) throws IOException {
objdb.rollbackPack(newPackDesc);
}
} finally {
ctx.release();
ctx.close();
}
}

6
org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/dfs/DfsInserter.java
View File

@ -601,7 +601,7 @@ public Set<ObjectId> getShallowCommits() throws IOException {
@Override
public void release() {
ctx.release();
ctx.close();
}
}
@ -631,7 +631,7 @@ public ObjectStream openStream() throws IOException {
// The newly created pack is registered in the cache.
return ctx.open(id, type).openStream();
} finally {
ctx.release();
ctx.close();
}
}
@ -642,7 +642,7 @@ size, new BufferedInputStream(new InflaterInputStream(
new ReadBackStream(pos), inf, bufsz), bufsz)) {
@Override
public void close() throws IOException {
ctx.release();
ctx.close();
super.close();
}
};

13
org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/dfs/DfsPackCompactor.java
View File

@ -179,11 +179,8 @@ public DfsPackCompactor exclude(PackWriter.ObjectIdSet set) {
*/
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) {
@ -206,8 +203,7 @@ public void compact(ProgressMonitor pm) throws IOException {
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);
@ -236,7 +232,7 @@ public void compact(ProgressMonitor pm) throws IOException {
writeIndex(objdb, pack, pw);
PackWriter.Statistics stats = pw.getStatistics();
pw.release();
pw.close();
pw = null;
pack.setPackStats(stats);
@ -250,11 +246,10 @@ public void compact(ProgressMonitor pm) throws IOException {
}
} finally {
if (pw != null)
pw.release();
pw.close();
}
} finally {
rw = null;
ctx.release();
}
}

5
org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/dfs/DfsRefDatabase.java
View File

@ -183,8 +183,7 @@ public Ref peel(Ref ref) throws IOException {
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(
@ -198,8 +197,6 @@ private Ref doPeel(final Ref leaf) throws MissingObjectException,
leaf.getName(),
leaf.getObjectId());
}
} finally {
rw.release();
}
}

4
org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/dfs/LargePackedWholeObject.java
View File

@ -112,8 +112,10 @@ public ObjectStream openStream() throws MissingObjectException, IOException {
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.

2
org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/dfs/PackInputStream.java
View File

@ -80,6 +80,6 @@ public int read() throws IOException {
@Override
public void close() {
ctx.release();
ctx.close();
}
}

5
org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/file/RefDirectory.java
View File

@ -477,8 +477,7 @@ public Ref peel(final Ref ref) throws IOException {
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
@ -487,8 +486,6 @@ private ObjectIdRef doPeel(final Ref leaf) throws MissingObjectException,
return new ObjectIdRef.PeeledNonTag(leaf.getStorage(), leaf
.getName(), leaf.getObjectId());
}
} finally {
rw.release();
}
}

4
org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/file/RefDirectoryRename.java
View File

@ -96,8 +96,7 @@ protected Result doRename() throws IOException {
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);
@ -178,7 +177,6 @@ protected Result doRename() throws IOException {
} catch (IOException err) {
FileUtils.delete(refdb.fileFor(tmp.getName()));
}
rw.release();
}
}

2
org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/pack/DeltaTask.java
View File

@ -288,7 +288,7 @@ public Object call() throws Exception {
runWindow(w);
} finally {
block.pm.endWorker();
or.release();
or.close();
or = null;
}
return null;

2
org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/pack/PackWriter.java
View File

@ -987,7 +987,7 @@ public void writePack(ProgressMonitor compressMonitor,
}
stats.totalBytes = out.length();
reader.release();
reader.close();
endPhase(writeMonitor);
}

196
org.eclipse.jgit/src/org/eclipse/jgit/lib/IndexDiff.java
View File

@ -400,118 +400,122 @@ public boolean diff(final ProgressMonitor monitor, int estWorkTreeSize,
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);
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 (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 (treeIterator != null) {
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) {
if (!treeIterator.idEqual(dirCacheIterator)
|| treeIterator.getEntryRawMode()
!= dirCacheIterator.getEntryRawMode()) {
// in repo, in index, content diff => changed
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 (!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());
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());
}
}
}
} 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 (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);
}
}
}
if (ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL) {

10
org.eclipse.jgit/src/org/eclipse/jgit/lib/RefUpdate.java
View File

@ -460,11 +460,8 @@ public Result forceUpdate() throws IOException {
* 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();
}
}
@ -510,11 +507,8 @@ Result execute(Result status) throws IOException {
* @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();
}
}

15
org.eclipse.jgit/src/org/eclipse/jgit/lib/Repository.java
View File

@ -379,8 +379,7 @@ public RefRename renameRef(final String fromRef, final String toRef) throws IOEx
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);
@ -388,8 +387,6 @@ public ObjectId resolve(final String revstr)
} else {
return (ObjectId) resolved;
}
} finally {
rw.release();
}
}
@ -406,8 +403,7 @@ public ObjectId resolve(final String revstr)
*/
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)
@ -415,8 +411,6 @@ public String simplify(final String revstr)
else
return ((AnyObjectId) resolved).getName();
return null;
} finally {
rw.release();
}
}
@ -791,8 +785,7 @@ private RevCommit resolveReflog(RevWalk rw, Ref ref, String time)
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;
@ -800,8 +793,6 @@ else if (matches.size() == 1)
return matches.iterator().next();
else
throw new AmbiguousObjectException(id, matches);
} finally {
reader.release();
}
}

17
org.eclipse.jgit/src/org/eclipse/jgit/merge/RecursiveMerger.java
View File

@ -269,14 +269,15 @@ private static PersonIdent mockAuthor(List<RevCommit> parents) {
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;

5
org.eclipse.jgit/src/org/eclipse/jgit/notes/LeafBucket.java
View File

@ -53,6 +53,7 @@
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;
@ -183,7 +184,9 @@ ObjectId writeTree(ObjectInserter inserter) throws IOException {
@Override
ObjectId getTreeId() {
return new ObjectInserter.Formatter().idFor(build());
try (Formatter f = new ObjectInserter.Formatter()) {
return f.idFor(build());
}
}
private TreeFormatter build() {

15
org.eclipse.jgit/src/org/eclipse/jgit/submodule/SubmoduleWalk.java
View File

@ -122,7 +122,7 @@ public static SubmoduleWalk forIndex(Repository repository)
DirCache index = repository.readDirCache();
generator.setTree(new DirCacheIterator(index));
} catch (IOException e) {
generator.release();
generator.close();
throw e;
}
return generator;
@ -152,10 +152,10 @@ public static SubmoduleWalk forPath(Repository repository,
if (filter.isDone(generator.walk))
return generator;
} catch (IOException e) {
generator.release();
generator.close();
throw e;
}
generator.release();
generator.close();
return null;
}
@ -183,10 +183,10 @@ public static SubmoduleWalk forPath(Repository repository,
if (filter.isDone(generator.walk))
return generator;
} catch (IOException e) {
generator.release();
generator.close();
throw e;
}
generator.release();
generator.close();
return null;
}
@ -419,8 +419,7 @@ public SubmoduleWalk loadModulesConfig() throws IOException, ConfigInvalidExcept
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
@ -446,8 +445,6 @@ public SubmoduleWalk loadModulesConfig() throws IOException, ConfigInvalidExcept
if (idx > 0)
rootTree.next(idx);
}
} finally {
configWalk.release();
}
}
return this;

4
org.eclipse.jgit/src/org/eclipse/jgit/transport/PushProcess.java
View File

@ -104,7 +104,7 @@ class PushProcess {
/**
* Create process for specified transport and refs updates specification.
*
*
* @param transport
* transport between remote and local repository, used to create
* connection.
@ -177,7 +177,7 @@ else if (!preprocessed.isEmpty())
}
return res;
} finally {
walker.release();
walker.close();
}
}

56
org.eclipse.jgit/src/org/eclipse/jgit/transport/UploadPack.java
View File

@ -630,7 +630,7 @@ public void upload(final InputStream input, final OutputStream output,
service();
} finally {
msgOut = NullOutputStream.INSTANCE;
walk.release();
walk.close();
if (timer != null) {
try {
timer.terminate();
@ -737,35 +737,35 @@ private void reportErrorDuringNegotiate(String msg) {
}
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;
// 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$
}
}
}
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 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();
}
@ -1460,7 +1460,7 @@ else if (ref.getName().startsWith(Constants.R_HEADS))
statistics = pw.getStatistics();
if (statistics != null)
logger.onPackStatistics(statistics);
pw.release();
pw.close();
}
if (sideband)

4
org.eclipse.jgit/src/org/eclipse/jgit/transport/WalkFetchConnection.java
View File

@ -252,8 +252,8 @@ public void setPackLockMessage(final String message) {
@Override
public void close() {
inserter.release();
reader.release();
inserter.close();
reader.close();
for (final RemotePack p : unfetchedPacks) {
if (p.tmpIdx != null)
p.tmpIdx.delete();

8
org.eclipse.jgit/src/org/eclipse/jgit/transport/WalkPushConnection.java
View File

@ -220,9 +220,9 @@ private void sendpack(final List<RemoteRefUpdate> updates,
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)
@ -293,8 +293,6 @@ private void sendpack(final List<RemoteRefUpdate> updates,
safeDelete(pathPack);
throw new TransportException(uri, JGitText.get().cannotStoreObjects, err);
} finally {
writer.release();
}
}