Use ObjectReader in RevWalk, TreeWalk

We don't actually need a Repository object here, just an ObjectReader
that can load content for us.  So change the API to depend on that.

However, this breaks the asCommit and asTag legacy translation methods
on RevCommit and RevTag, so we still have to keep the Repository
inside of RevWalk for those two types.  Hopefully we can drop those in
the future, and then drop the Repository off the RevWalk.

Change-Id: Iba983e48b663790061c43ae9ffbb77dfe6f4818e
Signed-off-by: Shawn O. Pearce <spearce@spearce.org>

6 files changed, 87 insertions, 76 deletions

diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/AbstractTreeIterator.java b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/AbstractTreeIterator.java
index 73357a4dfe..e74f13e851 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/AbstractTreeIterator.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/AbstractTreeIterator.java
@@ -55,7 +55,6 @@ import org.eclipse.jgit.lib.Constants;
 import org.eclipse.jgit.lib.FileMode;
 import org.eclipse.jgit.lib.MutableObjectId;
 import org.eclipse.jgit.lib.ObjectId;
-import org.eclipse.jgit.lib.Repository;
 import org.eclipse.jgit.lib.ObjectReader;
 import org.eclipse.jgit.treewalk.filter.TreeFilter;
 
@@ -432,8 +431,8 @@ public abstract class AbstractTreeIterator {
 	 * otherwise the caller would not be able to exit out of the subtree
 	 * iterator correctly and return to continue walking <code>this</code>.
 	 *
-	 * @param repo
-	 *            repository to load the tree data from.
+	 * @param reader
+	 *            reader to load the tree data from.
 	 * @return a new parser that walks over the current subtree.
 	 * @throws IncorrectObjectTypeException
 	 *             the current entry is not actually a tree and cannot be parsed
@@ -441,8 +440,9 @@ public abstract class AbstractTreeIterator {
 	 * @throws IOException
 	 *             a loose object or pack file could not be read.
 	 */
-	public abstract AbstractTreeIterator createSubtreeIterator(Repository repo)
-			throws IncorrectObjectTypeException, IOException;
+	public abstract AbstractTreeIterator createSubtreeIterator(
+			ObjectReader reader) throws IncorrectObjectTypeException,
+			IOException;
 
 	/**
 	 * Create a new iterator as though the current entry were a subtree.
@@ -460,12 +460,10 @@ public abstract class AbstractTreeIterator {
 	 * the caller would not be able to exit out of the subtree iterator
 	 * correctly and return to continue walking <code>this</code>.
 	 *
-	 * @param repo
-	 *            repository to load the tree data from.
+	 * @param reader
+	 *            reader to load the tree data from.
 	 * @param idBuffer
 	 *            temporary ObjectId buffer for use by this method.
-	 * @param curs
-	 *            window cursor to use during repository access.
 	 * @return a new parser that walks over the current subtree.
 	 * @throws IncorrectObjectTypeException
 	 *             the current entry is not actually a tree and cannot be parsed
@@ -473,10 +471,10 @@ public abstract class AbstractTreeIterator {
 	 * @throws IOException
 	 *             a loose object or pack file could not be read.
 	 */
-	public AbstractTreeIterator createSubtreeIterator(final Repository repo,
-			final MutableObjectId idBuffer, final ObjectReader curs)
+	public AbstractTreeIterator createSubtreeIterator(
+			final ObjectReader reader, final MutableObjectId idBuffer)
 			throws IncorrectObjectTypeException, IOException {
-		return createSubtreeIterator(repo);
+		return createSubtreeIterator(reader);
 	}
 
 	/**
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/CanonicalTreeParser.java b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/CanonicalTreeParser.java
index fc088d7760..8e4094a055 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/CanonicalTreeParser.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/CanonicalTreeParser.java
@@ -55,7 +55,6 @@ import org.eclipse.jgit.lib.FileMode;
 import org.eclipse.jgit.lib.MutableObjectId;
 import org.eclipse.jgit.lib.ObjectId;
 import org.eclipse.jgit.lib.ObjectReader;
-import org.eclipse.jgit.lib.Repository;
 
 /** Parses raw Git trees from the canonical semi-text/semi-binary format. */
 public class CanonicalTreeParser extends AbstractTreeIterator {
@@ -85,13 +84,11 @@ public class CanonicalTreeParser extends AbstractTreeIterator {
 	 *            may be null or the empty array to indicate the prefix is the
 	 *            root of the repository. A trailing slash ('/') is
 	 *            automatically appended if the prefix does not end in '/'.
-	 * @param repo
-	 *            repository to load the tree data from.
+	 * @param reader
+	 *            reader to load the tree data from.
 	 * @param treeId
 	 *            identity of the tree being parsed; used only in exception
 	 *            messages if data corruption is found.
-	 * @param curs
-	 *            a window cursor to use during data access from the repository.
 	 * @throws MissingObjectException
 	 *             the object supplied is not available from the repository.
 	 * @throws IncorrectObjectTypeException
@@ -100,11 +97,11 @@ public class CanonicalTreeParser extends AbstractTreeIterator {
 	 * @throws IOException
 	 *             a loose object or pack file could not be read.
 	 */
-	public CanonicalTreeParser(final byte[] prefix, final Repository repo,
-			final AnyObjectId treeId, final ObjectReader curs)
-			throws IncorrectObjectTypeException, IOException {
+	public CanonicalTreeParser(final byte[] prefix, final ObjectReader reader,
+			final AnyObjectId treeId) throws IncorrectObjectTypeException,
+			IOException {
 		super(prefix);
-		reset(repo, treeId, curs);
+		reset(reader, treeId);
 	}
 
 	private CanonicalTreeParser(final CanonicalTreeParser p) {
@@ -130,13 +127,11 @@ public class CanonicalTreeParser extends AbstractTreeIterator {
 	/**
 	 * Reset this parser to walk through the given tree.
 	 *
-	 * @param repo
-	 *            repository to load the tree data from.
+	 * @param reader
+	 *            reader to use during repository access.
 	 * @param id
 	 *            identity of the tree being parsed; used only in exception
 	 *            messages if data corruption is found.
-	 * @param curs
-	 *            window cursor to use during repository access.
 	 * @return the root level parser.
 	 * @throws MissingObjectException
 	 *             the object supplied is not available from the repository.
@@ -146,13 +141,13 @@ public class CanonicalTreeParser extends AbstractTreeIterator {
 	 * @throws IOException
 	 *             a loose object or pack file could not be read.
 	 */
-	public CanonicalTreeParser resetRoot(final Repository repo,
-			final AnyObjectId id, final ObjectReader curs)
-			throws IncorrectObjectTypeException, IOException {
+	public CanonicalTreeParser resetRoot(final ObjectReader reader,
+			final AnyObjectId id) throws IncorrectObjectTypeException,
+			IOException {
 		CanonicalTreeParser p = this;
 		while (p.parent != null)
 			p = (CanonicalTreeParser) p.parent;
-		p.reset(repo, id, curs);
+		p.reset(reader, id);
 		return p;
 	}
 
@@ -180,13 +175,11 @@ public class CanonicalTreeParser extends AbstractTreeIterator {
 	/**
 	 * Reset this parser to walk through the given tree.
 	 *
-	 * @param repo
-	 *            repository to load the tree data from.
+	 * @param reader
+	 *            reader to use during repository access.
 	 * @param id
 	 *            identity of the tree being parsed; used only in exception
 	 *            messages if data corruption is found.
-	 * @param curs
-	 *            window cursor to use during repository access.
 	 * @throws MissingObjectException
 	 *             the object supplied is not available from the repository.
 	 * @throws IncorrectObjectTypeException
@@ -195,22 +188,21 @@ public class CanonicalTreeParser extends AbstractTreeIterator {
 	 * @throws IOException
 	 *             a loose object or pack file could not be read.
 	 */
-	public void reset(final Repository repo, final AnyObjectId id,
-			final ObjectReader curs)
+	public void reset(final ObjectReader reader, final AnyObjectId id)
 			throws IncorrectObjectTypeException, IOException {
-		reset(curs.open(id, Constants.OBJ_TREE).getCachedBytes());
+		reset(reader.open(id, Constants.OBJ_TREE).getCachedBytes());
 	}
 
 	@Override
-	public CanonicalTreeParser createSubtreeIterator(final Repository repo,
-			final MutableObjectId idBuffer, final ObjectReader curs)
+	public CanonicalTreeParser createSubtreeIterator(final ObjectReader reader,
+			final MutableObjectId idBuffer)
 			throws IncorrectObjectTypeException, IOException {
 		idBuffer.fromRaw(idBuffer(), idOffset());
 		if (!FileMode.TREE.equals(mode)) {
 			final ObjectId me = idBuffer.toObjectId();
 			throw new IncorrectObjectTypeException(me, Constants.TYPE_TREE);
 		}
-		return createSubtreeIterator0(repo, idBuffer, curs);
+		return createSubtreeIterator0(reader, idBuffer);
 	}
 
 	/**
@@ -220,32 +212,25 @@ public class CanonicalTreeParser extends AbstractTreeIterator {
 	 * called only once the current entry has been identified as a tree and its
 	 * identity has been converted into an ObjectId.
 	 *
-	 * @param repo
-	 *            repository to load the tree data from.
+	 * @param reader
+	 *            reader to load the tree data from.
 	 * @param id
 	 *            ObjectId of the tree to open.
-	 * @param curs
-	 *            window cursor to use during repository access.
 	 * @return a new parser that walks over the current subtree.
 	 * @throws IOException
 	 *             a loose object or pack file could not be read.
 	 */
 	public final CanonicalTreeParser createSubtreeIterator0(
-			final Repository repo, final AnyObjectId id, final ObjectReader curs)
+			final ObjectReader reader, final AnyObjectId id)
 			throws IOException {
 		final CanonicalTreeParser p = new CanonicalTreeParser(this);
-		p.reset(repo, id, curs);
+		p.reset(reader, id);
 		return p;
 	}
 
-	public CanonicalTreeParser createSubtreeIterator(final Repository repo)
+	public CanonicalTreeParser createSubtreeIterator(final ObjectReader reader)
 			throws IncorrectObjectTypeException, IOException {
-		final ObjectReader curs = repo.newObjectReader();
-		try {
-			return createSubtreeIterator(repo, new MutableObjectId(), curs);
-		} finally {
-			curs.release();
-		}
+		return createSubtreeIterator(reader, new MutableObjectId());
 	}
 
 	@Override
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/EmptyTreeIterator.java b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/EmptyTreeIterator.java
index 1776b50887..7d4ee6d2bd 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/EmptyTreeIterator.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/EmptyTreeIterator.java
@@ -50,7 +50,7 @@ import java.io.IOException;
 import org.eclipse.jgit.errors.CorruptObjectException;
 import org.eclipse.jgit.errors.IncorrectObjectTypeException;
 import org.eclipse.jgit.lib.ObjectId;
-import org.eclipse.jgit.lib.Repository;
+import org.eclipse.jgit.lib.ObjectReader;
 
 /** Iterator over an empty tree (a directory with no files). */
 public class EmptyTreeIterator extends AbstractTreeIterator {
@@ -87,7 +87,7 @@ public class EmptyTreeIterator extends AbstractTreeIterator {
 	}
 
 	@Override
-	public AbstractTreeIterator createSubtreeIterator(final Repository repo)
+	public AbstractTreeIterator createSubtreeIterator(final ObjectReader reader)
 			throws IncorrectObjectTypeException, IOException {
 		return new EmptyTreeIterator(this);
 	}
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/FileTreeIterator.java b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/FileTreeIterator.java
index 8dfab8aa57..7f63646b5b 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/FileTreeIterator.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/FileTreeIterator.java
@@ -54,7 +54,7 @@ import java.io.InputStream;
 import org.eclipse.jgit.errors.IncorrectObjectTypeException;
 import org.eclipse.jgit.lib.Constants;
 import org.eclipse.jgit.lib.FileMode;
-import org.eclipse.jgit.lib.Repository;
+import org.eclipse.jgit.lib.ObjectReader;
 import org.eclipse.jgit.util.FS;
 
 /**
@@ -103,7 +103,7 @@ public class FileTreeIterator extends WorkingTreeIterator {
 	}
 
 	@Override
-	public AbstractTreeIterator createSubtreeIterator(final Repository repo)
+	public AbstractTreeIterator createSubtreeIterator(final ObjectReader reader)
 			throws IncorrectObjectTypeException, IOException {
 		return new FileTreeIterator(this, ((FileEntry) current()).file, fs);
 	}
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/NameConflictTreeWalk.java b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/NameConflictTreeWalk.java
index b569174bdb..99126e8615 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/NameConflictTreeWalk.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/NameConflictTreeWalk.java
@@ -46,6 +46,7 @@ package org.eclipse.jgit.treewalk;
 import org.eclipse.jgit.dircache.DirCacheBuilder;
 import org.eclipse.jgit.errors.CorruptObjectException;
 import org.eclipse.jgit.lib.FileMode;
+import org.eclipse.jgit.lib.ObjectReader;
 import org.eclipse.jgit.lib.Repository;
 
 /**
@@ -93,7 +94,17 @@ public class NameConflictTreeWalk extends TreeWalk {
 	 *            the repository the walker will obtain data from.
 	 */
 	public NameConflictTreeWalk(final Repository repo) {
-		super(repo);
+		this(repo.newObjectReader());
+	}
+
+	/**
+	 * Create a new tree walker for a given repository.
+	 *
+	 * @param or
+	 *            the reader the walker will obtain tree data from.
+	 */
+	public NameConflictTreeWalk(final ObjectReader or) {
+		super(or);
 	}
 
 	@Override
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/TreeWalk.java b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/TreeWalk.java
index aefa79c3a8..2ebabcb94d 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/TreeWalk.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/TreeWalk.java
@@ -113,11 +113,15 @@ public class TreeWalk {
 			final AnyObjectId... trees) throws MissingObjectException,
 			IncorrectObjectTypeException, CorruptObjectException, IOException {
 		final TreeWalk r = new TreeWalk(db);
-		r.setFilter(PathFilterGroup.createFromStrings(Collections
-				.singleton(path)));
-		r.setRecursive(r.getFilter().shouldBeRecursive());
-		r.reset(trees);
-		return r.next() ? r : null;
+		try {
+			r.setFilter(PathFilterGroup.createFromStrings(Collections
+					.singleton(path)));
+			r.setRecursive(r.getFilter().shouldBeRecursive());
+			r.reset(trees);
+			return r.next() ? r : null;
+		} finally {
+			r.release();
+		}
 	}
 
 	/**
@@ -151,12 +155,10 @@ public class TreeWalk {
 		return forPath(db, path, new ObjectId[] { tree });
 	}
 
-	private final Repository db;
+	private final ObjectReader reader;
 
 	private final MutableObjectId idBuffer = new MutableObjectId();
 
-	private final ObjectReader curs;
-
 	private TreeFilter filter;
 
 	AbstractTreeIterator[] trees;
@@ -180,19 +182,34 @@ public class TreeWalk {
 	 *            the repository the walker will obtain data from.
 	 */
 	public TreeWalk(final Repository repo) {
-		db = repo;
-		curs = repo.newObjectReader();
+		this(repo.newObjectReader());
+	}
+
+	/**
+	 * Create a new tree walker for a given repository.
+	 *
+	 * @param or
+	 *            the reader the walker will obtain tree data from.
+	 */
+	public TreeWalk(final ObjectReader or) {
+		reader = or;
 		filter = TreeFilter.ALL;
 		trees = new AbstractTreeIterator[] { new EmptyTreeIterator() };
 	}
 
+	/** @return the reader this walker is using to load objects. */
+	public ObjectReader getObjectReader() {
+		return reader;
+	}
+
 	/**
-	 * Get the repository this tree walker is reading from.
-	 *
-	 * @return the repository configured when the walker was created.
+	 * Release any resources used by this walker's reader.
+	 * <p>
+	 * A walker that has been released can be used again, but may need to be
+	 * released after the subsequent usage.
 	 */
-	public Repository getRepository() {
-		return db;
+	public void release() {
+		reader.release();
 	}
 
 	/**
@@ -320,7 +337,7 @@ public class TreeWalk {
 			if (o instanceof CanonicalTreeParser) {
 				o.matches = null;
 				o.matchShift = 0;
-				((CanonicalTreeParser) o).reset(db, id, curs);
+				((CanonicalTreeParser) o).reset(reader, id);
 				trees[0] = o;
 			} else {
 				trees[0] = parserFor(id);
@@ -367,7 +384,7 @@ public class TreeWalk {
 				if (o instanceof CanonicalTreeParser && o.pathOffset == 0) {
 					o.matches = null;
 					o.matchShift = 0;
-					((CanonicalTreeParser) o).reset(db, ids[i], curs);
+					((CanonicalTreeParser) o).reset(reader, ids[i]);
 					r[i] = o;
 					continue;
 				}
@@ -837,7 +854,7 @@ public class TreeWalk {
 			final AbstractTreeIterator t = trees[i];
 			final AbstractTreeIterator n;
 			if (t.matches == ch && !t.eof() && FileMode.TREE.equals(t.mode))
-				n = t.createSubtreeIterator(db, idBuffer, curs);
+				n = t.createSubtreeIterator(reader, idBuffer);
 			else
 				n = t.createEmptyTreeIterator();
 			tmp[i] = n;
@@ -912,7 +929,7 @@ public class TreeWalk {
 	private CanonicalTreeParser parserFor(final AnyObjectId id)
 			throws IncorrectObjectTypeException, IOException {
 		final CanonicalTreeParser p = new CanonicalTreeParser();
-		p.reset(db, id, curs);
+		p.reset(reader, id);
 		return p;
 	}