Browse Source

Start using ObjectInserter instead of ObjectWriter

Some newer style APIs are updated to use the newer ObjectInserter
interface instead of the now deprecated ObjectWriter.  In many of
the unit tests we don't bother to release the inserter, these are
typically using the file backend which doesn't need a release,
but in the future should use an in-memory HashMap based store,
which really wouldn't need it either.

Change-Id: I91a15e1dc42da68e6715397814e30fbd87fa2e73
Signed-off-by: Shawn O. Pearce <spearce@spearce.org>
tags/v0.9.1
Shawn O. Pearce 14 years ago
parent
commit
88530a179e

+ 45
- 9
org.eclipse.jgit.junit/src/org/eclipse/jgit/junit/TestRepository.java View File

import org.eclipse.jgit.lib.ObjectChecker; import org.eclipse.jgit.lib.ObjectChecker;
import org.eclipse.jgit.lib.ObjectDirectory; import org.eclipse.jgit.lib.ObjectDirectory;
import org.eclipse.jgit.lib.ObjectId; import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.ObjectWriter;
import org.eclipse.jgit.lib.ObjectInserter;
import org.eclipse.jgit.lib.PackFile; import org.eclipse.jgit.lib.PackFile;
import org.eclipse.jgit.lib.PackWriter; import org.eclipse.jgit.lib.PackWriter;
import org.eclipse.jgit.lib.PersonIdent; import org.eclipse.jgit.lib.PersonIdent;


private final RevWalk pool; private final RevWalk pool;


private final ObjectWriter writer;
private final ObjectInserter inserter;


private long now; private long now;


public TestRepository(R db, RevWalk rw) throws IOException { public TestRepository(R db, RevWalk rw) throws IOException {
this.db = db; this.db = db;
this.pool = rw; this.pool = rw;
this.writer = new ObjectWriter(db);
this.inserter = db.newObjectInserter();
this.now = 1236977987000L; this.now = 1236977987000L;
} }


* @throws Exception * @throws Exception
*/ */
public RevBlob blob(final byte[] content) throws Exception { public RevBlob blob(final byte[] content) throws Exception {
return pool.lookupBlob(writer.writeBlob(content));
ObjectId id;
try {
id = inserter.insert(Constants.OBJ_BLOB, content);
inserter.flush();
} finally {
inserter.release();
}
return pool.lookupBlob(id);
} }


/** /**
for (final DirCacheEntry e : entries) for (final DirCacheEntry e : entries)
b.add(e); b.add(e);
b.finish(); b.finish();
return pool.lookupTree(dc.writeTree(writer));
ObjectId root;
try {
root = dc.writeTree(inserter);
inserter.flush();
} finally {
inserter.release();
}
return pool.lookupTree(root);
} }


/** /**
c.setAuthor(new PersonIdent(author, new Date(now))); c.setAuthor(new PersonIdent(author, new Date(now)));
c.setCommitter(new PersonIdent(committer, new Date(now))); c.setCommitter(new PersonIdent(committer, new Date(now)));
c.setMessage(""); c.setMessage("");
return pool.lookupCommit(writer.writeCommit(c));
ObjectId id;
try {
id = inserter.insert(Constants.OBJ_COMMIT, inserter.format(c));
inserter.flush();
} finally {
inserter.release();
}
return pool.lookupCommit(id);
} }


/** @return a new commit builder. */ /** @return a new commit builder. */
t.setTag(name); t.setTag(name);
t.setTagger(new PersonIdent(committer, new Date(now))); t.setTagger(new PersonIdent(committer, new Date(now)));
t.setMessage(""); t.setMessage("");
return (RevTag) pool.lookupAny(writer.writeTag(t), Constants.OBJ_TAG);
ObjectId id;
try {
id = inserter.insert(Constants.OBJ_TAG, inserter.format(t));
inserter.flush();
} finally {
inserter.release();
}
return (RevTag) pool.lookupAny(id, Constants.OBJ_TAG);
} }


