| /* |
| * Copyright (C) 2008, Shawn O. Pearce <spearce@spearce.org> and others |
| * |
| * This program and the accompanying materials are made available under the |
| * terms of the Eclipse Distribution License v. 1.0 which is available at |
| * https://www.eclipse.org/org/documents/edl-v10.php. |
| * |
| * SPDX-License-Identifier: BSD-3-Clause |
| */ |
| |
| package org.eclipse.jgit.revwalk; |
| |
| import static java.util.Objects.requireNonNull; |
| import static org.eclipse.jgit.lib.Constants.OBJ_BLOB; |
| import static org.eclipse.jgit.lib.Constants.OBJ_COMMIT; |
| import static org.eclipse.jgit.lib.Constants.OBJ_TREE; |
| |
| import java.io.IOException; |
| import java.text.MessageFormat; |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| import org.eclipse.jgit.errors.CorruptObjectException; |
| import org.eclipse.jgit.errors.IncorrectObjectTypeException; |
| import org.eclipse.jgit.errors.LargeObjectException; |
| import org.eclipse.jgit.errors.MissingObjectException; |
| import org.eclipse.jgit.internal.JGitText; |
| import org.eclipse.jgit.lib.AnyObjectId; |
| import org.eclipse.jgit.lib.ObjectReader; |
| import org.eclipse.jgit.lib.Repository; |
| import org.eclipse.jgit.revwalk.filter.ObjectFilter; |
| import org.eclipse.jgit.util.RawParseUtils; |
| |
| /** |
| * Specialized subclass of RevWalk to include trees, blobs and tags. |
| * <p> |
| * Unlike RevWalk this subclass is able to remember starting roots that include |
| * annotated tags, or arbitrary trees or blobs. Once commit generation is |
| * complete and all commits have been popped by the application, individual |
| * annotated tag, tree and blob objects can be popped through the additional |
| * method {@link #nextObject()}. |
| * <p> |
| * Tree and blob objects reachable from interesting commits are automatically |
| * scheduled for inclusion in the results of {@link #nextObject()}, returning |
| * each object exactly once. Objects are sorted and returned according to the |
| * the commits that reference them and the order they appear within a tree. |
| * Ordering can be affected by changing the |
| * {@link org.eclipse.jgit.revwalk.RevSort} used to order the commits that are |
| * returned first. |
| */ |
| public class ObjectWalk extends RevWalk { |
| private static final int ID_SZ = 20; |
| private static final int TYPE_SHIFT = 12; |
| private static final int TYPE_TREE = 0040000 >>> TYPE_SHIFT; |
| private static final int TYPE_SYMLINK = 0120000 >>> TYPE_SHIFT; |
| private static final int TYPE_FILE = 0100000 >>> TYPE_SHIFT; |
| private static final int TYPE_GITLINK = 0160000 >>> TYPE_SHIFT; |
| |
| /** |
| * Indicates a non-RevCommit is in {@link #pendingObjects}. |
| * <p> |
| * We can safely reuse {@link RevWalk#REWRITE} here for the same value as it |
| * is only set on RevCommit and {@link #pendingObjects} never has RevCommit |
| * instances inserted into it. |
| */ |
| private static final int IN_PENDING = RevWalk.REWRITE; |
| |
| /** |
| * When walking over a tree and blob graph, objects are usually marked as |
| * seen as they are visited and this "seen" status is checked upon the next |
| * visit. If they are already "seen" then they are not processed (returned |
| * by {@link ObjectWalk#nextObject()}) again. However, this behavior can be |
| * overridden by supplying a different implementation of this class. |
| * |
| * @since 5.4 |
| */ |
| public interface VisitationPolicy { |
| /** |
| * Whenever the rev or object walk reaches a Git object, if that object |
| * already exists as a RevObject, this method is called to determine if |
| * that object should be visited. |
| * |
| * @param o |
| * the object to check if it should be visited |
| * @return true if the object should be visited |
| */ |
| boolean shouldVisit(RevObject o); |
| |
| /** |
| * Called when an object is visited. |
| * |
| * @param o |
| * the object that was visited |
| */ |
| void visited(RevObject o); |
| } |
| |
| /** |
| * The default visitation policy: causes all objects to be visited exactly |
| * once. |
| * |
| * @since 5.4 |
| */ |
| public static final VisitationPolicy SIMPLE_VISITATION_POLICY = |
| new VisitationPolicy() { |
| @Override |
| public boolean shouldVisit(RevObject o) { |
| return (o.flags & SEEN) == 0; |
| } |
| |
| @Override |
| public void visited(RevObject o) { |
| o.flags |= SEEN; |
| } |
| }; |
| |
| private List<RevObject> rootObjects; |
| |
| private BlockObjQueue pendingObjects; |
| |
| private ObjectFilter objectFilter; |
| |
| private TreeVisit freeVisit; |
| |
| private TreeVisit currVisit; |
| |
| private byte[] pathBuf; |
| |
| private int pathLen; |
| |
| private boolean boundary; |
| |
| private VisitationPolicy visitationPolicy = SIMPLE_VISITATION_POLICY; |
| |
| /** |
| * Create a new revision and object walker for a given repository. |
| * |
| * @param repo |
| * the repository the walker will obtain data from. |
| */ |
| public ObjectWalk(Repository repo) { |
| this(repo.newObjectReader()); |
| } |
| |
| /** |
| * Create a new revision and object walker for a given repository. |
| * |
| * @param or |
| * the reader the walker will obtain data from. The reader should |
| * be released by the caller when the walker is no longer |
| * required. |
| */ |
| public ObjectWalk(ObjectReader or) { |
| super(or); |
| setRetainBody(false); |
| rootObjects = new ArrayList<>(); |
| pendingObjects = new BlockObjQueue(); |
| objectFilter = ObjectFilter.ALL; |
| pathBuf = new byte[256]; |
| } |
| |
| /** |
| * Create an object reachability checker that will use bitmaps if possible. |
| * |
| * This reachability checker accepts any object as target. For checks |
| * exclusively between commits, see |
| * {@link RevWalk#createReachabilityChecker()}. |
| * |
| * @return an object reachability checker, using bitmaps if possible. |
| * |
| * @throws IOException |
| * when the index fails to load. |
| * |
| * @since 5.8 |
| * @deprecated use |
| * {@code ObjectReader#createObjectReachabilityChecker(ObjectWalk)} |
| * instead. |
| */ |
| @Deprecated |
| public final ObjectReachabilityChecker createObjectReachabilityChecker() |
| throws IOException { |
| return reader.createObjectReachabilityChecker(this); |
| } |
| |
| /** |
| * Mark an object or commit to start graph traversal from. |
| * <p> |
| * Callers are encouraged to use |
| * {@link org.eclipse.jgit.revwalk.RevWalk#parseAny(AnyObjectId)} instead of |
| * {@link org.eclipse.jgit.revwalk.RevWalk#lookupAny(AnyObjectId, int)}, as |
| * this method requires the object to be parsed before it can be added as a |
| * root for the traversal. |
| * <p> |
| * The method will automatically parse an unparsed object, but error |
| * handling may be more difficult for the application to explain why a |
| * RevObject is not actually valid. The object pool of this walker would |
| * also be 'poisoned' by the invalid RevObject. |
| * <p> |
| * This method will automatically call |
| * {@link org.eclipse.jgit.revwalk.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. |
| * @throws org.eclipse.jgit.errors.MissingObjectException |
| * the object supplied is not available from the object |
| * database. This usually indicates the supplied object is |
| * invalid, but the reference was constructed during an earlier |
| * invocation to |
| * {@link org.eclipse.jgit.revwalk.RevWalk#lookupAny(AnyObjectId, int)}. |
| * @throws org.eclipse.jgit.errors.IncorrectObjectTypeException |
| * the object was not parsed yet and it was discovered during |
| * parsing that it is not actually the type of the instance |
| * passed in. This usually indicates the caller used the wrong |
| * type in a |
| * {@link org.eclipse.jgit.revwalk.RevWalk#lookupAny(AnyObjectId, int)} |
| * call. |
| * @throws java.io.IOException |
| * a pack file or loose object could not be read. |
| */ |
| public void markStart(RevObject o) throws MissingObjectException, |
| IncorrectObjectTypeException, IOException { |
| while (o instanceof RevTag) { |
| addObject(o); |
| o = ((RevTag) o).getObject(); |
| parseHeaders(o); |
| } |
| |
| if (o instanceof RevCommit) |
| super.markStart((RevCommit) o); |
| else |
| addObject(o); |
| } |
| |
| /** |
| * Mark an object to not produce in the output. |
| * <p> |
| * Uninteresting objects denote not just themselves but also their entire |
| * reachable chain, back until the merge base of an uninteresting commit and |
| * an otherwise interesting commit. |
| * <p> |
| * Callers are encouraged to use |
| * {@link org.eclipse.jgit.revwalk.RevWalk#parseAny(AnyObjectId)} instead of |
| * {@link org.eclipse.jgit.revwalk.RevWalk#lookupAny(AnyObjectId, int)}, as |
| * this method requires the object to be parsed before it can be added as a |
| * root for the traversal. |
| * <p> |
| * The method will automatically parse an unparsed object, but error |
| * handling may be more difficult for the application to explain why a |
| * RevObject is not actually valid. The object pool of this walker would |
| * also be 'poisoned' by the invalid RevObject. |
| * <p> |
| * This method will automatically call |
| * {@link org.eclipse.jgit.revwalk.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 org.eclipse.jgit.errors.MissingObjectException |
| * the object supplied is not available from the object |
| * database. This usually indicates the supplied object is |
| * invalid, but the reference was constructed during an earlier |
| * invocation to |
| * {@link org.eclipse.jgit.revwalk.RevWalk#lookupAny(AnyObjectId, int)}. |
| * @throws org.eclipse.jgit.errors.IncorrectObjectTypeException |
| * the object was not parsed yet and it was discovered during |
| * parsing that it is not actually the type of the instance |
| * passed in. This usually indicates the caller used the wrong |
| * type in a |
| * {@link org.eclipse.jgit.revwalk.RevWalk#lookupAny(AnyObjectId, int)} |
| * call. |
| * @throws java.io.IOException |
| * a pack file or loose object could not be read. |
| */ |
| public void markUninteresting(RevObject o) throws MissingObjectException, |
| IncorrectObjectTypeException, IOException { |
| while (o instanceof RevTag) { |
| o.flags |= UNINTERESTING; |
| if (boundary) |
| addObject(o); |
| o = ((RevTag) o).getObject(); |
| parseHeaders(o); |
| } |
| |
| if (o instanceof RevCommit) |
| super.markUninteresting((RevCommit) o); |
| else if (o instanceof RevTree) |
| markTreeUninteresting((RevTree) o); |
| else |
| o.flags |= UNINTERESTING; |
| |
| if (o.getType() != OBJ_COMMIT && boundary) |
| addObject(o); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override |
| public void sort(RevSort s) { |
| super.sort(s); |
| boundary = hasRevSort(RevSort.BOUNDARY); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override |
| public void sort(RevSort s, boolean use) { |
| super.sort(s, use); |
| boundary = hasRevSort(RevSort.BOUNDARY); |
| } |
| |
| /** |
| * Get the currently configured object filter. |
| * |
| * @return the current filter. Never null as a filter is always needed. |
| * @since 4.0 |
| */ |
| public ObjectFilter getObjectFilter() { |
| return objectFilter; |
| } |
| |
| /** |
| * Set the object filter for this walker. This filter affects the objects |
| * visited by {@link #nextObject()}. It does not affect the commits listed |
| * by {@link #next()}. |
| * <p> |
| * If the filter returns false for an object, then that object is skipped |
| * and objects reachable from it are not enqueued to be walked recursively. |
| * This can be used to speed up the object walk by skipping subtrees that |
| * are known to be uninteresting. |
| * |
| * @param newFilter |
| * the new filter. If null the special |
| * {@link org.eclipse.jgit.revwalk.filter.ObjectFilter#ALL} |
| * filter will be used instead, as it matches every object. |
| * @since 4.0 |
| */ |
| public void setObjectFilter(ObjectFilter newFilter) { |
| assertNotStarted(); |
| objectFilter = newFilter != null ? newFilter : ObjectFilter.ALL; |
| } |
| |
| /** |
| * Sets the visitation policy to use during this walk. |
| * |
| * @param policy |
| * the {@code VisitationPolicy} to use |
| * @since 5.4 |
| */ |
| public void setVisitationPolicy(VisitationPolicy policy) { |
| assertNotStarted(); |
| visitationPolicy = requireNonNull(policy); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override |
| public RevCommit next() throws MissingObjectException, |
| IncorrectObjectTypeException, IOException { |
| for (;;) { |
| final RevCommit r = super.next(); |
| if (r == null) { |
| return null; |
| } |
| final RevTree t = r.getTree(); |
| if ((r.flags & UNINTERESTING) != 0) { |
| if (objectFilter.include(this, t)) { |
| markTreeUninteresting(t); |
| } |
| if (boundary) { |
| return r; |
| } |
| continue; |
| } |
| if (objectFilter.include(this, t)) { |
| pendingObjects.add(t); |
| } |
| return r; |
| } |
| } |
| |
| /** |
| * Skips the current tree such that {@link #nextObject()} does not return |
| * any objects inside it. This should be called right after |
| * {@link #nextObject()} returns the tree. |
| * |
| * @since 5.4 |
| */ |
| public void skipTree() { |
| if (currVisit != null) { |
| currVisit.ptr = currVisit.buf.length; |
| } |
| } |
| |
| /** |
| * Pop the next most recent object. |
| * |
| * @return next most recent object; null if traversal is over. |
| * @throws org.eclipse.jgit.errors.MissingObjectException |
| * one or more of the next objects are not available from the |
| * object database, but were thought to be candidates for |
| * traversal. This usually indicates a broken link. |
| * @throws org.eclipse.jgit.errors.IncorrectObjectTypeException |
| * one or more of the objects in a tree do not match the type |
| * indicated. |
| * @throws java.io.IOException |
| * a pack file or loose object could not be read. |
| */ |
| public RevObject nextObject() throws MissingObjectException, |
| IncorrectObjectTypeException, IOException { |
| pathLen = 0; |
| |
| TreeVisit tv = currVisit; |
| while (tv != null) { |
| byte[] buf = tv.buf; |
| for (int ptr = tv.ptr; ptr < buf.length;) { |
| int startPtr = ptr; |
| ptr = findObjectId(buf, ptr); |
| idBuffer.fromRaw(buf, ptr); |
| ptr += ID_SZ; |
| |
| if (!objectFilter.include(this, idBuffer)) { |
| continue; |
| } |
| |
| RevObject obj = objects.get(idBuffer); |
| if (obj != null && !visitationPolicy.shouldVisit(obj)) |
| continue; |
| |
| int mode = parseMode(buf, startPtr, ptr, tv); |
| switch (mode >>> TYPE_SHIFT) { |
| case TYPE_FILE: |
| case TYPE_SYMLINK: |
| if (obj == null) { |
| obj = new RevBlob(idBuffer); |
| visitationPolicy.visited(obj); |
| objects.add(obj); |
| return obj; |
| } |
| if (!(obj instanceof RevBlob)) |
| throw new IncorrectObjectTypeException(obj, OBJ_BLOB); |
| visitationPolicy.visited(obj); |
| if ((obj.flags & UNINTERESTING) == 0) |
| return obj; |
| if (boundary) |
| return obj; |
| continue; |
| |
| case TYPE_TREE: |
| if (obj == null) { |
| obj = new RevTree(idBuffer); |
| visitationPolicy.visited(obj); |
| objects.add(obj); |
| return pushTree(obj); |
| } |
| if (!(obj instanceof RevTree)) |
| throw new IncorrectObjectTypeException(obj, OBJ_TREE); |
| visitationPolicy.visited(obj); |
| if ((obj.flags & UNINTERESTING) == 0) |
| return pushTree(obj); |
| if (boundary) |
| return pushTree(obj); |
| continue; |
| |
| case TYPE_GITLINK: |
| continue; |
| |
| default: |
| throw new CorruptObjectException(MessageFormat.format( |
| JGitText.get().corruptObjectInvalidMode3, |
| String.format("%o", Integer.valueOf(mode)), //$NON-NLS-1$ |
| idBuffer.name(), |
| RawParseUtils.decode(buf, tv.namePtr, tv.nameEnd), |
| tv.obj)); |
| } |
| } |
| |
| currVisit = tv.parent; |
| releaseTreeVisit(tv); |
| tv = currVisit; |
| } |
| |
| for (;;) { |
| RevObject o = pendingObjects.next(); |
| if (o == null) { |
| return null; |
| } |
| if (!visitationPolicy.shouldVisit(o)) { |
| continue; |
| } |
| visitationPolicy.visited(o); |
| if ((o.flags & UNINTERESTING) == 0 || boundary) { |
| if (o instanceof RevTree) { |
| // The previous while loop should have exhausted the stack |
| // of trees. |
| assert currVisit == null; |
| |
| pushTree(o); |
| } |
| return o; |
| } |
| } |
| } |
| |
| private static int findObjectId(byte[] buf, int ptr) { |
| // Skip over the mode and name until the NUL before the ObjectId |
| // can be located. Skip the NUL as the function returns. |
| for (;;) { |
| if (buf[++ptr] == 0) return ++ptr; |
| if (buf[++ptr] == 0) return ++ptr; |
| if (buf[++ptr] == 0) return ++ptr; |
| if (buf[++ptr] == 0) return ++ptr; |
| |
| if (buf[++ptr] == 0) return ++ptr; |
| if (buf[++ptr] == 0) return ++ptr; |
| if (buf[++ptr] == 0) return ++ptr; |
| if (buf[++ptr] == 0) return ++ptr; |
| |
| if (buf[++ptr] == 0) return ++ptr; |
| if (buf[++ptr] == 0) return ++ptr; |
| if (buf[++ptr] == 0) return ++ptr; |
| if (buf[++ptr] == 0) return ++ptr; |
| |
| if (buf[++ptr] == 0) return ++ptr; |
| if (buf[++ptr] == 0) return ++ptr; |
| if (buf[++ptr] == 0) return ++ptr; |
| if (buf[++ptr] == 0) return ++ptr; |
| } |
| } |
| |
| private static int parseMode(byte[] buf, int startPtr, int recEndPtr, TreeVisit tv) { |
| int mode = buf[startPtr] - '0'; |
| for (;;) { |
| byte c = buf[++startPtr]; |
| if (' ' == c) |
| break; |
| mode <<= 3; |
| mode += c - '0'; |
| |
| c = buf[++startPtr]; |
| if (' ' == c) |
| break; |
| mode <<= 3; |
| mode += c - '0'; |
| |
| c = buf[++startPtr]; |
| if (' ' == c) |
| break; |
| mode <<= 3; |
| mode += c - '0'; |
| |
| c = buf[++startPtr]; |
| if (' ' == c) |
| break; |
| mode <<= 3; |
| mode += c - '0'; |
| |
| c = buf[++startPtr]; |
| if (' ' == c) |
| break; |
| mode <<= 3; |
| mode += c - '0'; |
| |
| c = buf[++startPtr]; |
| if (' ' == c) |
| break; |
| mode <<= 3; |
| mode += c - '0'; |
| |
| c = buf[++startPtr]; |
| if (' ' == c) |
| break; |
| mode <<= 3; |
| mode += c - '0'; |
| } |
| |
| tv.ptr = recEndPtr; |
| tv.namePtr = startPtr + 1; |
| tv.nameEnd = recEndPtr - (ID_SZ + 1); |
| return mode; |
| } |
| |
| /** |
| * Verify all interesting objects are available, and reachable. |
| * <p> |
| * Callers should populate starting points and ending points with |
| * {@link #markStart(RevObject)} and {@link #markUninteresting(RevObject)} |
| * and then use this method to verify all objects between those two points |
| * exist in the repository and are readable. |
| * <p> |
| * 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 org.eclipse.jgit.errors.MissingObjectException |
| * one or more of the next objects are not available from the |
| * object database, but were thought to be candidates for |
| * traversal. This usually indicates a broken link. |
| * @throws org.eclipse.jgit.errors.IncorrectObjectTypeException |
| * one or more of the objects in a tree do not match the type |
| * indicated. |
| * @throws java.io.IOException |
| * a pack file or loose object could not be read. |
| */ |
| public void checkConnectivity() throws MissingObjectException, |
| IncorrectObjectTypeException, IOException { |
| for (;;) { |
| final RevCommit c = next(); |
| if (c == null) |
| break; |
| } |
| for (;;) { |
| final RevObject o = nextObject(); |
| if (o == null) |
| break; |
| if (o instanceof RevBlob && !reader.has(o)) |
| throw new MissingObjectException(o, OBJ_BLOB); |
| } |
| } |
| |
| /** |
| * Get the current object's complete path. |
| * <p> |
| * This method is not very efficient and is primarily meant for debugging |
| * 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 |
| * has no path, such as for annotated tags or root level trees. |
| */ |
| public String getPathString() { |
| if (pathLen == 0) { |
| pathLen = updatePathBuf(currVisit); |
| if (pathLen == 0) |
| return null; |
| } |
| return RawParseUtils.decode(pathBuf, 0, pathLen); |
| } |
| |
| /** |
| * @return the current traversal depth from the root tree object |
| * @since 5.4 |
| */ |
| public int getTreeDepth() { |
| if (currVisit == null) { |
| return 0; |
| } |
| return currVisit.depth; |
| } |
| |
| /** |
| * Get the current object's path hash code. |
| * <p> |
| * This method computes a hash code on the fly for this path, the hash is |
| * suitable to cluster objects that may have similar paths together. |
| * |
| * @return path hash code; any integer may be returned. |
| */ |
| public int getPathHashCode() { |
| TreeVisit tv = currVisit; |
| if (tv == null) |
| return 0; |
| |
| int nameEnd = tv.nameEnd; |
| if (nameEnd == 0) { |
| // When nameEnd == 0 the subtree is itself the current path |
| // being visited. The name hash must be obtained from its |
| // parent tree. If there is no parent, this is a root tree with |
| // a hash code of 0. |
| tv = tv.parent; |
| if (tv == null) |
| return 0; |
| nameEnd = tv.nameEnd; |
| } |
| |
| byte[] buf; |
| int ptr; |
| |
| if (16 <= (nameEnd - tv.namePtr)) { |
| buf = tv.buf; |
| ptr = nameEnd - 16; |
| } else { |
| nameEnd = pathLen; |
| if (nameEnd == 0) { |
| nameEnd = updatePathBuf(currVisit); |
| pathLen = nameEnd; |
| } |
| buf = pathBuf; |
| ptr = Math.max(0, nameEnd - 16); |
| } |
| |
| int hash = 0; |
| for (; ptr < nameEnd; ptr++) { |
| byte c = buf[ptr]; |
| if (c != ' ') |
| hash = (hash >>> 2) + (c << 24); |
| } |
| return hash; |
| } |
| |
| /** |
| * Get the internal buffer holding the current path. |
| * |
| * @return the internal buffer holding the current path. |
| */ |
| public byte[] getPathBuffer() { |
| if (pathLen == 0) |
| pathLen = updatePathBuf(currVisit); |
| return pathBuf; |
| } |
| |
| /** |
| * Get length of the path in {@link #getPathBuffer()}. |
| * |
| * @return length of the path in {@link #getPathBuffer()}. |
| */ |
| public int getPathLength() { |
| if (pathLen == 0) |
| pathLen = updatePathBuf(currVisit); |
| return pathLen; |
| } |
| |
| private int updatePathBuf(TreeVisit tv) { |
| if (tv == null) |
| return 0; |
| |
| // If nameEnd == 0 this tree has not yet contributed an entry. |
| // Update only for the parent, which if null will be empty. |
| int nameEnd = tv.nameEnd; |
| if (nameEnd == 0) |
| return updatePathBuf(tv.parent); |
| |
| int ptr = tv.pathLen; |
| if (ptr == 0) { |
| ptr = updatePathBuf(tv.parent); |
| if (ptr == pathBuf.length) |
| growPathBuf(ptr); |
| if (ptr != 0) |
| pathBuf[ptr++] = '/'; |
| tv.pathLen = ptr; |
| } |
| |
| int namePtr = tv.namePtr; |
| int nameLen = nameEnd - namePtr; |
| int end = ptr + nameLen; |
| while (pathBuf.length < end) |
| growPathBuf(ptr); |
| System.arraycopy(tv.buf, namePtr, pathBuf, ptr, nameLen); |
| return end; |
| } |
| |
| private void growPathBuf(int ptr) { |
| byte[] newBuf = new byte[pathBuf.length << 1]; |
| System.arraycopy(pathBuf, 0, newBuf, 0, ptr); |
| pathBuf = newBuf; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override |
| public void dispose() { |
| super.dispose(); |
| pendingObjects = new BlockObjQueue(); |
| currVisit = null; |
| freeVisit = null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override |
| protected void reset(int retainFlags) { |
| super.reset(retainFlags); |
| |
| for (RevObject obj : rootObjects) |
| obj.flags &= ~IN_PENDING; |
| |
| rootObjects = new ArrayList<>(); |
| pendingObjects = new BlockObjQueue(); |
| currVisit = null; |
| freeVisit = null; |
| } |
| |
| private void addObject(RevObject o) { |
| if ((o.flags & IN_PENDING) == 0) { |
| o.flags |= IN_PENDING; |
| rootObjects.add(o); |
| pendingObjects.add(o); |
| } |
| } |
| |
| private void markTreeUninteresting(RevTree tree) |
| throws MissingObjectException, IncorrectObjectTypeException, |
| IOException { |
| if ((tree.flags & UNINTERESTING) != 0) |
| return; |
| tree.flags |= UNINTERESTING; |
| |
| byte[] raw = reader.open(tree, OBJ_TREE).getCachedBytes(); |
| for (int ptr = 0; ptr < raw.length;) { |
| byte c = raw[ptr]; |
| int mode = c - '0'; |
| for (;;) { |
| c = raw[++ptr]; |
| if (' ' == c) |
| break; |
| mode <<= 3; |
| mode += c - '0'; |
| } |
| while (raw[++ptr] != 0) { |
| // Skip entry name. |
| } |
| ptr++; // Skip NUL after entry name. |
| |
| switch (mode >>> TYPE_SHIFT) { |
| case TYPE_FILE: |
| case TYPE_SYMLINK: |
| idBuffer.fromRaw(raw, ptr); |
| lookupBlob(idBuffer).flags |= UNINTERESTING; |
| break; |
| |
| case TYPE_TREE: |
| idBuffer.fromRaw(raw, ptr); |
| markTreeUninteresting(lookupTree(idBuffer)); |
| break; |
| |
| case TYPE_GITLINK: |
| break; |
| |
| default: |
| idBuffer.fromRaw(raw, ptr); |
| throw new CorruptObjectException(MessageFormat.format( |
| JGitText.get().corruptObjectInvalidMode3, |
| String.format("%o", Integer.valueOf(mode)), //$NON-NLS-1$ |
| idBuffer.name(), "", tree)); //$NON-NLS-1$ |
| } |
| ptr += ID_SZ; |
| } |
| } |
| |
| private RevObject pushTree(RevObject obj) throws LargeObjectException, |
| MissingObjectException, IncorrectObjectTypeException, IOException { |
| TreeVisit tv = freeVisit; |
| if (tv != null) { |
| freeVisit = tv.parent; |
| tv.ptr = 0; |
| tv.namePtr = 0; |
| tv.nameEnd = 0; |
| tv.pathLen = 0; |
| } else { |
| tv = new TreeVisit(); |
| } |
| tv.obj = obj; |
| tv.buf = reader.open(obj, OBJ_TREE).getCachedBytes(); |
| tv.parent = currVisit; |
| currVisit = tv; |
| if (tv.parent == null) { |
| tv.depth = 1; |
| } else { |
| tv.depth = tv.parent.depth + 1; |
| } |
| |
| return obj; |
| } |
| |
| private void releaseTreeVisit(TreeVisit tv) { |
| tv.buf = null; |
| tv.parent = freeVisit; |
| freeVisit = tv; |
| } |
| |
| private static class TreeVisit { |
| /** Parent tree visit that entered this tree, null if root tree. */ |
| TreeVisit parent; |
| |
| /** The RevTree currently being iterated through. */ |
| RevObject obj; |
| |
| /** Canonical encoding of the tree named by {@link #obj}. */ |
| byte[] buf; |
| |
| /** Index of next entry to parse in {@link #buf}. */ |
| int ptr; |
| |
| /** Start of the current name entry in {@link #buf}. */ |
| int namePtr; |
| |
| /** One past end of name, {@code nameEnd - namePtr} is the length. */ |
| int nameEnd; |
| |
| /** Number of bytes in the path leading up to this tree. */ |
| int pathLen; |
| |
| /** Number of levels deep from the root tree. 0 for root tree. */ |
| int depth; |
| } |
| } |