private AbstractTreeIterator getTreeIterator(Repository db, String name) throws IOException {
final ObjectId id = db.resolve(name);
if (id == null) throw new IllegalArgumentException(name);
final CanonicalTreeParser p = new CanonicalTreeParser();
final ObjectReader or = db.newObjectReader();
try {
p.reset(or, new RevWalk(db).parseTree(id));
return p;
} finally {
or.release();
}
}
@NotNull
private InputStream openAttributes(@NotNull ObjectReader reader, @Nullable ObjectId id)
throws IOException {
if (ObjectId.zeroId().equals(id)) {
return new ByteArrayInputStream(new byte[0]);
}
return reader.open(id, Constants.OBJ_BLOB).openStream();
}
@NotNull
public ConvertTask convertTask(@NotNull ObjectReader reader, @NotNull TaskKey key)
throws IOException {
switch (key.getType()) {
case Simple:
{
if (!reader.has(key.getObjectId())) {
return keepMissingTask(key.getObjectId());
}
final RevObject revObject = new RevWalk(reader).parseAny(key.getObjectId());
if (revObject instanceof RevCommit) {
return convertCommitTask((RevCommit) revObject);
}
if (revObject instanceof RevTree) {
return convertTreeTask(reader, revObject, false);
}
if (revObject instanceof RevBlob) {
return copyTask(reader, revObject);
}
if (revObject instanceof RevTag) {
return convertTagTask((RevTag) revObject);
}
throw new IllegalStateException(
"Unsupported object type: " + key + " (" + revObject.getClass().getName() + ")");
}
case Root:
{
final RevObject revObject = new RevWalk(reader).parseAny(key.getObjectId());
if (revObject instanceof RevTree) {
return convertTreeTask(reader, revObject, true);
}
throw new IllegalStateException(
"Unsupported object type: " + key + " (" + revObject.getClass().getName() + ")");
}
case Attribute:
return createAttributesTask(reader, key.getObjectId());
case UploadLfs:
return convertLfsTask(reader, key.getObjectId());
default:
throw new IllegalStateException("Unknwon task key type: " + key.getType());
}
}
protected final double _testRawDeser(int reps, byte[] json, ObjectReader reader)
throws IOException {
long start = System.nanoTime();
final JsonFactory f = reader.getFactory();
while (--reps >= 0) {
JsonParser p = f.createParser(new ByteArrayInputStream(json));
JsonToken t;
while ((t = p.nextToken()) != null) {
if (t == JsonToken.VALUE_STRING) {
p.getText();
} else if (t.isNumeric()) {
p.getNumberValue();
}
;
}
p.close();
}
hash = f.hashCode();
return _msecsFromNanos(System.nanoTime() - start);
}
private boolean handleGetDiff(
HttpServletRequest request,
HttpServletResponse response,
Repository db,
String scope,
String pattern,
OutputStream out)
throws Exception {
Git git = new Git(db);
DiffCommand diff = git.diff();
diff.setOutputStream(new BufferedOutputStream(out));
AbstractTreeIterator oldTree;
AbstractTreeIterator newTree = new FileTreeIterator(db);
if (scope.contains("..")) { // $NON-NLS-1$
String[] commits = scope.split("\\.\\."); // $NON-NLS-1$
if (commits.length != 2) {
String msg = NLS.bind("Failed to generate diff for {0}", scope);
return statusHandler.handleRequest(
request,
response,
new ServerStatus(IStatus.ERROR, HttpServletResponse.SC_BAD_REQUEST, msg, null));
}
oldTree = getTreeIterator(db, commits[0]);
newTree = getTreeIterator(db, commits[1]);
} else if (scope.equals(GitConstants.KEY_DIFF_CACHED)) {
ObjectId head = db.resolve(Constants.HEAD + "^{tree}"); // $NON-NLS-1$
if (head == null) {
String msg = NLS.bind("Failed to generate diff for {0}, no HEAD", scope);
return statusHandler.handleRequest(
request,
response,
new ServerStatus(IStatus.ERROR, HttpServletResponse.SC_BAD_REQUEST, msg, null));
}
CanonicalTreeParser p = new CanonicalTreeParser();
ObjectReader reader = db.newObjectReader();
try {
p.reset(reader, head);
} finally {
reader.release();
}
oldTree = p;
newTree = new DirCacheIterator(db.readDirCache());
} else if (scope.equals(GitConstants.KEY_DIFF_DEFAULT)) {
oldTree = new DirCacheIterator(db.readDirCache());
} else {
oldTree = getTreeIterator(db, scope);
}
String[] paths = request.getParameterValues(ProtocolConstants.KEY_PATH);
TreeFilter filter = null;
TreeFilter pathFilter = null;
if (paths != null) {
if (paths.length > 1) {
Set<TreeFilter> pathFilters = new HashSet<TreeFilter>(paths.length);
for (String path : paths) {
pathFilters.add(PathFilter.create(path));
}
pathFilter = OrTreeFilter.create(pathFilters);
} else if (paths.length == 1) {
pathFilter = PathFilter.create(paths[0]);
}
}
if (pattern != null) {
PathFilter patternFilter = PathFilter.create(pattern);
if (pathFilter != null) filter = AndTreeFilter.create(patternFilter, pathFilter);
else filter = patternFilter;
} else {
filter = pathFilter;
}
if (filter != null) diff.setPathFilter(filter);
diff.setOldTree(oldTree);
diff.setNewTree(newTree);
diff.call();
return true;
}
