DirCacheIterator.java
/*
* Copyright (C) 2008-2009, Google Inc.
* 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.dircache;
import static java.nio.charset.StandardCharsets.UTF_8;
import java.io.IOException;
import java.io.InputStream;
import java.util.Collections;
import org.eclipse.jgit.attributes.AttributesNode;
import org.eclipse.jgit.attributes.AttributesRule;
import org.eclipse.jgit.errors.IncorrectObjectTypeException;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.FileMode;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.ObjectLoader;
import org.eclipse.jgit.lib.ObjectReader;
import org.eclipse.jgit.treewalk.AbstractTreeIterator;
import org.eclipse.jgit.treewalk.EmptyTreeIterator;
import org.eclipse.jgit.util.RawParseUtils;
/**
* Iterate a {@link org.eclipse.jgit.dircache.DirCache} as part of a
* <code>TreeWalk</code>.
* <p>
* This is an iterator to adapt a loaded <code>DirCache</code> instance (such as
* read from an existing <code>.git/index</code> file) to the tree structure
* used by a <code>TreeWalk</code>, making it possible for applications to walk
* over any combination of tree objects already in the object database, index
* files, or working directories.
*
* @see org.eclipse.jgit.treewalk.TreeWalk
*/
public class DirCacheIterator extends AbstractTreeIterator {
/** Byte array holding ".gitattributes" string */
private static final byte[] DOT_GIT_ATTRIBUTES_BYTES = Constants.DOT_GIT_ATTRIBUTES
.getBytes(UTF_8);
/** The cache this iterator was created to walk. */
protected final DirCache cache;
/** The tree this iterator is walking. */
private final DirCacheTree tree;
/** First position in this tree. */
private final int treeStart;
/** Last position in this tree. */
private final int treeEnd;
/** Special buffer to hold the ObjectId of {@link #currentSubtree}. */
private final byte[] subtreeId;
/** Index of entry within {@link #cache}. */
protected int ptr;
/** Next subtree to consider within {@link #tree}. */
private int nextSubtreePos;
/** The current file entry from {@link #cache}. */
protected DirCacheEntry currentEntry;
/** The subtree containing {@link #currentEntry} if this is first entry. */
protected DirCacheTree currentSubtree;
/**
* Create a new iterator for an already loaded DirCache instance.
* <p>
* The iterator implementation may copy part of the cache's data during
* construction, so the cache must be read in prior to creating the
* iterator.
*
* @param dc
* the cache to walk. It must be already loaded into memory.
*/
public DirCacheIterator(DirCache dc) {
cache = dc;
tree = dc.getCacheTree(true);
treeStart = 0;
treeEnd = tree.getEntrySpan();
subtreeId = new byte[Constants.OBJECT_ID_LENGTH];
if (!eof())
parseEntry();
}
DirCacheIterator(DirCacheIterator p, DirCacheTree dct) {
super(p, p.path, p.pathLen + 1);
cache = p.cache;
tree = dct;
treeStart = p.ptr;
treeEnd = treeStart + tree.getEntrySpan();
subtreeId = p.subtreeId;
ptr = p.ptr;
parseEntry();
}
/** {@inheritDoc} */
@Override
public AbstractTreeIterator createSubtreeIterator(ObjectReader reader)
throws IncorrectObjectTypeException, IOException {
if (currentSubtree == null)
throw new IncorrectObjectTypeException(getEntryObjectId(),
Constants.TYPE_TREE);
return new DirCacheIterator(this, currentSubtree);
}
/** {@inheritDoc} */
@Override
public EmptyTreeIterator createEmptyTreeIterator() {
final byte[] n = new byte[Math.max(pathLen + 1, DEFAULT_PATH_SIZE)];
System.arraycopy(path, 0, n, 0, pathLen);
n[pathLen] = '/';
return new EmptyTreeIterator(this, n, pathLen + 1);
}
/** {@inheritDoc} */
@Override
public boolean hasId() {
if (currentSubtree != null)
return currentSubtree.isValid();
return currentEntry != null;
}
/** {@inheritDoc} */
@Override
public byte[] idBuffer() {
if (currentSubtree != null)
return currentSubtree.isValid() ? subtreeId : zeroid;
if (currentEntry != null)
return currentEntry.idBuffer();
return zeroid;
}
/** {@inheritDoc} */
@Override
public int idOffset() {
if (currentSubtree != null)
return 0;
if (currentEntry != null)
return currentEntry.idOffset();
return 0;
}
/** {@inheritDoc} */
@Override
public void reset() {
if (!first()) {
ptr = treeStart;
nextSubtreePos = 0;
currentEntry = null;
currentSubtree = null;
if (!eof())
parseEntry();
}
}
/** {@inheritDoc} */
@Override
public boolean first() {
return ptr == treeStart;
}
/** {@inheritDoc} */
@Override
public boolean eof() {
return ptr == treeEnd;
}
/** {@inheritDoc} */
@Override
public void next(int delta) {
while (--delta >= 0) {
if (currentSubtree != null)
ptr += currentSubtree.getEntrySpan();
else
ptr++;
if (eof())
break;
parseEntry();
}
}
/** {@inheritDoc} */
@Override
public void back(int delta) {
while (--delta >= 0) {
if (currentSubtree != null)
nextSubtreePos--;
ptr--;
parseEntry(false);
if (currentSubtree != null)
ptr -= currentSubtree.getEntrySpan() - 1;
}
}
private void parseEntry() {
parseEntry(true);
}
private void parseEntry(boolean forward) {
currentEntry = cache.getEntry(ptr);
final byte[] cep = currentEntry.path;
if (!forward) {
if (nextSubtreePos > 0) {
final DirCacheTree p = tree.getChild(nextSubtreePos - 1);
if (p.contains(cep, pathOffset, cep.length)) {
nextSubtreePos--;
currentSubtree = p;
}
}
}
if (nextSubtreePos != tree.getChildCount()) {
final DirCacheTree s = tree.getChild(nextSubtreePos);
if (s.contains(cep, pathOffset, cep.length)) {
// The current position is the first file of this subtree.
// Use the subtree instead as the current position.
//
currentSubtree = s;
nextSubtreePos++;
if (s.isValid())
s.getObjectId().copyRawTo(subtreeId, 0);
mode = FileMode.TREE.getBits();
path = cep;
pathLen = pathOffset + s.nameLength();
return;
}
}
// The current position is a file/symlink/gitlink so we
// do not have a subtree located here.
//
mode = currentEntry.getRawMode();
path = cep;
pathLen = cep.length;
currentSubtree = null;
// Checks if this entry is a .gitattributes file
if (RawParseUtils.match(path, pathOffset, DOT_GIT_ATTRIBUTES_BYTES) == path.length)
attributesNode = new LazyLoadingAttributesNode(
currentEntry.getObjectId());
}
/**
* Get the DirCacheEntry for the current file.
*
* @return the current cache entry, if this iterator is positioned on a
* non-tree.
*/
public DirCacheEntry getDirCacheEntry() {
return currentSubtree == null ? currentEntry : null;
}
/**
* Retrieves the {@link org.eclipse.jgit.attributes.AttributesNode} for the
* current entry.
*
* @param reader
* {@link org.eclipse.jgit.lib.ObjectReader} used to parse the
* .gitattributes entry.
* @return {@link org.eclipse.jgit.attributes.AttributesNode} for the
* current entry.
* @throws java.io.IOException
* @since 3.7
*/
public AttributesNode getEntryAttributesNode(ObjectReader reader)
throws IOException {
if (attributesNode instanceof LazyLoadingAttributesNode)
attributesNode = ((LazyLoadingAttributesNode) attributesNode)
.load(reader);
return attributesNode;
}
/**
* {@link AttributesNode} implementation that provides lazy loading
* facilities.
*/
private static class LazyLoadingAttributesNode extends AttributesNode {
final ObjectId objectId;
LazyLoadingAttributesNode(ObjectId objectId) {
super(Collections.<AttributesRule> emptyList());
this.objectId = objectId;
}
AttributesNode load(ObjectReader reader) throws IOException {
AttributesNode r = new AttributesNode();
ObjectLoader loader = reader.open(objectId);
if (loader != null) {
try (InputStream in = loader.openStream()) {
r.parse(in);
}
}
return r.getRules().isEmpty() ? null : r;
}
}
}