/** /**
TestRepository.this.tick(tick); TestRepository.this.tick(tick);


final Commit c = new Commit(db); final Commit c = new Commit(db);
c.setTreeId(pool.lookupTree(tree.writeTree(writer)));
c.setParentIds(parents.toArray(new RevCommit[parents.size()])); c.setParentIds(parents.toArray(new RevCommit[parents.size()]));
c.setAuthor(new PersonIdent(author, new Date(now))); c.setAuthor(new PersonIdent(author, new Date(now)));
c.setCommitter(new PersonIdent(committer, new Date(now))); c.setCommitter(new PersonIdent(committer, new Date(now)));
c.setMessage(message); c.setMessage(message);


self = pool.lookupCommit(writer.writeCommit(c));
ObjectId commitId;
try {
c.setTreeId(tree.writeTree(inserter));
commitId = inserter.insert(Constants.OBJ_COMMIT, inserter
.format(c));
inserter.flush();
} finally {
inserter.release();
}
self = pool.lookupCommit(commitId);


if (branch != null) if (branch != null)
branch.update(self); branch.update(self);

+ 6
- 2
org.eclipse.jgit.test/tst/org/eclipse/jgit/lib/ReadTreeTest.java View File

} }


ObjectId genSha1(String data) { ObjectId genSha1(String data) {
ObjectWriter objectWriter = new ObjectWriter(db);
ObjectInserter w = db.newObjectInserter();
try { try {
return objectWriter.writeBlob(data.getBytes());
ObjectId id = w.insert(Constants.OBJ_BLOB, data.getBytes());
w.flush();
return id;
} catch (IOException e) { } catch (IOException e) {
fail(e.toString()); fail(e.toString());
} finally {
w.release();
} }
return null; return null;
} }

+ 11
- 9
org.eclipse.jgit.test/tst/org/eclipse/jgit/merge/CherryPickTest.java View File



package org.eclipse.jgit.merge; package org.eclipse.jgit.merge;


import java.io.ByteArrayInputStream;
import static org.eclipse.jgit.lib.Constants.OBJ_BLOB;
import static org.eclipse.jgit.lib.Constants.OBJ_COMMIT;


import org.eclipse.jgit.dircache.DirCache; import org.eclipse.jgit.dircache.DirCache;
import org.eclipse.jgit.dircache.DirCacheBuilder; import org.eclipse.jgit.dircache.DirCacheBuilder;
import org.eclipse.jgit.lib.Constants; import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.FileMode; import org.eclipse.jgit.lib.FileMode;
import org.eclipse.jgit.lib.ObjectId; import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.ObjectWriter;
import org.eclipse.jgit.lib.ObjectInserter;
import org.eclipse.jgit.lib.PersonIdent; import org.eclipse.jgit.lib.PersonIdent;
import org.eclipse.jgit.lib.RepositoryTestCase; import org.eclipse.jgit.lib.RepositoryTestCase;
import org.eclipse.jgit.treewalk.TreeWalk; import org.eclipse.jgit.treewalk.TreeWalk;
t.finish(); t.finish();
} }


final ObjectWriter ow = new ObjectWriter(db);
final ObjectInserter ow = db.newObjectInserter();
final ObjectId B = commit(ow, treeB, new ObjectId[] {}); final ObjectId B = commit(ow, treeB, new ObjectId[] {});
final ObjectId O = commit(ow, treeO, new ObjectId[] { B }); final ObjectId O = commit(ow, treeO, new ObjectId[] { B });
final ObjectId P = commit(ow, treeP, new ObjectId[] { B }); final ObjectId P = commit(ow, treeP, new ObjectId[] { B });
.getObjectId(0)); .getObjectId(0));
} }


private ObjectId commit(final ObjectWriter ow, final DirCache treeB,
private ObjectId commit(final ObjectInserter odi, final DirCache treeB,
final ObjectId[] parentIds) throws Exception { final ObjectId[] parentIds) throws Exception {
final Commit c = new Commit(db); final Commit c = new Commit(db);
c.setTreeId(treeB.writeTree(ow));
c.setTreeId(treeB.writeTree(odi));
c.setAuthor(new PersonIdent("A U Thor", "a.u.thor", 1L, 0)); c.setAuthor(new PersonIdent("A U Thor", "a.u.thor", 1L, 0));
c.setCommitter(c.getAuthor()); c.setCommitter(c.getAuthor());
c.setParentIds(parentIds); c.setParentIds(parentIds);
c.setMessage("Tree " + c.getTreeId().name()); c.setMessage("Tree " + c.getTreeId().name());
return ow.writeCommit(c);
ObjectId id = odi.insert(OBJ_COMMIT, odi.format(c));
odi.flush();
return id;
} }


private DirCacheEntry makeEntry(final String path, final FileMode mode) private DirCacheEntry makeEntry(final String path, final FileMode mode)
final String content) throws Exception { final String content) throws Exception {
final DirCacheEntry ent = new DirCacheEntry(path); final DirCacheEntry ent = new DirCacheEntry(path);
ent.setFileMode(mode); ent.setFileMode(mode);
final byte[] contentBytes = Constants.encode(content);
ent.setObjectId(new ObjectWriter(db).computeBlobSha1(
contentBytes.length, new ByteArrayInputStream(contentBytes)));
ent.setObjectId(new ObjectInserter.Formatter().idFor(OBJ_BLOB,
Constants.encode(content)));
return ent; return ent;
} }
} }

+ 18
- 15
org.eclipse.jgit.test/tst/org/eclipse/jgit/merge/SimpleMergeTest.java View File



package org.eclipse.jgit.merge; package org.eclipse.jgit.merge;


import java.io.ByteArrayInputStream;
import static org.eclipse.jgit.lib.Constants.OBJ_BLOB;
import static org.eclipse.jgit.lib.Constants.OBJ_COMMIT;

import java.io.IOException; import java.io.IOException;


import org.eclipse.jgit.dircache.DirCache; import org.eclipse.jgit.dircache.DirCache;
import org.eclipse.jgit.lib.Constants; import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.FileMode; import org.eclipse.jgit.lib.FileMode;
import org.eclipse.jgit.lib.ObjectId; import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.ObjectWriter;
import org.eclipse.jgit.lib.ObjectInserter;
import org.eclipse.jgit.lib.PersonIdent; import org.eclipse.jgit.lib.PersonIdent;
import org.eclipse.jgit.lib.SampleDataRepositoryTestCase; import org.eclipse.jgit.lib.SampleDataRepositoryTestCase;
import org.eclipse.jgit.treewalk.TreeWalk; import org.eclipse.jgit.treewalk.TreeWalk;
t.finish(); t.finish();
} }


final ObjectWriter ow = new ObjectWriter(db);
final ObjectInserter ow = db.newObjectInserter();
final ObjectId b = commit(ow, treeB, new ObjectId[] {}); final ObjectId b = commit(ow, treeB, new ObjectId[] {});
final ObjectId o = commit(ow, treeO, new ObjectId[] { b }); final ObjectId o = commit(ow, treeO, new ObjectId[] { b });
final ObjectId t = commit(ow, treeT, new ObjectId[] { b }); final ObjectId t = commit(ow, treeT, new ObjectId[] { b });
t.finish(); t.finish();
} }


final ObjectWriter ow = new ObjectWriter(db);
final ObjectInserter ow = db.newObjectInserter();
final ObjectId b = commit(ow, treeB, new ObjectId[] {}); final ObjectId b = commit(ow, treeB, new ObjectId[] {});
final ObjectId o = commit(ow, treeO, new ObjectId[] { b }); final ObjectId o = commit(ow, treeO, new ObjectId[] { b });
final ObjectId t = commit(ow, treeT, new ObjectId[] { b }); final ObjectId t = commit(ow, treeT, new ObjectId[] { b });
t.finish(); t.finish();
} }


final ObjectWriter ow = new ObjectWriter(db);
final ObjectInserter ow = db.newObjectInserter();
final ObjectId b = commit(ow, treeB, new ObjectId[] {}); final ObjectId b = commit(ow, treeB, new ObjectId[] {});
final ObjectId o = commit(ow, treeO, new ObjectId[] { b }); final ObjectId o = commit(ow, treeO, new ObjectId[] { b });
final ObjectId t = commit(ow, treeT, new ObjectId[] { b }); final ObjectId t = commit(ow, treeT, new ObjectId[] { b });
t.finish(); t.finish();
} }


final ObjectWriter ow = new ObjectWriter(db);
final ObjectInserter ow = db.newObjectInserter();
final ObjectId b = commit(ow, treeB, new ObjectId[] {}); final ObjectId b = commit(ow, treeB, new ObjectId[] {});
final ObjectId o = commit(ow, treeO, new ObjectId[] { b }); final ObjectId o = commit(ow, treeO, new ObjectId[] { b });
final ObjectId t = commit(ow, treeT, new ObjectId[] { b }); final ObjectId t = commit(ow, treeT, new ObjectId[] { b });
t.finish(); t.finish();
} }


final ObjectWriter ow = new ObjectWriter(db);
final ObjectInserter ow = db.newObjectInserter();
final ObjectId b = commit(ow, treeB, new ObjectId[] {}); final ObjectId b = commit(ow, treeB, new ObjectId[] {});
final ObjectId o = commit(ow, treeO, new ObjectId[] { b }); final ObjectId o = commit(ow, treeO, new ObjectId[] { b });
final ObjectId t = commit(ow, treeT, new ObjectId[] { b }); final ObjectId t = commit(ow, treeT, new ObjectId[] { b });
t.finish(); t.finish();
} }


final ObjectWriter ow = new ObjectWriter(db);
final ObjectInserter ow = db.newObjectInserter();
final ObjectId b = commit(ow, treeB, new ObjectId[] {}); final ObjectId b = commit(ow, treeB, new ObjectId[] {});
final ObjectId o = commit(ow, treeO, new ObjectId[] { b }); final ObjectId o = commit(ow, treeO, new ObjectId[] { b });
final ObjectId t = commit(ow, treeT, new ObjectId[] { b }); final ObjectId t = commit(ow, treeT, new ObjectId[] { b });
t.finish(); t.finish();
} }


final ObjectWriter ow = new ObjectWriter(db);
final ObjectInserter ow = db.newObjectInserter();
final ObjectId b = commit(ow, treeB, new ObjectId[] {}); final ObjectId b = commit(ow, treeB, new ObjectId[] {});
final ObjectId o = commit(ow, treeO, new ObjectId[] { b }); final ObjectId o = commit(ow, treeO, new ObjectId[] { b });
final ObjectId t = commit(ow, treeT, new ObjectId[] { b }); final ObjectId t = commit(ow, treeT, new ObjectId[] { b });
.getObjectId(0)); .getObjectId(0));
} }


private ObjectId commit(final ObjectWriter ow, final DirCache treeB,
private ObjectId commit(final ObjectInserter odi, final DirCache treeB,
final ObjectId[] parentIds) throws Exception { final ObjectId[] parentIds) throws Exception {
final Commit c = new Commit(db); final Commit c = new Commit(db);
c.setTreeId(treeB.writeTree(ow));
c.setTreeId(treeB.writeTree(odi));
c.setAuthor(new PersonIdent("A U Thor", "a.u.thor", 1L, 0)); c.setAuthor(new PersonIdent("A U Thor", "a.u.thor", 1L, 0));
c.setCommitter(c.getAuthor()); c.setCommitter(c.getAuthor());
c.setParentIds(parentIds); c.setParentIds(parentIds);
c.setMessage("Tree " + c.getTreeId().name()); c.setMessage("Tree " + c.getTreeId().name());
return ow.writeCommit(c);
ObjectId id = odi.insert(OBJ_COMMIT, odi.format(c));
odi.flush();
return id;
} }


private DirCacheEntry makeEntry(final String path, final FileMode mode) private DirCacheEntry makeEntry(final String path, final FileMode mode)
final String content) throws Exception { final String content) throws Exception {
final DirCacheEntry ent = new DirCacheEntry(path); final DirCacheEntry ent = new DirCacheEntry(path);
ent.setFileMode(mode); ent.setFileMode(mode);
final byte[] contentBytes = Constants.encode(content);
ent.setObjectId(new ObjectWriter(db).computeBlobSha1(
contentBytes.length, new ByteArrayInputStream(contentBytes)));
ent.setObjectId(new ObjectInserter.Formatter().idFor(OBJ_BLOB,
Constants.encode(content)));
return ent; return ent;
} }
} }

+ 15
- 11
org.eclipse.jgit.test/tst/org/eclipse/jgit/treewalk/filter/PathSuffixFilterTestCase.java View File



package org.eclipse.jgit.treewalk.filter; package org.eclipse.jgit.treewalk.filter;


import static org.eclipse.jgit.lib.Constants.OBJ_BLOB;

import java.io.IOException; import java.io.IOException;
import java.util.LinkedList; import java.util.LinkedList;
import java.util.List; import java.util.List;
import org.eclipse.jgit.dircache.DirCacheEntry; import org.eclipse.jgit.dircache.DirCacheEntry;
import org.eclipse.jgit.lib.FileMode; import org.eclipse.jgit.lib.FileMode;
import org.eclipse.jgit.lib.ObjectId; import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.ObjectWriter;
import org.eclipse.jgit.lib.ObjectInserter;
import org.eclipse.jgit.lib.RepositoryTestCase; import org.eclipse.jgit.lib.RepositoryTestCase;
import org.eclipse.jgit.treewalk.TreeWalk; import org.eclipse.jgit.treewalk.TreeWalk;


public class PathSuffixFilterTestCase extends RepositoryTestCase { public class PathSuffixFilterTestCase extends RepositoryTestCase {


public void testNonRecursiveFiltering() throws IOException { public void testNonRecursiveFiltering() throws IOException {
final ObjectWriter ow = new ObjectWriter(db);
final ObjectId aSth = ow.writeBlob("a.sth".getBytes());
final ObjectId aTxt = ow.writeBlob("a.txt".getBytes());
final ObjectInserter odi = db.newObjectInserter();
final ObjectId aSth = odi.insert(OBJ_BLOB, "a.sth".getBytes());
final ObjectId aTxt = odi.insert(OBJ_BLOB, "a.txt".getBytes());
final DirCache dc = DirCache.read(db); final DirCache dc = DirCache.read(db);
final DirCacheBuilder builder = dc.builder(); final DirCacheBuilder builder = dc.builder();
final DirCacheEntry aSthEntry = new DirCacheEntry("a.sth"); final DirCacheEntry aSthEntry = new DirCacheEntry("a.sth");
builder.add(aSthEntry); builder.add(aSthEntry);
builder.add(aTxtEntry); builder.add(aTxtEntry);
builder.finish(); builder.finish();
final ObjectId treeId = dc.writeTree(ow);
final ObjectId treeId = dc.writeTree(odi);
odi.flush();




final TreeWalk tw = new TreeWalk(db); final TreeWalk tw = new TreeWalk(db);
} }


public void testRecursiveFiltering() throws IOException { public void testRecursiveFiltering() throws IOException {
final ObjectWriter ow = new ObjectWriter(db);
final ObjectId aSth = ow.writeBlob("a.sth".getBytes());
final ObjectId aTxt = ow.writeBlob("a.txt".getBytes());
final ObjectId bSth = ow.writeBlob("b.sth".getBytes());
final ObjectId bTxt = ow.writeBlob("b.txt".getBytes());
final ObjectInserter odi = db.newObjectInserter();
final ObjectId aSth = odi.insert(OBJ_BLOB, "a.sth".getBytes());
final ObjectId aTxt = odi.insert(OBJ_BLOB, "a.txt".getBytes());
final ObjectId bSth = odi.insert(OBJ_BLOB, "b.sth".getBytes());
final ObjectId bTxt = odi.insert(OBJ_BLOB, "b.txt".getBytes());
final DirCache dc = DirCache.read(db); final DirCache dc = DirCache.read(db);
final DirCacheBuilder builder = dc.builder(); final DirCacheBuilder builder = dc.builder();
final DirCacheEntry aSthEntry = new DirCacheEntry("a.sth"); final DirCacheEntry aSthEntry = new DirCacheEntry("a.sth");
builder.add(bSthEntry); builder.add(bSthEntry);
builder.add(bTxtEntry); builder.add(bTxtEntry);
builder.finish(); builder.finish();
final ObjectId treeId = dc.writeTree(ow);
final ObjectId treeId = dc.writeTree(odi);
odi.flush();




final TreeWalk tw = new TreeWalk(db); final TreeWalk tw = new TreeWalk(db);

+ 50
- 43
org.eclipse.jgit/src/org/eclipse/jgit/api/CommitCommand.java View File

import org.eclipse.jgit.lib.Commit; import org.eclipse.jgit.lib.Commit;
import org.eclipse.jgit.lib.Constants; import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.ObjectId; import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.ObjectWriter;
import org.eclipse.jgit.lib.ObjectInserter;
import org.eclipse.jgit.lib.PersonIdent; import org.eclipse.jgit.lib.PersonIdent;
import org.eclipse.jgit.lib.Ref; import org.eclipse.jgit.lib.Ref;
import org.eclipse.jgit.lib.RefUpdate; import org.eclipse.jgit.lib.RefUpdate;
import org.eclipse.jgit.lib.RefUpdate.Result;
import org.eclipse.jgit.lib.Repository; import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.lib.RepositoryState; import org.eclipse.jgit.lib.RepositoryState;
import org.eclipse.jgit.lib.RefUpdate.Result;
import org.eclipse.jgit.revwalk.RevCommit; import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.revwalk.RevWalk; import org.eclipse.jgit.revwalk.RevWalk;


// lock the index // lock the index
DirCache index = DirCache.lock(repo); DirCache index = DirCache.lock(repo);
try { try {
ObjectWriter repoWriter = new ObjectWriter(repo);
// Write the index as tree to the object database. This may fail
// for example when the index contains unmerged pathes
// (unresolved conflicts)
ObjectId indexTreeId = index.writeTree(repoWriter);
ObjectInserter odi = repo.newObjectInserter();
try {
// Write the index as tree to the object database. This may
// fail for example when the index contains unmerged paths
// (unresolved conflicts)
ObjectId indexTreeId = index.writeTree(odi);


// Create a Commit object, populate it and write it
Commit commit = new Commit(repo);
commit.setCommitter(committer);
commit.setAuthor(author);
commit.setMessage(message);
// Create a Commit object, populate it and write it
Commit commit = new Commit(repo);
commit.setCommitter(committer);
commit.setAuthor(author);
commit.setMessage(message);


commit.setParentIds(parents.toArray(new ObjectId[]{}));
commit.setTreeId(indexTreeId);
ObjectId commitId = repoWriter.writeCommit(commit);
commit.setParentIds(parents.toArray(new ObjectId[] {}));
commit.setTreeId(indexTreeId);
ObjectId commitId = odi.insert(Constants.OBJ_COMMIT, odi
.format(commit));
odi.flush();


RevCommit revCommit = new RevWalk(repo).parseCommit(commitId);
RefUpdate ru = repo.updateRef(Constants.HEAD);
ru.setNewObjectId(commitId);
ru.setRefLogMessage("commit : " + revCommit.getShortMessage(),
false);
RevCommit revCommit = new RevWalk(repo)
.parseCommit(commitId);
RefUpdate ru = repo.updateRef(Constants.HEAD);
ru.setNewObjectId(commitId);
ru.setRefLogMessage("commit : "
+ revCommit.getShortMessage(), false);


ru.setExpectedOldObjectId(headId);
Result rc = ru.update();
switch (rc) {
case NEW:
case FAST_FORWARD:
setCallable(false);
if (state == RepositoryState.MERGING_RESOLVED) {
// Commit was successful. Now delete the files
// used for merge commits
new File(repo.getDirectory(), Constants.MERGE_HEAD)
.delete();
new File(repo.getDirectory(), Constants.MERGE_MSG)
.delete();
ru.setExpectedOldObjectId(headId);
Result rc = ru.update();
switch (rc) {
case NEW:
case FAST_FORWARD:
setCallable(false);
if (state == RepositoryState.MERGING_RESOLVED) {
// Commit was successful. Now delete the files
// used for merge commits
new File(repo.getDirectory(), Constants.MERGE_HEAD)
.delete();
new File(repo.getDirectory(), Constants.MERGE_MSG)
.delete();
}
return revCommit;
case REJECTED:
case LOCK_FAILURE:
throw new ConcurrentRefUpdateException(
JGitText.get().couldNotLockHEAD, ru.getRef(),
rc);
default:
throw new JGitInternalException(MessageFormat.format(
JGitText.get().updatingRefFailed,
Constants.HEAD, commitId.toString(), rc));
} }
return revCommit;
case REJECTED:
case LOCK_FAILURE:
throw new ConcurrentRefUpdateException(
JGitText.get().couldNotLockHEAD, ru.getRef(), rc);
default:
throw new JGitInternalException(MessageFormat.format(
JGitText.get().updatingRefFailed
, Constants.HEAD, commitId.toString(), rc));
} finally {
odi.release();
} }
} finally { } finally {
index.unlock(); index.unlock();

+ 5
- 3
org.eclipse.jgit/src/org/eclipse/jgit/dircache/DirCache.java View File

import org.eclipse.jgit.lib.Constants; import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.LockFile; import org.eclipse.jgit.lib.LockFile;
import org.eclipse.jgit.lib.ObjectId; import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.ObjectWriter;
import org.eclipse.jgit.lib.ObjectInserter;
import org.eclipse.jgit.lib.Repository; import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.util.IO; import org.eclipse.jgit.util.IO;
import org.eclipse.jgit.util.MutableInteger; import org.eclipse.jgit.util.MutableInteger;
* Write all index trees to the object store, returning the root tree. * Write all index trees to the object store, returning the root tree.
* *
* @param ow * @param ow
* the writer to use when serializing to the store.
* the writer to use when serializing to the store. The caller is
* responsible for flushing the inserter before trying to use the
* returned tree identity.
* @return identity for the root tree. * @return identity for the root tree.
* @throws UnmergedPathException * @throws UnmergedPathException
* one or more paths contain higher-order stages (stage > 0), * one or more paths contain higher-order stages (stage > 0),
* @throws IOException * @throws IOException
* an unexpected error occurred writing to the object store. * an unexpected error occurred writing to the object store.
*/ */
public ObjectId writeTree(final ObjectWriter ow)
public ObjectId writeTree(final ObjectInserter ow)
throws UnmergedPathException, IOException { throws UnmergedPathException, IOException {
return getCacheTree(true).writeTree(sortedEntries, 0, 0, ow); return getCacheTree(true).writeTree(sortedEntries, 0, 0, ow);
} }

