buf.append("\n");
buf.append(msg);
- final RevWalk walk = new RevWalk(db);
- walk.setRetainBody(true);
- final RevCommit c = new RevCommit(ObjectId.zeroId());
- c.parseCanonical(walk, Constants.encode(buf.toString()));
- return c;
+ try (RevWalk walk = new RevWalk(db)) {
+ RevCommit c = new RevCommit(ObjectId.zeroId());
+ c.parseCanonical(walk, Constants.encode(buf.toString()));
+ return c;
+ }
}
}
private RevCommit parseCommit(final ObjectReader reader,
final ObjectId headId) throws IOException {
final RevWalk walk = new RevWalk(reader);
- walk.setRetainBody(true);
return walk.parseCommit(headId);
}
final List<RevCommit> stashCommits = new ArrayList<RevCommit>(
stashEntries.size());
- final RevWalk walk = new RevWalk(repo);
- walk.setRetainBody(true);
- try {
- for (ReflogEntry entry : stashEntries)
+ try (RevWalk walk = new RevWalk(repo)) {
+ for (ReflogEntry entry : stashEntries) {
try {
stashCommits.add(walk.parseCommit(entry.getNewId()));
} catch (IOException e) {
JGitText.get().cannotReadCommit, entry.getNewId()),
e);
}
- } finally {
- walk.dispose();
+ }
}
return stashCommits;
}
else
revPool = new RevWalk(getRepository());
- revPool.setRetainBody(true);
SEEN = revPool.newFlag("SEEN"); //$NON-NLS-1$
reader = revPool.getObjectReader();
treeWalk = new TreeWalk(reader);
stats.interestingObjects = Collections.unmodifiableSet(new HashSet<ObjectId>(want));
stats.uninterestingObjects = Collections.unmodifiableSet(new HashSet<ObjectId>(have));
- walker.setRetainBody(false);
-
canBuildBitmaps = config.isBuildBitmaps()
&& !shallowPack
&& have.isEmpty()
*/
public ObjectWalk(ObjectReader or) {
super(or);
+ setRetainBody(false);
rootObjects = new ArrayList<RevObject>();
pendingObjects = new BlockObjQueue();
pathBuf = new byte[256];
/**
* Parse a commit from its canonical format.
- *
+ * <p>
* This method inserts the commit directly into the caller supplied revision
* pool, making it appear as though the commit exists in the repository,
* even if it doesn't. The repository under the pool is not affected.
+ * <p>
+ * The body of the commit (message, author, committer) is always retained in
+ * the returned {@code RevCommit}, even if the supplied {@code RevWalk} has
+ * been configured with {@code setRetainBody(false)}.
*
* @param rw
* the revision pool to allocate the commit within. The commit's
* tree and parent pointers will be obtained from this pool.
* @param raw
- * the canonical formatted commit to be parsed.
+ * the canonical formatted commit to be parsed. This buffer will
+ * be retained by the returned {@code RevCommit} and must not be
+ * modified by the caller.
* @return the parsed commit, in an isolated revision pool that is not
* available to the caller.
* @throws IOException
* in case of RevWalk initialization fails
*/
public static RevCommit parse(RevWalk rw, byte[] raw) throws IOException {
- ObjectInserter.Formatter fmt = new ObjectInserter.Formatter();
- boolean retain = rw.isRetainBody();
- rw.setRetainBody(true);
- RevCommit r = rw.lookupCommit(fmt.idFor(Constants.OBJ_COMMIT, raw));
- r.parseCanonical(rw, raw);
- rw.setRetainBody(retain);
- return r;
+ try (ObjectInserter.Formatter fmt = new ObjectInserter.Formatter()) {
+ RevCommit r = rw.lookupCommit(fmt.idFor(Constants.OBJ_COMMIT, raw));
+ r.parseCanonical(rw, raw);
+ r.buffer = raw;
+ return r;
+ }
}
static final RevCommit[] NO_PARENTS = {};
/**
* Parse an annotated tag from its canonical format.
- *
+ * <p>
* This method inserts the tag directly into the caller supplied revision
* pool, making it appear as though the tag exists in the repository, even
* if it doesn't. The repository under the pool is not affected.
+ * <p>
+ * The body of the tag (message, tagger, signature) is always retained in
+ * the returned {@code RevTag}, even if the supplied {@code RevWalk} has
+ * been configured with {@code setRetainBody(false)}.
*
* @param rw
* the revision pool to allocate the tag within. The tag's object
* pointer will be obtained from this pool.
* @param raw
- * the canonical formatted tag to be parsed.
+ * the canonical formatted tag to be parsed. This buffer will be
+ * retained by the returned {@code RevTag} and must not be
+ * modified by the caller.
* @return the parsed tag, in an isolated revision pool that is not
* available to the caller.
* @throws CorruptObjectException
*/
public static RevTag parse(RevWalk rw, byte[] raw)
throws CorruptObjectException {
- ObjectInserter.Formatter fmt = new ObjectInserter.Formatter();
- boolean retain = rw.isRetainBody();
- rw.setRetainBody(true);
- RevTag r = rw.lookupTag(fmt.idFor(Constants.OBJ_TAG, raw));
- r.parseCanonical(rw, raw);
- rw.setRetainBody(retain);
- return r;
+ try (ObjectInserter.Formatter fmt = new ObjectInserter.Formatter()) {
+ RevTag r = rw.lookupTag(fmt.idFor(Constants.OBJ_TAG, raw));
+ r.parseCanonical(rw, raw);
+ r.buffer = raw;
+ return r;
+ }
}
private RevObject object;
private TreeFilter treeFilter;
- private boolean retainBody;
+ private boolean retainBody = true;
private boolean rewriteParents = true;
sorting = EnumSet.of(RevSort.NONE);
filter = RevFilter.ALL;
treeFilter = TreeFilter.ALL;
- retainBody = true;
this.closeReader = closeReader;
}
* Usually the body is always retained, but some application code might not
* care and would prefer to discard the body of a commit as early as
* possible, to reduce memory usage.
+ * <p>
+ * True by default on {@link RevWalk} and false by default for
+ * {@link ObjectWalk}.
*
* @return true if the body should be retained; false it is discarded.
*/
* If a body of a commit or tag is not retained, the application must
* call {@link #parseBody(RevObject)} before the body can be safely
* accessed through the type specific access methods.
+ * <p>
+ * True by default on {@link RevWalk} and false by default for
+ * {@link ObjectWalk}.
*
* @param retain true to retain bodies; false to discard them early.
*/
parser = null;
try (final ObjectWalk ow = new ObjectWalk(db)) {
- ow.setRetainBody(false);
if (baseObjects != null) {
ow.sort(RevSort.TOPO);
if (!baseObjects.isEmpty())
projects / jgit.git / commitdiff