As discussed on the egit-dev mailing list, we prefer not to have trailing whitespace in our source code. Correct all currently offending lines by trimming them. Change-Id: I002b1d1980071084c0bc53242c8f5900970e6845 Signed-off-by: Shawn O. Pearce <spearce@spearce.org>tags/v0.7.0
@@ -79,7 +79,7 @@ public class Main { | |||
/** | |||
* Execute the command line. | |||
* | |||
* | |||
* @param argv | |||
* arguments. | |||
*/ |
@@ -162,7 +162,7 @@ public class DirCacheTreeTest extends RepositoryTestCase { | |||
* index larger than the default BufferedInputStream buffer size. This made | |||
* the DirCache unable to read the extensions when index size exceeded the | |||
* buffer size (in some cases at least). | |||
* | |||
* | |||
* @throws CorruptObjectException | |||
* @throws IOException | |||
*/ |
@@ -94,11 +94,11 @@ public class IndexDiffTest extends RepositoryTestCase { | |||
public void testModified() throws IOException { | |||
GitIndex index = new GitIndex(db); | |||
index.add(trash, writeTrashFile("file2", "file2")); | |||
index.add(trash, writeTrashFile("dir/file3", "dir/file3")); | |||
writeTrashFile("dir/file3", "changed"); | |||
Tree tree = new Tree(db); |
@@ -54,7 +54,7 @@ public class IndexTreeWalkerTest extends RepositoryTestCase { | |||
private ArrayList<String> treeOnlyEntriesVisited = new ArrayList<String>(); | |||
private ArrayList<String> bothVisited = new ArrayList<String>(); | |||
private ArrayList<String> indexOnlyEntriesVisited = new ArrayList<String>(); | |||
private class TestIndexTreeVisitor extends AbstractIndexTreeVisitor { | |||
public void visitEntry(TreeEntry treeEntry, Entry indexEntry, File file) { | |||
if (treeEntry == null) | |||
@@ -67,13 +67,13 @@ public class IndexTreeWalkerTest extends RepositoryTestCase { | |||
/* | |||
* Need to think about what I really need to be able to do.... | |||
* | |||
* | |||
* 1) Visit all entries in index and tree | |||
* 2) Get all directories that exist in the index, but not in the tree | |||
* -- I'm pretty sure that I don't need to do the other way around | |||
* because I already | |||
* because I already | |||
*/ | |||
public void testTreeOnlyOneLevel() throws IOException { | |||
GitIndex index = new GitIndex(db); | |||
Tree tree = new Tree(db); | |||
@@ -81,11 +81,11 @@ public class IndexTreeWalkerTest extends RepositoryTestCase { | |||
tree.addFile("bar"); | |||
new IndexTreeWalker(index, tree, trash, new TestIndexTreeVisitor()).walk(); | |||
assertTrue(treeOnlyEntriesVisited.get(0).equals("bar")); | |||
assertTrue(treeOnlyEntriesVisited.get(1).equals("foo")); | |||
} | |||
public void testIndexOnlyOneLevel() throws IOException { | |||
GitIndex index = new GitIndex(db); | |||
Tree tree = new Tree(db); | |||
@@ -93,11 +93,11 @@ public class IndexTreeWalkerTest extends RepositoryTestCase { | |||
index.add(trash, writeTrashFile("foo", "foo")); | |||
index.add(trash, writeTrashFile("bar", "bar")); | |||
new IndexTreeWalker(index, tree, trash, new TestIndexTreeVisitor()).walk(); | |||
assertTrue(indexOnlyEntriesVisited.get(0).equals("bar")); | |||
assertTrue(indexOnlyEntriesVisited.get(1).equals("foo")); | |||
} | |||
public void testBoth() throws IOException { | |||
GitIndex index = new GitIndex(db); | |||
Tree tree = new Tree(db); | |||
@@ -106,14 +106,14 @@ public class IndexTreeWalkerTest extends RepositoryTestCase { | |||
tree.addFile("b/b"); | |||
index.add(trash, writeTrashFile("c", "c")); | |||
tree.addFile("c"); | |||
new IndexTreeWalker(index, tree, trash, new TestIndexTreeVisitor()).walk(); | |||
assertTrue(indexOnlyEntriesVisited.contains("a")); | |||
assertTrue(treeOnlyEntriesVisited.contains("b/b")); | |||
assertTrue(bothVisited.contains("c")); | |||
} | |||
public void testIndexOnlySubDirs() throws IOException { | |||
GitIndex index = new GitIndex(db); | |||
Tree tree = new Tree(db); | |||
@@ -121,23 +121,23 @@ public class IndexTreeWalkerTest extends RepositoryTestCase { | |||
index.add(trash, writeTrashFile("foo/bar/baz", "foobar")); | |||
index.add(trash, writeTrashFile("asdf", "asdf")); | |||
new IndexTreeWalker(index, tree, trash, new TestIndexTreeVisitor()).walk(); | |||
assertEquals("asdf", indexOnlyEntriesVisited.get(0)); | |||
assertEquals("foo/bar/baz", indexOnlyEntriesVisited.get(1)); | |||
} | |||
public void testLeavingTree() throws IOException { | |||
GitIndex index = new GitIndex(db); | |||
index.add(trash, writeTrashFile("foo/bar", "foo/bar")); | |||
index.add(trash, writeTrashFile("foobar", "foobar")); | |||
new IndexTreeWalker(index, db.mapTree(index.writeTree()), trash, new AbstractIndexTreeVisitor() { | |||
@Override | |||
public void visitEntry(TreeEntry entry, Entry indexEntry, File f) { | |||
if (entry == null || indexEntry == null) | |||
fail(); | |||
} | |||
@Override | |||
public void finishVisitTree(Tree tree, int i, String curDir) | |||
throws IOException { | |||
@@ -146,7 +146,7 @@ public class IndexTreeWalkerTest extends RepositoryTestCase { | |||
if (i == 0) | |||
fail(); | |||
} | |||
}).walk(); | |||
} | |||
} |
@@ -64,14 +64,14 @@ public abstract class PackIndexTestCase extends RepositoryTestCase { | |||
/** | |||
* Return file with appropriate index version for prepared pack. | |||
* | |||
* | |||
* @return file with index | |||
*/ | |||
public abstract File getFileForPack34be9032(); | |||
/** | |||
* Return file with appropriate index version for prepared pack. | |||
* | |||
* | |||
* @return file with index | |||
*/ | |||
public abstract File getFileForPackdf2982f28(); |
@@ -54,7 +54,7 @@ import java.util.HashMap; | |||
import org.eclipse.jgit.errors.CheckoutConflictException; | |||
public class ReadTreeTest extends RepositoryTestCase { | |||
private Tree theHead; | |||
private Tree theMerge; | |||
private GitIndex theIndex; | |||
@@ -64,64 +64,64 @@ public class ReadTreeTest extends RepositoryTestCase { | |||
// Rule 0 is left out for obvious reasons :) | |||
public void testRules1thru3_NoIndexEntry() throws IOException { | |||
GitIndex index = new GitIndex(db); | |||
Tree head = new Tree(db); | |||
FileTreeEntry headFile = head.addFile("foo"); | |||
ObjectId objectId = ObjectId.fromString("ba78e065e2c261d4f7b8f42107588051e87e18e9"); | |||
headFile.setId(objectId); | |||
Tree merge = new Tree(db); | |||
WorkDirCheckout readTree = new WorkDirCheckout(db, trash, head, index, merge); | |||
readTree.prescanTwoTrees(); | |||
assertTrue(readTree.removed.contains("foo")); | |||
readTree = new WorkDirCheckout(db, trash, merge, index, head); | |||
readTree.prescanTwoTrees(); | |||
assertEquals(objectId, readTree.updated.get("foo")); | |||
ObjectId anotherId = ObjectId.fromString("ba78e065e2c261d4f7b8f42107588051e87e18ee"); | |||
merge.addFile("foo").setId(anotherId); | |||
readTree = new WorkDirCheckout(db, trash, head, index, merge); | |||
readTree.prescanTwoTrees(); | |||
assertEquals(anotherId, readTree.updated.get("foo")); | |||
} | |||
void setupCase(HashMap<String, String> headEntries, | |||
HashMap<String, String> mergeEntries, | |||
void setupCase(HashMap<String, String> headEntries, | |||
HashMap<String, String> mergeEntries, | |||
HashMap<String, String> indexEntries) throws IOException { | |||
theHead = buildTree(headEntries); | |||
theMerge = buildTree(mergeEntries); | |||
theIndex = buildIndex(indexEntries); | |||
} | |||
private GitIndex buildIndex(HashMap<String, String> indexEntries) throws IOException { | |||
GitIndex index = new GitIndex(db); | |||
if (indexEntries == null) | |||
return index; | |||
for (java.util.Map.Entry<String,String> e : indexEntries.entrySet()) { | |||
index.add(trash, writeTrashFile(e.getKey(), e.getValue())).forceRecheck(); | |||
} | |||
return index; | |||
} | |||
private Tree buildTree(HashMap<String, String> headEntries) throws IOException { | |||
Tree tree = new Tree(db); | |||
if (headEntries == null) | |||
if (headEntries == null) | |||
return tree; | |||
for (java.util.Map.Entry<String,String> e : headEntries.entrySet()) { | |||
tree.addFile(e.getKey()).setId(genSha1(e.getValue())); | |||
} | |||
return tree; | |||
} | |||
ObjectId genSha1(String data) { | |||
InputStream is = new ByteArrayInputStream(data.getBytes()); | |||
ObjectWriter objectWriter = new ObjectWriter(db); | |||
@@ -133,7 +133,7 @@ public class ReadTreeTest extends RepositoryTestCase { | |||
} | |||
return null; | |||
} | |||
private WorkDirCheckout go() throws IOException { | |||
theReadTree = new WorkDirCheckout(db, trash, theHead, theIndex, theMerge); | |||
theReadTree.prescanTwoTrees(); | |||
@@ -151,11 +151,11 @@ public class ReadTreeTest extends RepositoryTestCase { | |||
idxMap.put("foo", "foo"); | |||
setupCase(null, null, idxMap); | |||
theReadTree = go(); | |||
assertTrue(theReadTree.updated.isEmpty()); | |||
assertTrue(theReadTree.removed.isEmpty()); | |||
assertTrue(theReadTree.conflicts.isEmpty()); | |||
// rules 6 and 7 | |||
idxMap = new HashMap<String, String>(); | |||
idxMap.put("foo", "foo"); | |||
@@ -163,70 +163,70 @@ public class ReadTreeTest extends RepositoryTestCase { | |||
theReadTree = go(); | |||
assertAllEmpty(); | |||
// rules 8 and 9 | |||
HashMap<String, String> mergeMap; | |||
mergeMap = new HashMap<String, String>(); | |||
mergeMap.put("foo", "merge"); | |||
setupCase(null, mergeMap, idxMap); | |||
go(); | |||
assertTrue(theReadTree.updated.isEmpty()); | |||
assertTrue(theReadTree.removed.isEmpty()); | |||
assertTrue(theReadTree.conflicts.contains("foo")); | |||
// rule 10 | |||
HashMap<String, String> headMap = new HashMap<String, String>(); | |||
headMap.put("foo", "foo"); | |||
setupCase(headMap, null, idxMap); | |||
go(); | |||
assertTrue(theReadTree.removed.contains("foo")); | |||
assertTrue(theReadTree.updated.isEmpty()); | |||
assertTrue(theReadTree.conflicts.isEmpty()); | |||
// rule 11 | |||
setupCase(headMap, null, idxMap); | |||
new File(trash, "foo").delete(); | |||
writeTrashFile("foo", "bar"); | |||
theIndex.getMembers()[0].forceRecheck(); | |||
go(); | |||
assertTrue(theReadTree.removed.isEmpty()); | |||
assertTrue(theReadTree.updated.isEmpty()); | |||
assertTrue(theReadTree.conflicts.contains("foo")); | |||
// rule 12 & 13 | |||
headMap.put("foo", "head"); | |||
setupCase(headMap, null, idxMap); | |||
go(); | |||
assertTrue(theReadTree.removed.isEmpty()); | |||
assertTrue(theReadTree.updated.isEmpty()); | |||
assertTrue(theReadTree.conflicts.contains("foo")); | |||
// rules 14 & 15 | |||
setupCase(headMap, headMap, idxMap); | |||
go(); | |||
assertAllEmpty(); | |||
// rules 16 & 17 | |||
setupCase(headMap, mergeMap, idxMap); go(); | |||
assertTrue(theReadTree.conflicts.contains("foo")); | |||
// rules 18 & 19 | |||
setupCase(headMap, idxMap, idxMap); go(); | |||
assertAllEmpty(); | |||
// rule 20 | |||
setupCase(idxMap, mergeMap, idxMap); go(); | |||
assertTrue(theReadTree.updated.containsKey("foo")); | |||
// rules 21 | |||
setupCase(idxMap, mergeMap, idxMap); | |||
setupCase(idxMap, mergeMap, idxMap); | |||
new File(trash, "foo").delete(); | |||
writeTrashFile("foo", "bar"); | |||
theIndex.getMembers()[0].forceRecheck(); | |||
@@ -239,37 +239,37 @@ public class ReadTreeTest extends RepositoryTestCase { | |||
assertTrue(theReadTree.updated.isEmpty()); | |||
assertTrue(theReadTree.conflicts.isEmpty()); | |||
} | |||
public void testDirectoryFileSimple() throws IOException { | |||
theIndex = new GitIndex(db); | |||
theIndex.add(trash, writeTrashFile("DF", "DF")); | |||
Tree treeDF = db.mapTree(theIndex.writeTree()); | |||
recursiveDelete(new File(trash, "DF")); | |||
theIndex = new GitIndex(db); | |||
theIndex.add(trash, writeTrashFile("DF/DF", "DF/DF")); | |||
Tree treeDFDF = db.mapTree(theIndex.writeTree()); | |||
theIndex = new GitIndex(db); | |||
recursiveDelete(new File(trash, "DF")); | |||
theIndex.add(trash, writeTrashFile("DF", "DF")); | |||
theReadTree = new WorkDirCheckout(db, trash, treeDF, theIndex, treeDFDF); | |||
theReadTree.prescanTwoTrees(); | |||
assertTrue(theReadTree.removed.contains("DF")); | |||
assertTrue(theReadTree.updated.containsKey("DF/DF")); | |||
recursiveDelete(new File(trash, "DF")); | |||
theIndex = new GitIndex(db); | |||
theIndex.add(trash, writeTrashFile("DF/DF", "DF/DF")); | |||
theReadTree = new WorkDirCheckout(db, trash, treeDFDF, theIndex, treeDF); | |||
theReadTree.prescanTwoTrees(); | |||
assertTrue(theReadTree.removed.contains("DF/DF")); | |||
assertTrue(theReadTree.updated.containsKey("DF")); | |||
} | |||
/* | |||
* Directory/File Conflict cases: | |||
* It's entirely possible that in practice a number of these may be equivalent | |||
@@ -277,7 +277,7 @@ public class ReadTreeTest extends RepositoryTestCase { | |||
* that's all I care about. These are basically reverse-engineered from | |||
* what git currently does. If there are tests for these in git, it's kind of | |||
* hard to track them all down... | |||
* | |||
* | |||
* H I M Clean H==M H==I I==M Result | |||
* ------------------------------------------------------------------ | |||
*1 D D F Y N Y N Update | |||
@@ -290,7 +290,7 @@ public class ReadTreeTest extends RepositoryTestCase { | |||
*8 F D F N Y N N Conflict | |||
*9 F D F Y N N N Update | |||
*10 F D D N N Y Keep | |||
*11 F D D N N N Conflict | |||
*11 F D D N N N Conflict | |||
*12 F F D Y N Y N Update | |||
*13 F F D N N Y N Conflict | |||
*14 F F D N N N Conflict | |||
@@ -300,7 +300,7 @@ public class ReadTreeTest extends RepositoryTestCase { | |||
*18 F 0 D Update | |||
*19 D 0 F Update | |||
*/ | |||
public void testDirectoryFileConflicts_1() throws Exception { | |||
// 1 | |||
doit(mk("DF/DF"), mk("DF"), mk("DF/DF")); | |||
@@ -315,7 +315,7 @@ public class ReadTreeTest extends RepositoryTestCase { | |||
writeTrashFile("DF/DF", "different"); | |||
go(); | |||
assertConflict("DF/DF"); | |||
} | |||
public void testDirectoryFileConflicts_3() throws Exception { | |||
@@ -330,14 +330,14 @@ public class ReadTreeTest extends RepositoryTestCase { | |||
doit(mk("DF/DF"), mkmap("DF/DF", "foo"), mk("DF")); | |||
assertUpdated("DF/DF"); | |||
assertRemoved("DF"); | |||
} | |||
public void testDirectoryFileConflicts_5() throws Exception { | |||
// 5 | |||
doit(mk("DF/DF"), mk("DF"), mk("DF")); | |||
assertRemoved("DF/DF"); | |||
} | |||
public void testDirectoryFileConflicts_6() throws Exception { | |||
@@ -359,7 +359,7 @@ public class ReadTreeTest extends RepositoryTestCase { | |||
go(); | |||
assertRemoved("DF/DF/DF/DF/DF"); | |||
assertUpdated("DF/DF"); | |||
cleanUpDF(); | |||
setupCase(mk("DF/DF"), mk("DF/DF"), mk("DF/DF/DF/DF/DF")); | |||
writeTrashFile("DF/DF/DF/DF/DF", "diff"); | |||
@@ -383,7 +383,7 @@ public class ReadTreeTest extends RepositoryTestCase { | |||
cleanUpDF(); | |||
doit(mk("DF"), mk("DF/DF"), mk("DF/DF")); | |||
assertNoConflicts(); | |||
} | |||
public void testDirectoryFileConflicts_11() throws Exception { | |||
@@ -471,19 +471,19 @@ public class ReadTreeTest extends RepositoryTestCase { | |||
setUp(); | |||
recursiveDelete(new File(trash, "DF")); | |||
} | |||
private void assertConflict(String s) { | |||
assertTrue(theReadTree.conflicts.contains(s)); | |||
} | |||
private void assertUpdated(String s) { | |||
assertTrue(theReadTree.updated.containsKey(s)); | |||
} | |||
private void assertRemoved(String s) { | |||
assertTrue(theReadTree.removed.contains(s)); | |||
} | |||
private void assertNoConflicts() { | |||
assertTrue(theReadTree.conflicts.isEmpty()); | |||
} | |||
@@ -493,30 +493,30 @@ public class ReadTreeTest extends RepositoryTestCase { | |||
setupCase(h, m, i); | |||
go(); | |||
} | |||
private static HashMap<String, String> mk(String a) { | |||
return mkmap(a, a); | |||
} | |||
private static HashMap<String, String> mkmap(String... args) { | |||
if ((args.length % 2) > 0) | |||
if ((args.length % 2) > 0) | |||
throw new IllegalArgumentException("needs to be pairs"); | |||
HashMap<String, String> map = new HashMap<String, String>(); | |||
for (int i = 0; i < args.length; i += 2) { | |||
map.put(args[i], args[i+1]); | |||
} | |||
return map; | |||
} | |||
public void testUntrackedConflicts() throws IOException { | |||
public void testUntrackedConflicts() throws IOException { | |||
setupCase(null, mk("foo"), null); | |||
writeTrashFile("foo", "foo"); | |||
go(); | |||
assertConflict("foo"); | |||
recursiveDelete(new File(trash, "foo")); | |||
setupCase(null, mk("foo"), null); | |||
writeTrashFile("foo/bar/baz", ""); | |||
@@ -525,14 +525,14 @@ public class ReadTreeTest extends RepositoryTestCase { | |||
assertConflict("foo/bar/baz"); | |||
assertConflict("foo/blahblah"); | |||
recursiveDelete(new File(trash, "foo")); | |||
setupCase(mkmap("foo/bar", "", "foo/baz", ""), | |||
setupCase(mkmap("foo/bar", "", "foo/baz", ""), | |||
mk("foo"), mkmap("foo/bar", "", "foo/baz", "")); | |||
assertTrue(new File(trash, "foo/bar").exists()); | |||
go(); | |||
assertNoConflicts(); | |||
} | |||
@@ -554,23 +554,23 @@ public class ReadTreeTest extends RepositoryTestCase { | |||
theReadTree = new WorkDirCheckout(db, trash, theHead, theIndex, theMerge); | |||
theReadTree.checkout(); | |||
} | |||
public void testCheckoutOutChanges() throws IOException { | |||
setupCase(mk("foo"), mk("foo/bar"), mk("foo")); | |||
checkout(); | |||
assertFalse(new File(trash, "foo").isFile()); | |||
assertTrue(new File(trash, "foo/bar").isFile()); | |||
recursiveDelete(new File(trash, "foo")); | |||
setupCase(mk("foo/bar"), mk("foo"), mk("foo/bar")); | |||
checkout(); | |||
assertFalse(new File(trash, "foo/bar").isFile()); | |||
assertTrue(new File(trash, "foo").isFile()); | |||
setupCase(mk("foo"), mkmap("foo", "qux"), mkmap("foo", "bar")); | |||
try { | |||
checkout(); | |||
fail("did not throw exception"); |
@@ -276,10 +276,10 @@ public class T0003_Basic extends RepositoryTestCase { | |||
t.setTag("test020b"); | |||
t.setObjId(ObjectId.fromString("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391")); | |||
t.tag(); | |||
Tag mapTag = db.mapTag("test020b"); | |||
assertEquals("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", mapTag.getObjId().name()); | |||
// We do not repeat the plain tag test for other object types | |||
} | |||
@@ -330,7 +330,7 @@ public class T0003_Basic extends RepositoryTestCase { | |||
assertEquals(new PersonIdent(jauthor, 1154236443000L, -4 * 60), mapTag.getAuthor()); | |||
assertEquals("b5d3b45a96b340441f5abb9080411705c51cc86c", mapTag.getObjId().name()); | |||
} | |||
public void test023_createCommitNonAnullii() throws IOException { | |||
final ObjectId emptyId = new ObjectWriter(db).writeBlob(new byte[0]); | |||
final Tree almostEmptyTree = new Tree(db); | |||
@@ -363,7 +363,7 @@ public class T0003_Basic extends RepositoryTestCase { | |||
ObjectId cid = new ObjectWriter(db).writeCommit(commit); | |||
assertEquals("2979b39d385014b33287054b87f77bcb3ecb5ebf", cid.name()); | |||
} | |||
public void test025_packedRefs() throws IOException { | |||
test020_createBlobTag(); | |||
test021_createTreeTag(); | |||
@@ -502,9 +502,9 @@ public class T0003_Basic extends RepositoryTestCase { | |||
assertEquals(c2.getCommitId(), rm4.getParentIds()[1]); | |||
assertEquals(c3.getCommitId(), rm4.getParentIds()[2]); | |||
} | |||
public void test027_UnpackedRefHigherPriorityThanPacked() throws IOException { | |||
PrintWriter writer = new PrintWriter(new FileWriter(new File(db.getDirectory(), "refs/heads/a"))); | |||
PrintWriter writer = new PrintWriter(new FileWriter(new File(db.getDirectory(), "refs/heads/a"))); | |||
String unpackedId = "7f822839a2fe9760f386cbbbcb3f92c5fe81def7"; | |||
writer.print(unpackedId); | |||
writer.print('\n'); |
@@ -179,7 +179,7 @@ public class T0007_Index extends RepositoryTestCase { | |||
ObjectId id = index.writeTree(); | |||
assertEquals("c696abc3ab8e091c665f49d00eb8919690b3aec3", id.name()); | |||
writeTrashFile("a/b", "data:a/b"); | |||
index.add(trash, new File(trash, "a/b")); | |||
@@ -57,7 +57,7 @@ public class TreeIteratorLeafOnlyTest extends RepositoryTestCase { | |||
/** | |||
* one file | |||
* | |||
* | |||
* @throws IOException | |||
*/ | |||
public void testSimpleF1() throws IOException { | |||
@@ -70,7 +70,7 @@ public class TreeIteratorLeafOnlyTest extends RepositoryTestCase { | |||
/** | |||
* two files | |||
* | |||
* | |||
* @throws IOException | |||
*/ | |||
public void testSimpleF2() throws IOException { | |||
@@ -85,7 +85,7 @@ public class TreeIteratorLeafOnlyTest extends RepositoryTestCase { | |||
/** | |||
* Empty tree | |||
* | |||
* | |||
* @throws IOException | |||
*/ | |||
public void testSimpleT() throws IOException { | |||
@@ -94,7 +94,7 @@ public class TreeIteratorLeafOnlyTest extends RepositoryTestCase { | |||
TreeIterator i = makeIterator(tree); | |||
assertFalse(i.hasNext()); | |||
} | |||
public void testTricky() throws IOException { | |||
Tree tree = new Tree(db); | |||
tree.addFile("a.b"); |
@@ -59,7 +59,7 @@ public class TreeIteratorPostOrderTest extends RepositoryTestCase { | |||
/** | |||
* one file | |||
* | |||
* | |||
* @throws IOException | |||
*/ | |||
public void testSimpleF1() throws IOException { | |||
@@ -75,7 +75,7 @@ public class TreeIteratorPostOrderTest extends RepositoryTestCase { | |||
/** | |||
* two files | |||
* | |||
* | |||
* @throws IOException | |||
*/ | |||
public void testSimpleF2() throws IOException { | |||
@@ -93,7 +93,7 @@ public class TreeIteratorPostOrderTest extends RepositoryTestCase { | |||
/** | |||
* Empty tree | |||
* | |||
* | |||
* @throws IOException | |||
*/ | |||
public void testSimpleT() throws IOException { | |||
@@ -106,7 +106,7 @@ public class TreeIteratorPostOrderTest extends RepositoryTestCase { | |||
assertEquals("", i.next().getFullName()); | |||
assertFalse(i.hasNext()); | |||
} | |||
public void testTricky() throws IOException { | |||
Tree tree = new Tree(db); | |||
tree.addFile("a.b"); |
@@ -59,7 +59,7 @@ public class TreeIteratorPreOrderTest extends RepositoryTestCase { | |||
/** | |||
* one file | |||
* | |||
* | |||
* @throws IOException | |||
*/ | |||
public void testSimpleF1() throws IOException { | |||
@@ -75,7 +75,7 @@ public class TreeIteratorPreOrderTest extends RepositoryTestCase { | |||
/** | |||
* two files | |||
* | |||
* | |||
* @throws IOException | |||
*/ | |||
public void testSimpleF2() throws IOException { | |||
@@ -93,7 +93,7 @@ public class TreeIteratorPreOrderTest extends RepositoryTestCase { | |||
/** | |||
* Empty tree | |||
* | |||
* | |||
* @throws IOException | |||
*/ | |||
public void testSimpleT() throws IOException { | |||
@@ -106,7 +106,7 @@ public class TreeIteratorPreOrderTest extends RepositoryTestCase { | |||
assertEquals("a", i.next().getFullName()); | |||
assertFalse(i.hasNext()); | |||
} | |||
public void testTricky() throws IOException { | |||
Tree tree = new Tree(db); | |||
tree.addFile("a.b"); |
@@ -89,7 +89,7 @@ public class BundleWriterTest extends RepositoryTestCase { | |||
/** | |||
* Incremental bundle test | |||
* | |||
* | |||
* @throws Exception | |||
*/ | |||
public void testWrite1() throws Exception { |
@@ -187,4 +187,4 @@ final class AWTPlotRenderer extends AbstractPlotRenderer<SwingLane, Color> { | |||
return arcHeight * 3 + textw; | |||
} | |||
} | |||
} |
@@ -69,7 +69,7 @@ public class AwtAuthenticator extends Authenticator { | |||
/** | |||
* Add a cached authentication for future use. | |||
* | |||
* | |||
* @param ca | |||
* the information we should remember. | |||
*/ | |||
@@ -172,7 +172,7 @@ public class AwtAuthenticator extends Authenticator { | |||
/** | |||
* Create a new cached authentication. | |||
* | |||
* | |||
* @param aHost | |||
* system this is for. | |||
* @param aPort |
@@ -102,7 +102,7 @@ public class CommitGraphPane extends JTable { | |||
/** | |||
* Get the commit list this pane renders from. | |||
* | |||
* | |||
* @return the list the caller must populate. | |||
*/ | |||
public PlotCommitList getCommitList() { |
@@ -187,4 +187,4 @@ public class RawText implements Sequence { | |||
hash = (hash << 5) ^ (raw[ptr] & 0xff); | |||
return hash; | |||
} | |||
} | |||
} |
@@ -81,4 +81,4 @@ public interface Sequence { | |||
* @return true if the elements are equal; false if they are not equal. | |||
*/ | |||
public boolean equals(int thisIdx, Sequence other, int otherIdx); | |||
} | |||
} |
@@ -61,7 +61,7 @@ public class CheckoutConflictException extends IOException { | |||
public CheckoutConflictException(String file) { | |||
super("Checkout conflict with file: " + file); | |||
} | |||
/** | |||
* Construct a CheckoutConflictException for the specified set of files | |||
* | |||
@@ -73,7 +73,7 @@ public class CheckoutConflictException extends IOException { | |||
private static String buildList(String[] files) { | |||
StringBuilder builder = new StringBuilder(); | |||
for (String f : files) { | |||
for (String f : files) { | |||
builder.append("\n"); | |||
builder.append(f); | |||
} |
@@ -67,7 +67,7 @@ public class CompoundException extends Exception { | |||
/** | |||
* Constructs an exception detailing many potential reasons for failure. | |||
* | |||
* | |||
* @param why | |||
* Two or more exceptions that may have been the problem. | |||
*/ | |||
@@ -78,7 +78,7 @@ public class CompoundException extends Exception { | |||
/** | |||
* Get the complete list of reasons why this failure happened. | |||
* | |||
* | |||
* @return unmodifiable collection of all possible reasons. | |||
*/ | |||
public List<Throwable> getAllCauses() { |
@@ -64,7 +64,7 @@ public class NotSupportedException extends IOException { | |||
/** | |||
* Construct a NotSupportedException for some issue JGit cannot yet handle. | |||
* | |||
* | |||
* @param s | |||
* message describing the issue | |||
* @param why |
@@ -84,7 +84,7 @@ public class PackProtocolException extends TransportException { | |||
/** | |||
* Constructs an PackProtocolException with the specified detail message. | |||
* | |||
* | |||
* @param s | |||
* message | |||
*/ | |||
@@ -94,7 +94,7 @@ public class PackProtocolException extends TransportException { | |||
/** | |||
* Constructs an PackProtocolException with the specified detail message. | |||
* | |||
* | |||
* @param s | |||
* message | |||
* @param cause |
@@ -59,13 +59,13 @@ public class RevisionSyntaxException extends IOException { | |||
/** | |||
* Construct a RevisionSyntaxException indicating a syntax problem with a | |||
* revision (or object) string. | |||
* | |||
* | |||
* @param revstr The problematic revision string | |||
*/ | |||
public RevisionSyntaxException(String revstr) { | |||
this.revstr = revstr; | |||
} | |||
/** | |||
* Construct a RevisionSyntaxException indicating a syntax problem with a | |||
* revision (or object) string. |
@@ -46,7 +46,7 @@ package org.eclipse.jgit.errors; | |||
/** | |||
* Stops the driver loop of walker and finish with current results. | |||
* | |||
* | |||
* @see org.eclipse.jgit.revwalk.filter.RevFilter | |||
*/ | |||
public class StopWalkException extends RuntimeException { |
@@ -86,7 +86,7 @@ public class TransportException extends IOException { | |||
/** | |||
* Constructs an TransportException with the specified detail message. | |||
* | |||
* | |||
* @param s | |||
* message | |||
*/ | |||
@@ -96,7 +96,7 @@ public class TransportException extends IOException { | |||
/** | |||
* Constructs an TransportException with the specified detail message. | |||
* | |||
* | |||
* @param s | |||
* message | |||
* @param cause |
@@ -71,7 +71,7 @@ public abstract class AnyObjectId implements Comparable { | |||
/** | |||
* Compare to object identifier byte sequences for equality. | |||
* | |||
* | |||
* @param firstObjectId | |||
* the first identifier to compare. Must not be null. | |||
* @param secondObjectId | |||
@@ -108,7 +108,7 @@ public abstract class AnyObjectId implements Comparable { | |||
/** | |||
* For ObjectIdMap | |||
* | |||
* | |||
* @return a discriminator usable for a fan-out style map | |||
*/ | |||
public final int getFirstByte() { | |||
@@ -117,7 +117,7 @@ public abstract class AnyObjectId implements Comparable { | |||
/** | |||
* Compare this ObjectId to another and obtain a sort ordering. | |||
* | |||
* | |||
* @param other | |||
* the other id to compare to. Must not be null. | |||
* @return < 0 if this id comes before other; 0 if this id is equal to | |||
@@ -213,7 +213,7 @@ public abstract class AnyObjectId implements Comparable { | |||
/** | |||
* Determine if this ObjectId has exactly the same value as another. | |||
* | |||
* | |||
* @param other | |||
* the other id to compare to. May be null. | |||
* @return true only if both ObjectIds have identical bits. | |||
@@ -231,7 +231,7 @@ public abstract class AnyObjectId implements Comparable { | |||
/** | |||
* Copy this ObjectId to an output writer in raw binary. | |||
* | |||
* | |||
* @param w | |||
* the buffer to copy to. Must be in big endian order. | |||
*/ | |||
@@ -245,7 +245,7 @@ public abstract class AnyObjectId implements Comparable { | |||
/** | |||
* Copy this ObjectId to a byte array. | |||
* | |||
* | |||
* @param b | |||
* the buffer to copy to. | |||
* @param o | |||
@@ -277,7 +277,7 @@ public abstract class AnyObjectId implements Comparable { | |||
/** | |||
* Copy this ObjectId to an output writer in raw binary. | |||
* | |||
* | |||
* @param w | |||
* the stream to write to. | |||
* @throws IOException | |||
@@ -301,7 +301,7 @@ public abstract class AnyObjectId implements Comparable { | |||
/** | |||
* Copy this ObjectId to an output writer in hex format. | |||
* | |||
* | |||
* @param w | |||
* the stream to copy to. | |||
* @throws IOException | |||
@@ -336,7 +336,7 @@ public abstract class AnyObjectId implements Comparable { | |||
/** | |||
* Copy this ObjectId to an output writer in hex format. | |||
* | |||
* | |||
* @param w | |||
* the stream to copy to. | |||
* @throws IOException | |||
@@ -348,7 +348,7 @@ public abstract class AnyObjectId implements Comparable { | |||
/** | |||
* Copy this ObjectId to an output writer in hex format. | |||
* | |||
* | |||
* @param tmp | |||
* temporary char array to buffer construct into before writing. | |||
* Must be at least large enough to hold 2 digits for each byte | |||
@@ -469,7 +469,7 @@ public abstract class AnyObjectId implements Comparable { | |||
* This method is useful to shed any additional memory that may be tied to | |||
* the subclass, yet retain the unique identity of the object id for future | |||
* lookups within maps and repositories. | |||
* | |||
* | |||
* @return an immutable copy, using the smallest memory footprint possible. | |||
*/ | |||
public final ObjectId copy() { | |||
@@ -484,7 +484,7 @@ public abstract class AnyObjectId implements Comparable { | |||
* See {@link #copy()} if <code>this</code> is a possibly subclassed (but | |||
* immutable) identity and the application needs a lightweight identity | |||
* <i>only</i> reference. | |||
* | |||
* | |||
* @return an immutable copy. May be <code>this</code> if this is already | |||
* an immutable instance. | |||
*/ |
@@ -79,7 +79,7 @@ abstract class ByteWindow { | |||
/** | |||
* Copy bytes from the window to a caller supplied buffer. | |||
* | |||
* | |||
* @param pos | |||
* offset within the file to start copying from. | |||
* @param dstbuf | |||
@@ -100,7 +100,7 @@ abstract class ByteWindow { | |||
/** | |||
* Copy bytes from the window to a caller supplied buffer. | |||
* | |||
* | |||
* @param pos | |||
* offset within the window to start copying from. | |||
* @param dstbuf | |||
@@ -119,7 +119,7 @@ abstract class ByteWindow { | |||
/** | |||
* Pump bytes into the supplied inflater as input. | |||
* | |||
* | |||
* @param pos | |||
* offset within the file to start supplying input from. | |||
* @param dstbuf | |||
@@ -148,7 +148,7 @@ abstract class ByteWindow { | |||
/** | |||
* Pump bytes into the supplied inflater as input. | |||
* | |||
* | |||
* @param pos | |||
* offset within the window to start supplying input from. | |||
* @param dstbuf |
@@ -67,7 +67,7 @@ public class Commit implements Treeish { | |||
private ObjectId treeId; | |||
private ObjectId[] parentIds; | |||
private PersonIdent author; | |||
private PersonIdent committer; | |||
@@ -91,7 +91,7 @@ public class Commit implements Treeish { | |||
objdb = db; | |||
parentIds = EMPTY_OBJECTID_LIST; | |||
} | |||
/** | |||
* Create a commit associated with these parents and associate it with a | |||
* repository. |
@@ -123,7 +123,7 @@ public final class Constants { | |||
* Indicates the associated object is a commit. | |||
* <p> | |||
* <b>This constant is fixed and is defined by the Git packfile format.</b> | |||
* | |||
* | |||
* @see #TYPE_COMMIT | |||
*/ | |||
public static final int OBJ_COMMIT = 1; | |||
@@ -134,7 +134,7 @@ public final class Constants { | |||
* Indicates the associated object is a tree. | |||
* <p> | |||
* <b>This constant is fixed and is defined by the Git packfile format.</b> | |||
* | |||
* | |||
* @see #TYPE_BLOB | |||
*/ | |||
public static final int OBJ_TREE = 2; | |||
@@ -145,7 +145,7 @@ public final class Constants { | |||
* Indicates the associated object is a blob. | |||
* <p> | |||
* <b>This constant is fixed and is defined by the Git packfile format.</b> | |||
* | |||
* | |||
* @see #TYPE_BLOB | |||
*/ | |||
public static final int OBJ_BLOB = 3; | |||
@@ -156,7 +156,7 @@ public final class Constants { | |||
* Indicates the associated object is an annotated tag. | |||
* <p> | |||
* <b>This constant is fixed and is defined by the Git packfile format.</b> | |||
* | |||
* | |||
* @see #TYPE_TAG | |||
*/ | |||
public static final int OBJ_TAG = 4; | |||
@@ -203,7 +203,7 @@ public final class Constants { | |||
* <b>This constant is fixed and is defined by the Git packfile format.</b> | |||
*/ | |||
public static final byte[] PACK_SIGNATURE = { 'P', 'A', 'C', 'K' }; | |||
/** Native character encoding for commit messages, file names... */ | |||
public static final String CHARACTER_ENCODING = "UTF-8"; | |||
@@ -260,7 +260,7 @@ public final class Constants { | |||
/** | |||
* Create a new digest function for objects. | |||
* | |||
* | |||
* @return a new digest object. | |||
* @throws RuntimeException | |||
* this Java virtual machine does not support the required hash | |||
@@ -323,7 +323,7 @@ public final class Constants { | |||
/** | |||
* Parse an encoded type string into a type constant. | |||
* | |||
* | |||
* @param id | |||
* object id this type string came from; may be null if that is | |||
* not known at the time the parse is occurring. | |||
@@ -398,7 +398,7 @@ public final class Constants { | |||
/** | |||
* Convert an integer into its decimal representation. | |||
* | |||
* | |||
* @param s | |||
* the integer to convert. | |||
* @return a decimal representation of the input integer. The returned array | |||
@@ -410,7 +410,7 @@ public final class Constants { | |||
/** | |||
* Convert a string to US-ASCII encoding. | |||
* | |||
* | |||
* @param s | |||
* the string to convert. Must not contain any characters over | |||
* 127 (outside of 7-bit ASCII). |
@@ -146,4 +146,4 @@ public class FileBasedConfig extends Config { | |||
public String toString() { | |||
return getClass().getSimpleName() + "[" + getFile().getPath() + "]"; | |||
} | |||
} | |||
} |
@@ -138,7 +138,7 @@ public abstract class FileMode { | |||
/** | |||
* Convert a set of mode bits into a FileMode enumerated value. | |||
* | |||
* | |||
* @param bits | |||
* the mode bits the caller has somehow obtained. | |||
* @return the FileMode instance that represents the given bits. | |||
@@ -198,7 +198,7 @@ public abstract class FileMode { | |||
/** | |||
* Test a file mode for equality with this {@link FileMode} object. | |||
* | |||
* | |||
* @param modebits | |||
* @return true if the mode bits represent the same mode as this object | |||
*/ | |||
@@ -212,7 +212,7 @@ public abstract class FileMode { | |||
* indicate octal notation. This method is suitable for generation of a mode | |||
* string within a GIT tree object. | |||
* </p> | |||
* | |||
* | |||
* @param os | |||
* stream to copy the mode to. | |||
* @throws IOException | |||
@@ -233,7 +233,7 @@ public abstract class FileMode { | |||
* Get the object type that should appear for this type of mode. | |||
* <p> | |||
* See the object type constants in {@link Constants}. | |||
* | |||
* | |||
* @return one of the well known object type constants. | |||
*/ | |||
public int getObjectType() { |
@@ -210,7 +210,7 @@ public class GitIndex { | |||
* @param f | |||
* the file whose path shall be removed. | |||
* @return true if such a path was found (and thus removed) | |||
* @throws IOException | |||
* @throws IOException | |||
*/ | |||
public boolean remove(File wd, File f) throws IOException { | |||
byte[] key = makeKey(wd, f); | |||
@@ -530,13 +530,13 @@ public class GitIndex { | |||
} | |||
/** | |||
* Check if an entry's content is different from the cache, | |||
* | |||
* Check if an entry's content is different from the cache, | |||
* | |||
* File status information is used and status is same we | |||
* consider the file identical to the state in the working | |||
* directory. Native git uses more stat fields than we | |||
* have accessible in Java. | |||
* | |||
* | |||
* @param wd working directory to compare content with | |||
* @return true if content is most likely different. | |||
*/ | |||
@@ -545,17 +545,17 @@ public class GitIndex { | |||
} | |||
/** | |||
* Check if an entry's content is different from the cache, | |||
* | |||
* Check if an entry's content is different from the cache, | |||
* | |||
* File status information is used and status is same we | |||
* consider the file identical to the state in the working | |||
* directory. Native git uses more stat fields than we | |||
* have accessible in Java. | |||
* | |||
* | |||
* @param wd working directory to compare content with | |||
* @param forceContentCheck True if the actual file content | |||
* should be checked if modification time differs. | |||
* | |||
* | |||
* @return true if content is most likely different. | |||
*/ | |||
public boolean isModified(File wd, boolean forceContentCheck) { | |||
@@ -806,7 +806,7 @@ public class GitIndex { | |||
} | |||
} | |||
} | |||
/** | |||
* Add tree entry to index | |||
* @param te tree entry | |||
@@ -834,7 +834,7 @@ public class GitIndex { | |||
checkoutEntry(wd, e); | |||
} | |||
} | |||
/** | |||
* Check out content of the specified index entry | |||
* | |||
@@ -948,7 +948,7 @@ public class GitIndex { | |||
* Small beware: Unaccounted for are unmerged entries. You may want | |||
* to abort if members with stage != 0 are found if you are doing | |||
* any updating operations. All stages will be found after one another | |||
* here later. Currently only one stage per name is returned. | |||
* here later. Currently only one stage per name is returned. | |||
* | |||
* @return The index entries sorted | |||
*/ |
@@ -56,7 +56,7 @@ import org.eclipse.jgit.lib.GitIndex.Entry; | |||
public class IndexDiff { | |||
private GitIndex index; | |||
private Tree tree; | |||
/** | |||
* Construct an indexdiff for diffing the workdir against | |||
* the index. | |||
@@ -80,9 +80,9 @@ public class IndexDiff { | |||
this.tree = tree; | |||
this.index = index; | |||
} | |||
boolean anyChanges = false; | |||
/** | |||
* Run the diff operation. Until this is called, all lists will be empty | |||
* @return if anything is different between index, tree, and workdir | |||
@@ -105,7 +105,7 @@ public class IndexDiff { | |||
anyChanges = true; | |||
} | |||
} | |||
if (indexEntry != null) { | |||
if (!file.exists()) { | |||
missing.add(indexEntry.getName()); | |||
@@ -119,7 +119,7 @@ public class IndexDiff { | |||
} | |||
} | |||
}).walk(); | |||
return anyChanges; | |||
} | |||
@@ -156,7 +156,7 @@ public class IndexDiff { | |||
public HashSet<String> getMissing() { | |||
return missing; | |||
} | |||
/** | |||
* @return list of files on modified on disk relative to the index | |||
*/ |
@@ -69,7 +69,7 @@ public interface IndexTreeVisitor { | |||
* @throws IOException | |||
*/ | |||
public void visitEntry(TreeEntry treeEntry, Entry indexEntry, File file) throws IOException; | |||
/** | |||
* Visit a blob, and corresponding tree nodes and associated index entry. | |||
* |
@@ -75,12 +75,12 @@ public class IndexTreeWalker { | |||
this.root = root; | |||
this.visitor = visitor; | |||
this.newTree = null; | |||
threeTrees = false; | |||
indexMembers = index.getMembers(); | |||
} | |||
/** | |||
* Construct a walker for the index and two trees. | |||
* | |||
@@ -95,15 +95,15 @@ public class IndexTreeWalker { | |||
this.newTree = newTree; | |||
this.root = root; | |||
this.visitor = visitor; | |||
threeTrees = true; | |||
indexMembers = index.getMembers(); | |||
} | |||
Entry[] indexMembers; | |||
int indexCounter = 0; | |||
/** | |||
* Actually walk the index tree | |||
* | |||
@@ -124,7 +124,7 @@ public class IndexTreeWalker { | |||
int cmpma = compare(m, a); | |||
int cmpmi = compare(m, i); | |||
int cmpai = compare(a, i); | |||
TreeEntry pm = cmpma <= 0 && cmpmi <= 0 ? m : null; | |||
TreeEntry pa = cmpma >= 0 && cmpai <= 0 ? a : null; | |||
Entry pi = cmpmi >= 0 && cmpai >= 0 ? i : null; | |||
@@ -201,7 +201,7 @@ public class IndexTreeWalker { | |||
static boolean lt(TreeEntry h, Entry i) { | |||
return compare(h, i) < 0; | |||
} | |||
static boolean lt(Entry i, TreeEntry t) { | |||
return compare(t, i) > 0; | |||
} | |||
@@ -209,11 +209,11 @@ public class IndexTreeWalker { | |||
static boolean lt(TreeEntry h, TreeEntry m) { | |||
return compare(h, m) < 0; | |||
} | |||
static boolean eq(TreeEntry t1, TreeEntry t2) { | |||
return compare(t1, t2) == 0; | |||
} | |||
static boolean eq(TreeEntry t1, Entry e) { | |||
return compare(t1, e) == 0; | |||
} | |||
@@ -225,9 +225,9 @@ public class IndexTreeWalker { | |||
return 1; | |||
if (i == null) | |||
return -1; | |||
return Tree.compareNames(t.getFullNameUTF8(), i.getNameUTF8(), TreeEntry.lastChar(t), TreeEntry.lastChar(i)); | |||
return Tree.compareNames(t.getFullNameUTF8(), i.getNameUTF8(), TreeEntry.lastChar(t), TreeEntry.lastChar(i)); | |||
} | |||
static int compare(TreeEntry t1, TreeEntry t2) { | |||
if (t1 != null && t1.getParent() == null && t2 != null && t2.getParent() == null) | |||
return 0; | |||
@@ -244,5 +244,5 @@ public class IndexTreeWalker { | |||
return -1; | |||
return Tree.compareNames(t1.getFullNameUTF8(), t2.getFullNameUTF8(), TreeEntry.lastChar(t1), TreeEntry.lastChar(t2)); | |||
} | |||
} |
@@ -63,7 +63,7 @@ public class InflaterCache { | |||
* <p> | |||
* Inflaters obtained through this cache should be returned (if possible) by | |||
* {@link #release(Inflater)} to avoid garbage collection and reallocation. | |||
* | |||
* | |||
* @return an available inflater. Never null. | |||
*/ | |||
public static Inflater get() { | |||
@@ -82,7 +82,7 @@ public class InflaterCache { | |||
/** | |||
* Release an inflater previously obtained from this cache. | |||
* | |||
* | |||
* @param i | |||
* the inflater to return. May be null, in which case this method | |||
* does nothing. |
@@ -81,7 +81,7 @@ public class LockFile { | |||
/** | |||
* Create a new lock for any file. | |||
* | |||
* | |||
* @param f | |||
* the file that will be locked. | |||
*/ | |||
@@ -92,7 +92,7 @@ public class LockFile { | |||
/** | |||
* Try to establish the lock. | |||
* | |||
* | |||
* @return true if the lock is now held by the caller; false if it is held | |||
* by someone else. | |||
* @throws IOException | |||
@@ -132,7 +132,7 @@ public class LockFile { | |||
/** | |||
* Try to establish the lock for appending. | |||
* | |||
* | |||
* @return true if the lock is now held by the caller; false if it is held | |||
* by someone else. | |||
* @throws IOException | |||
@@ -155,7 +155,7 @@ public class LockFile { | |||
* <p> | |||
* This method does nothing if the current file does not exist, or exists | |||
* but is empty. | |||
* | |||
* | |||
* @throws IOException | |||
* the temporary file could not be written, or a read error | |||
* occurred while reading from the current file. The lock is | |||
@@ -195,7 +195,7 @@ public class LockFile { | |||
/** | |||
* Write an ObjectId and LF to the temporary file. | |||
* | |||
* | |||
* @param id | |||
* the id to store in the file. The id will be written in hex, | |||
* followed by a sole LF. | |||
@@ -231,7 +231,7 @@ public class LockFile { | |||
/** | |||
* Write arbitrary data to the temporary file. | |||
* | |||
* | |||
* @param content | |||
* the bytes to store in the temporary file. No additional bytes | |||
* are added, so if the file must end with an LF it must appear | |||
@@ -269,7 +269,7 @@ public class LockFile { | |||
* The stream may only be accessed once, and only after {@link #lock()} has | |||
* been successfully invoked and returned true. Callers must close the | |||
* stream prior to calling {@link #commit()} to commit the change. | |||
* | |||
* | |||
* @return a stream to write to the new file. The stream is unbuffered. | |||
*/ | |||
public OutputStream getOutputStream() { | |||
@@ -326,7 +326,7 @@ public class LockFile { | |||
/** | |||
* Request that {@link #commit()} remember modification time. | |||
* | |||
* | |||
* @param on | |||
* true if the commit method must remember the modification time. | |||
*/ | |||
@@ -338,7 +338,7 @@ public class LockFile { | |||
* Commit this change and release the lock. | |||
* <p> | |||
* If this method fails (returns false) the lock is still released. | |||
* | |||
* | |||
* @return true if the commit was successful and the file contains the new | |||
* data; false if the commit failed and the file remains with the | |||
* old data. | |||
@@ -368,7 +368,7 @@ public class LockFile { | |||
/** | |||
* Get the modification time of the output file when it was committed. | |||
* | |||
* | |||
* @return modification time of the lock file right before we committed it. | |||
*/ | |||
public long getCommitLastModified() { |
@@ -64,7 +64,7 @@ public class MutableObjectId extends AnyObjectId { | |||
/** | |||
* Copying constructor. | |||
* | |||
* | |||
* @param src | |||
* original entry, to copy id from | |||
*/ | |||
@@ -87,7 +87,7 @@ public class MutableObjectId extends AnyObjectId { | |||
/** | |||
* Convert an ObjectId from raw binary representation. | |||
* | |||
* | |||
* @param bs | |||
* the raw byte buffer to read from. At least 20 bytes must be | |||
* available within this byte array. | |||
@@ -98,7 +98,7 @@ public class MutableObjectId extends AnyObjectId { | |||
/** | |||
* Convert an ObjectId from raw binary representation. | |||
* | |||
* | |||
* @param bs | |||
* the raw byte buffer to read from. At least 20 bytes after p | |||
* must be available within this byte array. | |||
@@ -115,7 +115,7 @@ public class MutableObjectId extends AnyObjectId { | |||
/** | |||
* Convert an ObjectId from binary representation expressed in integers. | |||
* | |||
* | |||
* @param ints | |||
* the raw int buffer to read from. At least 5 integers must be | |||
* available within this integers array. | |||
@@ -126,13 +126,13 @@ public class MutableObjectId extends AnyObjectId { | |||
/** | |||
* Convert an ObjectId from binary representation expressed in integers. | |||
* | |||
* | |||
* @param ints | |||
* the raw int buffer to read from. At least 5 integers after p | |||
* must be available within this integers array. | |||
* @param p | |||
* position to read the first integer of data from. | |||
* | |||
* | |||
*/ | |||
public void fromRaw(final int[] ints, final int p) { | |||
w1 = ints[p]; | |||
@@ -144,7 +144,7 @@ public class MutableObjectId extends AnyObjectId { | |||
/** | |||
* Convert an ObjectId from hex characters (US-ASCII). | |||
* | |||
* | |||
* @param buf | |||
* the US-ASCII buffer to read from. At least 40 bytes after | |||
* offset must be available within this byte array. | |||
@@ -157,7 +157,7 @@ public class MutableObjectId extends AnyObjectId { | |||
/** | |||
* Convert an ObjectId from hex characters. | |||
* | |||
* | |||
* @param str | |||
* the string to read from. Must be 40 characters long. | |||
*/ |
@@ -63,7 +63,7 @@ public class ObjectId extends AnyObjectId { | |||
/** | |||
* Get the special all-null ObjectId. | |||
* | |||
* | |||
* @return the all-null ObjectId, often used to stand-in for no object. | |||
*/ | |||
public static final ObjectId zeroId() { | |||
@@ -74,7 +74,7 @@ public class ObjectId extends AnyObjectId { | |||
* Test a string of characters to verify it is a hex format. | |||
* <p> | |||
* If true the string can be parsed with {@link #fromString(String)}. | |||
* | |||
* | |||
* @param id | |||
* the string to test. | |||
* @return true if the string can converted into an ObjectId. | |||
@@ -94,7 +94,7 @@ public class ObjectId extends AnyObjectId { | |||
/** | |||
* Convert an ObjectId into a hex string representation. | |||
* | |||
* | |||
* @param i | |||
* the id to convert. May be null. | |||
* @return the hex string conversion of this id's content. | |||
@@ -105,7 +105,7 @@ public class ObjectId extends AnyObjectId { | |||
/** | |||
* Compare to object identifier byte sequences for equality. | |||
* | |||
* | |||
* @param firstBuffer | |||
* the first buffer to compare against. Must have at least 20 | |||
* bytes from position ai through the end of the buffer. | |||
@@ -144,7 +144,7 @@ public class ObjectId extends AnyObjectId { | |||
/** | |||
* Convert an ObjectId from raw binary representation. | |||
* | |||
* | |||
* @param bs | |||
* the raw byte buffer to read from. At least 20 bytes must be | |||
* available within this byte array. | |||
@@ -156,7 +156,7 @@ public class ObjectId extends AnyObjectId { | |||
/** | |||
* Convert an ObjectId from raw binary representation. | |||
* | |||
* | |||
* @param bs | |||
* the raw byte buffer to read from. At least 20 bytes after p | |||
* must be available within this byte array. | |||
@@ -201,7 +201,7 @@ public class ObjectId extends AnyObjectId { | |||
/** | |||
* Convert an ObjectId from hex characters (US-ASCII). | |||
* | |||
* | |||
* @param buf | |||
* the US-ASCII buffer to read from. At least 40 bytes after | |||
* offset must be available within this byte array. | |||
@@ -215,7 +215,7 @@ public class ObjectId extends AnyObjectId { | |||
/** | |||
* Convert an ObjectId from hex characters. | |||
* | |||
* | |||
* @param str | |||
* the string to read from. Must be 40 characters long. | |||
* @return the converted object id. | |||
@@ -254,7 +254,7 @@ public class ObjectId extends AnyObjectId { | |||
* This constructor is mostly useful for subclasses who want to extend an | |||
* ObjectId with more properties, but initialize from an existing ObjectId | |||
* instance acquired by other means. | |||
* | |||
* | |||
* @param src | |||
* another already parsed ObjectId to copy the value out of. | |||
*/ |
@@ -57,7 +57,7 @@ import java.util.Iterator; | |||
* not reference equality and not <code>.equals(Object)</code> equality. This | |||
* allows subclasses to override <code>equals</code> to supply their own | |||
* extended semantics. | |||
* | |||
* | |||
* @param <V> | |||
* type of subclass of ObjectId that will be stored in the map. | |||
*/ | |||
@@ -79,7 +79,7 @@ public class ObjectIdSubclassMap<V extends ObjectId> implements Iterable<V> { | |||
/** | |||
* Lookup an existing mapping. | |||
* | |||
* | |||
* @param toFind | |||
* the object identifier to find. | |||
* @return the instance mapped to toFind, or null if no mapping exists. | |||
@@ -103,7 +103,7 @@ public class ObjectIdSubclassMap<V extends ObjectId> implements Iterable<V> { | |||
* An existing mapping for <b>must not</b> be in this map. Callers must | |||
* first call {@link #get(AnyObjectId)} to verify there is no current | |||
* mapping prior to adding a new mapping. | |||
* | |||
* | |||
* @param newValue | |||
* the object to store. | |||
* @param |
@@ -68,7 +68,7 @@ public abstract class ObjectLoader { | |||
* <p> | |||
* Unlike {@link #getCachedBytes()} this method returns an array that might | |||
* be modified by the caller. | |||
* | |||
* | |||
* @return the bytes of this object. | |||
*/ | |||
public final byte[] getBytes() { | |||
@@ -85,7 +85,7 @@ public abstract class ObjectLoader { | |||
* saving on data copies between the internal cache and higher level code. | |||
* Callers who receive this reference <b>must not</b> modify its contents. | |||
* Changes (if made) will affect the cache but not the repository itself. | |||
* | |||
* | |||
* @return the cached bytes of this object. Do not modify it. | |||
*/ | |||
public abstract byte[] getCachedBytes(); |
@@ -105,7 +105,7 @@ public class PackFile implements Iterable<PackIndex.MutableEntry> { | |||
/** | |||
* Construct a reader for an existing, pre-indexed packfile. | |||
* | |||
* | |||
* @param idxFile | |||
* path of the <code>.idx</code> file listing the contents. | |||
* @param packFile | |||
@@ -161,7 +161,7 @@ public class PackFile implements Iterable<PackIndex.MutableEntry> { | |||
* For performance reasons only the index file is searched; the main pack | |||
* content is ignored entirely. | |||
* </p> | |||
* | |||
* | |||
* @param id | |||
* the object to look for. Must not be null. | |||
* @return true if the object is in this pack; false otherwise. | |||
@@ -174,7 +174,7 @@ public class PackFile implements Iterable<PackIndex.MutableEntry> { | |||
/** | |||
* Get an object from this pack. | |||
* | |||
* | |||
* @param curs | |||
* temporary working space associated with the calling thread. | |||
* @param id | |||
@@ -209,9 +209,9 @@ public class PackFile implements Iterable<PackIndex.MutableEntry> { | |||
* <p> | |||
* Iterator returns objects in SHA-1 lexicographical order. | |||
* </p> | |||
* | |||
* | |||
* @return iterator over entries of associated pack index | |||
* | |||
* | |||
* @see PackIndex#iterator() | |||
*/ | |||
public Iterator<PackIndex.MutableEntry> iterator() { | |||
@@ -225,7 +225,7 @@ public class PackFile implements Iterable<PackIndex.MutableEntry> { | |||
/** | |||
* Obtain the total number of objects available in this pack. This method | |||
* relies on pack index, giving number of effectively available objects. | |||
* | |||
* | |||
* @return number of objects in index of this pack, likewise in this pack | |||
* @throws IOException | |||
* the index file cannot be loaded into memory. |
@@ -70,7 +70,7 @@ public abstract class PackIndex implements Iterable<PackIndex.MutableEntry> { | |||
* implementation for that format will be constructed and returned to the | |||
* caller. The file may or may not be held open by the returned instance. | |||
* </p> | |||
* | |||
* | |||
* @param idxFile | |||
* existing pack .idx to read. | |||
* @return access implementation for the requested file. | |||
@@ -123,7 +123,7 @@ public abstract class PackIndex implements Iterable<PackIndex.MutableEntry> { | |||
/** | |||
* Determine if an object is contained within the pack file. | |||
* | |||
* | |||
* @param id | |||
* the object to look for. Must not be null. | |||
* @return true if the object is listed in this index; false otherwise. | |||
@@ -140,14 +140,14 @@ public abstract class PackIndex implements Iterable<PackIndex.MutableEntry> { | |||
* <p> | |||
* Iterator returns objects in SHA-1 lexicographical order. | |||
* </p> | |||
* | |||
* | |||
* @return iterator over pack index entries | |||
*/ | |||
public abstract Iterator<MutableEntry> iterator(); | |||
/** | |||
* Obtain the total number of objects described by this index. | |||
* | |||
* | |||
* @return number of objects in this index, and likewise in the associated | |||
* pack that this index was generated from. | |||
*/ | |||
@@ -212,7 +212,7 @@ public abstract class PackIndex implements Iterable<PackIndex.MutableEntry> { | |||
/** | |||
* Locate the file offset position for the requested object. | |||
* | |||
* | |||
* @param objId | |||
* name of the object to locate within the pack. | |||
* @return offset of the object's header and compressed content; -1 if the | |||
@@ -246,7 +246,7 @@ public abstract class PackIndex implements Iterable<PackIndex.MutableEntry> { | |||
/** | |||
* Represent mutable entry of pack index consisting of object id and offset | |||
* in pack (both mutable). | |||
* | |||
* | |||
*/ | |||
public static class MutableEntry { | |||
final MutableObjectId idBuffer = new MutableObjectId(); | |||
@@ -255,7 +255,7 @@ public abstract class PackIndex implements Iterable<PackIndex.MutableEntry> { | |||
/** | |||
* Returns offset for this index object entry | |||
* | |||
* | |||
* @return offset of this object in a pack file | |||
*/ | |||
public long getOffset() { |
@@ -54,7 +54,7 @@ import org.eclipse.jgit.util.SystemReader; | |||
/** | |||
* A combination of a person identity and time in Git. | |||
* | |||
* | |||
* Git combines Name + email + time + time zone to specify who wrote or | |||
* committed something. | |||
*/ | |||
@@ -71,7 +71,7 @@ public class PersonIdent { | |||
* Creates new PersonIdent from config info in repository, with current time. | |||
* This new PersonIdent gets the info from the default committer as available | |||
* from the configuration. | |||
* | |||
* | |||
* @param repo | |||
*/ | |||
public PersonIdent(final Repository repo) { | |||
@@ -84,7 +84,7 @@ public class PersonIdent { | |||
/** | |||
* Copy a {@link PersonIdent}. | |||
* | |||
* | |||
* @param pi | |||
* Original {@link PersonIdent} | |||
*/ | |||
@@ -94,7 +94,7 @@ public class PersonIdent { | |||
/** | |||
* Construct a new {@link PersonIdent} with current time. | |||
* | |||
* | |||
* @param aName | |||
* @param aEmailAddress | |||
*/ | |||
@@ -104,7 +104,7 @@ public class PersonIdent { | |||
/** | |||
* Copy a PersonIdent, but alter the clone's time stamp | |||
* | |||
* | |||
* @param pi | |||
* original {@link PersonIdent} | |||
* @param when | |||
@@ -118,7 +118,7 @@ public class PersonIdent { | |||
/** | |||
* Copy a {@link PersonIdent}, but alter the clone's time stamp | |||
* | |||
* | |||
* @param pi | |||
* original {@link PersonIdent} | |||
* @param aWhen | |||
@@ -133,7 +133,7 @@ public class PersonIdent { | |||
/** | |||
* Construct a PersonIdent from simple data | |||
* | |||
* | |||
* @param aName | |||
* @param aEmailAddress | |||
* @param aWhen | |||
@@ -151,7 +151,7 @@ public class PersonIdent { | |||
/** | |||
* Construct a {@link PersonIdent} | |||
* | |||
* | |||
* @param aName | |||
* @param aEmailAddress | |||
* @param aWhen | |||
@@ -169,7 +169,7 @@ public class PersonIdent { | |||
/** | |||
* Copy a PersonIdent, but alter the clone's time stamp | |||
* | |||
* | |||
* @param pi | |||
* original {@link PersonIdent} | |||
* @param aWhen | |||
@@ -187,7 +187,7 @@ public class PersonIdent { | |||
/** | |||
* Construct a PersonIdent from a string with full name, email, time time | |||
* zone string. The input string must be valid. | |||
* | |||
* | |||
* @param in | |||
* a Git internal format author/committer string. | |||
*/ | |||
@@ -278,7 +278,7 @@ public class PersonIdent { | |||
/** | |||
* Format for Git storage. | |||
* | |||
* | |||
* @return a string in the git author format | |||
*/ | |||
public String toExternalString() { |
@@ -53,7 +53,7 @@ public interface ProgressMonitor { | |||
* Advise the monitor of the total number of subtasks. | |||
* <p> | |||
* This should be invoked at most once per progress monitor interface. | |||
* | |||
* | |||
* @param totalTasks | |||
* the total number of tasks the caller will need to complete | |||
* their processing. | |||
@@ -62,7 +62,7 @@ public interface ProgressMonitor { | |||
/** | |||
* Begin processing a single task. | |||
* | |||
* | |||
* @param title | |||
* title to describe the task. Callers should publish these as | |||
* stable string constants that implementations could match | |||
@@ -79,7 +79,7 @@ public interface ProgressMonitor { | |||
* This is an incremental update; if invoked once per work unit the correct | |||
* value for our argument is <code>1</code>, to indicate a single unit of | |||
* work has been finished by the caller. | |||
* | |||
* | |||
* @param completed | |||
* the number of work units completed since the last call. | |||
*/ | |||
@@ -90,7 +90,7 @@ public interface ProgressMonitor { | |||
/** | |||
* Check for user task cancellation. | |||
* | |||
* | |||
* @return true if the user asked the process to stop working. | |||
*/ | |||
boolean isCancelled(); |
@@ -136,7 +136,7 @@ public class Ref { | |||
/** | |||
* Create a new ref pairing. | |||
* | |||
* | |||
* @param st | |||
* method used to store this ref. | |||
* @param origName | |||
@@ -153,7 +153,7 @@ public class Ref { | |||
/** | |||
* Create a new ref pairing. | |||
* | |||
* | |||
* @param st | |||
* method used to store this ref. | |||
* @param refName | |||
@@ -168,7 +168,7 @@ public class Ref { | |||
/** | |||
* Create a new ref pairing. | |||
* | |||
* | |||
* @param st | |||
* method used to store this ref. | |||
* @param origName | |||
@@ -196,7 +196,7 @@ public class Ref { | |||
/** | |||
* Create a new ref pairing. | |||
* | |||
* | |||
* @param st | |||
* method used to store this ref. | |||
* @param refName | |||
@@ -217,7 +217,7 @@ public class Ref { | |||
/** | |||
* What this ref is called within the repository. | |||
* | |||
* | |||
* @return name of this ref. | |||
*/ | |||
public String getName() { | |||
@@ -233,7 +233,7 @@ public class Ref { | |||
/** | |||
* Cached value of this ref. | |||
* | |||
* | |||
* @return the value of this ref at the last time we read it. | |||
*/ | |||
public ObjectId getObjectId() { | |||
@@ -242,7 +242,7 @@ public class Ref { | |||
/** | |||
* Cached value of <code>ref^{}</code> (the ref peeled to commit). | |||
* | |||
* | |||
* @return if this ref is an annotated tag the id of the commit (or tree or | |||
* blob) that the annotated tag refers to; null if this ref does not | |||
* refer to an annotated tag. |
@@ -66,7 +66,7 @@ public class RefComparator implements Comparator<Ref> { | |||
/** | |||
* Sorts the collection of refs, returning a new collection. | |||
* | |||
* | |||
* @param refs | |||
* collection to be sorted | |||
* @return sorted collection of refs | |||
@@ -76,4 +76,4 @@ public class RefComparator implements Comparator<Ref> { | |||
Collections.sort(r, INSTANCE); | |||
return r; | |||
} | |||
} | |||
} |
@@ -126,7 +126,7 @@ class RefDatabase { | |||
/** | |||
* Create a command to update, create or delete a ref in this repository. | |||
* | |||
* | |||
* @param name | |||
* name of the ref the caller wants to modify. | |||
* @return an update command. The caller must finish populating this command | |||
@@ -172,7 +172,7 @@ class RefDatabase { | |||
/** | |||
* Writes a symref (e.g. HEAD) to disk | |||
* | |||
* | |||
* @param name | |||
* symref name | |||
* @param target | |||
@@ -382,7 +382,7 @@ class RefDatabase { | |||
return new Ref(Ref.Storage.LOOSE, origName, target, null); | |||
if (!origName.equals(r.getName())) | |||
r = new Ref(Ref.Storage.LOOSE_PACKED, origName, r.getName(), r.getObjectId(), r.getPeeledObjectId(), true); | |||
return r; | |||
return r; | |||
} | |||
setModified(); |
@@ -53,7 +53,7 @@ import java.io.IOException; | |||
/** | |||
* Utility class to work with reflog files | |||
* | |||
* | |||
* @author Dave Watson | |||
*/ | |||
public class RefLogWriter { | |||
@@ -137,7 +137,7 @@ public class RefLogWriter { | |||
/** | |||
* Writes reflog entry for ref specified by refName | |||
* | |||
* | |||
* @param repo | |||
* repository to use | |||
* @param oldCommit |
@@ -172,4 +172,4 @@ public class RefRename { | |||
String getToName() { | |||
return newToUpdate.getName(); | |||
} | |||
} | |||
} |
@@ -189,7 +189,7 @@ public class RefUpdate { | |||
/** | |||
* Get the name of the ref this update will operate on. | |||
* | |||
* | |||
* @return name of underlying ref. | |||
*/ | |||
public String getName() { | |||
@@ -207,7 +207,7 @@ public class RefUpdate { | |||
/** | |||
* Get the new value the ref will be (or was) updated to. | |||
* | |||
* | |||
* @return new value. Null if the caller has not configured it. | |||
*/ | |||
public ObjectId getNewObjectId() { | |||
@@ -216,7 +216,7 @@ public class RefUpdate { | |||
/** | |||
* Set the new value the ref will update to. | |||
* | |||
* | |||
* @param id | |||
* the new value. | |||
*/ | |||
@@ -247,7 +247,7 @@ public class RefUpdate { | |||
/** | |||
* Check if this update wants to forcefully change the ref. | |||
* | |||
* | |||
* @return true if this update should ignore merge tests. | |||
*/ | |||
public boolean isForceUpdate() { | |||
@@ -256,7 +256,7 @@ public class RefUpdate { | |||
/** | |||
* Set if this update wants to forcefully change the ref. | |||
* | |||
* | |||
* @param b | |||
* true if this update should ignore merge tests. | |||
*/ | |||
@@ -287,7 +287,7 @@ public class RefUpdate { | |||
/** | |||
* Get the message to include in the reflog. | |||
* | |||
* | |||
* @return message the caller wants to include in the reflog; null if the | |||
* update should not be logged. | |||
*/ | |||
@@ -297,7 +297,7 @@ public class RefUpdate { | |||
/** | |||
* Set the message to include in the reflog. | |||
* | |||
* | |||
* @param msg | |||
* the message to describe this change. It may be null | |||
* if appendStatus is null in order not to append to the reflog | |||
@@ -331,7 +331,7 @@ public class RefUpdate { | |||
* populated with the value of the ref before the lock is taken, but the old | |||
* value may change if someone else modified the ref between the time we | |||
* last read it and when the ref was locked for update. | |||
* | |||
* | |||
* @return the value of the ref prior to the update being attempted; null if | |||
* the updated has not been attempted yet. | |||
*/ | |||
@@ -343,7 +343,7 @@ public class RefUpdate { | |||
* Get the status of this update. | |||
* <p> | |||
* The same value that was previously returned from an update method. | |||
* | |||
* | |||
* @return the status of the update. | |||
*/ | |||
public Result getResult() { | |||
@@ -360,7 +360,7 @@ public class RefUpdate { | |||
* <p> | |||
* This is just a convenient helper for setting the force flag, and as such | |||
* the merge test is performed. | |||
* | |||
* | |||
* @return the result status of the update. | |||
* @throws IOException | |||
* an unexpected IO error occurred while writing changes. | |||
@@ -376,11 +376,11 @@ public class RefUpdate { | |||
* Merge test will be performed according to {@link #isForceUpdate()}. | |||
* <p> | |||
* This is the same as: | |||
* | |||
* | |||
* <pre> | |||
* return update(new RevWalk(repository)); | |||
* </pre> | |||
* | |||
* | |||
* @return the result status of the update. | |||
* @throws IOException | |||
* an unexpected IO error occurred while writing changes. | |||
@@ -393,7 +393,7 @@ public class RefUpdate { | |||
* Gracefully update the ref to the new value. | |||
* <p> | |||
* Merge test will be performed according to {@link #isForceUpdate()}. | |||
* | |||
* | |||
* @param walk | |||
* a RevWalk instance this update command can borrow to perform | |||
* the merge test. The walk will be reset to perform the test. | |||
@@ -415,11 +415,11 @@ public class RefUpdate { | |||
* Delete the ref. | |||
* <p> | |||
* This is the same as: | |||
* | |||
* | |||
* <pre> | |||
* return delete(new RevWalk(repository)); | |||
* </pre> | |||
* | |||
* | |||
* @return the result status of the delete. | |||
* @throws IOException | |||
*/ | |||
@@ -429,7 +429,7 @@ public class RefUpdate { | |||
/** | |||
* Delete the ref. | |||
* | |||
* | |||
* @param walk | |||
* a RevWalk instance this delete command can borrow to perform | |||
* the merge test. The walk will be reset to perform the test. |
@@ -53,7 +53,7 @@ import java.util.Collection; | |||
/** | |||
* Writes out refs to the {@link Constants#INFO_REFS} and | |||
* {@link Constants#PACKED_REFS} files. | |||
* | |||
* | |||
* This class is abstract as the writing of the files must be handled by the | |||
* caller. This is because it is used by transport classes as well. | |||
*/ | |||
@@ -75,8 +75,8 @@ public abstract class RefWriter { | |||
* <p> | |||
* This method rebuilds the contents of the {@link Constants#INFO_REFS} file | |||
* to match the passed list of references. | |||
* | |||
* | |||
* | |||
* | |||
* @throws IOException | |||
* writing is not supported, or attempting to write the file | |||
* failed, possibly due to permissions or remote disk full, etc. | |||
@@ -114,7 +114,7 @@ public abstract class RefWriter { | |||
* This method rebuilds the contents of the {@link Constants#PACKED_REFS} | |||
* file to match the passed list of references, including only those refs | |||
* that have a storage type of {@link Ref.Storage#PACKED}. | |||
* | |||
* | |||
* @throws IOException | |||
* writing is not supported, or attempting to write the file | |||
* failed, possibly due to permissions or remote disk full, etc. | |||
@@ -159,7 +159,7 @@ public abstract class RefWriter { | |||
/** | |||
* Handles actual writing of ref files to the git repository, which may | |||
* differ slightly depending on the destination and transport. | |||
* | |||
* | |||
* @param file | |||
* path to ref file. | |||
* @param content |
@@ -111,7 +111,7 @@ public class Repository { | |||
/** | |||
* Construct a representation of a Git repository. | |||
* | |||
* | |||
* @param d | |||
* GIT_DIR (the location of the repository metadata). | |||
* @throws IOException | |||
@@ -251,7 +251,7 @@ public class Repository { | |||
/** | |||
* @param id | |||
* SHA-1 of an object. | |||
* | |||
* | |||
* @return a {@link ObjectLoader} for accessing the data of the named | |||
* object, or null if the object does not exist. | |||
* @throws IOException | |||
@@ -271,7 +271,7 @@ public class Repository { | |||
* temporary working space associated with the calling thread. | |||
* @param id | |||
* SHA-1 of an object. | |||
* | |||
* | |||
* @return a {@link ObjectLoader} for accessing the data of the named | |||
* object, or null if the object does not exist. | |||
* @throws IOException | |||
@@ -488,7 +488,7 @@ public class Repository { | |||
/** | |||
* Create a command to update, create or delete a ref in this repository. | |||
* | |||
* | |||
* @param ref | |||
* name of the ref the caller wants to modify. | |||
* @return an update command. The caller must finish populating this command | |||
@@ -666,7 +666,7 @@ public class Repository { | |||
refId = parents[0]; | |||
} else | |||
throw new IncorrectObjectTypeException(refId, Constants.TYPE_COMMIT); | |||
} | |||
} else { | |||
ref = mapObject(refId, null); | |||
@@ -771,7 +771,7 @@ public class Repository { | |||
/** | |||
* Add a single existing pack to the list of available pack files. | |||
* | |||
* | |||
* @param pack | |||
* path of the pack file to open. | |||
* @param idx | |||
@@ -817,7 +817,7 @@ public class Repository { | |||
ref = ref.substring(5); | |||
return ref; | |||
} | |||
/** | |||
* @return name of current branch. | |||
* @throws IOException | |||
@@ -884,7 +884,7 @@ public class Repository { | |||
* <p> | |||
* If the ref cannot be peeled (as it does not refer to an annotated tag) | |||
* the peeled id stays null, but {@link Ref#isPeeled()} will be true. | |||
* | |||
* | |||
* @param ref | |||
* The ref to peel | |||
* @return <code>ref</code> if <code>ref.isPeeled()</code> is true; else a |
@@ -605,4 +605,4 @@ public class Tree extends TreeEntry implements Treeish { | |||
return r.toString(); | |||
} | |||
} | |||
} |
@@ -78,7 +78,7 @@ public class WindowCache extends OffsetCache<ByteWindow, WindowCache.WindowRef> | |||
* The new configuration is applied immediately. If the new limits are | |||
* smaller than what what is currently cached, older entries will be purged | |||
* as soon as possible to allow the cache to meet the new limit. | |||
* | |||
* | |||
* @param packedGitLimit | |||
* maximum number of bytes to hold within this instance. | |||
* @param packedGitWindowSize |
@@ -59,7 +59,7 @@ public final class WindowCursor { | |||
/** | |||
* Copy bytes from the window to a caller supplied buffer. | |||
* | |||
* | |||
* @param pack | |||
* the file the desired window is stored within. | |||
* @param position | |||
@@ -95,7 +95,7 @@ public final class WindowCursor { | |||
/** | |||
* Pump bytes into the supplied inflater as input. | |||
* | |||
* | |||
* @param pack | |||
* the file the desired window is stored within. | |||
* @param position |
@@ -67,14 +67,14 @@ public class WorkDirCheckout { | |||
File root; | |||
GitIndex index; | |||
private boolean failOnConflict = true; | |||
Tree merge; | |||
/** | |||
* If <code>true</code>, will scan first to see if it's possible to check out, | |||
* If <code>true</code>, will scan first to see if it's possible to check out, | |||
* otherwise throw {@link CheckoutConflictException}. If <code>false</code>, | |||
* it will silently deal with the problem. | |||
* @param failOnConflict | |||
@@ -90,7 +90,7 @@ public class WorkDirCheckout { | |||
this.index = oldIndex; | |||
this.merge = repo.mapTree(newIndex.writeTree()); | |||
} | |||
/** | |||
* Create a checkout class for checking out one tree, merging with the index | |||
* | |||
@@ -99,7 +99,7 @@ public class WorkDirCheckout { | |||
* @param index current index | |||
* @param merge tree to check out | |||
*/ | |||
public WorkDirCheckout(Repository repo, File root, | |||
public WorkDirCheckout(Repository repo, File root, | |||
GitIndex index, Tree merge) { | |||
this.repo = repo; | |||
this.root = root; | |||
@@ -120,7 +120,7 @@ public class WorkDirCheckout { | |||
this(repo, root, index, merge); | |||
this.head = head; | |||
} | |||
/** | |||
* Execute this checkout | |||
* | |||
@@ -136,7 +136,7 @@ public class WorkDirCheckout { | |||
throw new CheckoutConflictException(entries); | |||
} | |||
} | |||
cleanUpConflicts(); | |||
if (head == null) | |||
checkoutOutIndexNoHead(); | |||
@@ -147,7 +147,7 @@ public class WorkDirCheckout { | |||
for (String path : removed) { | |||
index.remove(root, new File(root, path)); | |||
} | |||
for (java.util.Map.Entry<String, ObjectId> entry : updated.entrySet()) { | |||
Entry newEntry = index.addEntry(merge.findBlobMember(entry.getKey())); | |||
index.checkoutEntry(root, newEntry); | |||
@@ -160,7 +160,7 @@ public class WorkDirCheckout { | |||
Tree head = null; | |||
HashMap<String, ObjectId> updated = new HashMap<String, ObjectId>(); | |||
private void checkoutOutIndexNoHead() throws IOException { | |||
new IndexTreeWalker(index, merge, root, new AbstractIndexTreeVisitor() { | |||
public void visitEntry(TreeEntry m, Entry i, File f) throws IOException { | |||
@@ -176,7 +176,7 @@ public class WorkDirCheckout { | |||
if (i.isModified(root, true)) | |||
needsCheckout = true; | |||
} else needsCheckout = true; | |||
if (needsCheckout) { | |||
Entry newEntry = index.addEntry(m); | |||
index.checkoutEntry(root, newEntry); | |||
@@ -205,9 +205,9 @@ public class WorkDirCheckout { | |||
if (parentFile.list().length == 0) | |||
parentFile.delete(); | |||
else break; | |||
parentFile = parentFile.getParentFile(); | |||
} | |||
} | |||
} | |||
void prescanOneTree() throws IOException { | |||
@@ -227,12 +227,12 @@ public class WorkDirCheckout { | |||
}).walk(); | |||
conflicts.removeAll(removed); | |||
} | |||
private ArrayList<String> listFiles(File file) { | |||
ArrayList<String> list = new ArrayList<String>(); | |||
listFiles(file, list); | |||
return list; | |||
} | |||
} | |||
private void listFiles(File dir, ArrayList<String> list) { | |||
for (File f : dir.listFiles()) { | |||
@@ -267,24 +267,24 @@ public class WorkDirCheckout { | |||
} | |||
processEntry(treeEntry, auxEntry, indexEntry); | |||
} | |||
@Override | |||
public void finishVisitTree(Tree tree, Tree auxTree, String curDir) throws IOException { | |||
if (curDir.length() == 0) return; | |||
if (auxTree != null) { | |||
if (index.getEntry(curDir) != null) | |||
removed.add(curDir); | |||
} | |||
} | |||
} | |||
}).walk(); | |||
// if there's a conflict, don't list it under | |||
// to-be-removed, since that messed up our next | |||
// section | |||
removed.removeAll(conflicts); | |||
for (String path : updated.keySet()) { | |||
if (index.getEntry(path) == null) { | |||
File file = new File(root, path); | |||
@@ -295,8 +295,8 @@ public class WorkDirCheckout { | |||
} | |||
} | |||
} | |||
conflicts.removeAll(removed); | |||
} | |||
@@ -304,11 +304,11 @@ public class WorkDirCheckout { | |||
ObjectId iId = (i == null ? null : i.getObjectId()); | |||
ObjectId mId = (m == null ? null : m.getId()); | |||
ObjectId hId = (h == null ? null : h.getId()); | |||
String name = (i != null ? i.getName() : | |||
String name = (i != null ? i.getName() : | |||
(h != null ? h.getFullName() : | |||
m.getFullName())); | |||
if (i == null) { | |||
/* | |||
I (index) H M Result | |||
@@ -317,7 +317,7 @@ public class WorkDirCheckout { | |||
1 nothing nothing exists use M | |||
2 nothing exists nothing remove path from index | |||
3 nothing exists exists use M */ | |||
if (h == null) { | |||
updated.put(name,mId); | |||
} else if (m == null) { | |||
@@ -331,12 +331,12 @@ public class WorkDirCheckout { | |||
----------------------------------------------------- | |||
4 yes N/A N/A nothing nothing keep index | |||
5 no N/A N/A nothing nothing keep index | |||
6 yes N/A yes nothing exists keep index | |||
7 no N/A yes nothing exists keep index | |||
8 yes N/A no nothing exists fail | |||
9 no N/A no nothing exists fail */ | |||
if (m == null || mId.equals(iId)) { | |||
if (hasParentBlob(merge, name)) { | |||
if (i.isModified(root, true)) { | |||
@@ -355,7 +355,7 @@ public class WorkDirCheckout { | |||
12 yes no N/A exists nothing fail | |||
13 no no N/A exists nothing fail | |||
*/ | |||
if (hId.equals(iId)) { | |||
if (i.isModified(root, true)) { | |||
conflicts.add(name); | |||
@@ -374,14 +374,14 @@ public class WorkDirCheckout { | |||
conflicts.add(name); | |||
else updated.put(name, mId); | |||
} | |||
} | |||
} | |||
} | |||
private boolean hasParentBlob(Tree t, String name) throws IOException { | |||
if (name.indexOf("/") == -1) return false; | |||
String parent = name.substring(0, name.lastIndexOf("/")); | |||
if (t.findBlobMember(parent) != null) | |||
if (t.findBlobMember(parent) != null) | |||
return true; | |||
return hasParentBlob(t, parent); | |||
} |
@@ -70,7 +70,7 @@ import org.eclipse.jgit.revwalk.RevFlag; | |||
* starts at (upper left corner is) 0,0. If this is not true (like say in SWT) | |||
* the implementation must perform the cell offset computations within the | |||
* various draw methods. | |||
* | |||
* | |||
* @param <TLane> | |||
* type of lane being used by the application. | |||
* @param <TColor> | |||
@@ -85,7 +85,7 @@ public abstract class AbstractPlotRenderer<TLane extends PlotLane, TColor> { | |||
/** | |||
* Paint one commit using the underlying graphics library. | |||
* | |||
* | |||
* @param commit | |||
* the commit to render in this cell. Must not be null. | |||
* @param h | |||
@@ -185,7 +185,7 @@ public abstract class AbstractPlotRenderer<TLane extends PlotLane, TColor> { | |||
* If a null lane is supplied the return value must still be acceptable to a | |||
* drawing method. Usually this means the implementation should return a | |||
* default color. | |||
* | |||
* | |||
* @param myLane | |||
* the current lane. May be null. | |||
* @return graphics specific color reference. Must be a valid color. | |||
@@ -194,7 +194,7 @@ public abstract class AbstractPlotRenderer<TLane extends PlotLane, TColor> { | |||
/** | |||
* Draw a single line within this cell. | |||
* | |||
* | |||
* @param color | |||
* the color to use while drawing the line. | |||
* @param x1 | |||
@@ -216,7 +216,7 @@ public abstract class AbstractPlotRenderer<TLane extends PlotLane, TColor> { | |||
* <p> | |||
* Usually the commit dot is a filled oval in blue, then a drawn oval in | |||
* black, using the same coordinates for both operations. | |||
* | |||
* | |||
* @param x | |||
* upper left of the oval's bounding box. | |||
* @param y | |||
@@ -232,7 +232,7 @@ public abstract class AbstractPlotRenderer<TLane extends PlotLane, TColor> { | |||
* Draw a single boundary commit (aka uninteresting commit) dot. | |||
* <p> | |||
* Usually a boundary commit dot is a light gray oval with a white center. | |||
* | |||
* | |||
* @param x | |||
* upper left of the oval's bounding box. | |||
* @param y | |||
@@ -249,7 +249,7 @@ public abstract class AbstractPlotRenderer<TLane extends PlotLane, TColor> { | |||
* <p> | |||
* The font and colors used to render the text are left up to the | |||
* implementation. | |||
* | |||
* | |||
* @param msg | |||
* the text to draw. Does not contain LFs. | |||
* @param x |
@@ -49,7 +49,7 @@ import org.eclipse.jgit.lib.Ref; | |||
/** | |||
* A commit reference to a commit in the DAG. | |||
* | |||
* | |||
* @param <L> | |||
* type of lane being used by the plotter. | |||
* @see PlotCommitList | |||
@@ -69,7 +69,7 @@ public class PlotCommit<L extends PlotLane> extends RevCommit { | |||
/** | |||
* Create a new commit. | |||
* | |||
* | |||
* @param id | |||
* the identity of this commit. | |||
* @param tags | |||
@@ -112,7 +112,7 @@ public class PlotCommit<L extends PlotLane> extends RevCommit { | |||
/** | |||
* Get the number of child commits listed in this commit. | |||
* | |||
* | |||
* @return number of children; always a positive value but can be 0. | |||
*/ | |||
public final int getChildCount() { | |||
@@ -121,7 +121,7 @@ public class PlotCommit<L extends PlotLane> extends RevCommit { | |||
/** | |||
* Get the nth child from this commit's child list. | |||
* | |||
* | |||
* @param nth | |||
* child index to obtain. Must be in the range 0 through | |||
* {@link #getChildCount()}-1. | |||
@@ -135,7 +135,7 @@ public class PlotCommit<L extends PlotLane> extends RevCommit { | |||
/** | |||
* Determine if the given commit is a child (descendant) of this commit. | |||
* | |||
* | |||
* @param c | |||
* the commit to test. | |||
* @return true if the given commit built on top of this commit. | |||
@@ -149,7 +149,7 @@ public class PlotCommit<L extends PlotLane> extends RevCommit { | |||
/** | |||
* Obtain the lane this commit has been plotted into. | |||
* | |||
* | |||
* @return the assigned lane for this commit. | |||
*/ | |||
public final L getLane() { |
@@ -58,7 +58,7 @@ import org.eclipse.jgit.revwalk.RevWalk; | |||
* <p> | |||
* The source of the list must be a {@link PlotWalk} and {@link #fillTo(int)} | |||
* must be used to populate the list. | |||
* | |||
* | |||
* @param <L> | |||
* type of lane used by the application. | |||
*/ | |||
@@ -98,7 +98,7 @@ public class PlotCommitList<L extends PlotLane> extends | |||
* <p> | |||
* This method modifies the passed collection by adding the lanes in any | |||
* order. | |||
* | |||
* | |||
* @param currCommit | |||
* the commit the caller needs to get the lanes from. | |||
* @param result | |||
@@ -195,7 +195,7 @@ public class PlotCommitList<L extends PlotLane> extends | |||
/** | |||
* Return colors and other reusable information to the plotter when a lane | |||
* is no longer needed. | |||
* | |||
* | |||
* @param lane | |||
*/ | |||
protected void recycleLane(final L lane) { |
@@ -55,7 +55,7 @@ public class PlotLane { | |||
/** | |||
* Logical location of this lane within the graphing plane. | |||
* | |||
* | |||
* @return location of this lane, 0 through the maximum number of lanes. | |||
*/ | |||
public int getPosition() { |
@@ -73,7 +73,7 @@ public class PlotWalk extends RevWalk { | |||
/** | |||
* Create a new revision walker for a given repository. | |||
* | |||
* | |||
* @param repo | |||
* the repository the walker will obtain data from. | |||
*/ |
@@ -55,7 +55,7 @@ abstract class AbstractRevQueue extends Generator { | |||
* This method always adds the commit, even if it is already in the queue or | |||
* previously was in the queue but has already been removed. To control | |||
* queue admission use {@link #add(RevCommit, RevFlag)}. | |||
* | |||
* | |||
* @param c | |||
* commit to add. | |||
*/ | |||
@@ -68,7 +68,7 @@ abstract class AbstractRevQueue extends Generator { | |||
* flag; if it does not already have the flag than the commit is added to | |||
* the queue and the flag is set. This later will prevent the commit from | |||
* being added twice. | |||
* | |||
* | |||
* @param c | |||
* commit to add. | |||
* @param queueControl | |||
@@ -88,7 +88,7 @@ abstract class AbstractRevQueue extends Generator { | |||
* flag; if it does not already have the flag than the commit is added to | |||
* the queue and the flag is set. This later will prevent the commit from | |||
* being added twice. | |||
* | |||
* | |||
* @param c | |||
* commit whose parents should be added. | |||
* @param queueControl | |||
@@ -104,7 +104,7 @@ abstract class AbstractRevQueue extends Generator { | |||
/** | |||
* Remove the first commit from the queue. | |||
* | |||
* | |||
* @return the first commit of this queue. | |||
*/ | |||
public abstract RevCommit next(); |
@@ -79,7 +79,7 @@ abstract class BlockRevQueue extends AbstractRevQueue { | |||
* <p> | |||
* Free lists are not thread-safe. Applications must ensure that all queues | |||
* sharing the same free list are doing so from only a single thread. | |||
* | |||
* | |||
* @param q | |||
* the other queue we will steal entries from. | |||
*/ |
@@ -98,7 +98,7 @@ public class DateRevQueue extends AbstractRevQueue { | |||
/** | |||
* Peek at the next commit, without removing it. | |||
* | |||
* | |||
* @return the next available commit; null if there are no commits left. | |||
*/ | |||
public RevCommit peek() { |
@@ -82,7 +82,7 @@ public class FIFORevQueue extends BlockRevQueue { | |||
/** | |||
* Insert the commit pointer at the front of the queue. | |||
* | |||
* | |||
* @param c | |||
* the commit to insert into the queue. | |||
*/ |
@@ -55,7 +55,7 @@ import org.eclipse.jgit.errors.MissingObjectException; | |||
* Conceptually a Generator is an iterator or a queue, it returns commits until | |||
* there are no more relevant. Generators may be piped/stacked together to | |||
* create a more complex set of operations. | |||
* | |||
* | |||
* @see PendingGenerator | |||
* @see StartGenerator | |||
*/ | |||
@@ -77,7 +77,7 @@ abstract class Generator { | |||
/** | |||
* Connect the supplied queue to this generator's own free list (if any). | |||
* | |||
* | |||
* @param q | |||
* another FIFO queue that wants to share our queue's free list. | |||
*/ | |||
@@ -87,7 +87,7 @@ abstract class Generator { | |||
/** | |||
* Obtain flags describing the output behavior of this generator. | |||
* | |||
* | |||
* @return one or more of the constants declared in this class, describing | |||
* how this generator produces its results. | |||
*/ | |||
@@ -95,7 +95,7 @@ abstract class Generator { | |||
/** | |||
* Return the next commit to the application, or the next generator. | |||
* | |||
* | |||
* @return next available commit; null if no more are to be returned. | |||
* @throws MissingObjectException | |||
* @throws IncorrectObjectTypeException |
@@ -92,7 +92,7 @@ public class ObjectWalk extends RevWalk { | |||
/** | |||
* Create a new revision and object walker for a given repository. | |||
* | |||
* | |||
* @param repo | |||
* the repository the walker will obtain data from. | |||
*/ | |||
@@ -118,7 +118,7 @@ public class ObjectWalk extends RevWalk { | |||
* This method will automatically call {@link RevWalk#markStart(RevCommit)} | |||
* if passed RevCommit instance, or a RevTag that directly (or indirectly) | |||
* references a RevCommit. | |||
* | |||
* | |||
* @param o | |||
* the object to start traversing from. The object passed must be | |||
* from this same revision walker. | |||
@@ -169,7 +169,7 @@ public class ObjectWalk extends RevWalk { | |||
* This method will automatically call {@link RevWalk#markStart(RevCommit)} | |||
* if passed RevCommit instance, or a RevTag that directly (or indirectly) | |||
* references a RevCommit. | |||
* | |||
* | |||
* @param o | |||
* the object to start traversing from. The object passed must be | |||
* @throws MissingObjectException | |||
@@ -229,7 +229,7 @@ public class ObjectWalk extends RevWalk { | |||
/** | |||
* Pop the next most recent object. | |||
* | |||
* | |||
* @return next most recent object; null if traversal is over. | |||
* @throws MissingObjectException | |||
* one or or more of the next objects are not available from the | |||
@@ -323,7 +323,7 @@ public class ObjectWalk extends RevWalk { | |||
* This method returns successfully if everything is connected; it throws an | |||
* exception if there is a connectivity problem. The exception message | |||
* provides some detail about the connectivity failure. | |||
* | |||
* | |||
* @throws MissingObjectException | |||
* one or or more of the next objects are not available from the | |||
* object database, but were thought to be candidates for | |||
@@ -357,7 +357,7 @@ public class ObjectWalk extends RevWalk { | |||
* and final output generation. Applications should try to avoid calling it, | |||
* and if invoked do so only once per interesting entry, where the name is | |||
* absolutely required for correct function. | |||
* | |||
* | |||
* @return complete path of the current entry, from the root of the | |||
* repository. If the current entry is in a subtree there will be at | |||
* least one '/' in the returned string. Null if the current entry |
@@ -52,7 +52,7 @@ import org.eclipse.jgit.lib.Constants; | |||
public class RevBlob extends RevObject { | |||
/** | |||
* Create a new blob reference. | |||
* | |||
* | |||
* @param id | |||
* object name for the blob. | |||
*/ |
@@ -75,7 +75,7 @@ public class RevCommit extends RevObject { | |||
/** | |||
* Create a new commit reference. | |||
* | |||
* | |||
* @param id | |||
* object name for the commit. | |||
*/ | |||
@@ -149,7 +149,7 @@ public class RevCommit extends RevObject { | |||
buffer = raw; | |||
flags |= PARSED; | |||
} | |||
@Override | |||
public final int getType() { | |||
return Constants.OBJ_COMMIT; | |||
@@ -187,7 +187,7 @@ public class RevCommit extends RevObject { | |||
* an unparsed commit or a commit with no parents is discovered. This | |||
* permits applications to force a flag through the history chain when | |||
* necessary. | |||
* | |||
* | |||
* @param flag | |||
* the single flag value to carry back onto parents. | |||
*/ | |||
@@ -199,7 +199,7 @@ public class RevCommit extends RevObject { | |||
/** | |||
* Time from the "committer " line of the buffer. | |||
* | |||
* | |||
* @return time, expressed as seconds since the epoch. | |||
*/ | |||
public final int getCommitTime() { | |||
@@ -208,7 +208,7 @@ public class RevCommit extends RevObject { | |||
/** | |||
* Parse this commit buffer for display. | |||
* | |||
* | |||
* @param walk | |||
* revision walker owning this reference. | |||
* @return parsed commit. | |||
@@ -219,7 +219,7 @@ public class RevCommit extends RevObject { | |||
/** | |||
* Get a reference to this commit's tree. | |||
* | |||
* | |||
* @return tree of this commit. | |||
*/ | |||
public final RevTree getTree() { | |||
@@ -228,7 +228,7 @@ public class RevCommit extends RevObject { | |||
/** | |||
* Get the number of parent commits listed in this commit. | |||
* | |||
* | |||
* @return number of parents; always a positive value but can be 0. | |||
*/ | |||
public final int getParentCount() { | |||
@@ -237,7 +237,7 @@ public class RevCommit extends RevObject { | |||
/** | |||
* Get the nth parent from this commit's parent list. | |||
* | |||
* | |||
* @param nth | |||
* parent index to obtain. Must be in the range 0 through | |||
* {@link #getParentCount()}-1. | |||
@@ -256,7 +256,7 @@ public class RevCommit extends RevObject { | |||
* this commit's parent list. Applications relying on this list should be | |||
* very careful to ensure they do not modify its contents during their use | |||
* of it. | |||
* | |||
* | |||
* @return the array of parents. | |||
*/ | |||
public final RevCommit[] getParents() { | |||
@@ -270,7 +270,7 @@ public class RevCommit extends RevObject { | |||
* this commit's message buffer within a RevFilter. Applications relying on | |||
* this buffer should be very careful to ensure they do not modify its | |||
* contents during their use of it. | |||
* | |||
* | |||
* @return the raw unparsed commit body. This is <b>NOT A COPY</b>. | |||
* Altering the contents of this buffer may alter the walker's | |||
* knowledge of this commit, and the results it produces. | |||
@@ -293,7 +293,7 @@ public class RevCommit extends RevObject { | |||
* RevFilter implementations should try to use {@link RawParseUtils} to scan | |||
* the {@link #getRawBuffer()} instead, as this will allow faster evaluation | |||
* of commits. | |||
* | |||
* | |||
* @return identity of the author (name, email) and the time the commit was | |||
* made by the author; null if no author line was found. | |||
*/ | |||
@@ -319,7 +319,7 @@ public class RevCommit extends RevObject { | |||
* RevFilter implementations should try to use {@link RawParseUtils} to scan | |||
* the {@link #getRawBuffer()} instead, as this will allow faster evaluation | |||
* of commits. | |||
* | |||
* | |||
* @return identity of the committer (name, email) and the time the commit | |||
* was made by the committer; null if no committer line was found. | |||
*/ | |||
@@ -338,7 +338,7 @@ public class RevCommit extends RevObject { | |||
* after taking the commit's character set into account and decoding the | |||
* buffer using that character set. This method is a fairly expensive | |||
* operation and produces a new string on each invocation. | |||
* | |||
* | |||
* @return decoded commit message as a string. Never null. | |||
*/ | |||
public final String getFullMessage() { | |||
@@ -360,7 +360,7 @@ public class RevCommit extends RevObject { | |||
* after taking the commit's character set into account and decoding the | |||
* buffer using that character set. This method is a fairly expensive | |||
* operation and produces a new string on each invocation. | |||
* | |||
* | |||
* @return decoded commit message as a string. Never null. The returned | |||
* string does not contain any LFs, even if the first paragraph | |||
* spanned multiple lines. Embedded LFs are converted to spaces. |
@@ -51,7 +51,7 @@ import org.eclipse.jgit.revwalk.filter.RevFilter; | |||
/** | |||
* An ordered list of {@link RevCommit} subclasses. | |||
* | |||
* | |||
* @param <E> | |||
* type of subclass of RevCommit the list is storing. | |||
*/ | |||
@@ -69,7 +69,7 @@ public class RevCommitList<E extends RevCommit> extends RevObjectList<E> { | |||
* <p> | |||
* Same as <code>applyFlag(matching, flag, 0, size())</code>, but without | |||
* the incremental behavior. | |||
* | |||
* | |||
* @param matching | |||
* the filter to test commits with. If the filter includes a | |||
* commit it will have the flag set; if the filter does not | |||
@@ -102,7 +102,7 @@ public class RevCommitList<E extends RevCommit> extends RevObjectList<E> { | |||
* This version allows incremental testing and application, such as from a | |||
* background thread that needs to periodically halt processing and send | |||
* updates to the UI. | |||
* | |||
* | |||
* @param matching | |||
* the filter to test commits with. If the filter includes a | |||
* commit it will have the flag set; if the filter does not | |||
@@ -159,7 +159,7 @@ public class RevCommitList<E extends RevCommit> extends RevObjectList<E> { | |||
* <p> | |||
* Same as <code>clearFlag(flag, 0, size())</code>, but without the | |||
* incremental behavior. | |||
* | |||
* | |||
* @param flag | |||
* the flag to remove. Applications are responsible for | |||
* allocating this flag from the source RevWalk. | |||
@@ -173,7 +173,7 @@ public class RevCommitList<E extends RevCommit> extends RevObjectList<E> { | |||
* <p> | |||
* This method is actually implemented in terms of: | |||
* <code>applyFlag(RevFilter.NONE, flag, rangeBegin, rangeEnd)</code>. | |||
* | |||
* | |||
* @param flag | |||
* the flag to remove. Applications are responsible for | |||
* allocating this flag from the source RevWalk. | |||
@@ -197,7 +197,7 @@ public class RevCommitList<E extends RevCommit> extends RevObjectList<E> { | |||
/** | |||
* Find the next commit that has the given flag set. | |||
* | |||
* | |||
* @param flag | |||
* the flag to test commits against. | |||
* @param begin | |||
@@ -227,7 +227,7 @@ public class RevCommitList<E extends RevCommit> extends RevObjectList<E> { | |||
/** | |||
* Find the next commit that has the given flag set. | |||
* | |||
* | |||
* @param flag | |||
* the flag to test commits against. | |||
* @param begin | |||
@@ -259,7 +259,7 @@ public class RevCommitList<E extends RevCommit> extends RevObjectList<E> { | |||
/** | |||
* Set the revision walker this list populates itself from. | |||
* | |||
* | |||
* @param w | |||
* the walker to populate from. | |||
* @see #fillTo(int) | |||
@@ -270,7 +270,7 @@ public class RevCommitList<E extends RevCommit> extends RevObjectList<E> { | |||
/** | |||
* Is this list still pending more items? | |||
* | |||
* | |||
* @return true if {@link #fillTo(int)} might be able to extend the list | |||
* size when called. | |||
*/ | |||
@@ -286,7 +286,7 @@ public class RevCommitList<E extends RevCommit> extends RevObjectList<E> { | |||
* fewer total commits available from the walk then the method will return | |||
* early. Callers can test the final size of the list by {@link #size()} to | |||
* determine if the high water mark specified was met. | |||
* | |||
* | |||
* @param highMark | |||
* number of commits the caller wants this list to contain when | |||
* the fill operation is complete. | |||
@@ -347,7 +347,7 @@ public class RevCommitList<E extends RevCommit> extends RevObjectList<E> { | |||
* Optional callback invoked when commits enter the list by fillTo. | |||
* <p> | |||
* This method is only called during {@link #fillTo(int)}. | |||
* | |||
* | |||
* @param index | |||
* the list position this object will appear at. | |||
* @param e |
@@ -76,7 +76,7 @@ public class RevFlag { | |||
/** | |||
* Get the revision walk instance this flag was created from. | |||
* | |||
* | |||
* @return the walker this flag was allocated out of, and belongs to. | |||
*/ | |||
public RevWalk getRevWalk() { |
@@ -51,7 +51,7 @@ import java.util.List; | |||
/** | |||
* Multiple application level mark bits for {@link RevObject}s. | |||
* | |||
* | |||
* @see RevFlag | |||
*/ | |||
public class RevFlagSet extends AbstractSet<RevFlag> { | |||
@@ -66,7 +66,7 @@ public class RevFlagSet extends AbstractSet<RevFlag> { | |||
/** | |||
* Create a set of flags, copied from an existing set. | |||
* | |||
* | |||
* @param s | |||
* the set to copy flags from. | |||
*/ | |||
@@ -77,7 +77,7 @@ public class RevFlagSet extends AbstractSet<RevFlag> { | |||
/** | |||
* Create a set of flags, copied from an existing collection. | |||
* | |||
* | |||
* @param s | |||
* the collection to copy flags from. | |||
*/ |
@@ -89,14 +89,14 @@ public abstract class RevObject extends ObjectId { | |||
/** | |||
* Get Git object type. See {@link Constants}. | |||
* | |||
* | |||
* @return object type | |||
*/ | |||
public abstract int getType(); | |||
/** | |||
* Get the name of this object. | |||
* | |||
* | |||
* @return unique hash of this object. | |||
*/ | |||
public final ObjectId getId() { | |||
@@ -115,7 +115,7 @@ public abstract class RevObject extends ObjectId { | |||
/** | |||
* Test to see if the flag has been set on this object. | |||
* | |||
* | |||
* @param flag | |||
* the flag to test. | |||
* @return true if the flag has been added to this object; false if not. | |||
@@ -126,7 +126,7 @@ public abstract class RevObject extends ObjectId { | |||
/** | |||
* Test to see if any flag in the set has been set on this object. | |||
* | |||
* | |||
* @param set | |||
* the flags to test. | |||
* @return true if any flag in the set has been added to this object; false | |||
@@ -138,7 +138,7 @@ public abstract class RevObject extends ObjectId { | |||
/** | |||
* Test to see if all flags in the set have been set on this object. | |||
* | |||
* | |||
* @param set | |||
* the flags to test. | |||
* @return true if all flags of the set have been added to this object; | |||
@@ -152,7 +152,7 @@ public abstract class RevObject extends ObjectId { | |||
* Add a flag to this object. | |||
* <p> | |||
* If the flag is already set on this object then the method has no effect. | |||
* | |||
* | |||
* @param flag | |||
* the flag to mark on this object, for later testing. | |||
*/ | |||
@@ -162,7 +162,7 @@ public abstract class RevObject extends ObjectId { | |||
/** | |||
* Add a set of flags to this object. | |||
* | |||
* | |||
* @param set | |||
* the set of flags to mark on this object, for later testing. | |||
*/ | |||
@@ -174,7 +174,7 @@ public abstract class RevObject extends ObjectId { | |||
* Remove a flag from this object. | |||
* <p> | |||
* If the flag is not set on this object then the method has no effect. | |||
* | |||
* | |||
* @param flag | |||
* the flag to remove from this object. | |||
*/ | |||
@@ -184,7 +184,7 @@ public abstract class RevObject extends ObjectId { | |||
/** | |||
* Remove a set of flags from this object. | |||
* | |||
* | |||
* @param set | |||
* the flag to remove from this object. | |||
*/ |
@@ -49,7 +49,7 @@ import java.util.AbstractList; | |||
/** | |||
* An ordered list of {@link RevObject} subclasses. | |||
* | |||
* | |||
* @param <E> | |||
* type of subclass of RevObject the list is storing. | |||
*/ |
@@ -68,7 +68,7 @@ public class RevTag extends RevObject { | |||
/** | |||
* Create a new tag reference. | |||
* | |||
* | |||
* @param id | |||
* object name for the tag. | |||
*/ | |||
@@ -188,7 +188,7 @@ public class RevTag extends RevObject { | |||
/** | |||
* Parse this tag buffer for display. | |||
* | |||
* | |||
* @param walk | |||
* revision walker owning this reference. | |||
* @return parsed tag. | |||
@@ -199,7 +199,7 @@ public class RevTag extends RevObject { | |||
/** | |||
* Get a reference to the object this tag was placed on. | |||
* | |||
* | |||
* @return object this tag refers to. | |||
*/ | |||
public final RevObject getObject() { | |||
@@ -208,7 +208,7 @@ public class RevTag extends RevObject { | |||
/** | |||
* Get the name of this tag, from the tag header. | |||
* | |||
* | |||
* @return name of the tag, according to the tag header. | |||
*/ | |||
public final String getTagName() { |
@@ -52,7 +52,7 @@ import org.eclipse.jgit.lib.Constants; | |||
public class RevTree extends RevObject { | |||
/** | |||
* Create a new tree reference. | |||
* | |||
* | |||
* @param id | |||
* object name for the tree. | |||
*/ |
@@ -128,7 +128,7 @@ public class RevWalk implements Iterable<RevCommit> { | |||
* mark the commit REWRITE. Later we can rewrite the parents of a REWRITE | |||
* child to remove chains of REWRITE commits before we produce the child to | |||
* the application. | |||
* | |||
* | |||
* @see RewriteGenerator | |||
*/ | |||
static final int REWRITE = 1 << 3; | |||
@@ -185,7 +185,7 @@ public class RevWalk implements Iterable<RevCommit> { | |||
/** | |||
* Create a new revision walker for a given repository. | |||
* | |||
* | |||
* @param repo | |||
* the repository the walker will obtain data from. | |||
*/ | |||
@@ -205,7 +205,7 @@ public class RevWalk implements Iterable<RevCommit> { | |||
/** | |||
* Get the repository this walker loads objects from. | |||
* | |||
* | |||
* @return the repository this walker was created to read. | |||
*/ | |||
public Repository getRepository() { | |||
@@ -224,7 +224,7 @@ public class RevWalk implements Iterable<RevCommit> { | |||
* handling may be more difficult for the application to explain why a | |||
* RevCommit is not actually a commit. The object pool of this walker would | |||
* also be 'poisoned' by the non-commit RevCommit. | |||
* | |||
* | |||
* @param c | |||
* the commit to start traversing from. The commit passed must be | |||
* from this same revision walker. | |||
@@ -254,7 +254,7 @@ public class RevWalk implements Iterable<RevCommit> { | |||
/** | |||
* Mark commits to start graph traversal from. | |||
* | |||
* | |||
* @param list | |||
* commits to start traversing from. The commits passed must be | |||
* from this same revision walker. | |||
@@ -294,7 +294,7 @@ public class RevWalk implements Iterable<RevCommit> { | |||
* handling may be more difficult for the application to explain why a | |||
* RevCommit is not actually a commit. The object pool of this walker would | |||
* also be 'poisoned' by the non-commit RevCommit. | |||
* | |||
* | |||
* @param c | |||
* the commit to start traversing from. The commit passed must be | |||
* from this same revision walker. | |||
@@ -330,7 +330,7 @@ public class RevWalk implements Iterable<RevCommit> { | |||
* commits, and then executes a walk until an answer can be obtained. | |||
* Currently allocated RevFlags that have been added to RevCommit instances | |||
* will be retained through the reset. | |||
* | |||
* | |||
* @param base | |||
* commit the caller thinks is reachable from <code>tip</code>. | |||
* @param tip | |||
@@ -370,7 +370,7 @@ public class RevWalk implements Iterable<RevCommit> { | |||
/** | |||
* Pop the next most recent commit. | |||
* | |||
* | |||
* @return next most recent commit; null if traversal is over. | |||
* @throws MissingObjectException | |||
* one or or more of the next commit's parents are not available | |||
@@ -389,7 +389,7 @@ public class RevWalk implements Iterable<RevCommit> { | |||
/** | |||
* Obtain the sort types applied to the commits returned. | |||
* | |||
* | |||
* @return the sorting strategies employed. At least one strategy is always | |||
* used, but that strategy may be {@link RevSort#NONE}. | |||
*/ | |||
@@ -413,7 +413,7 @@ public class RevWalk implements Iterable<RevCommit> { | |||
* <p> | |||
* Disables all sorting strategies, then enables only the single strategy | |||
* supplied by the caller. | |||
* | |||
* | |||
* @param s | |||
* a sorting strategy to enable. | |||
*/ | |||
@@ -430,7 +430,7 @@ public class RevWalk implements Iterable<RevCommit> { | |||
* may take precedence over others. As an example, {@link RevSort#TOPO} must | |||
* take precedence over {@link RevSort#COMMIT_TIME_DESC}, otherwise it | |||
* cannot enforce its ordering. | |||
* | |||
* | |||
* @param s | |||
* a sorting strategy to enable or disable. | |||
* @param use | |||
@@ -452,7 +452,7 @@ public class RevWalk implements Iterable<RevCommit> { | |||
/** | |||
* Get the currently configured commit filter. | |||
* | |||
* | |||
* @return the current filter. Never null as a filter is always needed. | |||
*/ | |||
public RevFilter getRevFilter() { | |||
@@ -472,7 +472,7 @@ public class RevWalk implements Iterable<RevCommit> { | |||
* unless the filter implementation specifically states it is (and always | |||
* will be) thread-safe. Callers may use {@link RevFilter#clone()} to create | |||
* a unique filter tree for this RevWalk instance. | |||
* | |||
* | |||
* @param newFilter | |||
* the new filter. If null the special {@link RevFilter#ALL} | |||
* filter will be used instead, as it matches every commit. | |||
@@ -486,7 +486,7 @@ public class RevWalk implements Iterable<RevCommit> { | |||
/** | |||
* Get the tree filter used to simplify commits by modified paths. | |||
* | |||
* | |||
* @return the current filter. Never null as a filter is always needed. If | |||
* no filter is being applied {@link TreeFilter#ALL} is returned. | |||
*/ | |||
@@ -507,7 +507,7 @@ public class RevWalk implements Iterable<RevCommit> { | |||
* Usually callers should be inserting a filter graph including | |||
* {@link TreeFilter#ANY_DIFF} along with one or more | |||
* {@link org.eclipse.jgit.treewalk.filter.PathFilter} instances. | |||
* | |||
* | |||
* @param newFilter | |||
* new filter. If null the special {@link TreeFilter#ALL} filter | |||
* will be used instead, as it matches everything. | |||
@@ -568,7 +568,7 @@ public class RevWalk implements Iterable<RevCommit> { | |||
* <p> | |||
* The tree may or may not exist in the repository. It is impossible to tell | |||
* from this method's return value. | |||
* | |||
* | |||
* @param id | |||
* name of the tree object. | |||
* @return reference to the tree object. Never null. | |||
@@ -587,7 +587,7 @@ public class RevWalk implements Iterable<RevCommit> { | |||
* <p> | |||
* The commit may or may not exist in the repository. It is impossible to | |||
* tell from this method's return value. | |||
* | |||
* | |||
* @param id | |||
* name of the commit object. | |||
* @return reference to the commit object. Never null. | |||
@@ -606,7 +606,7 @@ public class RevWalk implements Iterable<RevCommit> { | |||
* <p> | |||
* The object may or may not exist in the repository. It is impossible to | |||
* tell from this method's return value. | |||
* | |||
* | |||
* @param id | |||
* name of the object. | |||
* @param type | |||
@@ -643,7 +643,7 @@ public class RevWalk implements Iterable<RevCommit> { | |||
* Unlike {@link #lookupCommit(AnyObjectId)} this method only returns | |||
* successfully if the commit object exists, is verified to be a commit, and | |||
* was parsed without error. | |||
* | |||
* | |||
* @param id | |||
* name of the commit object. | |||
* @return reference to the commit object. Never null. | |||
@@ -713,7 +713,7 @@ public class RevWalk implements Iterable<RevCommit> { | |||
* without error. Parsing an object can be expensive as the type must be | |||
* determined. For blobs this may mean the blob content was unpacked | |||
* unnecessarily, and thrown away. | |||
* | |||
* | |||
* @param id | |||
* name of the object. | |||
* @return reference to the object. Never null. | |||
@@ -768,7 +768,7 @@ public class RevWalk implements Iterable<RevCommit> { | |||
* <p> | |||
* This method only returns successfully if the object exists and was parsed | |||
* without error. | |||
* | |||
* | |||
* @param obj | |||
* the object the caller needs to be parsed. | |||
* @throws MissingObjectException | |||
@@ -806,7 +806,7 @@ public class RevWalk implements Iterable<RevCommit> { | |||
* Applications are only assured to be able to create 24 unique flags on any | |||
* given revision walker instance. Any flags beyond 24 are offered only if | |||
* the implementation has extra free space within its internal storage. | |||
* | |||
* | |||
* @param name | |||
* description of the flag, primarily useful for debugging. | |||
* @return newly constructed flag instance. | |||
@@ -832,7 +832,7 @@ public class RevWalk implements Iterable<RevCommit> { | |||
* <p> | |||
* A carried flag is copied from the child commit onto its parents when the | |||
* child commit is popped from the lowest level of walk's internal graph. | |||
* | |||
* | |||
* @param flag | |||
* the flag to carry onto parents, if set on a descendant. | |||
*/ | |||
@@ -849,7 +849,7 @@ public class RevWalk implements Iterable<RevCommit> { | |||
* <p> | |||
* A carried flag is copied from the child commit onto its parents when the | |||
* child commit is popped from the lowest level of walk's internal graph. | |||
* | |||
* | |||
* @param set | |||
* the flags to carry onto parents, if set on a descendant. | |||
*/ | |||
@@ -867,7 +867,7 @@ public class RevWalk implements Iterable<RevCommit> { | |||
* If the flag was previously being carried, the carrying request is | |||
* removed. Disposing of a carried flag while a traversal is in progress has | |||
* an undefined behavior. | |||
* | |||
* | |||
* @param flag | |||
* the to recycle. | |||
*/ | |||
@@ -909,7 +909,7 @@ public class RevWalk implements Iterable<RevCommit> { | |||
* Unlike {@link #dispose()} previously acquired RevObject (and RevCommit) | |||
* instances are not invalidated. RevFlag instances are not invalidated, but | |||
* are removed from all RevObjects. | |||
* | |||
* | |||
* @param retainFlags | |||
* application flags that should <b>not</b> be cleared from | |||
* existing commit objects. | |||
@@ -924,7 +924,7 @@ public class RevWalk implements Iterable<RevCommit> { | |||
* Unlike {@link #dispose()} previously acquired RevObject (and RevCommit) | |||
* instances are not invalidated. RevFlag instances are not invalidated, but | |||
* are removed from all RevObjects. | |||
* | |||
* | |||
* @param retainFlags | |||
* application flags that should <b>not</b> be cleared from | |||
* existing commit objects. | |||
@@ -942,7 +942,7 @@ public class RevWalk implements Iterable<RevCommit> { | |||
* Unlike {@link #dispose()} previously acquired RevObject (and RevCommit) | |||
* instances are not invalidated. RevFlag instances are not invalidated, but | |||
* are removed from all RevObjects. | |||
* | |||
* | |||
* @param retainFlags | |||
* application flags that should <b>not</b> be cleared from | |||
* existing commit objects. | |||
@@ -1012,7 +1012,7 @@ public class RevWalk implements Iterable<RevCommit> { | |||
* <p> | |||
* If a checked exception is thrown during the walk (see {@link #next()}) | |||
* it is rethrown from the Iterator as a {@link RevWalkException}. | |||
* | |||
* | |||
* @return an iterator over this walker's commits. | |||
* @see RevWalkException | |||
*/ | |||
@@ -1068,7 +1068,7 @@ public class RevWalk implements Iterable<RevCommit> { | |||
/** | |||
* Construct a new unparsed commit for the given object. | |||
* | |||
* | |||
* @param id | |||
* the object this walker requires a commit reference for. | |||
* @return a new unparsed reference for the object. |
@@ -65,7 +65,7 @@ import org.eclipse.jgit.errors.MissingObjectException; | |||
* that makes the DAG dense. Not fully buffering the commits first would cause | |||
* this loop to abort early, due to commits not being parsed and colored | |||
* correctly. | |||
* | |||
* | |||
* @see RewriteTreeFilter | |||
*/ | |||
class RewriteGenerator extends Generator { |
@@ -64,7 +64,7 @@ import org.eclipse.jgit.treewalk.filter.TreeFilter; | |||
* the commit is colored with {@link RevWalk#REWRITE}, allowing a later pass | |||
* implemented by {@link RewriteGenerator} to remove those colored commits from | |||
* the DAG. | |||
* | |||
* | |||
* @see RewriteGenerator | |||
*/ | |||
class RewriteTreeFilter extends RevFilter { |
@@ -62,7 +62,7 @@ class TopoSortGenerator extends Generator { | |||
* When the constructor completes the supplied generator will have no | |||
* commits remaining, as all of the commits will be held inside of this | |||
* generator's internal buffer. | |||
* | |||
* | |||
* @param s | |||
* generator to pull all commits out of, and into this buffer. | |||
* @throws MissingObjectException |
@@ -57,7 +57,7 @@ import org.eclipse.jgit.revwalk.RevWalk; | |||
public abstract class CommitTimeRevFilter extends RevFilter { | |||
/** | |||
* Create a new filter to select commits before a given date/time. | |||
* | |||
* | |||
* @param ts | |||
* the point in time to cut on. | |||
* @return a new filter to select commits on or before <code>ts</code>. | |||
@@ -68,7 +68,7 @@ public abstract class CommitTimeRevFilter extends RevFilter { | |||
/** | |||
* Create a new filter to select commits after a given date/time. | |||
* | |||
* | |||
* @param ts | |||
* the point in time to cut on. | |||
* @return a new filter to select commits on or after <code>ts</code>. |
@@ -63,7 +63,7 @@ import org.eclipse.jgit.revwalk.RevWalk; | |||
public abstract class OrRevFilter extends RevFilter { | |||
/** | |||
* Create a filter with two filters, one of which must match. | |||
* | |||
* | |||
* @param a | |||
* first filter to test. | |||
* @param b | |||
@@ -78,7 +78,7 @@ public abstract class OrRevFilter extends RevFilter { | |||
/** | |||
* Create a filter around many filters, one of which must match. | |||
* | |||
* | |||
* @param list | |||
* list of filters to match against. Must contain at least 2 | |||
* filters. | |||
@@ -96,7 +96,7 @@ public abstract class OrRevFilter extends RevFilter { | |||
/** | |||
* Create a filter around many filters, one of which must match. | |||
* | |||
* | |||
* @param list | |||
* list of filters to match against. Must contain at least 2 | |||
* filters. |
@@ -56,7 +56,7 @@ import org.eclipse.jgit.revwalk.RevWalk; | |||
public abstract class RevFlagFilter extends RevFilter { | |||
/** | |||
* Create a new filter that tests for a single flag. | |||
* | |||
* | |||
* @param a | |||
* the flag to test. | |||
* @return filter that selects only commits with flag <code>a</code>. | |||
@@ -69,7 +69,7 @@ public abstract class RevFlagFilter extends RevFilter { | |||
/** | |||
* Create a new filter that tests all flags in a set. | |||
* | |||
* | |||
* @param a | |||
* set of flags to test. | |||
* @return filter that selects only commits with all flags in <code>a</code>. | |||
@@ -83,7 +83,7 @@ public abstract class RevFlagFilter extends RevFilter { | |||
/** | |||
* Create a new filter that tests all flags in a set. | |||
* | |||
* | |||
* @param a | |||
* set of flags to test. | |||
* @return filter that selects only commits with all flags in <code>a</code>. | |||
@@ -94,7 +94,7 @@ public abstract class RevFlagFilter extends RevFilter { | |||
/** | |||
* Create a new filter that tests for any flag in a set. | |||
* | |||
* | |||
* @param a | |||
* set of flags to test. | |||
* @return filter that selects only commits with any flag in <code>a</code>. | |||
@@ -108,7 +108,7 @@ public abstract class RevFlagFilter extends RevFilter { | |||
/** | |||
* Create a new filter that tests for any flag in a set. | |||
* | |||
* | |||
* @param a | |||
* set of flags to test. | |||
* @return filter that selects only commits with any flag in <code>a</code>. |
@@ -56,7 +56,7 @@ import org.eclipse.jgit.util.RawSubStringPattern; | |||
public abstract class SubStringRevFilter extends RevFilter { | |||
/** | |||
* Can this string be safely handled by a substring filter? | |||
* | |||
* | |||
* @param pattern | |||
* the pattern text proposed by the user. | |||
* @return true if a substring filter can perform this pattern match; false | |||
@@ -87,7 +87,7 @@ public abstract class SubStringRevFilter extends RevFilter { | |||
/** | |||
* Construct a new matching filter. | |||
* | |||
* | |||
* @param patternText | |||
* text to locate. This should be a safe string as described by | |||
* the {@link #safe(String)} as regular expression meta | |||
@@ -106,7 +106,7 @@ public abstract class SubStringRevFilter extends RevFilter { | |||
/** | |||
* Obtain the raw text to match against. | |||
* | |||
* | |||
* @param cmit | |||
* current commit being evaluated. | |||
* @return sequence for the commit's content that we need to match on. |
@@ -535,4 +535,4 @@ abstract class BasePackFetchConnection extends BasePackConnection implements | |||
private static class CancelledException extends Exception { | |||
private static final long serialVersionUID = 1L; | |||
} | |||
} | |||
} |
@@ -107,4 +107,4 @@ public interface Connection { | |||
*/ | |||
public void close(); | |||
} | |||
} |
@@ -69,7 +69,7 @@ import org.eclipse.jgit.lib.Ref; | |||
* <p> | |||
* FetchConnection instances are not thread safe and may be accessed by only one | |||
* thread at a time. | |||
* | |||
* | |||
* @see Transport | |||
*/ | |||
public interface FetchConnection extends Connection { | |||
@@ -88,7 +88,7 @@ public interface FetchConnection extends Connection { | |||
* should always be preferred over remotely available objects and packs. | |||
* {@link Transport#isFetchThin()} should be honored if applicable. | |||
* </p> | |||
* | |||
* | |||
* @param monitor | |||
* progress monitor to inform the end-user about the amount of | |||
* work completed, or to indicate cancellation. Implementations | |||
@@ -124,7 +124,7 @@ public interface FetchConnection extends Connection { | |||
* By returning only true/false (and not the actual list of tags obtained) | |||
* the transport itself does not need to be aware of whether or not tags | |||
* were included in the transfer. | |||
* | |||
* | |||
* @return true if the last fetch call implicitly included tag objects; | |||
* false if tags were not implicitly obtained. | |||
*/ |
@@ -52,7 +52,7 @@ import java.util.List; | |||
/** | |||
* Final status after a successful fetch from a remote repository. | |||
* | |||
* | |||
* @see Transport#fetch(org.eclipse.jgit.lib.ProgressMonitor, Collection) | |||
*/ | |||
public class FetchResult extends OperationResult { |
@@ -104,7 +104,7 @@ public class IndexPack { | |||
* files within the repository's <code>objects</code> directory. To use the | |||
* data contained within them call {@link #renameAndOpenPack()} once the | |||
* indexing is complete. | |||
* | |||
* | |||
* @param db | |||
* the repository that will receive the new pack. | |||
* @param is | |||
@@ -187,7 +187,7 @@ public class IndexPack { | |||
/** | |||
* Create a new pack indexer utility. | |||
* | |||
* | |||
* @param db | |||
* @param src | |||
* stream to read the pack data from. If the stream is buffered | |||
@@ -239,7 +239,7 @@ public class IndexPack { | |||
* Thin packs are sometimes used during network transfers to allow a delta | |||
* to be sent without a base object. Such packs are not permitted on disk. | |||
* They can be fixed by copying the base object onto the end of the pack. | |||
* | |||
* | |||
* @param fix | |||
* true to enable fixing a thin pack. | |||
*/ | |||
@@ -296,10 +296,10 @@ public class IndexPack { | |||
/** | |||
* Consume data from the input stream until the packfile is indexed. | |||
* | |||
* | |||
* @param progress | |||
* progress feedback | |||
* | |||
* | |||
* @throws IOException | |||
*/ | |||
public void index(final ProgressMonitor progress) throws IOException { | |||
@@ -997,7 +997,7 @@ public class IndexPack { | |||
* If the call completes successfully the repository this IndexPack instance | |||
* was created with will have the objects in the pack available for reading | |||
* and use, without needing to scan for packs. | |||
* | |||
* | |||
* @throws IOException | |||
* The pack could not be inserted into the repository's objects | |||
* directory. The pack no longer exists on disk, as it was |
@@ -136,4 +136,4 @@ public abstract class OperationResult { | |||
void add(final TrackingRefUpdate u) { | |||
updates.put(u.getLocalName(), u); | |||
} | |||
} | |||
} |
@@ -52,7 +52,7 @@ package org.eclipse.jgit.transport; | |||
* Implementations of PackTransport setup connections and move objects back and | |||
* forth by creating pack files on the source side and indexing them on the | |||
* receiving side. | |||
* | |||
* | |||
* @see BasePackFetchConnection | |||
* @see BasePackPushConnection | |||
*/ |
@@ -65,7 +65,7 @@ import org.eclipse.jgit.transport.RemoteRefUpdate.Status; | |||
* <p> | |||
* PushConnection instances are not thread safe and may be accessed by only one | |||
* thread at a time. | |||
* | |||
* | |||
* @see Transport | |||
*/ | |||
public interface PushConnection extends Connection { |
@@ -108,7 +108,7 @@ public class RefSpec { | |||
* <li><code>+refs/head/*:refs/remotes/origin/*</code></li> | |||
* <li><code>:refs/head/master</code></li> | |||
* </ul> | |||
* | |||
* | |||
* @param spec | |||
* string describing the specification. | |||
* @throws IllegalArgumentException | |||
@@ -150,7 +150,7 @@ public class RefSpec { | |||
/** | |||
* Check if this specification wants to forcefully update the destination. | |||
* | |||
* | |||
* @return true if this specification asks for updates without merge tests. | |||
*/ | |||
public boolean isForceUpdate() { | |||
@@ -159,7 +159,7 @@ public class RefSpec { | |||
/** | |||
* Create a new RefSpec with a different force update setting. | |||
* | |||
* | |||
* @param forceUpdate | |||
* new value for force update in the returned instance. | |||
* @return a new RefSpec with force update as specified. | |||
@@ -176,7 +176,7 @@ public class RefSpec { | |||
* If this is a wildcard pattern then the source and destination names | |||
* returned by {@link #getSource()} and {@link #getDestination()} will not | |||
* be actual ref names, but instead will be patterns. | |||
* | |||
* | |||
* @return true if this specification could match more than one ref. | |||
*/ | |||
public boolean isWildcard() { | |||
@@ -189,7 +189,7 @@ public class RefSpec { | |||
* During a fetch this is the name of the ref on the remote repository we | |||
* are fetching from. During a push this is the name of the ref on the local | |||
* repository we are pushing out from. | |||
* | |||
* | |||
* @return name (or wildcard pattern) to match the source ref. | |||
*/ | |||
public String getSource() { | |||
@@ -198,7 +198,7 @@ public class RefSpec { | |||
/** | |||
* Create a new RefSpec with a different source name setting. | |||
* | |||
* | |||
* @param source | |||
* new value for source in the returned instance. | |||
* @return a new RefSpec with source as specified. | |||
@@ -228,7 +228,7 @@ public class RefSpec { | |||
* ObjectId should be stored transiently in order to prepare a merge. | |||
* <p> | |||
* If null during a push, use {@link #getSource()} instead. | |||
* | |||
* | |||
* @return name (or wildcard) pattern to match the destination ref. | |||
*/ | |||
public String getDestination() { | |||
@@ -237,7 +237,7 @@ public class RefSpec { | |||
/** | |||
* Create a new RefSpec with a different destination name setting. | |||
* | |||
* | |||
* @param destination | |||
* new value for destination in the returned instance. | |||
* @return a new RefSpec with destination as specified. | |||
@@ -258,7 +258,7 @@ public class RefSpec { | |||
/** | |||
* Create a new RefSpec with a different source/destination name setting. | |||
* | |||
* | |||
* @param source | |||
* new value for source in the returned instance. | |||
* @param destination | |||
@@ -292,7 +292,7 @@ public class RefSpec { | |||
/** | |||
* Does this specification's source description match the ref? | |||
* | |||
* | |||
* @param r | |||
* ref whose name should be tested. | |||
* @return true if the names match; false otherwise. | |||
@@ -314,7 +314,7 @@ public class RefSpec { | |||
/** | |||
* Does this specification's destination description match the ref? | |||
* | |||
* | |||
* @param r | |||
* ref whose name should be tested. | |||
* @return true if the names match; false otherwise. | |||
@@ -354,7 +354,7 @@ public class RefSpec { | |||
* <p> | |||
* Callers must first verify the passed ref matches this specification, | |||
* otherwise expansion results may be unpredictable. | |||
* | |||
* | |||
* @param r | |||
* a ref that matched our source specification. Could be a | |||
* wildcard also. |
@@ -141,7 +141,7 @@ public class RemoteConfig { | |||
* This constructor succeeds even if the requested remote is not defined | |||
* within the supplied configuration file. If that occurs then there will be | |||
* no URIs and no ref specifications known to the new instance. | |||
* | |||
* | |||
* @param rc | |||
* the existing configuration to get the remote settings from. | |||
* The configuration must already be loaded into memory. | |||
@@ -195,7 +195,7 @@ public class RemoteConfig { | |||
/** | |||
* Update this remote's definition within the configuration. | |||
* | |||
* | |||
* @param rc | |||
* the configuration file to store ourselves into. | |||
*/ | |||
@@ -259,7 +259,7 @@ public class RemoteConfig { | |||
/** | |||
* Get the local name this remote configuration is recognized as. | |||
* | |||
* | |||
* @return name assigned by the user to this configuration block. | |||
*/ | |||
public String getName() { | |||
@@ -268,7 +268,7 @@ public class RemoteConfig { | |||
/** | |||
* Get all configured URIs under this remote. | |||
* | |||
* | |||
* @return the set of URIs known to this remote. | |||
*/ | |||
public List<URIish> getURIs() { | |||
@@ -277,7 +277,7 @@ public class RemoteConfig { | |||
/** | |||
* Add a new URI to the end of the list of URIs. | |||
* | |||
* | |||
* @param toAdd | |||
* the new URI to add to this remote. | |||
* @return true if the URI was added; false if it already exists. | |||
@@ -290,7 +290,7 @@ public class RemoteConfig { | |||
/** | |||
* Remove a URI from the list of URIs. | |||
* | |||
* | |||
* @param toRemove | |||
* the URI to remove from this remote. | |||
* @return true if the URI was added; false if it already exists. | |||
@@ -334,7 +334,7 @@ public class RemoteConfig { | |||
/** | |||
* Remembered specifications for fetching from a repository. | |||
* | |||
* | |||
* @return set of specs used by default when fetching. | |||
*/ | |||
public List<RefSpec> getFetchRefSpecs() { | |||
@@ -343,7 +343,7 @@ public class RemoteConfig { | |||
/** | |||
* Add a new fetch RefSpec to this remote. | |||
* | |||
* | |||
* @param s | |||
* the new specification to add. | |||
* @return true if the specification was added; false if it already exists. | |||
@@ -380,7 +380,7 @@ public class RemoteConfig { | |||
/** | |||
* Remove a fetch RefSpec from this remote. | |||
* | |||
* | |||
* @param s | |||
* the specification to remove. | |||
* @return true if the specification existed and was removed. | |||
@@ -391,7 +391,7 @@ public class RemoteConfig { | |||
/** | |||
* Remembered specifications for pushing to a repository. | |||
* | |||
* | |||
* @return set of specs used by default when pushing. | |||
*/ | |||
public List<RefSpec> getPushRefSpecs() { | |||
@@ -400,7 +400,7 @@ public class RemoteConfig { | |||
/** | |||
* Add a new push RefSpec to this remote. | |||
* | |||
* | |||
* @param s | |||
* the new specification to add. | |||
* @return true if the specification was added; false if it already exists. | |||
@@ -413,7 +413,7 @@ public class RemoteConfig { | |||
/** | |||
* Remove a push RefSpec from this remote. | |||
* | |||
* | |||
* @param s | |||
* the specification to remove. | |||
* @return true if the specification existed and was removed. | |||
@@ -428,7 +428,7 @@ public class RemoteConfig { | |||
* This value is only useful for an SSH style connection, where Git is | |||
* asking the remote system to execute a program that provides the necessary | |||
* network protocol. | |||
* | |||
* | |||
* @return location of 'git-upload-pack' on the remote system. If no | |||
* location has been configured the default of 'git-upload-pack' is | |||
* returned instead. | |||
@@ -443,7 +443,7 @@ public class RemoteConfig { | |||
* This value is only useful for an SSH style connection, where Git is | |||
* asking the remote system to execute a program that provides the necessary | |||
* network protocol. | |||
* | |||
* | |||
* @return location of 'git-receive-pack' on the remote system. If no | |||
* location has been configured the default of 'git-receive-pack' is | |||
* returned instead. | |||
@@ -454,7 +454,7 @@ public class RemoteConfig { | |||
/** | |||
* Get the description of how annotated tags should be treated during fetch. | |||
* | |||
* | |||
* @return option indicating the behavior of annotated tags in fetch. | |||
*/ | |||
public TagOpt getTagOpt() { | |||
@@ -463,7 +463,7 @@ public class RemoteConfig { | |||
/** | |||
* Set the description of how annotated tags should be treated on fetch. | |||
* | |||
* | |||
* @param option | |||
* method to use when handling annotated tags. | |||
*/ |
@@ -68,7 +68,7 @@ import org.eclipse.jgit.util.RawParseUtils; | |||
* <p> | |||
* Channel 3 results in an exception being thrown, as the remote side has issued | |||
* an unrecoverable error. | |||
* | |||
* | |||
* @see PacketLineIn#sideband(ProgressMonitor) | |||
*/ | |||
class SideBandInputStream extends InputStream { |
@@ -66,7 +66,7 @@ public abstract class SshSessionFactory { | |||
* <p> | |||
* A factory is always available. By default the factory will read from the | |||
* user's <code>$HOME/.ssh</code> and assume OpenSSH compatibility. | |||
* | |||
* | |||
* @return factory the current factory for this JVM. | |||
*/ | |||
public static SshSessionFactory getInstance() { | |||
@@ -75,7 +75,7 @@ public abstract class SshSessionFactory { | |||
/** | |||
* Change the JVM-wide factory to a different implementation. | |||
* | |||
* | |||
* @param newFactory | |||
* factory for future sessions to be created through. If null the | |||
* default factory will be restored.s | |||
@@ -95,7 +95,7 @@ public abstract class SshSessionFactory { | |||
* <p> | |||
* The caller must connect the session by invoking <code>connect()</code> | |||
* if it has not already been connected. | |||
* | |||
* | |||
* @param user | |||
* username to authenticate as. If null a reasonable default must | |||
* be selected by the implementation. This may be | |||
@@ -118,7 +118,7 @@ public abstract class SshSessionFactory { | |||
/** | |||
* Close (or recycle) a session to a host. | |||
* | |||
* | |||
* @param session | |||
* a session previously obtained from this factory's | |||
* {@link #getSession(String,String, String, int)} method.s |
@@ -84,7 +84,7 @@ public enum TagOpt { | |||
/** | |||
* Get the command line/configuration file text for this value. | |||
* | |||
* | |||
* @return text that appears in the configuration file to activate this. | |||
*/ | |||
public String option() { | |||
@@ -93,7 +93,7 @@ public enum TagOpt { | |||
/** | |||
* Convert a command line/configuration file text into a value instance. | |||
* | |||
* | |||
* @param o | |||
* the configuration file text value. | |||
* @return the option that matches the passed parameter. |
@@ -80,7 +80,7 @@ public class TrackingRefUpdate { | |||
* Get the name of the remote ref. | |||
* <p> | |||
* Usually this is of the form "refs/heads/master". | |||
* | |||
* | |||
* @return the name used within the remote repository. | |||
*/ | |||
public String getRemoteName() { | |||
@@ -91,7 +91,7 @@ public class TrackingRefUpdate { | |||
* Get the name of the local tracking ref. | |||
* <p> | |||
* Usually this is of the form "refs/remotes/origin/master". | |||
* | |||
* | |||
* @return the name used within this local repository. | |||
*/ | |||
public String getLocalName() { | |||
@@ -100,7 +100,7 @@ public class TrackingRefUpdate { | |||
/** | |||
* Get the new value the ref will be (or was) updated to. | |||
* | |||
* | |||
* @return new value. Null if the caller has not configured it. | |||
*/ | |||
public ObjectId getNewObjectId() { | |||
@@ -114,7 +114,7 @@ public class TrackingRefUpdate { | |||
* populated with the value of the ref before the lock is taken, but the old | |||
* value may change if someone else modified the ref between the time we | |||
* last read it and when the ref was locked for update. | |||
* | |||
* | |||
* @return the value of the ref prior to the update being attempted; null if | |||
* the updated has not been attempted yet. | |||
*/ | |||
@@ -124,7 +124,7 @@ public class TrackingRefUpdate { | |||
/** | |||
* Get the status of this update. | |||
* | |||
* | |||
* @return the status of the update. | |||
*/ | |||
public Result getResult() { |
@@ -91,7 +91,7 @@ public abstract class Transport { | |||
* Open a new transport instance to connect two repositories. | |||
* <p> | |||
* This method assumes {@link Operation#FETCH}. | |||
* | |||
* | |||
* @param local | |||
* existing local repository. | |||
* @param remote | |||
@@ -197,7 +197,7 @@ public abstract class Transport { | |||
* Open a new transport instance to connect two repositories. | |||
* <p> | |||
* This method assumes {@link Operation#FETCH}. | |||
* | |||
* | |||
* @param local | |||
* existing local repository. | |||
* @param cfg | |||
@@ -319,7 +319,7 @@ public abstract class Transport { | |||
/** | |||
* Open a new transport instance to connect two repositories. | |||
* | |||
* | |||
* @param local | |||
* existing local repository. | |||
* @param remote | |||
@@ -520,7 +520,7 @@ public abstract class Transport { | |||
/** | |||
* Create a new transport instance. | |||
* | |||
* | |||
* @param local | |||
* the repository this instance will fetch into, or push out of. | |||
* This must be the repository passed to | |||
@@ -540,7 +540,7 @@ public abstract class Transport { | |||
* Get the URI this transport connects to. | |||
* <p> | |||
* Each transport instance connects to at most one URI at any point in time. | |||
* | |||
* | |||
* @return the URI describing the location of the remote repository. | |||
*/ | |||
public URIish getURI() { | |||
@@ -549,7 +549,7 @@ public abstract class Transport { | |||
/** | |||
* Get the name of the remote executable providing upload-pack service. | |||
* | |||
* | |||
* @return typically "git-upload-pack". | |||
*/ | |||
public String getOptionUploadPack() { | |||
@@ -558,7 +558,7 @@ public abstract class Transport { | |||
/** | |||
* Set the name of the remote executable providing upload-pack services. | |||
* | |||
* | |||
* @param where | |||
* name of the executable. | |||
*/ | |||
@@ -571,7 +571,7 @@ public abstract class Transport { | |||
/** | |||
* Get the description of how annotated tags should be treated during fetch. | |||
* | |||
* | |||
* @return option indicating the behavior of annotated tags in fetch. | |||
*/ | |||
public TagOpt getTagOpt() { | |||
@@ -580,7 +580,7 @@ public abstract class Transport { | |||
/** | |||
* Set the description of how annotated tags should be treated on fetch. | |||
* | |||
* | |||
* @param option | |||
* method to use when handling annotated tags. | |||
*/ | |||
@@ -762,7 +762,7 @@ public abstract class Transport { | |||
* tracking refs associated with the remote repository are automatically | |||
* updated if this transport was created from a {@link RemoteConfig} with | |||
* fetch RefSpecs defined. | |||
* | |||
* | |||
* @param monitor | |||
* progress monitor to inform the user about our processing | |||
* activity. Must not be null. Use {@link NullProgressMonitor} if | |||
@@ -898,7 +898,7 @@ public abstract class Transport { | |||
/** | |||
* Begins a new connection for fetching from the remote repository. | |||
* | |||
* | |||
* @return a fresh connection to fetch from the remote repository. | |||
* @throws NotSupportedException | |||
* the implementation does not support fetching. | |||
@@ -910,7 +910,7 @@ public abstract class Transport { | |||
/** | |||
* Begins a new connection for pushing into the remote repository. | |||
* | |||
* | |||
* @return a fresh connection to push into the remote repository. | |||
* @throws NotSupportedException | |||
* the implementation does not support pushing. |