+ 4
- 4
org.eclipse.jgit/src/org/eclipse/jgit/dircache/DirCacheTree.java View File

import org.eclipse.jgit.lib.Constants; import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.FileMode; import org.eclipse.jgit.lib.FileMode;
import org.eclipse.jgit.lib.ObjectId; import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.ObjectWriter;
import org.eclipse.jgit.lib.ObjectInserter;
import org.eclipse.jgit.util.MutableInteger; import org.eclipse.jgit.util.MutableInteger;
import org.eclipse.jgit.util.RawParseUtils; import org.eclipse.jgit.util.RawParseUtils;


* an unexpected error occurred writing to the object store. * an unexpected error occurred writing to the object store.
*/ */
ObjectId writeTree(final DirCacheEntry[] cache, int cIdx, ObjectId writeTree(final DirCacheEntry[] cache, int cIdx,
final int pathOffset, final ObjectWriter ow)
final int pathOffset, final ObjectInserter ow)
throws UnmergedPathException, IOException { throws UnmergedPathException, IOException {
if (id == null) { if (id == null) {
final int endIdx = cIdx + entrySpan; final int endIdx = cIdx + entrySpan;
entryIdx++; entryIdx++;
} }


id = ow.writeCanonicalTree(out.toByteArray());
id = ow.insert(Constants.OBJ_TREE, out.toByteArray());
} }
return id; return id;
} }


private int computeSize(final DirCacheEntry[] cache, int cIdx, private int computeSize(final DirCacheEntry[] cache, int cIdx,
final int pathOffset, final ObjectWriter ow)
final int pathOffset, final ObjectInserter ow)
throws UnmergedPathException, IOException { throws UnmergedPathException, IOException {
final int endIdx = cIdx + entrySpan; final int endIdx = cIdx + entrySpan;
int childIdx = 0; int childIdx = 0;

+ 8
- 1
org.eclipse.jgit/src/org/eclipse/jgit/lib/Commit.java View File

public void commit() throws IOException { public void commit() throws IOException {
if (getCommitId() != null) if (getCommitId() != null)
throw new IllegalStateException(MessageFormat.format(JGitText.get().commitAlreadyExists, getCommitId())); throw new IllegalStateException(MessageFormat.format(JGitText.get().commitAlreadyExists, getCommitId()));
setCommitId(new ObjectWriter(objdb).writeCommit(this));
ObjectInserter odi = objdb.getObjectDatabase().newInserter();
try {
ObjectId id = odi.insert(Constants.OBJ_COMMIT, odi.format(this));
odi.flush();
setCommitId(id);
} finally {
odi.release();
}
} }


public String toString() { public String toString() {

+ 8
- 3
org.eclipse.jgit/src/org/eclipse/jgit/lib/Tag.java View File

final RefUpdate ru; final RefUpdate ru;


if (tagger!=null || message!=null || type!=null) { if (tagger!=null || message!=null || type!=null) {
ObjectId tagid = new ObjectWriter(objdb).writeTag(this);
setTagId(tagid);
id = tagid;
ObjectInserter odi = objdb.newObjectInserter();
try {
id = odi.insert(Constants.OBJ_TAG, odi.format(this));
odi.flush();
setTagId(id);
} finally {
odi.release();
}
} else { } else {
id = objId; id = objId;
} }

+ 6
- 6
org.eclipse.jgit/src/org/eclipse/jgit/merge/Merger.java View File

import org.eclipse.jgit.lib.AnyObjectId; import org.eclipse.jgit.lib.AnyObjectId;
import org.eclipse.jgit.lib.Constants; import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.ObjectId; import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.ObjectWriter;
import org.eclipse.jgit.lib.ObjectInserter;
import org.eclipse.jgit.lib.Repository; import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.lib.WindowCursor; import org.eclipse.jgit.lib.WindowCursor;
import org.eclipse.jgit.revwalk.RevCommit; import org.eclipse.jgit.revwalk.RevCommit;
/** A RevWalk for computing merge bases, or listing incoming commits. */ /** A RevWalk for computing merge bases, or listing incoming commits. */
protected final RevWalk walk; protected final RevWalk walk;


private ObjectWriter writer;
private ObjectInserter inserter;


/** The original objects supplied in the merge; this can be any tree-ish. */ /** The original objects supplied in the merge; this can be any tree-ish. */
protected RevObject[] sourceObjects; protected RevObject[] sourceObjects;
/** /**
* @return an object writer to create objects in {@link #getRepository()}. * @return an object writer to create objects in {@link #getRepository()}.
*/ */
public ObjectWriter getObjectWriter() {
if (writer == null)
writer = new ObjectWriter(getRepository());
return writer;
public ObjectInserter getObjectInserter() {
if (inserter == null)
inserter = getRepository().newObjectInserter();
return inserter;
} }


/** /**

+ 11
- 1
org.eclipse.jgit/src/org/eclipse/jgit/merge/StrategySimpleTwoWayInCore.java View File

import org.eclipse.jgit.errors.UnmergedPathException; import org.eclipse.jgit.errors.UnmergedPathException;
import org.eclipse.jgit.lib.FileMode; import org.eclipse.jgit.lib.FileMode;
import org.eclipse.jgit.lib.ObjectId; import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.ObjectInserter;
import org.eclipse.jgit.lib.Repository; import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.treewalk.AbstractTreeIterator; import org.eclipse.jgit.treewalk.AbstractTreeIterator;
import org.eclipse.jgit.treewalk.NameConflictTreeWalk; import org.eclipse.jgit.treewalk.NameConflictTreeWalk;
if (hasConflict) if (hasConflict)
return false; return false;
try { try {
resultTree = cache.writeTree(getObjectWriter());
ObjectInserter odi = getObjectInserter();
try {
resultTree = cache.writeTree(odi);
odi.flush();
} finally {
// We don't know if our caller will release the
// inserter, so make sure we do it ourselves.
//
odi.release();
}
return true; return true;
} catch (UnmergedPathException upe) { } catch (UnmergedPathException upe) {
resultTree = null; resultTree = null;

Loading…
Cancel
Save